@particle-academy/fancy-flow 0.22.0 → 0.23.0

package/dist/index.cjs

@@ -8,7 +8,1717 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var ReactExports__default = /*#__PURE__*/_interopDefault(ReactExports);
 
-// src/registry/builtin.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn2, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/@dagrejs/dagre/dist/dagre.esm.js
+function me(e, n) {
+  e[n] ? e[n]++ : e[n] = 1;
+}
+function Ee(e, n) {
+  e[n] !== void 0 && !--e[n] && delete e[n];
+}
+function C(e, n, t, r) {
+  let o = "" + n, i = "" + t;
+  if (!e && o > i) {
+    let s = o;
+    o = i, i = s;
+  }
+  return o + "
" + i + "
" + (r === void 0 ? "\0" : r);
+}
+function gn(e, n, t, r) {
+  let o = "" + n, i = "" + t;
+  if (!e && o > i) {
+    let a = o;
+    o = i, i = a;
+  }
+  let s = { v: o, w: i };
+  return r && (s.name = r), s;
+}
+function Y(e, n) {
+  return C(e, n.v, n.w, n.name);
+}
+function mn(e) {
+  let n = { options: { directed: e.isDirected(), multigraph: e.isMultigraph(), compound: e.isCompound() }, nodes: En(e), edges: Ln(e) }, t = e.graph();
+  return t !== void 0 && (n.value = structuredClone(t)), n;
+}
+function En(e) {
+  return e.nodes().map((n) => {
+    let t = e.node(n), r = e.parent(n), o = { v: n };
+    return t !== void 0 && (o.value = t), r !== void 0 && (o.parent = r), o;
+  });
+}
+function Ln(e) {
+  return e.edges().map((n) => {
+    let t = e.edge(n), r = { v: n.v, w: n.w };
+    return n.name !== void 0 && (r.name = n.name), t !== void 0 && (r.value = t), r;
+  });
+}
+function yn(e) {
+  let n = new p(e.options);
+  return e.value !== void 0 && n.setGraph(e.value), e.nodes.forEach((t) => {
+    n.setNode(t.v, t.value), t.parent && n.setParent(t.v, t.parent);
+  }), e.edges.forEach((t) => {
+    n.setEdge({ v: t.v, w: t.w, name: t.name }, t.value);
+  }), n;
+}
+function we(e, n, t, r) {
+  return Nn(e, String(n), t || wn, r || function(o) {
+    return e.outEdges(o);
+  });
+}
+function Nn(e, n, t, r) {
+  let o = {}, i, s = 0, a = e.nodes(), d = function(c) {
+    let h = t(c);
+    o[c.v].distance + h < o[c.w].distance && (o[c.w] = { distance: o[c.v].distance + h, predecessor: c.v }, i = true);
+  }, l = function() {
+    a.forEach(function(c) {
+      r(c).forEach(function(h) {
+        let f = h.v === c ? h.v : h.w, g = f === h.v ? h.w : h.v;
+        d({ v: f, w: g });
+      });
+    });
+  };
+  a.forEach(function(c) {
+    let h = c === n ? 0 : Number.POSITIVE_INFINITY;
+    o[c] = { distance: h, predecessor: "" };
+  });
+  let u = a.length;
+  for (let c = 1; c < u && (i = false, s++, l(), !!i); c++) ;
+  if (s === u - 1 && (i = false, l(), i)) throw new Error("The graph contains a negative weight cycle");
+  return o;
+}
+function Gn(e) {
+  let n = {}, t = [], r;
+  function o(i) {
+    i in n || (n[i] = true, r.push(i), e.successors(i).forEach(o), e.predecessors(i).forEach(o));
+  }
+  return e.nodes().forEach(function(i) {
+    r = [], o(i), r.length && t.push(r);
+  }), t;
+}
+function F(e, n, t, r) {
+  let o = function(i) {
+    return e.outEdges(i);
+  };
+  return vn(e, String(n), t || kn, r || o);
+}
+function vn(e, n, t, r) {
+  let o = {}, i = new Ne(), s, a, d = function(l) {
+    let u = l.v !== s ? l.v : l.w, c = o[u], h = t(l), f = a.distance + h;
+    if (h < 0) throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + l + " Weight: " + h);
+    f < c.distance && (c.distance = f, c.predecessor = s, i.decrease(u, f));
+  };
+  for (e.nodes().forEach(function(l) {
+    let u = l === n ? 0 : Number.POSITIVE_INFINITY;
+    o[l] = { distance: u, predecessor: "" }, i.add(l, u);
+  }); i.size() > 0 && (s = i.removeMin(), a = o[s], a.distance !== Number.POSITIVE_INFINITY); ) r(s).forEach(d);
+  return o;
+}
+function _n(e, n, t) {
+  return e.nodes().reduce(function(r, o) {
+    return r[o] = F(e, o, n, t), r;
+  }, {});
+}
+function Ge(e) {
+  let n = 0, t = [], r = {}, o = [];
+  function i(s) {
+    let a = r[s] = { onStack: true, lowlink: n, index: n++ };
+    if (t.push(s), e.successors(s).forEach(function(d) {
+      d in r ? r[d].onStack && (a.lowlink = Math.min(a.lowlink, r[d].index)) : (i(d), a.lowlink = Math.min(a.lowlink, r[d].lowlink));
+    }), a.lowlink === a.index) {
+      let d = [], l;
+      do
+        l = t.pop(), r[l].onStack = false, d.push(l);
+      while (s !== l);
+      o.push(d);
+    }
+  }
+  return e.nodes().forEach(function(s) {
+    s in r || i(s);
+  }), o;
+}
+function xn(e) {
+  return Ge(e).filter(function(n) {
+    return n.length > 1 || n.length === 1 && e.hasEdge(n[0], n[0]);
+  });
+}
+function On(e, n, t) {
+  return In(e, n || Tn, t || function(r) {
+    return e.outEdges(r);
+  });
+}
+function In(e, n, t) {
+  let r = {}, o = e.nodes();
+  return o.forEach(function(i) {
+    r[i] = {}, r[i][i] = { distance: 0, predecessor: "" }, o.forEach(function(s) {
+      i !== s && (r[i][s] = { distance: Number.POSITIVE_INFINITY, predecessor: "" });
+    }), t(i).forEach(function(s) {
+      let a = s.v === i ? s.w : s.v, d = n(s);
+      r[i][a] = { distance: d, predecessor: i };
+    });
+  }), o.forEach(function(i) {
+    let s = r[i];
+    o.forEach(function(a) {
+      let d = r[a];
+      o.forEach(function(l) {
+        let u = d[i], c = s[l], h = d[l], f = u.distance + c.distance;
+        f < h.distance && (h.distance = f, h.predecessor = c.predecessor);
+      });
+    });
+  }), r;
+}
+function ke(e) {
+  let n = {}, t = {}, r = [];
+  function o(i) {
+    if (i in t) throw new D();
+    i in n || (t[i] = true, n[i] = true, e.predecessors(i).forEach(o), delete t[i], r.push(i));
+  }
+  if (e.sinks().forEach(o), Object.keys(n).length !== e.nodeCount()) throw new D();
+  return r;
+}
+function Cn(e) {
+  try {
+    ke(e);
+  } catch (n) {
+    if (n instanceof D) return false;
+    throw n;
+  }
+  return true;
+}
+function Rn(e, n, t, r, o) {
+  Array.isArray(n) || (n = [n]);
+  let i = ((a) => {
+    var d;
+    return (d = e.isDirected() ? e.successors(a) : e.neighbors(a)) != null ? d : [];
+  }), s = {};
+  return n.forEach(function(a) {
+    if (!e.hasNode(a)) throw new Error("Graph does not have node: " + a);
+    o = ve(e, a, t === "post", s, i, r, o);
+  }), o;
+}
+function ve(e, n, t, r, o, i, s) {
+  return n in r || (r[n] = true, t || (s = i(s, n)), o(n).forEach(function(a) {
+    s = ve(e, a, t, r, o, i, s);
+  }), t && (s = i(s, n))), s;
+}
+function _e(e, n, t) {
+  return Rn(e, n, t, function(r, o) {
+    return r.push(o), r;
+  }, []);
+}
+function Pn(e, n) {
+  return _e(e, n, "post");
+}
+function Mn(e, n) {
+  return _e(e, n, "pre");
+}
+function jn(e, n) {
+  let t = new p(), r = {}, o = new Ne(), i;
+  function s(d) {
+    let l = d.v === i ? d.w : d.v, u = o.priority(l);
+    if (u !== void 0) {
+      let c = n(d);
+      c < u && (r[l] = i, o.decrease(l, c));
+    }
+  }
+  if (e.nodeCount() === 0) return t;
+  e.nodes().forEach(function(d) {
+    o.add(d, Number.POSITIVE_INFINITY), t.setNode(d);
+  }), o.decrease(e.nodes()[0], 0);
+  let a = false;
+  for (; o.size() > 0; ) {
+    if (i = o.removeMin(), i in r) t.setEdge(i, r[i]);
+    else {
+      if (a) throw new Error("Input graph is not connected: " + e);
+      a = true;
+    }
+    e.nodeEdges(i).forEach(s);
+  }
+  return t;
+}
+function Sn(e, n, t, r) {
+  return Fn(e, n, t, r != null ? r : ((o) => {
+    let i = e.outEdges(o);
+    return i != null ? i : [];
+  }));
+}
+function Fn(e, n, t, r) {
+  if (t === void 0) return F(e, n, t, r);
+  let o = false, i = e.nodes();
+  for (let s = 0; s < i.length; s++) {
+    let a = r(i[s]);
+    for (let d = 0; d < a.length; d++) {
+      let l = a[d], u = l.v === i[s] ? l.v : l.w, c = u === l.v ? l.w : l.v;
+      t({ v: u, w: c }) < 0 && (o = true);
+    }
+    if (o) return we(e, n, t, r);
+  }
+  return F(e, n, t, r);
+}
+function w(e, n, t, r) {
+  let o = r;
+  for (; e.hasNode(o); ) o = j(r);
+  return t.dummy = n, e.setNode(o, t), o;
+}
+function xe(e) {
+  let n = new p().setGraph(e.graph());
+  return e.nodes().forEach((t) => n.setNode(t, e.node(t))), e.edges().forEach((t) => {
+    let r = n.edge(t.v, t.w) || { weight: 0, minlen: 1 }, o = e.edge(t);
+    n.setEdge(t.v, t.w, { weight: r.weight + o.weight, minlen: Math.max(r.minlen, o.minlen) });
+  }), n;
+}
+function A(e) {
+  let n = new p({ multigraph: e.isMultigraph() }).setGraph(e.graph());
+  return e.nodes().forEach((t) => {
+    e.children(t).length || n.setNode(t, e.node(t));
+  }), e.edges().forEach((t) => {
+    n.setEdge(t, e.edge(t));
+  }), n;
+}
+function H(e, n) {
+  let t = e.x, r = e.y, o = n.x - t, i = n.y - r, s = e.width / 2, a = e.height / 2;
+  if (!o && !i) throw new Error("Not possible to find intersection inside of the rectangle");
+  let d, l;
+  return Math.abs(i) * s > Math.abs(o) * a ? (i < 0 && (a = -a), d = a * o / i, l = a) : (o < 0 && (s = -s), d = s, l = s * i / o), { x: t + d, y: r + l };
+}
+function N(e) {
+  let n = k(X(e) + 1).map(() => []);
+  return e.nodes().forEach((t) => {
+    let r = e.node(t), o = r.rank;
+    o !== void 0 && (n[o] || (n[o] = []), n[o][r.order] = t);
+  }), n;
+}
+function Te(e) {
+  let n = e.nodes().map((r) => {
+    let o = e.node(r).rank;
+    return o === void 0 ? Number.MAX_VALUE : o;
+  }), t = L(Math.min, n);
+  e.nodes().forEach((r) => {
+    let o = e.node(r);
+    Object.hasOwn(o, "rank") && (o.rank -= t);
+  });
+}
+function Oe(e) {
+  let n = e.nodes().map((s) => e.node(s).rank).filter((s) => s !== void 0), t = L(Math.min, n), r = [];
+  e.nodes().forEach((s) => {
+    let a = e.node(s).rank - t;
+    r[a] || (r[a] = []), r[a].push(s);
+  });
+  let o = 0, i = e.graph().nodeRankFactor;
+  Array.from(r).forEach((s, a) => {
+    s === void 0 && a % i !== 0 ? --o : s !== void 0 && o && s.forEach((d) => e.node(d).rank += o);
+  });
+}
+function q(e, n, t, r) {
+  let o = { width: 0, height: 0 };
+  return arguments.length >= 4 && (o.rank = t, o.order = r), w(e, "border", o, n);
+}
+function Dn(e, n = Ie) {
+  let t = [];
+  for (let r = 0; r < e.length; r += n) {
+    let o = e.slice(r, r + n);
+    t.push(o);
+  }
+  return t;
+}
+function L(e, n) {
+  if (n.length > Ie) {
+    let t = Dn(n);
+    return e(...t.map((r) => e(...r)));
+  } else return e(...n);
+}
+function X(e) {
+  let t = e.nodes().map((r) => {
+    let o = e.node(r).rank;
+    return o === void 0 ? Number.MIN_VALUE : o;
+  });
+  return L(Math.max, t);
+}
+function Ce(e, n) {
+  let t = { lhs: [], rhs: [] };
+  return e.forEach((r) => {
+    n(r) ? t.lhs.push(r) : t.rhs.push(r);
+  }), t;
+}
+function P(e, n) {
+  let t = Date.now();
+  try {
+    return n();
+  } finally {
+    console.log(e + " time: " + (Date.now() - t) + "ms");
+  }
+}
+function M(e, n) {
+  return n();
+}
+function j(e) {
+  let n = ++An;
+  return e + ("" + n);
+}
+function k(e, n, t = 1) {
+  n == null && (n = e, e = 0);
+  let r = (i) => i < n;
+  t < 0 && (r = (i) => n < i);
+  let o = [];
+  for (let i = e; r(i); i += t) o.push(i);
+  return o;
+}
+function T(e, n) {
+  let t = {};
+  for (let r of n) e[r] !== void 0 && (t[r] = e[r]);
+  return t;
+}
+function O(e, n) {
+  let t;
+  return typeof n == "string" ? t = (r) => r[n] : t = n, Object.entries(e).reduce((r, [o, i]) => (r[o] = t(i, o), r), {});
+}
+function Re(e, n) {
+  return e.reduce((t, r, o) => (t[r] = n[o], t), {});
+}
+function Pe(e) {
+  e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
+}
+function Vn(e, n) {
+  if (e !== "_next" && e !== "_prev") return n;
+}
+function Q(e, n) {
+  if (e.nodeCount() <= 1) return [];
+  let t = Yn(e, n || Wn);
+  return Bn(t.graph, t.buckets, t.zeroIdx).flatMap((o) => e.outEdges(o.v, o.w) || []);
+}
+function Bn(e, n, t) {
+  var a;
+  let r = [], o = n[n.length - 1], i = n[0], s;
+  for (; e.nodeCount(); ) {
+    for (; s = i.dequeue(); ) $(e, n, t, s);
+    for (; s = o.dequeue(); ) $(e, n, t, s);
+    if (e.nodeCount()) {
+      for (let d = n.length - 2; d > 0; --d) if (s = (a = n[d]) == null ? void 0 : a.dequeue(), s) {
+        r = r.concat($(e, n, t, s, true) || []);
+        break;
+      }
+    }
+  }
+  return r;
+}
+function $(e, n, t, r, o) {
+  let i = [], s = o ? i : void 0;
+  return (e.inEdges(r.v) || []).forEach((a) => {
+    let d = e.edge(a), l = e.node(a.v);
+    o && i.push({ v: a.v, w: a.w }), l.out -= d, J(n, t, l);
+  }), (e.outEdges(r.v) || []).forEach((a) => {
+    let d = e.edge(a), l = a.w, u = e.node(l);
+    u.in -= d, J(n, t, u);
+  }), e.removeNode(r.v), s;
+}
+function Yn(e, n) {
+  let t = new p(), r = 0, o = 0;
+  e.nodes().forEach((a) => {
+    t.setNode(a, { v: a, in: 0, out: 0 });
+  }), e.edges().forEach((a) => {
+    let d = t.edge(a.v, a.w) || 0, l = n(a), u = d + l;
+    t.setEdge(a.v, a.w, u);
+    let c = t.node(a.v), h = t.node(a.w);
+    o = Math.max(o, c.out += l), r = Math.max(r, h.in += l);
+  });
+  let i = zn(o + r + 3).map(() => new Me()), s = r + 1;
+  return t.nodes().forEach((a) => {
+    J(i, s, t.node(a));
+  }), { graph: t, buckets: i, zeroIdx: s };
+}
+function J(e, n, t) {
+  var r, o, i;
+  t.out ? t.in ? (i = e[t.out - t.in + n]) == null || i.enqueue(t) : (o = e[e.length - 1]) == null || o.enqueue(t) : (r = e[0]) == null || r.enqueue(t);
+}
+function zn(e) {
+  let n = [];
+  for (let t = 0; t < e; t++) n.push(t);
+  return n;
+}
+function je(e) {
+  (e.graph().acyclicer === "greedy" ? Q(e, t(e)) : Hn(e)).forEach((r) => {
+    let o = e.edge(r);
+    e.removeEdge(r), o.forwardName = r.name, o.reversed = true, e.setEdge(r.w, r.v, o, j("rev"));
+  });
+  function t(r) {
+    return (o) => r.edge(o).weight;
+  }
+}
+function Hn(e) {
+  let n = [], t = {}, r = {};
+  function o(i) {
+    Object.hasOwn(r, i) || (r[i] = true, t[i] = true, e.outEdges(i).forEach((s) => {
+      Object.hasOwn(t, s.w) ? n.push(s) : o(s.w);
+    }), delete t[i]);
+  }
+  return e.nodes().forEach(o), n;
+}
+function Se(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    if (t.reversed) {
+      e.removeEdge(n);
+      let r = t.forwardName;
+      delete t.reversed, delete t.forwardName, e.setEdge(n.w, n.v, t, r);
+    }
+  });
+}
+function Fe(e) {
+  e.graph().dummyChains = [], e.edges().forEach((n) => Xn(e, n));
+}
+function Xn(e, n) {
+  let t = n.v, r = e.node(t).rank, o = n.w, i = e.node(o).rank, s = n.name, a = e.edge(n), d = a.labelRank;
+  if (i === r + 1) return;
+  e.removeEdge(n);
+  let l, u, c;
+  for (c = 0, ++r; r < i; ++c, ++r) a.points = [], u = { width: 0, height: 0, edgeLabel: a, edgeObj: n, rank: r }, l = w(e, "edge", u, "_d"), r === d && (u.width = a.width, u.height = a.height, u.dummy = "edge-label", u.labelpos = a.labelpos), e.setEdge(t, l, { weight: a.weight }, s), c === 0 && e.graph().dummyChains.push(l), t = l;
+  e.setEdge(t, o, { weight: a.weight }, s);
+}
+function De(e) {
+  e.graph().dummyChains.forEach((n) => {
+    let t = e.node(n), r = t.edgeLabel, o;
+    for (e.setEdge(t.edgeObj, r); t.dummy; ) o = e.successors(n)[0], e.removeNode(n), r.points.push({ x: t.x, y: t.y }), t.dummy === "edge-label" && (r.x = t.x, r.y = t.y, r.width = t.width, r.height = t.height), n = o, t = e.node(n);
+  });
+}
+function S(e) {
+  let n = {};
+  function t(r) {
+    let o = e.node(r);
+    if (Object.hasOwn(n, r)) return o.rank;
+    n[r] = true;
+    let i = e.outEdges(r), s = i ? i.map((d) => d == null ? Number.POSITIVE_INFINITY : t(d.w) - e.edge(d).minlen) : [], a = L(Math.min, s);
+    return a === Number.POSITIVE_INFINITY && (a = 0), o.rank = a;
+  }
+  e.sources().forEach(t);
+}
+function v(e, n) {
+  return e.node(n.w).rank - e.node(n.v).rank - e.edge(n).minlen;
+}
+function Kn(e) {
+  let n = new p({ directed: false }), t = e.nodes();
+  if (t.length === 0) throw new Error("Graph must have at least one node");
+  let r = t[0], o = e.nodeCount();
+  n.setNode(r, {});
+  let i, s;
+  for (; $n(n, e) < o && (i = Jn(n, e), !!i); ) s = n.hasNode(i.v) ? v(e, i) : -v(e, i), Qn(n, e, s);
+  return n;
+}
+function $n(e, n) {
+  function t(r) {
+    let o = n.nodeEdges(r);
+    o && o.forEach((i) => {
+      let s = i.v, a = r === s ? i.w : s;
+      !e.hasNode(a) && !v(n, i) && (e.setNode(a, {}), e.setEdge(r, a, {}), t(a));
+    });
+  }
+  return e.nodes().forEach(t), e.nodeCount();
+}
+function Jn(e, n) {
+  return n.edges().reduce((r, o) => {
+    let i = Number.POSITIVE_INFINITY;
+    return e.hasNode(o.v) !== e.hasNode(o.w) && (i = v(n, o)), i < r[0] ? [i, o] : r;
+  }, [Number.POSITIVE_INFINITY, null])[1];
+}
+function Qn(e, n, t) {
+  e.nodes().forEach((r) => n.node(r).rank += t);
+}
+function x(e) {
+  e = xe(e), S(e);
+  let n = V(e);
+  ee(n), Z(n, e);
+  let t, r;
+  for (; t = Ye(n); ) r = ze(n, e, t), He(n, e, t, r);
+}
+function Z(e, n) {
+  let t = et(e, e.nodes());
+  t = t.slice(0, t.length - 1), t.forEach((r) => nt(e, n, r));
+}
+function nt(e, n, t) {
+  let o = e.node(t).parent, i = e.edge(t, o);
+  i.cutvalue = We(e, n, t);
+}
+function We(e, n, t) {
+  let o = e.node(t).parent, i = true, s = n.edge(t, o), a = 0;
+  s || (i = false, s = n.edge(o, t)), a = s.weight;
+  let d = n.nodeEdges(t);
+  return d && d.forEach((l) => {
+    let u = l.v === t, c = u ? l.w : l.v;
+    if (c !== o) {
+      let h = u === i, f = n.edge(l).weight;
+      if (a += h ? f : -f, rt(e, t, c)) {
+        let b = e.edge(t, c).cutvalue;
+        a += h ? -b : b;
+      }
+    }
+  }), a;
+}
+function ee(e, n) {
+  arguments.length < 2 && (n = e.nodes()[0]), Be(e, {}, 1, n);
+}
+function Be(e, n, t, r, o) {
+  let i = t, s = e.node(r);
+  n[r] = true;
+  let a = e.neighbors(r);
+  return a && a.forEach((d) => {
+    Object.hasOwn(n, d) || (t = Be(e, n, t, d, r));
+  }), s.low = i, s.lim = t++, o ? s.parent = o : delete s.parent, t;
+}
+function Ye(e) {
+  return e.edges().find((n) => e.edge(n).cutvalue < 0);
+}
+function ze(e, n, t) {
+  let r = t.v, o = t.w;
+  n.hasEdge(r, o) || (r = t.w, o = t.v);
+  let i = e.node(r), s = e.node(o), a = i, d = false;
+  return i.lim > s.lim && (a = s, d = true), n.edges().filter((u) => d === Ae(e, e.node(u.v), a) && d !== Ae(e, e.node(u.w), a)).reduce((u, c) => v(n, c) < v(n, u) ? c : u);
+}
+function He(e, n, t, r) {
+  let o = t.v, i = t.w;
+  e.removeEdge(o, i), e.setEdge(r.v, r.w, {}), ee(e), Z(e, n), tt(e, n);
+}
+function tt(e, n) {
+  let t = e.nodes().find((o) => !e.node(o).parent);
+  if (!t) return;
+  let r = Zn(e, [t]);
+  r = r.slice(1), r.forEach((o) => {
+    let s = e.node(o).parent, a = n.edge(o, s), d = false;
+    a || (a = n.edge(s, o), d = true), n.node(o).rank = n.node(s).rank + (d ? a.minlen : -a.minlen);
+  });
+}
+function rt(e, n, t) {
+  return e.hasEdge(n, t);
+}
+function Ae(e, n, t) {
+  return t.low <= n.lim && n.lim <= t.lim;
+}
+function ot(e) {
+  let n = e.graph().ranker;
+  if (typeof n == "function") return n(e);
+  switch (n) {
+    case "network-simplex":
+      qe(e);
+      break;
+    case "tight-tree":
+      st(e);
+      break;
+    case "longest-path":
+      it(e);
+      break;
+    case "none":
+      break;
+    default:
+      qe(e);
+  }
+}
+function st(e) {
+  S(e), V(e);
+}
+function qe(e) {
+  Ve(e);
+}
+function at(e) {
+  let n = lt(e);
+  e.graph().dummyChains.forEach((t) => {
+    let r = e.node(t), o = r.edgeObj, i = dt(e, n, o.v, o.w), s = i.path, a = i.lca, d = 0, l = s[d], u = true;
+    for (; t !== o.w; ) {
+      if (r = e.node(t), u) {
+        for (; (l = s[d]) !== a && e.node(l).maxRank < r.rank; ) d++;
+        l === a && (u = false);
+      }
+      if (!u) {
+        for (; d < s.length - 1 && e.node(s[d + 1]).minRank <= r.rank; ) d++;
+        l = s[d];
+      }
+      l !== void 0 && e.setParent(t, l), t = e.successors(t)[0];
+    }
+  });
+}
+function dt(e, n, t, r) {
+  let o = [], i = [], s = Math.min(n[t].low, n[r].low), a = Math.max(n[t].lim, n[r].lim), d;
+  d = t;
+  do
+    d = e.parent(d), o.push(d);
+  while (d && (n[d].low > s || a > n[d].lim));
+  let l = d, u = r;
+  for (; (u = e.parent(u)) !== l; ) i.push(u);
+  return { path: o.concat(i.reverse()), lca: l };
+}
+function lt(e) {
+  let n = {}, t = 0;
+  function r(o) {
+    let i = t;
+    e.children(o).forEach(r), n[o] = { low: i, lim: t++ };
+  }
+  return e.children(_).forEach(r), n;
+}
+function Ke(e) {
+  let n = w(e, "root", {}, "_root"), t = ut(e), r = Object.values(t), o = L(Math.max, r) - 1, i = 2 * o + 1;
+  e.graph().nestingRoot = n, e.edges().forEach((a) => e.edge(a).minlen *= i);
+  let s = ct(e) + 1;
+  e.children(_).forEach((a) => $e(e, n, i, s, o, t, a)), e.graph().nodeRankFactor = i;
+}
+function $e(e, n, t, r, o, i, s) {
+  var c;
+  let a = e.children(s);
+  if (!a.length) {
+    s !== n && e.setEdge(n, s, { weight: 0, minlen: t });
+    return;
+  }
+  let d = q(e, "_bt"), l = q(e, "_bb"), u = e.node(s);
+  e.setParent(d, s), u.borderTop = d, e.setParent(l, s), u.borderBottom = l, a.forEach((h) => {
+    var y;
+    $e(e, n, t, r, o, i, h);
+    let f = e.node(h), g = f.borderTop ? f.borderTop : h, b = f.borderBottom ? f.borderBottom : h, m = f.borderTop ? r : 2 * r, E = g !== b ? 1 : o - ((y = i[s]) != null ? y : 0) + 1;
+    e.setEdge(d, g, { weight: m, minlen: E, nestingEdge: true }), e.setEdge(b, l, { weight: m, minlen: E, nestingEdge: true });
+  }), e.parent(s) || e.setEdge(n, d, { weight: 0, minlen: o + ((c = i[s]) != null ? c : 0) });
+}
+function ut(e) {
+  let n = {};
+  function t(r, o) {
+    let i = e.children(r);
+    i && i.length && i.forEach((s) => t(s, o + 1)), n[r] = o;
+  }
+  return e.children(_).forEach((r) => t(r, 1)), n;
+}
+function ct(e) {
+  return e.edges().reduce((n, t) => n + e.edge(t).weight, 0);
+}
+function Je(e) {
+  let n = e.graph();
+  e.removeNode(n.nestingRoot), delete n.nestingRoot, e.edges().forEach((t) => {
+    e.edge(t).nestingEdge && e.removeEdge(t);
+  });
+}
+function ft(e) {
+  function n(t) {
+    let r = e.children(t), o = e.node(t);
+    if (r.length && r.forEach(n), Object.hasOwn(o, "minRank")) {
+      o.borderLeft = [], o.borderRight = [];
+      for (let i = o.minRank, s = o.maxRank + 1; i < s; ++i) Qe(e, "borderLeft", "_bl", t, o, i), Qe(e, "borderRight", "_br", t, o, i);
+    }
+  }
+  e.children(_).forEach(n);
+}
+function Qe(e, n, t, r, o, i) {
+  let s = { width: 0, height: 0, rank: i, borderType: n }, a = o[n][i - 1], d = w(e, "border", s, t);
+  o[n][i] = d, e.setParent(d, r), a && e.setEdge(a, d, { weight: 1 });
+}
+function nn(e) {
+  var t;
+  let n = (t = e.graph().rankdir) == null ? void 0 : t.toLowerCase();
+  (n === "lr" || n === "rl") && rn(e);
+}
+function tn(e) {
+  var t;
+  let n = (t = e.graph().rankdir) == null ? void 0 : t.toLowerCase();
+  (n === "bt" || n === "rl") && bt(e), (n === "lr" || n === "rl") && (gt(e), rn(e));
+}
+function rn(e) {
+  e.nodes().forEach((n) => en(e.node(n))), e.edges().forEach((n) => en(e.edge(n)));
+}
+function en(e) {
+  let n = e.width;
+  e.width = e.height, e.height = n;
+}
+function bt(e) {
+  e.nodes().forEach((n) => ne(e.node(n))), e.edges().forEach((n) => {
+    var r;
+    let t = e.edge(n);
+    (r = t.points) == null || r.forEach(ne), Object.hasOwn(t, "y") && ne(t);
+  });
+}
+function ne(e) {
+  e.y = -e.y;
+}
+function gt(e) {
+  e.nodes().forEach((n) => te(e.node(n))), e.edges().forEach((n) => {
+    var r;
+    let t = e.edge(n);
+    (r = t.points) == null || r.forEach(te), Object.hasOwn(t, "x") && te(t);
+  });
+}
+function te(e) {
+  let n = e.x;
+  e.x = e.y, e.y = n;
+}
+function re(e) {
+  let n = {}, t = e.nodes().filter((d) => !e.children(d).length), r = t.map((d) => e.node(d).rank), o = L(Math.max, r), i = k(o + 1).map(() => []);
+  function s(d) {
+    if (n[d]) return;
+    n[d] = true;
+    let l = e.node(d);
+    i[l.rank].push(d);
+    let u = e.successors(d);
+    u && u.forEach(s);
+  }
+  return t.sort((d, l) => e.node(d).rank - e.node(l).rank).forEach(s), i;
+}
+function oe(e, n) {
+  let t = 0;
+  for (let r = 1; r < n.length; ++r) t += mt(e, n[r - 1], n[r]);
+  return t;
+}
+function mt(e, n, t) {
+  let r = Re(t, t.map((l, u) => u)), o = n.flatMap((l) => {
+    let u = e.outEdges(l);
+    return u ? u.map((c) => ({ pos: r[c.w], weight: e.edge(c).weight })).sort((c, h) => c.pos - h.pos) : [];
+  }), i = 1;
+  for (; i < t.length; ) i <<= 1;
+  let s = 2 * i - 1;
+  i -= 1;
+  let a = new Array(s).fill(0), d = 0;
+  return o.forEach((l) => {
+    let u = l.pos + i;
+    a[u] += l.weight;
+    let c = 0;
+    for (; u > 0; ) u % 2 && (c += a[u + 1]), u = u - 1 >> 1, a[u] += l.weight;
+    d += l.weight * c;
+  }), d;
+}
+function ie(e, n = []) {
+  return n.map((t) => {
+    let r = e.inEdges(t);
+    if (!r || !r.length) return { v: t };
+    {
+      let o = r.reduce((i, s) => {
+        let a = e.edge(s), d = e.node(s.v);
+        return { sum: i.sum + a.weight * d.order, weight: i.weight + a.weight };
+      }, { sum: 0, weight: 0 });
+      return { v: t, barycenter: o.sum / o.weight, weight: o.weight };
+    }
+  });
+}
+function se(e, n) {
+  let t = {};
+  e.forEach((o, i) => {
+    let s = { indegree: 0, in: [], out: [], vs: [o.v], i };
+    o.barycenter !== void 0 && (s.barycenter = o.barycenter, s.weight = o.weight), t[o.v] = s;
+  }), n.edges().forEach((o) => {
+    let i = t[o.v], s = t[o.w];
+    i !== void 0 && s !== void 0 && (s.indegree++, i.out.push(s));
+  });
+  let r = Object.values(t).filter((o) => !o.indegree);
+  return Et(r);
+}
+function Et(e) {
+  let n = [];
+  function t(o) {
+    return (i) => {
+      i.merged || (i.barycenter === void 0 || o.barycenter === void 0 || i.barycenter >= o.barycenter) && Lt(o, i);
+    };
+  }
+  function r(o) {
+    return (i) => {
+      i.in.push(o), --i.indegree === 0 && e.push(i);
+    };
+  }
+  for (; e.length; ) {
+    let o = e.pop();
+    n.push(o), o.in.reverse().forEach(t(o)), o.out.forEach(r(o));
+  }
+  return n.filter((o) => !o.merged).map((o) => T(o, ["vs", "i", "barycenter", "weight"]));
+}
+function Lt(e, n) {
+  let t = 0, r = 0;
+  e.weight && (t += e.barycenter * e.weight, r += e.weight), n.weight && (t += n.barycenter * n.weight, r += n.weight), e.vs = n.vs.concat(e.vs), e.barycenter = t / r, e.weight = r, e.i = Math.min(n.i, e.i), n.merged = true;
+}
+function ae(e, n) {
+  let t = Ce(e, (u) => Object.hasOwn(u, "barycenter")), r = t.lhs, o = t.rhs.sort((u, c) => c.i - u.i), i = [], s = 0, a = 0, d = 0;
+  r.sort(yt(!!n)), d = on(i, o, d), r.forEach((u) => {
+    d += u.vs.length, i.push(u.vs), s += u.barycenter * u.weight, a += u.weight, d = on(i, o, d);
+  });
+  let l = { vs: i.flat(1) };
+  return a && (l.barycenter = s / a, l.weight = a), l;
+}
+function on(e, n, t) {
+  let r;
+  for (; n.length && (r = n[n.length - 1]).i <= t; ) n.pop(), e.push(r.vs), t++;
+  return t;
+}
+function yt(e) {
+  return (n, t) => n.barycenter < t.barycenter ? -1 : n.barycenter > t.barycenter ? 1 : e ? t.i - n.i : n.i - t.i;
+}
+function W(e, n, t, r) {
+  let o = e.children(n), i = e.node(n), s = i ? i.borderLeft : void 0, a = i ? i.borderRight : void 0, d = {};
+  s && (o = o.filter((h) => h !== s && h !== a));
+  let l = ie(e, o);
+  l.forEach((h) => {
+    if (e.children(h.v).length) {
+      let f = W(e, h.v, t, r);
+      d[h.v] = f, Object.hasOwn(f, "barycenter") && Nt(h, f);
+    }
+  });
+  let u = se(l, t);
+  wt(u, d);
+  let c = ae(u, r);
+  if (s && a) {
+    c.vs = [s, c.vs, a].flat(1);
+    let h = e.predecessors(s);
+    if (h && h.length) {
+      let f = e.node(h[0]), g = e.predecessors(a), b = e.node(g[0]);
+      Object.hasOwn(c, "barycenter") || (c.barycenter = 0, c.weight = 0), c.barycenter = (c.barycenter * c.weight + f.order + b.order) / (c.weight + 2), c.weight += 2;
+    }
+  }
+  return c;
+}
+function wt(e, n) {
+  e.forEach((t) => {
+    t.vs = t.vs.flatMap((r) => n[r] ? n[r].vs : r);
+  });
+}
+function Nt(e, n) {
+  e.barycenter !== void 0 ? (e.barycenter = (e.barycenter * e.weight + n.barycenter * n.weight) / (e.weight + n.weight), e.weight += n.weight) : (e.barycenter = n.barycenter, e.weight = n.weight);
+}
+function de(e, n, t, r) {
+  r || (r = e.nodes());
+  let o = Gt(e), i = new p({ compound: true }).setGraph({ root: o }).setDefaultNodeLabel((s) => e.node(s));
+  return r.forEach((s) => {
+    let a = e.node(s), d = e.parent(s);
+    if (a.rank === n || a.minRank <= n && n <= a.maxRank) {
+      i.setNode(s), i.setParent(s, d || o);
+      let l = e[t](s);
+      l && l.forEach((u) => {
+        let c = u.v === s ? u.w : u.v, h = i.edge(c, s), f = h !== void 0 ? h.weight : 0;
+        i.setEdge(c, s, { weight: e.edge(u).weight + f });
+      }), Object.hasOwn(a, "minRank") && i.setNode(s, { borderLeft: a.borderLeft[n], borderRight: a.borderRight[n] });
+    }
+  }), i;
+}
+function Gt(e) {
+  let n;
+  for (; e.hasNode(n = j("_root")); ) ;
+  return n;
+}
+function le(e, n, t) {
+  let r = {}, o;
+  t.forEach((i) => {
+    let s = e.parent(i), a, d;
+    for (; s; ) {
+      if (a = e.parent(s), a ? (d = r[a], r[a] = s) : (d = o, o = s), d && d !== s) {
+        n.setEdge(d, s);
+        return;
+      }
+      s = a;
+    }
+  });
+}
+function B(e, n = {}) {
+  if (typeof n.customOrder == "function") {
+    n.customOrder(e, B);
+    return;
+  }
+  let t = X(e), r = sn(e, k(1, t + 1), "inEdges"), o = sn(e, k(t - 1, -1, -1), "outEdges"), i = re(e);
+  if (an(e, i), n.disableOptimalOrderHeuristic) return;
+  let s = Number.POSITIVE_INFINITY, a, d = n.constraints || [];
+  for (let l = 0, u = 0; u < 4; ++l, ++u) {
+    kt(l % 2 ? r : o, l % 4 >= 2, d), i = N(e);
+    let c = oe(e, i);
+    c < s ? (u = 0, a = Object.assign({}, i), s = c) : c === s && (a = structuredClone(i));
+  }
+  an(e, a);
+}
+function sn(e, n, t) {
+  let r = /* @__PURE__ */ new Map(), o = (i, s) => {
+    r.has(i) || r.set(i, []), r.get(i).push(s);
+  };
+  for (let i of e.nodes()) {
+    let s = e.node(i);
+    if (typeof s.rank == "number" && o(s.rank, i), typeof s.minRank == "number" && typeof s.maxRank == "number") for (let a = s.minRank; a <= s.maxRank; a++) a !== s.rank && o(a, i);
+  }
+  return n.map(function(i) {
+    return de(e, i, t, r.get(i) || []);
+  });
+}
+function kt(e, n, t) {
+  let r = new p();
+  e.forEach(function(o) {
+    t.forEach((a) => r.setEdge(a.left, a.right));
+    let i = o.graph().root, s = W(o, i, r, n);
+    s.vs.forEach((a, d) => o.node(a).order = d), le(o, r, s.vs);
+  });
+}
+function an(e, n) {
+  Object.values(n).forEach((t) => t.forEach((r, o) => e.node(r).order = o));
+}
+function vt(e, n) {
+  let t = {};
+  function r(o, i) {
+    let s = 0, a = 0, d = o.length, l = i[i.length - 1];
+    return i.forEach((u, c) => {
+      let h = xt(e, u), f = h ? e.node(h).order : d;
+      (h || u === l) && (i.slice(a, c + 1).forEach((g) => {
+        let b = e.predecessors(g);
+        b && b.forEach((m) => {
+          let E = e.node(m), y = E.order;
+          (y < s || f < y) && !(E.dummy && e.node(g).dummy) && dn(t, m, g);
+        });
+      }), a = c + 1, s = f);
+    }), i;
+  }
+  return n.length && n.reduce(r), t;
+}
+function _t(e, n) {
+  let t = {};
+  function r(i, s, a, d, l) {
+    k(s, a).forEach((u) => {
+      let c = i[u];
+      if (c !== void 0 && e.node(c).dummy) {
+        let h = e.predecessors(c);
+        h && h.forEach((f) => {
+          if (f === void 0) return;
+          let g = e.node(f);
+          g.dummy && (g.order < d || g.order > l) && dn(t, f, c);
+        });
+      }
+    });
+  }
+  function o(i, s) {
+    let a = -1, d = -1, l = 0;
+    return s.forEach((u, c) => {
+      if (e.node(u).dummy === "border") {
+        let h = e.predecessors(u);
+        if (h && h.length) {
+          let f = h[0];
+          if (f === void 0) return;
+          d = e.node(f).order, r(s, l, c, a, d), l = c, a = d;
+        }
+      }
+      r(s, l, s.length, d, i.length);
+    }), s;
+  }
+  return n.length && n.reduce(o), t;
+}
+function xt(e, n) {
+  if (e.node(n).dummy) {
+    let t = e.predecessors(n);
+    if (t) return t.find((r) => e.node(r).dummy);
+  }
+}
+function dn(e, n, t) {
+  if (n > t) {
+    let o = n;
+    n = t, t = o;
+  }
+  let r = e[n];
+  r || (e[n] = r = {}), r[t] = true;
+}
+function Tt(e, n, t) {
+  if (n > t) {
+    let o = n;
+    n = t, t = o;
+  }
+  let r = e[n];
+  return r !== void 0 && Object.hasOwn(r, t);
+}
+function Ot(e, n, t, r) {
+  let o = {}, i = {}, s = {};
+  return n.forEach((a) => {
+    a.forEach((d, l) => {
+      o[d] = d, i[d] = d, s[d] = l;
+    });
+  }), n.forEach((a) => {
+    let d = -1;
+    a.forEach((l) => {
+      let u = r(l);
+      if (u && u.length) {
+        let c = u.sort((f, g) => {
+          let b = s[f], m = s[g];
+          return (b !== void 0 ? b : 0) - (m !== void 0 ? m : 0);
+        }), h = (c.length - 1) / 2;
+        for (let f = Math.floor(h), g = Math.ceil(h); f <= g; ++f) {
+          let b = c[f];
+          if (b === void 0) continue;
+          let m = s[b];
+          if (m !== void 0 && i[l] === l && d < m && !Tt(t, l, b)) {
+            let E = o[b];
+            E !== void 0 && (i[b] = l, i[l] = o[l] = E, d = m);
+          }
+        }
+      }
+    });
+  }), { root: o, align: i };
+}
+function It(e, n, t, r, o = false) {
+  let i = {}, s = Ct(e, n, t, o), a = o ? "borderLeft" : "borderRight";
+  function d(f, g) {
+    let b = s.nodes().slice(), m = {}, E = b.pop();
+    for (; E; ) {
+      if (m[E]) f(E);
+      else {
+        m[E] = true, b.push(E);
+        for (let y of g(E)) b.push(y);
+      }
+      E = b.pop();
+    }
+  }
+  function l(f) {
+    let g = s.inEdges(f);
+    g ? i[f] = g.reduce((b, m) => {
+      var I;
+      let E = (I = i[m.v]) != null ? I : 0, y = s.edge(m);
+      return Math.max(b, E + (y !== void 0 ? y : 0));
+    }, 0) : i[f] = 0;
+  }
+  function u(f) {
+    let g = s.outEdges(f), b = Number.POSITIVE_INFINITY;
+    g && (b = g.reduce((E, y) => {
+      let I = i[y.w], be = s.edge(y);
+      return Math.min(E, (I !== void 0 ? I : 0) - (be !== void 0 ? be : 0));
+    }, Number.POSITIVE_INFINITY));
+    let m = e.node(f);
+    b !== Number.POSITIVE_INFINITY && m.borderType !== a && (i[f] = Math.max(i[f] !== void 0 ? i[f] : 0, b));
+  }
+  function c(f) {
+    return s.predecessors(f) || [];
+  }
+  function h(f) {
+    return s.successors(f) || [];
+  }
+  return d(l, c), d(u, h), Object.keys(r).forEach((f) => {
+    var b;
+    let g = t[f];
+    g !== void 0 && (i[f] = (b = i[g]) != null ? b : 0);
+  }), i;
+}
+function Ct(e, n, t, r) {
+  let o = new p(), i = e.graph(), s = jt(i.nodesep, i.edgesep, r);
+  return n.forEach((a) => {
+    let d;
+    a.forEach((l) => {
+      let u = t[l];
+      if (u !== void 0) {
+        if (o.setNode(u), d !== void 0) {
+          let c = t[d];
+          if (c !== void 0) {
+            let h = o.edge(c, u);
+            o.setEdge(c, u, Math.max(s(e, l, d), h || 0));
+          }
+        }
+        d = l;
+      }
+    });
+  }), o;
+}
+function Rt(e, n) {
+  return Object.values(n).reduce((t, r) => {
+    let o = Number.NEGATIVE_INFINITY, i = Number.POSITIVE_INFINITY;
+    Object.entries(r).forEach(([a, d]) => {
+      let l = St(e, a) / 2;
+      o = Math.max(d + l, o), i = Math.min(d - l, i);
+    });
+    let s = o - i;
+    return s < t[0] && (t = [s, r]), t;
+  }, [Number.POSITIVE_INFINITY, null])[1];
+}
+function Pt(e, n) {
+  let t = Object.values(n), r = L(Math.min, t), o = L(Math.max, t);
+  ["u", "d"].forEach((i) => {
+    ["l", "r"].forEach((s) => {
+      let a = i + s, d = e[a];
+      if (!d || d === n) return;
+      let l = Object.values(d), u = r - L(Math.min, l);
+      s !== "l" && (u = o - L(Math.max, l)), u && (e[a] = O(d, (c) => c + u));
+    });
+  });
+}
+function Mt(e, n = void 0) {
+  let t = e.ul;
+  return t ? O(t, (r, o) => {
+    var s, a;
+    if (n) {
+      let d = n.toLowerCase(), l = e[d];
+      if (l && l[o] !== void 0) return l[o];
+    }
+    let i = Object.values(e).map((d) => {
+      let l = d[o];
+      return l !== void 0 ? l : 0;
+    }).sort((d, l) => d - l);
+    return (((s = i[1]) != null ? s : 0) + ((a = i[2]) != null ? a : 0)) / 2;
+  }) : {};
+}
+function ln(e) {
+  let n = N(e), t = Object.assign(vt(e, n), _t(e, n)), r = {}, o;
+  ["u", "d"].forEach((s) => {
+    o = s === "u" ? n : Object.values(n).reverse(), ["l", "r"].forEach((a) => {
+      a === "r" && (o = o.map((c) => Object.values(c).reverse()));
+      let l = Ot(e, o, t, (c) => (s === "u" ? e.predecessors(c) : e.successors(c)) || []), u = It(e, o, l.root, l.align, a === "r");
+      a === "r" && (u = O(u, (c) => -c)), r[s + a] = u;
+    });
+  });
+  let i = Rt(e, r);
+  return Pt(r, i), Mt(r, e.graph().align);
+}
+function jt(e, n, t) {
+  return (r, o, i) => {
+    let s = r.node(o), a = r.node(i), d = 0, l;
+    if (d += s.width / 2, Object.hasOwn(s, "labelpos")) switch (s.labelpos.toLowerCase()) {
+      case "l":
+        l = -s.width / 2;
+        break;
+      case "r":
+        l = s.width / 2;
+        break;
+    }
+    if (l && (d += t ? l : -l), l = void 0, d += (s.dummy ? n : e) / 2, d += (a.dummy ? n : e) / 2, d += a.width / 2, Object.hasOwn(a, "labelpos")) switch (a.labelpos.toLowerCase()) {
+      case "l":
+        l = a.width / 2;
+        break;
+      case "r":
+        l = -a.width / 2;
+        break;
+    }
+    return l && (d += t ? l : -l), d;
+  };
+}
+function St(e, n) {
+  return e.node(n).width;
+}
+function un(e) {
+  e = A(e), Ft(e), Object.entries(ln(e)).forEach(([n, t]) => e.node(n).x = t);
+}
+function Ft(e) {
+  let n = N(e), t = e.graph(), r = t.ranksep, o = t.rankalign, i = 0;
+  n.forEach((s) => {
+    let a = s.reduce((d, l) => {
+      var c;
+      let u = (c = e.node(l).height) != null ? c : 0;
+      return d > u ? d : u;
+    }, 0);
+    s.forEach((d) => {
+      let l = e.node(d);
+      o === "top" ? l.y = i + l.height / 2 : o === "bottom" ? l.y = i + a - l.height / 2 : l.y = i + a / 2;
+    }), i += a + r;
+  });
+}
+function he(e, n = {}) {
+  let t = n.debugTiming ? P : M;
+  return t("layout", () => {
+    let r = t("  buildLayoutGraph", () => Xt(e));
+    return t("  runLayout", () => Dt(r, t, n)), t("  updateInputGraph", () => At(e, r)), r;
+  });
+}
+function Dt(e, n, t) {
+  n("    makeSpaceForEdgeLabels", () => Ut(e)), n("    removeSelfEdges", () => rr(e)), n("    acyclic", () => je(e)), n("    nestingGraph.run", () => Ke(e)), n("    rank", () => Xe(A(e))), n("    injectEdgeLabelProxies", () => Kt(e)), n("    removeEmptyRanks", () => Oe(e)), n("    nestingGraph.cleanup", () => Je(e)), n("    normalizeRanks", () => Te(e)), n("    assignRankMinMax", () => $t(e)), n("    removeEdgeLabelProxies", () => Jt(e)), n("    normalize.run", () => Fe(e)), n("    parentDummyChains", () => Ue(e)), n("    addBorderSegments", () => Ze(e)), n("    order", () => B(e, t)), n("    insertSelfEdges", () => or(e)), n("    adjustCoordinateSystem", () => nn(e)), n("    position", () => un(e)), n("    positionSelfEdges", () => ir(e)), n("    removeBorderNodes", () => tr(e)), n("    normalize.undo", () => De(e)), n("    fixupEdgeLabelCoords", () => er(e)), n("    undoCoordinateSystem", () => tn(e)), n("    translateGraph", () => Qt(e)), n("    assignNodeIntersects", () => Zt(e)), n("    reversePoints", () => nr(e)), n("    acyclic.undo", () => Se(e));
+}
+function At(e, n) {
+  e.nodes().forEach((t) => {
+    let r = e.node(t), o = n.node(t);
+    r && (r.x = o.x, r.y = o.y, r.order = o.order, r.rank = o.rank, n.children(t).length && (r.width = o.width, r.height = o.height));
+  }), e.edges().forEach((t) => {
+    let r = e.edge(t), o = n.edge(t);
+    r.points = o.points, Object.hasOwn(o, "x") && (r.x = o.x, r.y = o.y);
+  }), e.graph().width = n.graph().width, e.graph().height = n.graph().height;
+}
+function Xt(e) {
+  let n = new p({ multigraph: true, compound: true }), t = ce(e.graph());
+  return n.setGraph(Object.assign({}, Wt, ue(t, Vt), T(t, Bt))), e.nodes().forEach((r) => {
+    let o = ce(e.node(r)), i = ue(o, Yt);
+    Object.keys(cn).forEach((a) => {
+      i[a] === void 0 && (i[a] = cn[a]);
+    }), n.setNode(r, i);
+    let s = e.parent(r);
+    s !== void 0 && n.setParent(r, s);
+  }), e.edges().forEach((r) => {
+    let o = ce(e.edge(r));
+    n.setEdge(r, Object.assign({}, Ht, ue(o, zt), T(o, qt)));
+  }), n;
+}
+function Ut(e) {
+  let n = e.graph();
+  n.ranksep /= 2, e.edges().forEach((t) => {
+    let r = e.edge(t);
+    r.minlen *= 2, r.labelpos.toLowerCase() !== "c" && (n.rankdir === "TB" || n.rankdir === "BT" ? r.width += r.labeloffset : r.height += r.labeloffset);
+  });
+}
+function Kt(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    if (t.width && t.height) {
+      let r = e.node(n.v), i = { rank: (e.node(n.w).rank - r.rank) / 2 + r.rank, e: n };
+      w(e, "edge-proxy", i, "_ep");
+    }
+  });
+}
+function $t(e) {
+  let n = 0;
+  e.nodes().forEach((t) => {
+    let r = e.node(t);
+    r.borderTop && (r.minRank = e.node(r.borderTop).rank, r.maxRank = e.node(r.borderBottom).rank, n = Math.max(n, r.maxRank));
+  }), e.graph().maxRank = n;
+}
+function Jt(e) {
+  e.nodes().forEach((n) => {
+    let t = e.node(n);
+    if (t.dummy === "edge-proxy") {
+      let r = t;
+      e.edge(r.e).labelRank = t.rank, e.removeNode(n);
+    }
+  });
+}
+function Qt(e) {
+  let n = Number.POSITIVE_INFINITY, t = 0, r = Number.POSITIVE_INFINITY, o = 0, i = e.graph(), s = i.marginx || 0, a = i.marginy || 0;
+  function d(l) {
+    let u = l.x, c = l.y, h = l.width, f = l.height;
+    n = Math.min(n, u - h / 2), t = Math.max(t, u + h / 2), r = Math.min(r, c - f / 2), o = Math.max(o, c + f / 2);
+  }
+  e.nodes().forEach((l) => d(e.node(l))), e.edges().forEach((l) => {
+    let u = e.edge(l);
+    Object.hasOwn(u, "x") && d(u);
+  }), n -= s, r -= a, e.nodes().forEach((l) => {
+    let u = e.node(l);
+    u.x -= n, u.y -= r;
+  }), e.edges().forEach((l) => {
+    let u = e.edge(l);
+    u.points.forEach((c) => {
+      c.x -= n, c.y -= r;
+    }), Object.hasOwn(u, "x") && (u.x -= n), Object.hasOwn(u, "y") && (u.y -= r);
+  }), i.width = t - n + s, i.height = o - r + a;
+}
+function Zt(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n), r = e.node(n.v), o = e.node(n.w), i, s;
+    t.points ? (i = t.points[0], s = t.points[t.points.length - 1]) : (t.points = [], i = o, s = r), t.points.unshift(H(r, i)), t.points.push(H(o, s));
+  });
+}
+function er(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    if (Object.hasOwn(t, "x")) switch ((t.labelpos === "l" || t.labelpos === "r") && (t.width -= t.labeloffset), t.labelpos) {
+      case "l":
+        t.x -= t.width / 2 + t.labeloffset;
+        break;
+      case "r":
+        t.x += t.width / 2 + t.labeloffset;
+        break;
+    }
+  });
+}
+function nr(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    t.reversed && t.points.reverse();
+  });
+}
+function tr(e) {
+  e.nodes().forEach((n) => {
+    if (e.children(n).length) {
+      let t = e.node(n), r = e.node(t.borderTop), o = e.node(t.borderBottom), i = e.node(t.borderLeft[t.borderLeft.length - 1]), s = e.node(t.borderRight[t.borderRight.length - 1]);
+      t.width = Math.abs(s.x - i.x), t.height = Math.abs(o.y - r.y), t.x = i.x + t.width / 2, t.y = r.y + t.height / 2;
+    }
+  }), e.nodes().forEach((n) => {
+    e.node(n).dummy === "border" && e.removeNode(n);
+  });
+}
+function rr(e) {
+  e.edges().forEach((n) => {
+    if (n.v === n.w) {
+      let t = e.node(n.v);
+      t.selfEdges || (t.selfEdges = []), t.selfEdges.push({ e: n, label: e.edge(n) }), e.removeEdge(n);
+    }
+  });
+}
+function or(e) {
+  N(e).forEach((t) => {
+    let r = 0;
+    t.forEach((o, i) => {
+      let s = e.node(o);
+      s.order = i + r, (s.selfEdges || []).forEach((a) => {
+        w(e, "selfedge", { width: a.label.width, height: a.label.height, rank: s.rank, order: i + ++r, e: a.e, label: a.label }, "_se");
+      }), delete s.selfEdges;
+    });
+  });
+}
+function ir(e) {
+  e.nodes().forEach((n) => {
+    let t = e.node(n);
+    if (t.dummy === "selfedge") {
+      let r = t, o = e.node(r.e.v), i = o.x + o.width / 2, s = o.y, a = t.x - i, d = o.height / 2;
+      e.setEdge(r.e, r.label), e.removeNode(n), r.label.points = [{ x: i + 2 * a / 3, y: s - d }, { x: i + 5 * a / 6, y: s - d }, { x: i + a, y: s }, { x: i + 5 * a / 6, y: s + d }, { x: i + 2 * a / 3, y: s + d }], r.label.x = t.x, r.label.y = t.y;
+    }
+  });
+}
+function ue(e, n) {
+  return O(T(e, n), Number);
+}
+function ce(e) {
+  let n = {};
+  return e && Object.entries(e).forEach(([t, r]) => {
+    typeof t == "string" && (t = t.toLowerCase()), n[t] = r;
+  }), n;
+}
+function fe(e) {
+  let n = N(e), t = new p({ compound: true, multigraph: true }).setGraph({});
+  return e.nodes().forEach((r) => {
+    t.setNode(r, { label: r }), t.setParent(r, "layer" + e.node(r).rank);
+  }), e.edges().forEach((r) => t.setEdge(r.v, r.w, {}, r.name)), n.forEach((r, o) => {
+    let i = "layer" + o;
+    t.setNode(i, { rank: "same" }), r.reduce((s, a) => (t.setEdge(s, a, { style: "invis" }), a));
+  }), t;
+}
+var ge, hn, fn, pe, z, bn, Le, p, pn, ye, R, wn, Ne, kn, Tn, D, Ie, An, _, U, K, Me, Wn, V, Zn, et, Ve, Xe, it, Ue, Ze, Vt, Wt, Bt, Yt, cn, zt, Ht, qt, sr, To;
+var init_dagre_esm = __esm({
+  "node_modules/@dagrejs/dagre/dist/dagre.esm.js"() {
+    ge = Object.defineProperty;
+    hn = (e, n, t) => n in e ? ge(e, n, { enumerable: true, configurable: true, writable: true, value: t }) : e[n] = t;
+    fn = (e, n) => {
+      for (var t in n) ge(e, t, { get: n[t], enumerable: true });
+    };
+    pe = (e, n, t) => hn(e, typeof n != "symbol" ? n + "" : n, t);
+    z = {};
+    fn(z, { Graph: () => p, alg: () => R, json: () => ye, version: () => pn });
+    bn = Object.defineProperty;
+    Le = (e, n) => {
+      for (var t in n) bn(e, t, { get: n[t], enumerable: true });
+    };
+    p = class {
+      constructor(e) {
+        this._isDirected = true, this._isMultigraph = false, this._isCompound = false, this._nodes = {}, this._in = {}, this._preds = {}, this._out = {}, this._sucs = {}, this._edgeObjs = {}, this._edgeLabels = {}, this._nodeCount = 0, this._edgeCount = 0, this._defaultNodeLabelFn = () => {
+        }, this._defaultEdgeLabelFn = () => {
+        }, e && (this._isDirected = "directed" in e ? e.directed : true, this._isMultigraph = "multigraph" in e ? e.multigraph : false, this._isCompound = "compound" in e ? e.compound : false), this._isCompound && (this._parent = {}, this._children = {}, this._children["\0"] = {});
+      }
+      isDirected() {
+        return this._isDirected;
+      }
+      isMultigraph() {
+        return this._isMultigraph;
+      }
+      isCompound() {
+        return this._isCompound;
+      }
+      setGraph(e) {
+        return this._label = e, this;
+      }
+      graph() {
+        return this._label;
+      }
+      setDefaultNodeLabel(e) {
+        return typeof e != "function" ? this._defaultNodeLabelFn = () => e : this._defaultNodeLabelFn = e, this;
+      }
+      nodeCount() {
+        return this._nodeCount;
+      }
+      nodes() {
+        return Object.keys(this._nodes);
+      }
+      sources() {
+        return this.nodes().filter((e) => Object.keys(this._in[e]).length === 0);
+      }
+      sinks() {
+        return this.nodes().filter((e) => Object.keys(this._out[e]).length === 0);
+      }
+      setNodes(e, n) {
+        return e.forEach((t) => {
+          n !== void 0 ? this.setNode(t, n) : this.setNode(t);
+        }), this;
+      }
+      setNode(e, n) {
+        return e in this._nodes ? (arguments.length > 1 && (this._nodes[e] = n), this) : (this._nodes[e] = arguments.length > 1 ? n : this._defaultNodeLabelFn(e), this._isCompound && (this._parent[e] = "\0", this._children[e] = {}, this._children["\0"][e] = true), this._in[e] = {}, this._preds[e] = {}, this._out[e] = {}, this._sucs[e] = {}, ++this._nodeCount, this);
+      }
+      node(e) {
+        return this._nodes[e];
+      }
+      hasNode(e) {
+        return e in this._nodes;
+      }
+      removeNode(e) {
+        if (e in this._nodes) {
+          let n = (t) => this.removeEdge(this._edgeObjs[t]);
+          delete this._nodes[e], this._isCompound && (this._removeFromParentsChildList(e), delete this._parent[e], this.children(e).forEach((t) => {
+            this.setParent(t);
+          }), delete this._children[e]), Object.keys(this._in[e]).forEach(n), delete this._in[e], delete this._preds[e], Object.keys(this._out[e]).forEach(n), delete this._out[e], delete this._sucs[e], --this._nodeCount;
+        }
+        return this;
+      }
+      setParent(e, n) {
+        if (!this._isCompound) throw new Error("Cannot set parent in a non-compound graph");
+        if (n === void 0) n = "\0";
+        else {
+          n += "";
+          for (let t = n; t !== void 0; t = this.parent(t)) if (t === e) throw new Error("Setting " + n + " as parent of " + e + " would create a cycle");
+          this.setNode(n);
+        }
+        return this.setNode(e), this._removeFromParentsChildList(e), this._parent[e] = n, this._children[n][e] = true, this;
+      }
+      parent(e) {
+        if (this._isCompound) {
+          let n = this._parent[e];
+          if (n !== "\0") return n;
+        }
+      }
+      children(e = "\0") {
+        if (this._isCompound) {
+          let n = this._children[e];
+          if (n) return Object.keys(n);
+        } else {
+          if (e === "\0") return this.nodes();
+          if (this.hasNode(e)) return [];
+        }
+        return [];
+      }
+      predecessors(e) {
+        let n = this._preds[e];
+        if (n) return Object.keys(n);
+      }
+      successors(e) {
+        let n = this._sucs[e];
+        if (n) return Object.keys(n);
+      }
+      neighbors(e) {
+        let n = this.predecessors(e);
+        if (n) {
+          let t = new Set(n);
+          for (let r of this.successors(e)) t.add(r);
+          return Array.from(t.values());
+        }
+      }
+      isLeaf(e) {
+        let n;
+        return this.isDirected() ? n = this.successors(e) : n = this.neighbors(e), n.length === 0;
+      }
+      filterNodes(e) {
+        let n = new this.constructor({ directed: this._isDirected, multigraph: this._isMultigraph, compound: this._isCompound });
+        n.setGraph(this.graph()), Object.entries(this._nodes).forEach(([o, i]) => {
+          e(o) && n.setNode(o, i);
+        }), Object.values(this._edgeObjs).forEach((o) => {
+          n.hasNode(o.v) && n.hasNode(o.w) && n.setEdge(o, this.edge(o));
+        });
+        let t = {}, r = (o) => {
+          let i = this.parent(o);
+          return !i || n.hasNode(i) ? (t[o] = i != null ? i : void 0, i != null ? i : void 0) : i in t ? t[i] : r(i);
+        };
+        return this._isCompound && n.nodes().forEach((o) => n.setParent(o, r(o))), n;
+      }
+      setDefaultEdgeLabel(e) {
+        return typeof e != "function" ? this._defaultEdgeLabelFn = () => e : this._defaultEdgeLabelFn = e, this;
+      }
+      edgeCount() {
+        return this._edgeCount;
+      }
+      edges() {
+        return Object.values(this._edgeObjs);
+      }
+      setPath(e, n) {
+        return e.reduce((t, r) => (n !== void 0 ? this.setEdge(t, r, n) : this.setEdge(t, r), r)), this;
+      }
+      setEdge(e, n, t, r) {
+        let o, i, s, a, d = false;
+        typeof e == "object" && e !== null && "v" in e ? (o = e.v, i = e.w, s = e.name, arguments.length === 2 && (a = n, d = true)) : (o = e, i = n, s = r, arguments.length > 2 && (a = t, d = true)), o = "" + o, i = "" + i, s !== void 0 && (s = "" + s);
+        let l = C(this._isDirected, o, i, s);
+        if (l in this._edgeLabels) return d && (this._edgeLabels[l] = a), this;
+        if (s !== void 0 && !this._isMultigraph) throw new Error("Cannot set a named edge when isMultigraph = false");
+        this.setNode(o), this.setNode(i), this._edgeLabels[l] = d ? a : this._defaultEdgeLabelFn(o, i, s);
+        let u = gn(this._isDirected, o, i, s);
+        return o = u.v, i = u.w, Object.freeze(u), this._edgeObjs[l] = u, me(this._preds[i], o), me(this._sucs[o], i), this._in[i][l] = u, this._out[o][l] = u, this._edgeCount++, this;
+      }
+      edge(e, n, t) {
+        let r = arguments.length === 1 ? Y(this._isDirected, e) : C(this._isDirected, e, n, t);
+        return this._edgeLabels[r];
+      }
+      edgeAsObj(e, n, t) {
+        let r = arguments.length === 1 ? this.edge(e) : this.edge(e, n, t);
+        return typeof r != "object" ? { label: r } : r;
+      }
+      hasEdge(e, n, t) {
+        return (arguments.length === 1 ? Y(this._isDirected, e) : C(this._isDirected, e, n, t)) in this._edgeLabels;
+      }
+      removeEdge(e, n, t) {
+        let r = arguments.length === 1 ? Y(this._isDirected, e) : C(this._isDirected, e, n, t), o = this._edgeObjs[r];
+        if (o) {
+          let i = o.v, s = o.w;
+          delete this._edgeLabels[r], delete this._edgeObjs[r], Ee(this._preds[s], i), Ee(this._sucs[i], s), delete this._in[s][r], delete this._out[i][r], this._edgeCount--;
+        }
+        return this;
+      }
+      inEdges(e, n) {
+        return this.isDirected() ? this.filterEdges(this._in[e], e, n) : this.nodeEdges(e, n);
+      }
+      outEdges(e, n) {
+        return this.isDirected() ? this.filterEdges(this._out[e], e, n) : this.nodeEdges(e, n);
+      }
+      nodeEdges(e, n) {
+        if (e in this._nodes) return this.filterEdges({ ...this._in[e], ...this._out[e] }, e, n);
+      }
+      _removeFromParentsChildList(e) {
+        delete this._children[this._parent[e]][e];
+      }
+      filterEdges(e, n, t) {
+        if (!e) return;
+        let r = Object.values(e);
+        return t ? r.filter((o) => o.v === n && o.w === t || o.v === t && o.w === n) : r;
+      }
+    };
+    pn = "4.0.1";
+    ye = {};
+    Le(ye, { read: () => yn, write: () => mn });
+    R = {};
+    Le(R, { CycleException: () => D, bellmanFord: () => we, components: () => Gn, dijkstra: () => F, dijkstraAll: () => _n, findCycles: () => xn, floydWarshall: () => On, isAcyclic: () => Cn, postorder: () => Pn, preorder: () => Mn, prim: () => jn, shortestPaths: () => Sn, tarjan: () => Ge, topsort: () => ke });
+    wn = () => 1;
+    Ne = class {
+      constructor() {
+        this._arr = [], this._keyIndices = {};
+      }
+      size() {
+        return this._arr.length;
+      }
+      keys() {
+        return this._arr.map((e) => e.key);
+      }
+      has(e) {
+        return e in this._keyIndices;
+      }
+      priority(e) {
+        let n = this._keyIndices[e];
+        if (n !== void 0) return this._arr[n].priority;
+      }
+      min() {
+        if (this.size() === 0) throw new Error("Queue underflow");
+        return this._arr[0].key;
+      }
+      add(e, n) {
+        let t = this._keyIndices, r = String(e);
+        if (!(r in t)) {
+          let o = this._arr, i = o.length;
+          return t[r] = i, o.push({ key: r, priority: n }), this._decrease(i), true;
+        }
+        return false;
+      }
+      removeMin() {
+        this._swap(0, this._arr.length - 1);
+        let e = this._arr.pop();
+        return delete this._keyIndices[e.key], this._heapify(0), e.key;
+      }
+      decrease(e, n) {
+        let t = this._keyIndices[e];
+        if (t === void 0) throw new Error(`Key not found: ${e}`);
+        let r = this._arr[t].priority;
+        if (n > r) throw new Error(`New priority is greater than current priority. Key: ${e} Old: ${r} New: ${n}`);
+        this._arr[t].priority = n, this._decrease(t);
+      }
+      _heapify(e) {
+        let n = this._arr, t = 2 * e, r = t + 1, o = e;
+        t < n.length && (o = n[t].priority < n[o].priority ? t : o, r < n.length && (o = n[r].priority < n[o].priority ? r : o), o !== e && (this._swap(e, o), this._heapify(o)));
+      }
+      _decrease(e) {
+        let n = this._arr, t = n[e].priority, r;
+        for (; e !== 0 && (r = e >> 1, !(n[r].priority < t)); ) this._swap(e, r), e = r;
+      }
+      _swap(e, n) {
+        let t = this._arr, r = this._keyIndices, o = t[e], i = t[n];
+        t[e] = i, t[n] = o, r[i.key] = e, r[o.key] = n;
+      }
+    };
+    kn = () => 1;
+    Tn = () => 1;
+    D = class extends Error {
+      constructor(...e) {
+        super(...e);
+      }
+    };
+    Ie = 65535;
+    An = 0;
+    _ = "\0";
+    U = "3.0.0";
+    K = class {
+      constructor() {
+        pe(this, "_sentinel");
+        let n = {};
+        n._next = n._prev = n, this._sentinel = n;
+      }
+      dequeue() {
+        let n = this._sentinel, t = n._prev;
+        if (t !== n) return Pe(t), t;
+      }
+      enqueue(n) {
+        let t = this._sentinel;
+        n._prev && n._next && Pe(n), n._next = t._next, t._next._prev = n, t._next = n, n._prev = t;
+      }
+      toString() {
+        let n = [], t = this._sentinel, r = t._prev;
+        for (; r !== t; ) n.push(JSON.stringify(r, Vn)), r = r._prev;
+        return "[" + n.join(", ") + "]";
+      }
+    };
+    Me = K;
+    Wn = () => 1;
+    V = Kn;
+    ({ preorder: Zn, postorder: et } = R);
+    Ve = x;
+    x.initLowLimValues = ee;
+    x.initCutValues = Z;
+    x.calcCutValue = We;
+    x.leaveEdge = Ye;
+    x.enterEdge = ze;
+    x.exchangeEdges = He;
+    Xe = ot;
+    it = S;
+    Ue = at;
+    Ze = ft;
+    Vt = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+    Wt = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "TB", rankalign: "center" };
+    Bt = ["acyclicer", "ranker", "rankdir", "align", "rankalign"];
+    Yt = ["width", "height", "rank"];
+    cn = { width: 0, height: 0 };
+    zt = ["minlen", "weight", "width", "height", "labeloffset"];
+    Ht = { minlen: 1, weight: 1, width: 0, height: 0, labeloffset: 10, labelpos: "r" };
+    qt = ["labelpos"];
+    sr = { graphlib: z, version: U, layout: he, debug: fe, util: { time: P, notime: M } };
+    To = sr;
+  }
+});
+
+// src/layout/index.ts
+var layout_exports = {};
+__export(layout_exports, {
+  autoLayout: () => autoLayout
+});
+function autoLayout(graph, options = {}) {
+  const dir = options.direction ?? "LR";
+  const nodesep = options.nodeSep ?? 48;
+  const ranksep = options.rankSep ?? 96;
+  const dw = options.defaultWidth ?? 180;
+  const dh = options.defaultHeight ?? 64;
+  const inScope = (n) => options.scope ? n.parentId === options.scope : !n.parentId;
+  const targets = graph.nodes.filter(inScope);
+  if (targets.length === 0) return graph.nodes;
+  const ids = new Set(targets.map((n) => n.id));
+  const g = new To.graphlib.Graph();
+  g.setGraph({ rankdir: dir, nodesep, ranksep });
+  g.setDefaultEdgeLabel(() => ({}));
+  for (const n of targets) {
+    g.setNode(n.id, { width: n.width ?? dw, height: n.height ?? dh });
+  }
+  for (const e of graph.edges) {
+    if (ids.has(e.source) && ids.has(e.target)) g.setEdge(e.source, e.target);
+  }
+  To.layout(g);
+  const pos = /* @__PURE__ */ new Map();
+  for (const n of targets) {
+    const d = g.node(n.id);
+    if (d) pos.set(n.id, { x: d.x - d.width / 2, y: d.y - d.height / 2 });
+  }
+  return graph.nodes.map((n) => {
+    const p2 = pos.get(n.id);
+    return p2 ? { ...n, position: p2 } : n;
+  });
+}
+var init_layout = __esm({
+  "src/layout/index.ts"() {
+    init_dagre_esm();
+  }
+});
 
 // src/registry/registry.ts
 var kinds = /* @__PURE__ */ new Map();
@@ -42,7 +1752,7 @@ function kindIds(kind) {
 }
 function listNodeKinds(category) {
   const all = Array.from(kinds.values());
-  return category ? all.filter((k) => k.category === category) : all;
+  return category ? all.filter((k2) => k2.category === category) : all;
 }
 function onNodeKindsChanged(listener) {
   listeners.add(listener);
@@ -127,10 +1837,10 @@ function validateField(field, value) {
         return `${field.label} must be a key/value map`;
       }
       const allowed = field.valueOptions?.map((o) => o.value);
-      for (const [k, v] of Object.entries(value)) {
-        if (typeof v !== "string") return `${field.label}: "${k}" must be a string`;
-        if (allowed && !allowed.includes(v)) {
-          return `${field.label}: "${k}" must be one of ${allowed.join(", ")}`;
+      for (const [k2, v2] of Object.entries(value)) {
+        if (typeof v2 !== "string") return `${field.label}: "${k2}" must be a string`;
+        if (allowed && !allowed.includes(v2)) {
+          return `${field.label}: "${k2}" must be one of ${allowed.join(", ")}`;
         }
       }
       return null;
@@ -182,9 +1892,9 @@ function getRichInputAdapter() {
 function isRichInputEnabled() {
   return adapter !== null && (adapter.renderDocument !== void 0 || adapter.renderEditor !== void 0);
 }
-function onRichInputAdapterChanged(fn) {
-  listeners2.add(fn);
-  return () => listeners2.delete(fn);
+function onRichInputAdapterChanged(fn2) {
+  listeners2.add(fn2);
+  return () => listeners2.delete(fn2);
 }
 function RichInputPreview({ config }) {
   const a = getRichInputAdapter();
@@ -225,8 +1935,8 @@ function cc(names) {
       }
     }
   } else {
-    for (let k in names) {
-      if (names[k]) out += (out && " ") + k;
+    for (let k2 in names) {
+      if (names[k2]) out += (out && " ") + k2;
     }
   }
   return out;
@@ -236,14 +1946,14 @@ function cc(names) {
 var noop = { value: () => {
 } };
 function dispatch() {
-  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {
-    if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
-    _[t] = [];
+  for (var i = 0, n = arguments.length, _2 = {}, t; i < n; ++i) {
+    if (!(t = arguments[i] + "") || t in _2 || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
+    _2[t] = [];
   }
-  return new Dispatch(_);
+  return new Dispatch(_2);
 }
-function Dispatch(_) {
-  this._ = _;
+function Dispatch(_2) {
+  this._ = _2;
 }
 function parseTypenames(typenames, types) {
   return typenames.trim().split(/^|\s+/).map(function(t) {
@@ -256,21 +1966,21 @@ function parseTypenames(typenames, types) {
 Dispatch.prototype = dispatch.prototype = {
   constructor: Dispatch,
   on: function(typename, callback) {
-    var _ = this._, T = parseTypenames(typename + "", _), t, i = -1, n = T.length;
+    var _2 = this._, T2 = parseTypenames(typename + "", _2), t, i = -1, n = T2.length;
     if (arguments.length < 2) {
-      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
+      while (++i < n) if ((t = (typename = T2[i]).type) && (t = get(_2[t], typename.name))) return t;
       return;
     }
     if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
     while (++i < n) {
-      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
-      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
+      if (t = (typename = T2[i]).type) _2[t] = set(_2[t], typename.name, callback);
+      else if (callback == null) for (t in _2) _2[t] = set(_2[t], typename.name, null);
     }
     return this;
   },
   copy: function() {
-    var copy = {}, _ = this._;
-    for (var t in _) copy[t] = _[t].slice();
+    var copy = {}, _2 = this._;
+    for (var t in _2) copy[t] = _2[t].slice();
     return new Dispatch(copy);
   },
   call: function(type, that) {
@@ -348,8 +2058,8 @@ function selector_default(selector2) {
 // node_modules/d3-selection/src/selection/select.js
 function select_default(select) {
   if (typeof select !== "function") select = selector_default(select);
-  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, subgroup = subgroups[j2] = new Array(n), node, subnode, i = 0; i < n; ++i) {
       if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
         if ("__data__" in node) subnode.__data__ = node.__data__;
         subgroup[i] = subnode;
@@ -360,8 +2070,8 @@ function select_default(select) {
 }
 
 // node_modules/d3-selection/src/array.js
-function array(x) {
-  return x == null ? [] : Array.isArray(x) ? x : Array.from(x);
+function array(x2) {
+  return x2 == null ? [] : Array.isArray(x2) ? x2 : Array.from(x2);
 }
 
 // node_modules/d3-selection/src/selectorAll.js
@@ -383,8 +2093,8 @@ function arrayAll(select) {
 function selectAll_default(select) {
   if (typeof select === "function") select = arrayAll(select);
   else select = selectorAll_default(select);
-  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, node, i = 0; i < n; ++i) {
       if (node = group[i]) {
         subgroups.push(select.call(node, node.__data__, i, group));
         parents.push(node);
@@ -437,8 +2147,8 @@ function selectChildren_default(match) {
 // node_modules/d3-selection/src/selection/filter.js
 function filter_default(match) {
   if (typeof match !== "function") match = matcher_default(match);
-  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, subgroup = subgroups[j2] = [], node, i = 0; i < n; ++i) {
       if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
         subgroup.push(node);
       }
@@ -480,9 +2190,9 @@ EnterNode.prototype = {
 };
 
 // node_modules/d3-selection/src/constant.js
-function constant_default(x) {
+function constant_default(x2) {
   return function() {
-    return x;
+    return x2;
   };
 }
 
@@ -538,8 +2248,8 @@ function data_default(value, key) {
   if (!arguments.length) return Array.from(this, datum);
   var bind = key ? bindKey : bindIndex, parents = this._parents, groups = this._groups;
   if (typeof value !== "function") value = constant_default(value);
-  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
-    var parent = parents[j], group = groups[j], groupLength = group.length, data = arraylike(value.call(parent, parent && parent.__data__, j, parents)), dataLength = data.length, enterGroup = enter[j] = new Array(dataLength), updateGroup = update[j] = new Array(dataLength), exitGroup = exit[j] = new Array(groupLength);
+  for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j2 = 0; j2 < m; ++j2) {
+    var parent = parents[j2], group = groups[j2], groupLength = group.length, data = arraylike(value.call(parent, parent && parent.__data__, j2, parents)), dataLength = data.length, enterGroup = enter[j2] = new Array(dataLength), updateGroup = update[j2] = new Array(dataLength), exitGroup = exit[j2] = new Array(groupLength);
     bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
     for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
       if (previous = enterGroup[i0]) {
@@ -584,23 +2294,23 @@ function join_default(onenter, onupdate, onexit) {
 // node_modules/d3-selection/src/selection/merge.js
 function merge_default(context) {
   var selection2 = context.selection ? context.selection() : context;
-  for (var groups0 = this._groups, groups1 = selection2._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
-    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
+  for (var groups0 = this._groups, groups1 = selection2._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j2 = 0; j2 < m; ++j2) {
+    for (var group0 = groups0[j2], group1 = groups1[j2], n = group0.length, merge = merges[j2] = new Array(n), node, i = 0; i < n; ++i) {
       if (node = group0[i] || group1[i]) {
         merge[i] = node;
       }
     }
   }
-  for (; j < m0; ++j) {
-    merges[j] = groups0[j];
+  for (; j2 < m0; ++j2) {
+    merges[j2] = groups0[j2];
   }
   return new Selection(merges, this._parents);
 }
 
 // node_modules/d3-selection/src/selection/order.js
 function order_default() {
-  for (var groups = this._groups, j = -1, m = groups.length; ++j < m; ) {
-    for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
+  for (var groups = this._groups, j2 = -1, m = groups.length; ++j2 < m; ) {
+    for (var group = groups[j2], i = group.length - 1, next = group[i], node; --i >= 0; ) {
       if (node = group[i]) {
         if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
         next = node;
@@ -616,8 +2326,8 @@ function sort_default(compare) {
   function compareNode(a, b) {
     return a && b ? compare(a.__data__, b.__data__) : !a - !b;
   }
-  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, sortgroup = sortgroups[j2] = new Array(n), node, i = 0; i < n; ++i) {
       if (node = group[i]) {
         sortgroup[i] = node;
       }
@@ -645,8 +2355,8 @@ function nodes_default() {
 
 // node_modules/d3-selection/src/selection/node.js
 function node_default() {
-  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
-    for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
+  for (var groups = this._groups, j2 = 0, m = groups.length; j2 < m; ++j2) {
+    for (var group = groups[j2], i = 0, n = group.length; i < n; ++i) {
       var node = group[i];
       if (node) return node;
     }
@@ -668,8 +2378,8 @@ function empty_default() {
 
 // node_modules/d3-selection/src/selection/each.js
 function each_default(callback) {
-  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
-    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
+  for (var groups = this._groups, j2 = 0, m = groups.length; j2 < m; ++j2) {
+    for (var group = groups[j2], i = 0, n = group.length, node; i < n; ++i) {
       if (node = group[i]) callback.call(node, node.__data__, i, group);
     }
   }
@@ -699,16 +2409,16 @@ function attrConstantNS(fullname, value) {
 }
 function attrFunction(name, value) {
   return function() {
-    var v = value.apply(this, arguments);
-    if (v == null) this.removeAttribute(name);
-    else this.setAttribute(name, v);
+    var v2 = value.apply(this, arguments);
+    if (v2 == null) this.removeAttribute(name);
+    else this.setAttribute(name, v2);
   };
 }
 function attrFunctionNS(fullname, value) {
   return function() {
-    var v = value.apply(this, arguments);
-    if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
-    else this.setAttributeNS(fullname.space, fullname.local, v);
+    var v2 = value.apply(this, arguments);
+    if (v2 == null) this.removeAttributeNS(fullname.space, fullname.local);
+    else this.setAttributeNS(fullname.space, fullname.local, v2);
   };
 }
 function attr_default(name, value) {
@@ -738,9 +2448,9 @@ function styleConstant(name, value, priority) {
 }
 function styleFunction(name, value, priority) {
   return function() {
-    var v = value.apply(this, arguments);
-    if (v == null) this.style.removeProperty(name);
-    else this.style.setProperty(name, v, priority);
+    var v2 = value.apply(this, arguments);
+    if (v2 == null) this.style.removeProperty(name);
+    else this.style.setProperty(name, v2, priority);
   };
 }
 function style_default(name, value, priority) {
@@ -763,9 +2473,9 @@ function propertyConstant(name, value) {
 }
 function propertyFunction(name, value) {
   return function() {
-    var v = value.apply(this, arguments);
-    if (v == null) delete this[name];
-    else this[name] = v;
+    var v2 = value.apply(this, arguments);
+    if (v2 == null) delete this[name];
+    else this[name] = v2;
   };
 }
 function property_default(name, value) {
@@ -846,8 +2556,8 @@ function textConstant(value) {
 }
 function textFunction(value) {
   return function() {
-    var v = value.apply(this, arguments);
-    this.textContent = v == null ? "" : v;
+    var v2 = value.apply(this, arguments);
+    this.textContent = v2 == null ? "" : v2;
   };
 }
 function text_default(value) {
@@ -865,8 +2575,8 @@ function htmlConstant(value) {
 }
 function htmlFunction(value) {
   return function() {
-    var v = value.apply(this, arguments);
-    this.innerHTML = v == null ? "" : v;
+    var v2 = value.apply(this, arguments);
+    this.innerHTML = v2 == null ? "" : v2;
   };
 }
 function html_default(value) {
@@ -950,24 +2660,24 @@ function parseTypenames2(typenames) {
 }
 function onRemove(typename) {
   return function() {
-    var on = this.__on;
-    if (!on) return;
-    for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
-      if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
+    var on2 = this.__on;
+    if (!on2) return;
+    for (var j2 = 0, i = -1, m = on2.length, o; j2 < m; ++j2) {
+      if (o = on2[j2], (!typename.type || o.type === typename.type) && o.name === typename.name) {
         this.removeEventListener(o.type, o.listener, o.options);
       } else {
-        on[++i] = o;
+        on2[++i] = o;
       }
     }
-    if (++i) on.length = i;
+    if (++i) on2.length = i;
     else delete this.__on;
   };
 }
 function onAdd(typename, value, options) {
   return function() {
-    var on = this.__on, o, listener = contextListener(value);
-    if (on) for (var j = 0, m = on.length; j < m; ++j) {
-      if ((o = on[j]).type === typename.type && o.name === typename.name) {
+    var on2 = this.__on, o, listener = contextListener(value);
+    if (on2) for (var j2 = 0, m = on2.length; j2 < m; ++j2) {
+      if ((o = on2[j2]).type === typename.type && o.name === typename.name) {
         this.removeEventListener(o.type, o.listener, o.options);
         this.addEventListener(o.type, o.listener = listener, o.options = options);
         o.value = value;
@@ -976,16 +2686,16 @@ function onAdd(typename, value, options) {
     }
     this.addEventListener(typename.type, listener, options);
     o = { type: typename.type, name: typename.name, value, listener, options };
-    if (!on) this.__on = [o];
-    else on.push(o);
+    if (!on2) this.__on = [o];
+    else on2.push(o);
   };
 }
 function on_default(typename, value, options) {
   var typenames = parseTypenames2(typename + ""), i, n = typenames.length, t;
   if (arguments.length < 2) {
-    var on = this.node().__on;
-    if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
-      for (i = 0, o = on[j]; i < n; ++i) {
+    var on2 = this.node().__on;
+    if (on2) for (var j2 = 0, m = on2.length, o; j2 < m; ++j2) {
+      for (i = 0, o = on2[j2]; i < n; ++i) {
         if ((t = typenames[i]).type === o.type && t.name === o.name) {
           return o.value;
         }
@@ -993,8 +2703,8 @@ function on_default(typename, value, options) {
     }
     return;
   }
-  on = value ? onAdd : onRemove;
-  for (i = 0; i < n; ++i) this.each(on(typenames[i], value, options));
+  on2 = value ? onAdd : onRemove;
+  for (i = 0; i < n; ++i) this.each(on2(typenames[i], value, options));
   return this;
 }
 
@@ -1026,8 +2736,8 @@ function dispatch_default2(type, params) {
 
 // node_modules/d3-selection/src/selection/iterator.js
 function* iterator_default() {
-  for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
-    for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
+  for (var groups = this._groups, j2 = 0, m = groups.length; j2 < m; ++j2) {
+    for (var group = groups[j2], i = 0, n = group.length, node; i < n; ++i) {
       if (node = group[i]) yield node;
     }
   }
@@ -1155,7 +2865,7 @@ function yesdrag(view, noclick) {
 }
 
 // node_modules/d3-drag/src/constant.js
-var constant_default2 = (x) => () => x;
+var constant_default2 = (x2) => () => x2;
 
 // node_modules/d3-drag/src/event.js
 function DragEvent(type, {
@@ -1164,7 +2874,7 @@ function DragEvent(type, {
   target,
   identifier,
   active,
-  x,
+  x: x2,
   y,
   dx,
   dy,
@@ -1177,7 +2887,7 @@ function DragEvent(type, {
     target: { value: target, enumerable: true, configurable: true },
     identifier: { value: identifier, enumerable: true, configurable: true },
     active: { value: active, enumerable: true, configurable: true },
-    x: { value: x, enumerable: true, configurable: true },
+    x: { value: x2, enumerable: true, configurable: true },
     y: { value: y, enumerable: true, configurable: true },
     dx: { value: dx, enumerable: true, configurable: true },
     dy: { value: dy, enumerable: true, configurable: true },
@@ -1266,22 +2976,22 @@ function drag_default() {
     }
   }
   function beforestart(that, container2, event, d, identifier, touch) {
-    var dispatch2 = listeners3.copy(), p = pointer_default(touch || event, container2), dx, dy, s;
+    var dispatch2 = listeners3.copy(), p2 = pointer_default(touch || event, container2), dx, dy, s;
     if ((s = subject.call(that, new DragEvent("beforestart", {
       sourceEvent: event,
       target: drag,
       identifier,
       active,
-      x: p[0],
-      y: p[1],
+      x: p2[0],
+      y: p2[1],
       dx: 0,
       dy: 0,
       dispatch: dispatch2
     }), d)) == null) return;
-    dx = s.x - p[0] || 0;
-    dy = s.y - p[1] || 0;
+    dx = s.x - p2[0] || 0;
+    dy = s.y - p2[1] || 0;
     return function gesture(type, event2, touch2) {
-      var p0 = p, n;
+      var p0 = p2, n;
       switch (type) {
         case "start":
           gestures[identifier] = gesture, n = active++;
@@ -1290,7 +3000,7 @@ function drag_default() {
           delete gestures[identifier], --active;
         // falls through
         case "drag":
-          p = pointer_default(touch2 || event2, container2), n = active;
+          p2 = pointer_default(touch2 || event2, container2), n = active;
           break;
       }
       dispatch2.call(
@@ -1302,34 +3012,34 @@ function drag_default() {
           target: drag,
           identifier,
           active: n,
-          x: p[0] + dx,
-          y: p[1] + dy,
-          dx: p[0] - p0[0],
-          dy: p[1] - p0[1],
+          x: p2[0] + dx,
+          y: p2[1] + dy,
+          dx: p2[0] - p0[0],
+          dy: p2[1] - p0[1],
           dispatch: dispatch2
         }),
         d
       );
     };
   }
-  drag.filter = function(_) {
-    return arguments.length ? (filter2 = typeof _ === "function" ? _ : constant_default2(!!_), drag) : filter2;
+  drag.filter = function(_2) {
+    return arguments.length ? (filter2 = typeof _2 === "function" ? _2 : constant_default2(!!_2), drag) : filter2;
   };
-  drag.container = function(_) {
-    return arguments.length ? (container = typeof _ === "function" ? _ : constant_default2(_), drag) : container;
+  drag.container = function(_2) {
+    return arguments.length ? (container = typeof _2 === "function" ? _2 : constant_default2(_2), drag) : container;
   };
-  drag.subject = function(_) {
-    return arguments.length ? (subject = typeof _ === "function" ? _ : constant_default2(_), drag) : subject;
+  drag.subject = function(_2) {
+    return arguments.length ? (subject = typeof _2 === "function" ? _2 : constant_default2(_2), drag) : subject;
   };
-  drag.touchable = function(_) {
-    return arguments.length ? (touchable = typeof _ === "function" ? _ : constant_default2(!!_), drag) : touchable;
+  drag.touchable = function(_2) {
+    return arguments.length ? (touchable = typeof _2 === "function" ? _2 : constant_default2(!!_2), drag) : touchable;
   };
   drag.on = function() {
     var value = listeners3.on.apply(listeners3, arguments);
     return value === listeners3 ? drag : value;
   };
-  drag.clickDistance = function(_) {
-    return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2);
+  drag.clickDistance = function(_2) {
+    return arguments.length ? (clickDistance2 = (_2 = +_2) * _2, drag) : Math.sqrt(clickDistance2);
   };
   return drag;
 }
@@ -1565,13 +3275,13 @@ function Rgb(r, g, b, opacity) {
   this.opacity = +opacity;
 }
 define_default(Rgb, rgb, extend(Color, {
-  brighter(k) {
-    k = k == null ? brighter : Math.pow(brighter, k);
-    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  brighter(k2) {
+    k2 = k2 == null ? brighter : Math.pow(brighter, k2);
+    return new Rgb(this.r * k2, this.g * k2, this.b * k2, this.opacity);
   },
-  darker(k) {
-    k = k == null ? darker : Math.pow(darker, k);
-    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  darker(k2) {
+    k2 = k2 == null ? darker : Math.pow(darker, k2);
+    return new Rgb(this.r * k2, this.g * k2, this.b * k2, this.opacity);
   },
   rgb() {
     return this;
@@ -1643,13 +3353,13 @@ function Hsl(h, s, l, opacity) {
   this.opacity = +opacity;
 }
 define_default(Hsl, hsl, extend(Color, {
-  brighter(k) {
-    k = k == null ? brighter : Math.pow(brighter, k);
-    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  brighter(k2) {
+    k2 = k2 == null ? brighter : Math.pow(brighter, k2);
+    return new Hsl(this.h, this.s, this.l * k2, this.opacity);
   },
-  darker(k) {
-    k = k == null ? darker : Math.pow(darker, k);
-    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  darker(k2) {
+    k2 = k2 == null ? darker : Math.pow(darker, k2);
+    return new Hsl(this.h, this.s, this.l * k2, this.opacity);
   },
   rgb() {
     var h = this.h % 360 + (this.h < 0) * 360, s = isNaN(h) || isNaN(this.s) ? 0 : this.s, l = this.l, m2 = l + (l < 0.5 ? l : 1 - l) * s, m1 = 2 * l - m2;
@@ -1683,7 +3393,7 @@ function hsl2rgb(h, m1, m2) {
 }
 
 // node_modules/d3-interpolate/src/constant.js
-var constant_default3 = (x) => () => x;
+var constant_default3 = (x2) => () => x2;
 
 // node_modules/d3-interpolate/src/color.js
 function linear(a, d) {
@@ -1732,17 +3442,17 @@ function numberArray_default(a, b) {
     return c;
   };
 }
-function isNumberArray(x) {
-  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+function isNumberArray(x2) {
+  return ArrayBuffer.isView(x2) && !(x2 instanceof DataView);
 }
 
 // node_modules/d3-interpolate/src/array.js
 function genericArray(a, b) {
-  var nb = b ? b.length : 0, na = a ? Math.min(nb, a.length) : 0, x = new Array(na), c = new Array(nb), i;
-  for (i = 0; i < na; ++i) x[i] = value_default(a[i], b[i]);
+  var nb = b ? b.length : 0, na = a ? Math.min(nb, a.length) : 0, x2 = new Array(na), c = new Array(nb), i;
+  for (i = 0; i < na; ++i) x2[i] = value_default(a[i], b[i]);
   for (; i < nb; ++i) c[i] = b[i];
   return function(t) {
-    for (i = 0; i < na; ++i) c[i] = x[i](t);
+    for (i = 0; i < na; ++i) c[i] = x2[i](t);
     return c;
   };
 }
@@ -1764,18 +3474,18 @@ function number_default(a, b) {
 
 // node_modules/d3-interpolate/src/object.js
 function object_default(a, b) {
-  var i = {}, c = {}, k;
+  var i = {}, c = {}, k2;
   if (a === null || typeof a !== "object") a = {};
   if (b === null || typeof b !== "object") b = {};
-  for (k in b) {
-    if (k in a) {
-      i[k] = value_default(a[k], b[k]);
+  for (k2 in b) {
+    if (k2 in a) {
+      i[k2] = value_default(a[k2], b[k2]);
     } else {
-      c[k] = b[k];
+      c[k2] = b[k2];
     }
   }
   return function(t) {
-    for (k in i) c[k] = i[k](t);
+    for (k2 in i) c[k2] = i[k2](t);
     return c;
   };
 }
@@ -1794,7 +3504,7 @@ function one(b) {
   };
 }
 function string_default(a, b) {
-  var bi = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
+  var bi = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i = -1, s = [], q2 = [];
   a = a + "", b = b + "";
   while ((am = reA.exec(a)) && (bm = reB.exec(b))) {
     if ((bs = bm.index) > bi) {
@@ -1807,7 +3517,7 @@ function string_default(a, b) {
       else s[++i] = bm;
     } else {
       s[++i] = null;
-      q.push({ i, x: number_default(am, bm) });
+      q2.push({ i, x: number_default(am, bm) });
     }
     bi = reB.lastIndex;
   }
@@ -1816,8 +3526,8 @@ function string_default(a, b) {
     if (s[i]) s[i] += bs;
     else s[++i] = bs;
   }
-  return s.length < 2 ? q[0] ? one(q[0].x) : zero(b) : (b = q.length, function(t) {
-    for (var i2 = 0, o; i2 < b; ++i2) s[(o = q[i2]).i] = o.x(t);
+  return s.length < 2 ? q2[0] ? one(q2[0].x) : zero(b) : (b = q2.length, function(t) {
+    for (var i2 = 0, o; i2 < b; ++i2) s[(o = q2[i2]).i] = o.x(t);
     return s.join("");
   });
 }
@@ -1874,49 +3584,49 @@ function interpolateTransform(parse, pxComma, pxParen, degParen) {
   function pop(s) {
     return s.length ? s.pop() + " " : "";
   }
-  function translate(xa, ya, xb, yb, s, q) {
+  function translate(xa, ya, xb, yb, s, q2) {
     if (xa !== xb || ya !== yb) {
       var i = s.push("translate(", null, pxComma, null, pxParen);
-      q.push({ i: i - 4, x: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
+      q2.push({ i: i - 4, x: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
     } else if (xb || yb) {
       s.push("translate(" + xb + pxComma + yb + pxParen);
     }
   }
-  function rotate(a, b, s, q) {
+  function rotate(a, b, s, q2) {
     if (a !== b) {
       if (a - b > 180) b += 360;
       else if (b - a > 180) a += 360;
-      q.push({ i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number_default(a, b) });
+      q2.push({ i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number_default(a, b) });
     } else if (b) {
       s.push(pop(s) + "rotate(" + b + degParen);
     }
   }
-  function skewX(a, b, s, q) {
+  function skewX(a, b, s, q2) {
     if (a !== b) {
-      q.push({ i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number_default(a, b) });
+      q2.push({ i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number_default(a, b) });
     } else if (b) {
       s.push(pop(s) + "skewX(" + b + degParen);
     }
   }
-  function scale(xa, ya, xb, yb, s, q) {
+  function scale(xa, ya, xb, yb, s, q2) {
     if (xa !== xb || ya !== yb) {
       var i = s.push(pop(s) + "scale(", null, ",", null, ")");
-      q.push({ i: i - 4, x: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
+      q2.push({ i: i - 4, x: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
     } else if (xb !== 1 || yb !== 1) {
       s.push(pop(s) + "scale(" + xb + "," + yb + ")");
     }
   }
   return function(a, b) {
-    var s = [], q = [];
+    var s = [], q2 = [];
     a = parse(a), b = parse(b);
-    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
-    rotate(a.rotate, b.rotate, s, q);
-    skewX(a.skewX, b.skewX, s, q);
-    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
+    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q2);
+    rotate(a.rotate, b.rotate, s, q2);
+    skewX(a.skewX, b.skewX, s, q2);
+    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q2);
     a = b = null;
     return function(t) {
-      var i = -1, n = q.length, o;
-      while (++i < n) s[(o = q[i]).i] = o.x(t);
+      var i = -1, n = q2.length, o;
+      while (++i < n) s[(o = q2[i]).i] = o.x(t);
       return s.join("");
     };
   };
@@ -1926,32 +3636,32 @@ var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
 
 // node_modules/d3-interpolate/src/zoom.js
 var epsilon2 = 1e-12;
-function cosh(x) {
-  return ((x = Math.exp(x)) + 1 / x) / 2;
+function cosh(x2) {
+  return ((x2 = Math.exp(x2)) + 1 / x2) / 2;
 }
-function sinh(x) {
-  return ((x = Math.exp(x)) - 1 / x) / 2;
+function sinh(x2) {
+  return ((x2 = Math.exp(x2)) - 1 / x2) / 2;
 }
-function tanh(x) {
-  return ((x = Math.exp(2 * x)) - 1) / (x + 1);
+function tanh(x2) {
+  return ((x2 = Math.exp(2 * x2)) - 1) / (x2 + 1);
 }
 var zoom_default = (function zoomRho(rho, rho2, rho4) {
   function zoom(p0, p1) {
-    var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i, S;
+    var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i, S2;
     if (d2 < epsilon2) {
-      S = Math.log(w1 / w0) / rho;
+      S2 = Math.log(w1 / w0) / rho;
       i = function(t) {
         return [
           ux0 + t * dx,
           uy0 + t * dy,
-          w0 * Math.exp(rho * t * S)
+          w0 * Math.exp(rho * t * S2)
         ];
       };
     } else {
       var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
-      S = (r1 - r0) / rho;
+      S2 = (r1 - r0) / rho;
       i = function(t) {
-        var s = t * S, coshr0 = cosh(r0), u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));
+        var s = t * S2, coshr0 = cosh(r0), u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));
         return [
           ux0 + u * dx,
           uy0 + u * dy,
@@ -1959,12 +3669,12 @@ var zoom_default = (function zoomRho(rho, rho2, rho4) {
         ];
       };
     }
-    i.duration = S * 1e3 * rho / Math.SQRT2;
+    i.duration = S2 * 1e3 * rho / Math.SQRT2;
     return i;
   }
-  zoom.rho = function(_) {
-    var _1 = Math.max(1e-3, +_), _2 = _1 * _1, _4 = _2 * _2;
-    return zoomRho(_1, _2, _4);
+  zoom.rho = function(_2) {
+    var _1 = Math.max(1e-3, +_2), _22 = _1 * _1, _4 = _22 * _22;
+    return zoomRho(_1, _22, _4);
   };
   return zoom;
 })(Math.SQRT2, 2, 4);
@@ -2137,7 +3847,7 @@ function create(node, id2, self) {
     if (self.delay <= elapsed) start2(elapsed - self.delay);
   }
   function start2(elapsed) {
-    var i, j, n, o;
+    var i, j2, n, o;
     if (self.state !== SCHEDULED) return stop();
     for (i in schedules) {
       o = schedules[i];
@@ -2167,12 +3877,12 @@ function create(node, id2, self) {
     if (self.state !== STARTING) return;
     self.state = STARTED;
     tween = new Array(n = self.tween.length);
-    for (i = 0, j = -1; i < n; ++i) {
+    for (i = 0, j2 = -1; i < n; ++i) {
       if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) {
-        tween[++j] = o;
+        tween[++j2] = o;
       }
     }
-    tween.length = j + 1;
+    tween.length = j2 + 1;
   }
   function tick(elapsed) {
     var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1), i = -1, n = tween.length;
@@ -2423,9 +4133,9 @@ function ease_default(value) {
 // node_modules/d3-transition/src/transition/easeVarying.js
 function easeVarying(id2, value) {
   return function() {
-    var v = value.apply(this, arguments);
-    if (typeof v !== "function") throw new Error();
-    set2(this, id2).ease = v;
+    var v2 = value.apply(this, arguments);
+    if (typeof v2 !== "function") throw new Error();
+    set2(this, id2).ease = v2;
   };
 }
 function easeVarying_default(value) {
@@ -2436,8 +4146,8 @@ function easeVarying_default(value) {
 // node_modules/d3-transition/src/transition/filter.js
 function filter_default2(match) {
   if (typeof match !== "function") match = matcher_default(match);
-  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, subgroup = subgroups[j2] = [], node, i = 0; i < n; ++i) {
       if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
         subgroup.push(node);
       }
@@ -2449,15 +4159,15 @@ function filter_default2(match) {
 // node_modules/d3-transition/src/transition/merge.js
 function merge_default2(transition2) {
   if (transition2._id !== this._id) throw new Error();
-  for (var groups0 = this._groups, groups1 = transition2._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
-    for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
+  for (var groups0 = this._groups, groups1 = transition2._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j2 = 0; j2 < m; ++j2) {
+    for (var group0 = groups0[j2], group1 = groups1[j2], n = group0.length, merge = merges[j2] = new Array(n), node, i = 0; i < n; ++i) {
       if (node = group0[i] || group1[i]) {
         merge[i] = node;
       }
     }
   }
-  for (; j < m0; ++j) {
-    merges[j] = groups0[j];
+  for (; j2 < m0; ++j2) {
+    merges[j2] = groups0[j2];
   }
   return new Transition(merges, this._parents, this._name, this._id);
 }
@@ -2473,8 +4183,8 @@ function start(name) {
 function onFunction(id2, name, listener) {
   var on0, on1, sit = start(name) ? init : set2;
   return function() {
-    var schedule = sit(this, id2), on = schedule.on;
-    if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);
+    var schedule = sit(this, id2), on2 = schedule.on;
+    if (on2 !== on0) (on1 = (on0 = on2).copy()).on(name, listener);
     schedule.on = on1;
   };
 }
@@ -2499,8 +4209,8 @@ function remove_default2() {
 function select_default3(select) {
   var name = this._name, id2 = this._id;
   if (typeof select !== "function") select = selector_default(select);
-  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, subgroup = subgroups[j2] = new Array(n), node, subnode, i = 0; i < n; ++i) {
       if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
         if ("__data__" in node) subnode.__data__ = node.__data__;
         subgroup[i] = subnode;
@@ -2515,12 +4225,12 @@ function select_default3(select) {
 function selectAll_default2(select) {
   var name = this._name, id2 = this._id;
   if (typeof select !== "function") select = selectorAll_default(select);
-  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, node, i = 0; i < n; ++i) {
       if (node = group[i]) {
-        for (var children2 = select.call(node, node.__data__, i, group), child, inherit2 = get2(node, id2), k = 0, l = children2.length; k < l; ++k) {
-          if (child = children2[k]) {
-            schedule_default(child, name, id2, k, children2, inherit2);
+        for (var children2 = select.call(node, node.__data__, i, group), child, inherit2 = get2(node, id2), k2 = 0, l = children2.length; k2 < l; ++k2) {
+          if (child = children2[k2]) {
+            schedule_default(child, name, id2, k2, children2, inherit2);
           }
         }
         subgroups.push(children2);
@@ -2568,8 +4278,8 @@ function styleFunction2(name, interpolate, value) {
 function styleMaybeRemove(id2, name) {
   var on0, on1, listener0, key = "style." + name, event = "end." + key, remove2;
   return function() {
-    var schedule = set2(this, id2), on = schedule.on, listener = schedule.value[key] == null ? remove2 || (remove2 = styleRemove2(name)) : void 0;
-    if (on !== on0 || listener0 !== listener) (on1 = (on0 = on).copy()).on(event, listener0 = listener);
+    var schedule = set2(this, id2), on2 = schedule.on, listener = schedule.value[key] == null ? remove2 || (remove2 = styleRemove2(name)) : void 0;
+    if (on2 !== on0 || listener0 !== listener) (on1 = (on0 = on2).copy()).on(event, listener0 = listener);
     schedule.on = on1;
   };
 }
@@ -2645,8 +4355,8 @@ function textTween_default(value) {
 // node_modules/d3-transition/src/transition/transition.js
 function transition_default() {
   var name = this._name, id0 = this._id, id1 = newId();
-  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, node, i = 0; i < n; ++i) {
       if (node = group[i]) {
         var inherit2 = get2(node, id0);
         schedule_default(node, name, id1, i, group, {
@@ -2669,9 +4379,9 @@ function end_default() {
       if (--size === 0) resolve();
     } };
     that.each(function() {
-      var schedule = set2(this, id2), on = schedule.on;
-      if (on !== on0) {
-        on1 = (on0 = on).copy();
+      var schedule = set2(this, id2), on2 = schedule.on;
+      if (on2 !== on0) {
+        on1 = (on0 = on2).copy();
         on1._.cancel.push(cancel);
         on1._.interrupt.push(cancel);
         on1._.end.push(end);
@@ -2756,8 +4466,8 @@ function transition_default2(name) {
   } else {
     id2 = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + "";
   }
-  for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
-    for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
+  for (var groups = this._groups, m = groups.length, j2 = 0; j2 < m; ++j2) {
+    for (var group = groups[j2], n = group.length, node, i = 0; i < n; ++i) {
       if (node = group[i]) {
         schedule_default(node, name, id2, i, group, timing || inherit(node, id2));
       }
@@ -2771,7 +4481,7 @@ selection_default.prototype.interrupt = interrupt_default2;
 selection_default.prototype.transition = transition_default2;
 
 // node_modules/d3-zoom/src/constant.js
-var constant_default4 = (x) => () => x;
+var constant_default4 = (x2) => () => x2;
 
 // node_modules/d3-zoom/src/event.js
 function ZoomEvent(type, {
@@ -2790,24 +4500,24 @@ function ZoomEvent(type, {
 }
 
 // node_modules/d3-zoom/src/transform.js
-function Transform(k, x, y) {
-  this.k = k;
-  this.x = x;
+function Transform(k2, x2, y) {
+  this.k = k2;
+  this.x = x2;
   this.y = y;
 }
 Transform.prototype = {
   constructor: Transform,
-  scale: function(k) {
-    return k === 1 ? this : new Transform(this.k * k, this.x, this.y);
+  scale: function(k2) {
+    return k2 === 1 ? this : new Transform(this.k * k2, this.x, this.y);
   },
-  translate: function(x, y) {
-    return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);
+  translate: function(x2, y) {
+    return x2 === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x2, this.y + this.k * y);
   },
   apply: function(point) {
     return [point[0] * this.k + this.x, point[1] * this.k + this.y];
   },
-  applyX: function(x) {
-    return x * this.k + this.x;
+  applyX: function(x2) {
+    return x2 * this.k + this.x;
   },
   applyY: function(y) {
     return y * this.k + this.y;
@@ -2815,14 +4525,14 @@ Transform.prototype = {
   invert: function(location) {
     return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];
   },
-  invertX: function(x) {
-    return (x - this.x) / this.k;
+  invertX: function(x2) {
+    return (x2 - this.x) / this.k;
   },
   invertY: function(y) {
     return (y - this.y) / this.k;
   },
-  rescaleX: function(x) {
-    return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));
+  rescaleX: function(x2) {
+    return x2.copy().domain(x2.range().map(this.invertX, this).map(x2.invert, x2));
   },
   rescaleY: function(y) {
     return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));
@@ -2895,42 +4605,42 @@ function zoom_default2() {
       });
     }
   };
-  zoom.scaleBy = function(selection2, k, p, event) {
+  zoom.scaleBy = function(selection2, k2, p2, event) {
     zoom.scaleTo(selection2, function() {
-      var k0 = this.__zoom.k, k1 = typeof k === "function" ? k.apply(this, arguments) : k;
+      var k0 = this.__zoom.k, k1 = typeof k2 === "function" ? k2.apply(this, arguments) : k2;
       return k0 * k1;
-    }, p, event);
+    }, p2, event);
   };
-  zoom.scaleTo = function(selection2, k, p, event) {
+  zoom.scaleTo = function(selection2, k2, p2, event) {
     zoom.transform(selection2, function() {
-      var e = extent.apply(this, arguments), t0 = this.__zoom, p0 = p == null ? centroid(e) : typeof p === "function" ? p.apply(this, arguments) : p, p1 = t0.invert(p0), k1 = typeof k === "function" ? k.apply(this, arguments) : k;
+      var e = extent.apply(this, arguments), t0 = this.__zoom, p0 = p2 == null ? centroid(e) : typeof p2 === "function" ? p2.apply(this, arguments) : p2, p1 = t0.invert(p0), k1 = typeof k2 === "function" ? k2.apply(this, arguments) : k2;
       return constrain(translate(scale(t0, k1), p0, p1), e, translateExtent);
-    }, p, event);
+    }, p2, event);
   };
-  zoom.translateBy = function(selection2, x, y, event) {
+  zoom.translateBy = function(selection2, x2, y, event) {
     zoom.transform(selection2, function() {
       return constrain(this.__zoom.translate(
-        typeof x === "function" ? x.apply(this, arguments) : x,
+        typeof x2 === "function" ? x2.apply(this, arguments) : x2,
         typeof y === "function" ? y.apply(this, arguments) : y
       ), extent.apply(this, arguments), translateExtent);
     }, null, event);
   };
-  zoom.translateTo = function(selection2, x, y, p, event) {
+  zoom.translateTo = function(selection2, x2, y, p2, event) {
     zoom.transform(selection2, function() {
-      var e = extent.apply(this, arguments), t = this.__zoom, p0 = p == null ? centroid(e) : typeof p === "function" ? p.apply(this, arguments) : p;
+      var e = extent.apply(this, arguments), t = this.__zoom, p0 = p2 == null ? centroid(e) : typeof p2 === "function" ? p2.apply(this, arguments) : p2;
       return constrain(identity2.translate(p0[0], p0[1]).scale(t.k).translate(
-        typeof x === "function" ? -x.apply(this, arguments) : -x,
+        typeof x2 === "function" ? -x2.apply(this, arguments) : -x2,
         typeof y === "function" ? -y.apply(this, arguments) : -y
       ), e, translateExtent);
-    }, p, event);
+    }, p2, event);
   };
-  function scale(transform2, k) {
-    k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], k));
-    return k === transform2.k ? transform2 : new Transform(k, transform2.x, transform2.y);
+  function scale(transform2, k2) {
+    k2 = Math.max(scaleExtent[0], Math.min(scaleExtent[1], k2));
+    return k2 === transform2.k ? transform2 : new Transform(k2, transform2.x, transform2.y);
   }
   function translate(transform2, p0, p1) {
-    var x = p0[0] - p1[0] * transform2.k, y = p0[1] - p1[1] * transform2.k;
-    return x === transform2.x && y === transform2.y ? transform2 : new Transform(transform2.k, x, y);
+    var x2 = p0[0] - p1[0] * transform2.k, y = p0[1] - p1[1] * transform2.k;
+    return x2 === transform2.x && y === transform2.y ? transform2 : new Transform(transform2.k, x2, y);
   }
   function centroid(extent2) {
     return [(+extent2[0][0] + +extent2[1][0]) / 2, (+extent2[0][1] + +extent2[1][1]) / 2];
@@ -2941,12 +4651,12 @@ function zoom_default2() {
     }).on("interrupt.zoom end.zoom", function() {
       gesture(this, arguments).event(event).end();
     }).tween("zoom", function() {
-      var that = this, args = arguments, g = gesture(that, args).event(event), e = extent.apply(that, args), p = point == null ? centroid(e) : typeof point === "function" ? point.apply(that, args) : point, w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]), a = that.__zoom, b = typeof transform2 === "function" ? transform2.apply(that, args) : transform2, i = interpolate(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k));
+      var that = this, args = arguments, g = gesture(that, args).event(event), e = extent.apply(that, args), p2 = point == null ? centroid(e) : typeof point === "function" ? point.apply(that, args) : point, w2 = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]), a = that.__zoom, b = typeof transform2 === "function" ? transform2.apply(that, args) : transform2, i = interpolate(a.invert(p2).concat(w2 / a.k), b.invert(p2).concat(w2 / b.k));
       return function(t) {
         if (t === 1) t = b;
         else {
-          var l = i(t), k = w / l[2];
-          t = new Transform(k, p[0] - l[0] * k, p[1] - l[1] * k);
+          var l = i(t), k2 = w2 / l[2];
+          t = new Transform(k2, p2[0] - l[0] * k2, p2[1] - l[1] * k2);
         }
         g.zoom(null, t);
       };
@@ -3007,21 +4717,21 @@ function zoom_default2() {
   };
   function wheeled(event, ...args) {
     if (!filter2.apply(this, arguments)) return;
-    var g = gesture(this, args).event(event), t = this.__zoom, k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], t.k * Math.pow(2, wheelDelta2.apply(this, arguments)))), p = pointer_default(event);
+    var g = gesture(this, args).event(event), t = this.__zoom, k2 = Math.max(scaleExtent[0], Math.min(scaleExtent[1], t.k * Math.pow(2, wheelDelta2.apply(this, arguments)))), p2 = pointer_default(event);
     if (g.wheel) {
-      if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) {
-        g.mouse[1] = t.invert(g.mouse[0] = p);
+      if (g.mouse[0][0] !== p2[0] || g.mouse[0][1] !== p2[1]) {
+        g.mouse[1] = t.invert(g.mouse[0] = p2);
       }
       clearTimeout(g.wheel);
-    } else if (t.k === k) return;
+    } else if (t.k === k2) return;
     else {
-      g.mouse = [p, t.invert(p)];
+      g.mouse = [p2, t.invert(p2)];
       interrupt_default(this);
       g.start();
     }
     noevent_default2(event);
     g.wheel = setTimeout(wheelidled, wheelDelay);
-    g.zoom("mouse", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent, translateExtent));
+    g.zoom("mouse", constrain(translate(scale(t, k2), g.mouse[0], g.mouse[1]), g.extent, translateExtent));
     function wheelidled() {
       g.wheel = null;
       g.end();
@@ -3029,10 +4739,10 @@ function zoom_default2() {
   }
   function mousedowned(event, ...args) {
     if (touchending || !filter2.apply(this, arguments)) return;
-    var currentTarget = event.currentTarget, g = gesture(this, args, true).event(event), v = select_default2(event.view).on("mousemove.zoom", mousemoved, true).on("mouseup.zoom", mouseupped, true), p = pointer_default(event, currentTarget), x0 = event.clientX, y0 = event.clientY;
+    var currentTarget = event.currentTarget, g = gesture(this, args, true).event(event), v2 = select_default2(event.view).on("mousemove.zoom", mousemoved, true).on("mouseup.zoom", mouseupped, true), p2 = pointer_default(event, currentTarget), x0 = event.clientX, y0 = event.clientY;
     nodrag_default(event.view);
     nopropagation2(event);
-    g.mouse = [p, this.__zoom.invert(p)];
+    g.mouse = [p2, this.__zoom.invert(p2)];
     interrupt_default(this);
     g.start();
     function mousemoved(event2) {
@@ -3044,7 +4754,7 @@ function zoom_default2() {
       g.event(event2).zoom("mouse", constrain(translate(g.that.__zoom, g.mouse[0] = pointer_default(event2, currentTarget), g.mouse[1]), g.extent, translateExtent));
     }
     function mouseupped(event2) {
-      v.on("mousemove.zoom mouseup.zoom", null);
+      v2.on("mousemove.zoom mouseup.zoom", null);
       yesdrag(event2.view, g.moved);
       noevent_default2(event2);
       g.event(event2).end();
@@ -3059,17 +4769,17 @@ function zoom_default2() {
   }
   function touchstarted(event, ...args) {
     if (!filter2.apply(this, arguments)) return;
-    var touches = event.touches, n = touches.length, g = gesture(this, args, event.changedTouches.length === n).event(event), started, i, t, p;
+    var touches = event.touches, n = touches.length, g = gesture(this, args, event.changedTouches.length === n).event(event), started, i, t, p2;
     nopropagation2(event);
     for (i = 0; i < n; ++i) {
-      t = touches[i], p = pointer_default(t, this);
-      p = [p, this.__zoom.invert(p), t.identifier];
-      if (!g.touch0) g.touch0 = p, started = true, g.taps = 1 + !!touchstarting;
-      else if (!g.touch1 && g.touch0[2] !== p[2]) g.touch1 = p, g.taps = 0;
+      t = touches[i], p2 = pointer_default(t, this);
+      p2 = [p2, this.__zoom.invert(p2), t.identifier];
+      if (!g.touch0) g.touch0 = p2, started = true, g.taps = 1 + !!touchstarting;
+      else if (!g.touch1 && g.touch0[2] !== p2[2]) g.touch1 = p2, g.taps = 0;
     }
     if (touchstarting) touchstarting = clearTimeout(touchstarting);
     if (started) {
-      if (g.taps < 2) touchfirst = p[0], touchstarting = setTimeout(function() {
+      if (g.taps < 2) touchfirst = p2[0], touchstarting = setTimeout(function() {
         touchstarting = null;
       }, touchDelay);
       interrupt_default(this);
@@ -3078,22 +4788,22 @@ function zoom_default2() {
   }
   function touchmoved(event, ...args) {
     if (!this.__zooming) return;
-    var g = gesture(this, args).event(event), touches = event.changedTouches, n = touches.length, i, t, p, l;
+    var g = gesture(this, args).event(event), touches = event.changedTouches, n = touches.length, i, t, p2, l;
     noevent_default2(event);
     for (i = 0; i < n; ++i) {
-      t = touches[i], p = pointer_default(t, this);
-      if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p;
-      else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p;
+      t = touches[i], p2 = pointer_default(t, this);
+      if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p2;
+      else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p2;
     }
     t = g.that.__zoom;
     if (g.touch1) {
       var p0 = g.touch0[0], l0 = g.touch0[1], p1 = g.touch1[0], l1 = g.touch1[1], dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp, dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl;
       t = scale(t, Math.sqrt(dp / dl));
-      p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
+      p2 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
       l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];
-    } else if (g.touch0) p = g.touch0[0], l = g.touch0[1];
+    } else if (g.touch0) p2 = g.touch0[0], l = g.touch0[1];
     else return;
-    g.zoom("touch", constrain(translate(t, p, l), g.extent, translateExtent));
+    g.zoom("touch", constrain(translate(t, p2, l), g.extent, translateExtent));
   }
   function touchended(event, ...args) {
     if (!this.__zooming) return;
@@ -3115,48 +4825,48 @@ function zoom_default2() {
       if (g.taps === 2) {
         t = pointer_default(t, this);
         if (Math.hypot(touchfirst[0] - t[0], touchfirst[1] - t[1]) < tapDistance) {
-          var p = select_default2(this).on("dblclick.zoom");
-          if (p) p.apply(this, arguments);
+          var p2 = select_default2(this).on("dblclick.zoom");
+          if (p2) p2.apply(this, arguments);
         }
       }
     }
   }
-  zoom.wheelDelta = function(_) {
-    return arguments.length ? (wheelDelta2 = typeof _ === "function" ? _ : constant_default4(+_), zoom) : wheelDelta2;
+  zoom.wheelDelta = function(_2) {
+    return arguments.length ? (wheelDelta2 = typeof _2 === "function" ? _2 : constant_default4(+_2), zoom) : wheelDelta2;
   };
-  zoom.filter = function(_) {
-    return arguments.length ? (filter2 = typeof _ === "function" ? _ : constant_default4(!!_), zoom) : filter2;
+  zoom.filter = function(_2) {
+    return arguments.length ? (filter2 = typeof _2 === "function" ? _2 : constant_default4(!!_2), zoom) : filter2;
   };
-  zoom.touchable = function(_) {
-    return arguments.length ? (touchable = typeof _ === "function" ? _ : constant_default4(!!_), zoom) : touchable;
+  zoom.touchable = function(_2) {
+    return arguments.length ? (touchable = typeof _2 === "function" ? _2 : constant_default4(!!_2), zoom) : touchable;
   };
-  zoom.extent = function(_) {
-    return arguments.length ? (extent = typeof _ === "function" ? _ : constant_default4([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent;
+  zoom.extent = function(_2) {
+    return arguments.length ? (extent = typeof _2 === "function" ? _2 : constant_default4([[+_2[0][0], +_2[0][1]], [+_2[1][0], +_2[1][1]]]), zoom) : extent;
   };
-  zoom.scaleExtent = function(_) {
-    return arguments.length ? (scaleExtent[0] = +_[0], scaleExtent[1] = +_[1], zoom) : [scaleExtent[0], scaleExtent[1]];
+  zoom.scaleExtent = function(_2) {
+    return arguments.length ? (scaleExtent[0] = +_2[0], scaleExtent[1] = +_2[1], zoom) : [scaleExtent[0], scaleExtent[1]];
   };
-  zoom.translateExtent = function(_) {
-    return arguments.length ? (translateExtent[0][0] = +_[0][0], translateExtent[1][0] = +_[1][0], translateExtent[0][1] = +_[0][1], translateExtent[1][1] = +_[1][1], zoom) : [[translateExtent[0][0], translateExtent[0][1]], [translateExtent[1][0], translateExtent[1][1]]];
+  zoom.translateExtent = function(_2) {
+    return arguments.length ? (translateExtent[0][0] = +_2[0][0], translateExtent[1][0] = +_2[1][0], translateExtent[0][1] = +_2[0][1], translateExtent[1][1] = +_2[1][1], zoom) : [[translateExtent[0][0], translateExtent[0][1]], [translateExtent[1][0], translateExtent[1][1]]];
   };
-  zoom.constrain = function(_) {
-    return arguments.length ? (constrain = _, zoom) : constrain;
+  zoom.constrain = function(_2) {
+    return arguments.length ? (constrain = _2, zoom) : constrain;
   };
-  zoom.duration = function(_) {
-    return arguments.length ? (duration = +_, zoom) : duration;
+  zoom.duration = function(_2) {
+    return arguments.length ? (duration = +_2, zoom) : duration;
   };
-  zoom.interpolate = function(_) {
-    return arguments.length ? (interpolate = _, zoom) : interpolate;
+  zoom.interpolate = function(_2) {
+    return arguments.length ? (interpolate = _2, zoom) : interpolate;
   };
   zoom.on = function() {
     var value = listeners3.on.apply(listeners3, arguments);
     return value === listeners3 ? zoom : value;
   };
-  zoom.clickDistance = function(_) {
-    return arguments.length ? (clickDistance2 = (_ = +_) * _, zoom) : Math.sqrt(clickDistance2);
+  zoom.clickDistance = function(_2) {
+    return arguments.length ? (clickDistance2 = (_2 = +_2) * _2, zoom) : Math.sqrt(clickDistance2);
   };
-  zoom.tapDistance = function(_) {
-    return arguments.length ? (tapDistance = +_, zoom) : tapDistance;
+  zoom.tapDistance = function(_2) {
+    return arguments.length ? (tapDistance = +_2, zoom) : tapDistance;
   };
   return zoom;
 }
@@ -3188,7 +4898,7 @@ var elementSelectionKeys = ["Enter", " ", "Escape"];
 var defaultAriaLabelConfig = {
   "node.a11yDescription.default": "Press enter or space to select a node. Press delete to remove it and escape to cancel.",
   "node.a11yDescription.keyboardDisabled": "Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.",
-  "node.a11yDescription.ariaLiveMessage": ({ direction, x, y }) => `Moved selected node ${direction}. New position, x: ${x}, y: ${y}`,
+  "node.a11yDescription.ariaLiveMessage": ({ direction, x: x2, y }) => `Moved selected node ${direction}. New position, x: ${x2}, y: ${y}`,
   "edge.a11yDescription.default": "Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.",
   // Control elements
   "controls.ariaLabel": "Control Panel",
@@ -3314,8 +5024,8 @@ var getNodesInside = (nodes, rect, [tx, ty, tScale] = [0, 0, 1], partially = fal
     }
     const width = measured.width ?? node.width ?? node.initialWidth ?? 0;
     const height = measured.height ?? node.height ?? node.initialHeight ?? 0;
-    const { x, y } = node.internals.positionAbsolute;
-    const overlappingArea = getRectsOverlappingArea(paneX, paneY, paneWidth, paneHeight, x, y, width, height);
+    const { x: x2, y } = node.internals.positionAbsolute;
+    const overlappingArea = getRectsOverlappingArea(paneX, paneY, paneWidth, paneHeight, x2, y, width, height);
     const area = width * height;
     const partiallyVisible = partially && overlappingArea > 0;
     const forceInitialRender = !node.internals.handleBounds;
@@ -3465,33 +5175,33 @@ var getBoundsOfBoxes = (box1, box2) => ({
   x2: Math.max(box1.x2, box2.x2),
   y2: Math.max(box1.y2, box2.y2)
 });
-var rectToBox = ({ x, y, width, height }) => ({
-  x,
+var rectToBox = ({ x: x2, y, width, height }) => ({
+  x: x2,
   y,
-  x2: x + width,
+  x2: x2 + width,
   y2: y + height
 });
-var boxToRect = ({ x, y, x2, y2 }) => ({
-  x,
+var boxToRect = ({ x: x2, y, x2: x22, y2 }) => ({
+  x: x2,
   y,
-  width: x2 - x,
+  width: x22 - x2,
   height: y2 - y
 });
 var nodeToRect = (node, nodeOrigin = [0, 0]) => {
-  const { x, y } = isInternalNodeBase(node) ? node.internals.positionAbsolute : getNodePositionWithOrigin(node, nodeOrigin);
+  const { x: x2, y } = isInternalNodeBase(node) ? node.internals.positionAbsolute : getNodePositionWithOrigin(node, nodeOrigin);
   return {
-    x,
+    x: x2,
     y,
     width: node.measured?.width ?? node.width ?? node.initialWidth ?? 0,
     height: node.measured?.height ?? node.height ?? node.initialHeight ?? 0
   };
 };
 var nodeToBox = (node, nodeOrigin = [0, 0]) => {
-  const { x, y } = isInternalNodeBase(node) ? node.internals.positionAbsolute : getNodePositionWithOrigin(node, nodeOrigin);
+  const { x: x2, y } = isInternalNodeBase(node) ? node.internals.positionAbsolute : getNodePositionWithOrigin(node, nodeOrigin);
   return {
-    x,
+    x: x2,
     y,
-    x2: x + (node.measured?.width ?? node.width ?? node.initialWidth ?? 0),
+    x2: x2 + (node.measured?.width ?? node.width ?? node.initialWidth ?? 0),
     y2: y + (node.measured?.height ?? node.height ?? node.initialHeight ?? 0)
   };
 };
@@ -3515,16 +5225,16 @@ var snapPosition = (position, snapGrid = [1, 1]) => {
     y: snapGrid[1] * Math.round(position.y / snapGrid[1])
   };
 };
-var pointToRendererPoint = ({ x, y }, [tx, ty, tScale], snapToGrid = false, snapGrid = [1, 1]) => {
+var pointToRendererPoint = ({ x: x2, y }, [tx, ty, tScale], snapToGrid = false, snapGrid = [1, 1]) => {
   const position = {
-    x: (x - tx) / tScale,
+    x: (x2 - tx) / tScale,
     y: (y - ty) / tScale
   };
   return snapToGrid ? snapPosition(position, snapGrid) : position;
 };
-var rendererPointToPoint = ({ x, y }, [tx, ty, tScale]) => {
+var rendererPointToPoint = ({ x: x2, y }, [tx, ty, tScale]) => {
   return {
-    x: x * tScale + tx,
+    x: x2 * tScale + tx,
     y: y * tScale + ty
   };
 };
@@ -3569,9 +5279,9 @@ function parsePaddings(padding, width, height) {
   }
   return { top: 0, right: 0, bottom: 0, left: 0, x: 0, y: 0 };
 }
-function calculateAppliedPaddings(bounds, x, y, zoom, width, height) {
-  const { x: left, y: top } = rendererPointToPoint(bounds, [x, y, zoom]);
-  const { x: boundRight, y: boundBottom } = rendererPointToPoint({ x: bounds.x + bounds.width, y: bounds.y + bounds.height }, [x, y, zoom]);
+function calculateAppliedPaddings(bounds, x2, y, zoom, width, height) {
+  const { x: left, y: top } = rendererPointToPoint(bounds, [x2, y, zoom]);
+  const { x: boundRight, y: boundBottom } = rendererPointToPoint({ x: bounds.x + bounds.width, y: bounds.y + bounds.height }, [x2, y, zoom]);
   const right = width - boundRight;
   const bottom = height - boundBottom;
   return {
@@ -3582,24 +5292,24 @@ function calculateAppliedPaddings(bounds, x, y, zoom, width, height) {
   };
 }
 var getViewportForBounds = (bounds, width, height, minZoom, maxZoom, padding) => {
-  const p = parsePaddings(padding, width, height);
-  const xZoom = (width - p.x) / bounds.width;
-  const yZoom = (height - p.y) / bounds.height;
+  const p2 = parsePaddings(padding, width, height);
+  const xZoom = (width - p2.x) / bounds.width;
+  const yZoom = (height - p2.y) / bounds.height;
   const zoom = Math.min(xZoom, yZoom);
   const clampedZoom = clamp(zoom, minZoom, maxZoom);
   const boundsCenterX = bounds.x + bounds.width / 2;
   const boundsCenterY = bounds.y + bounds.height / 2;
-  const x = width / 2 - boundsCenterX * clampedZoom;
+  const x2 = width / 2 - boundsCenterX * clampedZoom;
   const y = height / 2 - boundsCenterY * clampedZoom;
-  const newPadding = calculateAppliedPaddings(bounds, x, y, clampedZoom, width, height);
+  const newPadding = calculateAppliedPaddings(bounds, x2, y, clampedZoom, width, height);
   const offset = {
-    left: Math.min(newPadding.left - p.left, 0),
-    top: Math.min(newPadding.top - p.top, 0),
-    right: Math.min(newPadding.right - p.right, 0),
-    bottom: Math.min(newPadding.bottom - p.bottom, 0)
+    left: Math.min(newPadding.left - p2.left, 0),
+    top: Math.min(newPadding.top - p2.top, 0),
+    right: Math.min(newPadding.right - p2.right, 0),
+    bottom: Math.min(newPadding.bottom - p2.bottom, 0)
   };
   return {
-    x: x - offset.left + offset.right,
+    x: x2 - offset.left + offset.right,
     y: y - offset.top + offset.bottom,
     zoom: clampedZoom
   };
@@ -3651,8 +5361,8 @@ function mergeAriaLabelConfig(partial) {
   return { ...defaultAriaLabelConfig, ...partial || {} };
 }
 function getPointerPosition(event, { snapGrid = [0, 0], snapToGrid = false, transform: transform2, containerBounds }) {
-  const { x, y } = getEventPosition(event);
-  const pointerPos = pointToRendererPoint({ x: x - (containerBounds?.left ?? 0), y: y - (containerBounds?.top ?? 0) }, transform2);
+  const { x: x2, y } = getEventPosition(event);
+  const pointerPos = pointToRendererPoint({ x: x2 - (containerBounds?.left ?? 0), y: y - (containerBounds?.top ?? 0) }, transform2);
   const { x: xSnapped, y: ySnapped } = snapToGrid ? snapPosition(pointerPos, snapGrid) : pointerPos;
   return {
     xSnapped,
@@ -3964,18 +5674,18 @@ function getPoints({ source, sourcePosition = Position.Bottom, target, targetPos
 }
 function getBend(a, b, c, size) {
   const bendSize = Math.min(distance(a, b) / 2, distance(b, c) / 2, size);
-  const { x, y } = b;
-  if (a.x === x && x === c.x || a.y === y && y === c.y) {
-    return `L${x} ${y}`;
+  const { x: x2, y } = b;
+  if (a.x === x2 && x2 === c.x || a.y === y && y === c.y) {
+    return `L${x2} ${y}`;
   }
   if (a.y === y) {
     const xDir2 = a.x < c.x ? -1 : 1;
     const yDir2 = a.y < c.y ? 1 : -1;
-    return `L ${x + bendSize * xDir2},${y}Q ${x},${y} ${x},${y + bendSize * yDir2}`;
+    return `L ${x2 + bendSize * xDir2},${y}Q ${x2},${y} ${x2},${y + bendSize * yDir2}`;
   }
   const xDir = a.x < c.x ? 1 : -1;
   const yDir = a.y < c.y ? -1 : 1;
-  return `L ${x},${y + bendSize * yDir}Q ${x},${y} ${x + bendSize * xDir},${y}`;
+  return `L ${x2},${y + bendSize * yDir}Q ${x2},${y} ${x2 + bendSize * xDir},${y}`;
 }
 function getSmoothStepPath({ sourceX, sourceY, sourcePosition = Position.Bottom, targetX, targetY, targetPosition = Position.Top, borderRadius = 5, centerX, centerY, offset = 20, stepPosition = 0.5 }) {
   const [points, labelX, labelY, offsetX, offsetY] = getPoints({
@@ -4052,22 +5762,22 @@ function toHandleBounds(handles) {
   };
 }
 function getHandlePosition(node, handle, fallbackPosition = Position.Left, center = false) {
-  const x = (handle?.x ?? 0) + node.internals.positionAbsolute.x;
+  const x2 = (handle?.x ?? 0) + node.internals.positionAbsolute.x;
   const y = (handle?.y ?? 0) + node.internals.positionAbsolute.y;
   const { width, height } = handle ?? getNodeDimensions(node);
   if (center) {
-    return { x: x + width / 2, y: y + height / 2 };
+    return { x: x2 + width / 2, y: y + height / 2 };
   }
   const position = handle?.position ?? fallbackPosition;
   switch (position) {
     case Position.Top:
-      return { x: x + width / 2, y };
+      return { x: x2 + width / 2, y };
     case Position.Right:
-      return { x: x + width, y: y + height / 2 };
+      return { x: x2 + width, y: y + height / 2 };
     case Position.Bottom:
-      return { x: x + width / 2, y: y + height };
+      return { x: x2 + width / 2, y: y + height };
     case Position.Left:
-      return { x, y: y + height / 2 };
+      return { x: x2, y: y + height / 2 };
   }
 }
 function getHandle$1(bounds, handleId) {
@@ -4273,16 +5983,16 @@ function updateChildNode(node, nodeLookup, parentLookup, options, rootParentInde
     rootParentIndex.i = parentNode.internals.rootParentIndex;
   }
   const selectedNodeZ = elevateNodesOnSelect && !isManualZIndexMode(zIndexMode) ? SELECTED_NODE_Z : 0;
-  const { x, y, z } = calculateChildXYZ(node, parentNode, nodeOrigin, nodeExtent, selectedNodeZ, zIndexMode);
+  const { x: x2, y, z: z2 } = calculateChildXYZ(node, parentNode, nodeOrigin, nodeExtent, selectedNodeZ, zIndexMode);
   const { positionAbsolute } = node.internals;
-  const positionChanged = x !== positionAbsolute.x || y !== positionAbsolute.y;
-  if (positionChanged || z !== node.internals.z) {
+  const positionChanged = x2 !== positionAbsolute.x || y !== positionAbsolute.y;
+  if (positionChanged || z2 !== node.internals.z) {
     nodeLookup.set(node.id, {
       ...node,
       internals: {
         ...node.internals,
-        positionAbsolute: positionChanged ? { x, y } : positionAbsolute,
-        z
+        positionAbsolute: positionChanged ? { x: x2, y } : positionAbsolute,
+        z: z2
       }
     });
   }
@@ -4568,13 +6278,13 @@ function getEventHandlerParams({ nodeId, dragItems, nodeLookup, dragging = true
     nodesFromDragItems
   ];
 }
-function calculateSnapOffset({ dragItems, snapGrid, x, y }) {
+function calculateSnapOffset({ dragItems, snapGrid, x: x2, y }) {
   const refDragItem = dragItems.values().next().value;
   if (!refDragItem) {
     return null;
   }
   const refPos = {
-    x: x - refDragItem.distance.x,
+    x: x2 - refDragItem.distance.x,
     y: y - refDragItem.distance.y
   };
   const refPosSnapped = snapPosition(refPos, snapGrid);
@@ -4597,23 +6307,23 @@ function XYDrag({ onNodeMouseDown, getStoreItems, onDragStart, onDrag, onDragSto
   let dragEvent = null;
   function update({ noDragClassName, handleSelector, domNode, isSelectable, nodeId, nodeClickDistance = 0 }) {
     d3Selection = select_default2(domNode);
-    function updateNodes({ x, y }) {
+    function updateNodes({ x: x2, y }) {
       const { nodeLookup, nodeExtent, snapGrid, snapToGrid, nodeOrigin, onNodeDrag, onSelectionDrag, onError, updateNodePositions } = getStoreItems();
-      lastPos = { x, y };
+      lastPos = { x: x2, y };
       let hasChange = false;
       const isMultiDrag = dragItems.size > 1;
       const nodesBox = isMultiDrag && nodeExtent ? rectToBox(getInternalNodesBounds(dragItems)) : null;
       const multiDragSnapOffset = isMultiDrag && snapToGrid ? calculateSnapOffset({
         dragItems,
         snapGrid,
-        x,
+        x: x2,
         y
       }) : null;
       for (const [id2, dragItem] of dragItems) {
         if (!nodeLookup.has(id2)) {
           continue;
         }
-        let nextPosition = { x: x - dragItem.distance.x, y: y - dragItem.distance.y };
+        let nextPosition = { x: x2 - dragItem.distance.x, y: y - dragItem.distance.y };
         if (snapToGrid) {
           nextPosition = multiDragSnapOffset ? {
             x: Math.round(nextPosition.x + multiDragSnapOffset.x),
@@ -4624,12 +6334,12 @@ function XYDrag({ onNodeMouseDown, getStoreItems, onDragStart, onDrag, onDragSto
         if (isMultiDrag && nodeExtent && !dragItem.extent && nodesBox) {
           const { positionAbsolute: positionAbsolute2 } = dragItem.internals;
           const x1 = positionAbsolute2.x - nodesBox.x + nodeExtent[0][0];
-          const x2 = positionAbsolute2.x + dragItem.measured.width - nodesBox.x2 + nodeExtent[1][0];
+          const x22 = positionAbsolute2.x + dragItem.measured.width - nodesBox.x2 + nodeExtent[1][0];
           const y1 = positionAbsolute2.y - nodesBox.y + nodeExtent[0][1];
           const y2 = positionAbsolute2.y + dragItem.measured.height - nodesBox.y2 + nodeExtent[1][1];
           adjustedNodeExtent = [
             [x1, y1],
-            [x2, y2]
+            [x22, y2]
           ];
         }
         const { position, positionAbsolute } = calculateNodePosition({
@@ -4738,9 +6448,9 @@ function XYDrag({ onNodeMouseDown, getStoreItems, onDragStart, onDrag, onDragSto
       }
       if (!dragStarted) {
         const currentMousePosition = getEventPosition(event.sourceEvent, containerBounds);
-        const x = currentMousePosition.x - mousePosition.x;
+        const x2 = currentMousePosition.x - mousePosition.x;
         const y = currentMousePosition.y - mousePosition.y;
-        const distance2 = Math.sqrt(x * x + y * y);
+        const distance2 = Math.sqrt(x2 * x2 + y * y);
         if (distance2 > nodeDragThreshold) {
           startDrag(event);
         }
@@ -4820,16 +6530,16 @@ function getClosestHandle(position, connectionRadius, nodeLookup, fromHandle) {
       if (fromHandle.nodeId === handle.nodeId && fromHandle.type === handle.type && fromHandle.id === handle.id) {
         continue;
       }
-      const { x, y } = getHandlePosition(node, handle, handle.position, true);
-      const distance2 = Math.sqrt(Math.pow(x - position.x, 2) + Math.pow(y - position.y, 2));
+      const { x: x2, y } = getHandlePosition(node, handle, handle.position, true);
+      const distance2 = Math.sqrt(Math.pow(x2 - position.x, 2) + Math.pow(y - position.y, 2));
       if (distance2 > connectionRadius) {
         continue;
       }
       if (distance2 < minDistance) {
-        closestHandles = [{ ...handle, x, y }];
+        closestHandles = [{ ...handle, x: x2, y }];
         minDistance = distance2;
       } else if (distance2 === minDistance) {
-        closestHandles.push({ ...handle, x, y });
+        closestHandles.push({ ...handle, x: x2, y });
       }
     }
   }
@@ -4875,7 +6585,7 @@ function onPointerDown(event, { connectionMode, connectionRadius, handleId, node
   const doc = getHostForElement(event.target);
   let autoPanId = 0;
   let closestHandle;
-  const { x, y } = getEventPosition(event);
+  const { x: x2, y } = getEventPosition(event);
   const handleType = getHandleType(edgeUpdaterType, handleDomNode);
   const containerBounds = domNode?.getBoundingClientRect();
   let connectionStarted = false;
@@ -4895,8 +6605,8 @@ function onPointerDown(event, { connectionMode, connectionRadius, handleId, node
     if (!autoPanOnConnect || !containerBounds) {
       return;
     }
-    const [x2, y2] = calcAutoPan(position, containerBounds, autoPanSpeed);
-    panBy2({ x: x2, y: y2 });
+    const [x3, y2] = calcAutoPan(position, containerBounds, autoPanSpeed);
+    panBy2({ x: x3, y: y2 });
     autoPanId = requestAnimationFrame(autoPan);
   }
   const fromHandle = {
@@ -4931,7 +6641,7 @@ function onPointerDown(event, { connectionMode, connectionRadius, handleId, node
   function onPointerMove(event2) {
     if (!connectionStarted) {
       const { x: evtX, y: evtY } = getEventPosition(event2);
-      const dx = evtX - x;
+      const dx = evtX - x2;
       const dy = evtY - y;
       const nextConnectionStarted = dx * dx + dy * dy > dragThreshold * dragThreshold;
       if (!nextConnectionStarted) {
@@ -5017,8 +6727,8 @@ function onPointerDown(event, { connectionMode, connectionRadius, handleId, node
 function isValidHandle(event, { handle, connectionMode, fromNodeId, fromHandleId, fromType, doc, lib, flowId, isValidConnection = alwaysValid, nodeLookup }) {
   const isTarget = fromType === "target";
   const handleDomNode = handle ? doc.querySelector(`.${lib}-flow__handle[data-id="${flowId}-${handle?.nodeId}-${handle?.id}-${handle?.type}"]`) : null;
-  const { x, y } = getEventPosition(event);
-  const handleBelow = doc.elementFromPoint(x, y);
+  const { x: x2, y } = getEventPosition(event);
+  const handleBelow = doc.elementFromPoint(x2, y);
   const handleToCheck = handleBelow?.classList.contains(`${lib}-flow__handle`) ? handleBelow : handleDomNode;
   const result = {
     handleDomNode: handleToCheck,
@@ -5118,7 +6828,7 @@ var transformToViewport = (transform2) => ({
   y: transform2.y,
   zoom: transform2.k
 });
-var viewportToTransform = ({ x, y, zoom }) => identity2.translate(x, y).scale(zoom);
+var viewportToTransform = ({ x: x2, y, zoom }) => identity2.translate(x2, y).scale(zoom);
 var isWrappedWithClass = (event, className) => event.target.closest(`.${className}`);
 var isRightClickPan = (panOnDrag, usedButton) => usedButton === 2 && Array.isArray(panOnDrag) && panOnDrag.includes(2);
 var defaultEase = (t) => ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
@@ -5613,12 +7323,12 @@ function getDimensionsAfterResize(startValues, controlDirection, pointerPosition
       }
     }
   }
-  const x = affectsX ? startX + distX : startX;
+  const x2 = affectsX ? startX + distX : startX;
   const y = affectsY ? startY + distY : startY;
   return {
     width: startWidth + (affectsX ? -distX : distX),
     height: startHeight + (affectsY ? -distY : distY),
-    x: nodeOrigin[0] * distX * (!affectsX ? 1 : -1) + x,
+    x: nodeOrigin[0] * distX * (!affectsX ? 1 : -1) + x2,
     y: nodeOrigin[1] * distY * (!affectsY ? 1 : -1) + y
   };
 }
@@ -5630,15 +7340,15 @@ var initStartValues = {
   aspectRatio: 1
 };
 function nodeToChildExtent(child, parent, nodeOrigin) {
-  const x = parent.position.x + child.position.x;
+  const x2 = parent.position.x + child.position.x;
   const y = parent.position.y + child.position.y;
   const width = child.measured.width ?? 0;
   const height = child.measured.height ?? 0;
   const originOffsetX = nodeOrigin[0] * width;
   const originOffsetY = nodeOrigin[1] * height;
   return [
-    [x - originOffsetX, y - originOffsetY],
-    [x + width - originOffsetX, y + height - originOffsetY]
+    [x2 - originOffsetX, y - originOffsetY],
+    [x2 + width - originOffsetX, y + height - originOffsetY]
   ];
 }
 function XYResizer({ domNode, nodeId, getStoreItems, onChange, onEnd }) {
@@ -5744,21 +7454,21 @@ function XYResizer({ domNode, nodeId, getStoreItems, onChange, onEnd }) {
       const { x: prevX, y: prevY, width: prevWidth, height: prevHeight } = prevValues;
       const change = {};
       const nodeOrigin = node.origin ?? storeNodeOrigin;
-      const { width, height, x, y } = getDimensionsAfterResize(startValues, params.controlDirection, pointerPosition, params.boundaries, params.keepAspectRatio, nodeOrigin, nodeExtent, childExtent);
+      const { width, height, x: x2, y } = getDimensionsAfterResize(startValues, params.controlDirection, pointerPosition, params.boundaries, params.keepAspectRatio, nodeOrigin, nodeExtent, childExtent);
       const isWidthChange = width !== prevWidth;
       const isHeightChange = height !== prevHeight;
-      const isXPosChange = x !== prevX && isWidthChange;
+      const isXPosChange = x2 !== prevX && isWidthChange;
       const isYPosChange = y !== prevY && isHeightChange;
       if (!isXPosChange && !isYPosChange && !isWidthChange && !isHeightChange) {
         return;
       }
       if (isXPosChange || isYPosChange || nodeOrigin[0] === 1 || nodeOrigin[1] === 1) {
-        change.x = isXPosChange ? x : prevValues.x;
+        change.x = isXPosChange ? x2 : prevValues.x;
         change.y = isYPosChange ? y : prevValues.y;
         prevValues.x = change.x;
         prevValues.y = change.y;
         if (childNodes.length > 0) {
-          const xChange = x - prevX;
+          const xChange = x2 - prevX;
           const yChange = y - prevY;
           for (const childNode of childNodes) {
             childNode.position = {
@@ -6053,7 +7763,7 @@ function SelectionListenerInner({ onSelectionChange }) {
   ReactExports.useEffect(() => {
     const params = { nodes: selectedNodes, edges: selectedEdges };
     onSelectionChange?.(params);
-    store.getState().onSelectionChangeHandlers.forEach((fn) => fn(params));
+    store.getState().onSelectionChangeHandlers.forEach((fn2) => fn2(params));
   }, [selectedNodes, selectedEdges, onSelectionChange]);
   return null;
 }
@@ -6290,7 +8000,7 @@ function useKeyPress(keyCode = null, options = { target: defaultDoc, actInsideIn
   return keyPressed;
 }
 function isMatchingKey(keyCodes, pressedKeys, isUp) {
-  return keyCodes.filter((keys) => isUp || keys.length === pressedKeys.size).some((keys) => keys.every((k) => pressedKeys.has(k)));
+  return keyCodes.filter((keys) => isUp || keys.length === pressedKeys.size).some((keys) => keys.every((k2) => pressedKeys.has(k2)));
 }
 function useKeyOrCode(eventCode, keysToWatch) {
   return keysToWatch.includes(eventCode) ? "code" : "key";
@@ -6325,11 +8035,11 @@ var useViewportHelper = () => {
         return true;
       },
       getViewport: () => {
-        const [x, y, zoom] = store.getState().transform;
-        return { x, y, zoom };
+        const [x2, y, zoom] = store.getState().transform;
+        return { x: x2, y, zoom };
       },
-      setCenter: async (x, y, options) => {
-        return store.getState().setCenter(x, y, options);
+      setCenter: async (x2, y, options) => {
+        return store.getState().setCenter(x2, y, options);
       },
       fitBounds: async (bounds, options) => {
         const { width, height, minZoom, maxZoom, panZoom } = store.getState();
@@ -6677,12 +8387,12 @@ function useReactFlow() {
       },
       toObject: () => {
         const { nodes = [], edges = [], transform: transform2 } = store.getState();
-        const [x, y, zoom] = transform2;
+        const [x2, y, zoom] = transform2;
         return {
           nodes: nodes.map((n) => ({ ...n })),
           edges: edges.map((e) => ({ ...e })),
           viewport: {
-            x,
+            x: x2,
             y,
             zoom
           }
@@ -6878,10 +8588,10 @@ function ZoomPane({ onPaneContextMenu, zoomOnScroll = true, zoomOnPinch = true,
           onViewportChangeEnd?.(vp);
         }
       });
-      const { x, y, zoom } = panZoom.current.getViewport();
+      const { x: x2, y, zoom } = panZoom.current.getViewport();
       store.setState({
         panZoom: panZoom.current,
-        transform: [x, y, zoom],
+        transform: [x2, y, zoom],
         domNode: zoomPane.current.closest(".react-flow")
       });
       return () => {
@@ -7013,15 +8723,15 @@ function Pane({ isSelecting, selectionKeyPressed, selectionMode = SelectionMode.
     }
     event.target?.setPointerCapture?.(event.pointerId);
     selectionInProgress.current = false;
-    const { x, y } = getEventPosition(event.nativeEvent, containerBounds.current);
-    const userSelectionStartPosition = pointToRendererPoint({ x, y }, transform2);
+    const { x: x2, y } = getEventPosition(event.nativeEvent, containerBounds.current);
+    const userSelectionStartPosition = pointToRendererPoint({ x: x2, y }, transform2);
     store.setState({
       userSelectionRect: {
         width: 0,
         height: 0,
         startX: userSelectionStartPosition.x,
         startY: userSelectionStartPosition.y,
-        x,
+        x: x2,
         y
       }
     });
@@ -7080,8 +8790,8 @@ function Pane({ isSelecting, selectionKeyPressed, selectionMode = SelectionMode.
     if (!autoPanOnSelection || !containerBounds.current) {
       return;
     }
-    const [x, y] = calcAutoPan(position.current, containerBounds.current, autoPanSpeed);
-    panBy2({ x, y }).then((panned) => {
+    const [x2, y] = calcAutoPan(position.current, containerBounds.current, autoPanSpeed);
+    panBy2({ x: x2, y }).then((panned) => {
       if (!selectionInProgress.current || !panned) {
         autoPanId.current = requestAnimationFrame(autoPan);
         return;
@@ -7459,14 +9169,14 @@ function getNodeInlineStyleDimensions(node) {
   };
 }
 var selector$f = (s) => {
-  const { width, height, x, y } = getInternalNodesBounds(s.nodeLookup, {
+  const { width, height, x: x2, y } = getInternalNodesBounds(s.nodeLookup, {
     filter: (node) => !!node.selected
   });
   return {
     width: isNumeric(width) ? width : null,
     height: isNumeric(height) ? height : null,
     userSelectionActive: s.userSelectionActive,
-    transformString: `translate(${s.transform[0]}px,${s.transform[1]}px) scale(${s.transform[2]}) translate(${x}px,${y}px)`
+    transformString: `translate(${s.transform[0]}px,${s.transform[1]}px) scale(${s.transform[2]}) translate(${x2}px,${y}px)`
   };
 };
 function NodesSelection({ onSelectionContextMenu, noPanClassName, disableKeyboardA11y }) {
@@ -7851,7 +9561,7 @@ var MarkerDefinitions = ({ defaultColor, rfId }) => {
 };
 MarkerDefinitions.displayName = "MarkerDefinitions";
 var MarkerDefinitions$1 = ReactExports.memo(MarkerDefinitions);
-function EdgeTextComponent({ x, y, label, labelStyle, labelShowBg = true, labelBgStyle, labelBgPadding = [2, 4], labelBgBorderRadius = 2, children: children2, className, ...rest }) {
+function EdgeTextComponent({ x: x2, y, label, labelStyle, labelShowBg = true, labelBgStyle, labelBgPadding = [2, 4], labelBgBorderRadius = 2, children: children2, className, ...rest }) {
   const [edgeTextBbox, setEdgeTextBbox] = ReactExports.useState({ x: 1, y: 0, width: 0, height: 0 });
   const edgeTextClasses = cc(["react-flow__edge-textwrapper", className]);
   const edgeTextRef = ReactExports.useRef(null);
@@ -7869,7 +9579,7 @@ function EdgeTextComponent({ x, y, label, labelStyle, labelShowBg = true, labelB
   if (!label) {
     return null;
   }
-  return jsxRuntime.jsxs("g", { transform: `translate(${x - edgeTextBbox.width / 2} ${y - edgeTextBbox.height / 2})`, className: edgeTextClasses, visibility: edgeTextBbox.width ? "visible" : "hidden", ...rest, children: [labelShowBg && jsxRuntime.jsx("rect", { width: edgeTextBbox.width + 2 * labelBgPadding[0], x: -labelBgPadding[0], y: -labelBgPadding[1], height: edgeTextBbox.height + 2 * labelBgPadding[1], className: "react-flow__edge-textbg", style: labelBgStyle, rx: labelBgBorderRadius, ry: labelBgBorderRadius }), jsxRuntime.jsx("text", { className: "react-flow__edge-text", y: edgeTextBbox.height / 2, dy: "0.3em", ref: edgeTextRef, style: labelStyle, children: label }), children2] });
+  return jsxRuntime.jsxs("g", { transform: `translate(${x2 - edgeTextBbox.width / 2} ${y - edgeTextBbox.height / 2})`, className: edgeTextClasses, visibility: edgeTextBbox.width ? "visible" : "hidden", ...rest, children: [labelShowBg && jsxRuntime.jsx("rect", { width: edgeTextBbox.width + 2 * labelBgPadding[0], x: -labelBgPadding[0], y: -labelBgPadding[1], height: edgeTextBbox.height + 2 * labelBgPadding[1], className: "react-flow__edge-textbg", style: labelBgStyle, rx: labelBgBorderRadius, ry: labelBgBorderRadius }), jsxRuntime.jsx("text", { className: "react-flow__edge-text", y: edgeTextBbox.height / 2, dy: "0.3em", ref: edgeTextRef, style: labelStyle, children: label }), children2] });
 }
 EdgeTextComponent.displayName = "EdgeText";
 var EdgeText = ReactExports.memo(EdgeTextComponent);
@@ -8010,12 +9720,12 @@ var nullPosition = {
   targetPosition: null,
   zIndex: void 0
 };
-var shiftX = (x, shift, position) => {
+var shiftX = (x2, shift, position) => {
   if (position === Position.Left)
-    return x - shift;
+    return x2 - shift;
   if (position === Position.Right)
-    return x + shift;
-  return x;
+    return x2 + shift;
+  return x2;
 };
 var shiftY = (y, shift, position) => {
   if (position === Position.Top)
@@ -8356,8 +10066,8 @@ var getInitialState = ({ nodes, edges, defaultNodes, defaultEdges, width, height
     const bounds = getInternalNodesBounds(nodeLookup, {
       filter: (node) => !!((node.width || node.initialWidth) && (node.height || node.initialHeight))
     });
-    const { x, y, zoom } = getViewportForBounds(bounds, width, height, minZoom, maxZoom, fitViewOptions?.padding ?? 0.1);
-    transform2 = [x, y, zoom];
+    const { x: x2, y, zoom } = getViewportForBounds(bounds, width, height, minZoom, maxZoom, fitViewOptions?.padding ?? 0.1);
+    transform2 = [x2, y, zoom];
   }
   return {
     rfId: "1",
@@ -8679,14 +10389,14 @@ var createStore2 = ({ nodes, edges, defaultNodes, defaultEdges, width, height, f
       const { transform: transform2, width: width2, height: height2, panZoom, translateExtent } = get3();
       return panBy({ delta, panZoom, transform: transform2, translateExtent, width: width2, height: height2 });
     },
-    setCenter: async (x, y, options) => {
+    setCenter: async (x2, y, options) => {
       const { width: width2, height: height2, maxZoom: maxZoom2, panZoom } = get3();
       if (!panZoom) {
         return false;
       }
       const nextZoom = typeof options?.zoom !== "undefined" ? options.zoom : maxZoom2;
       await panZoom.setViewport({
-        x: width2 / 2 - x * nextZoom,
+        x: width2 / 2 - x2 * nextZoom,
         y: height2 / 2 - y * nextZoom,
         zoom: nextZoom
       }, { duration: options?.duration, ease: options?.ease, interpolate: options?.interpolate });
@@ -8855,10 +10565,10 @@ function ControlsComponent({ style: style2, showZoom = true, showFitView = true,
 }
 ControlsComponent.displayName = "Controls";
 var Controls = ReactExports.memo(ControlsComponent);
-function MiniMapNodeComponent({ id: id2, x, y, width, height, style: style2, color: color2, strokeColor, strokeWidth, className, borderRadius, shapeRendering, selected: selected2, onClick }) {
+function MiniMapNodeComponent({ id: id2, x: x2, y, width, height, style: style2, color: color2, strokeColor, strokeWidth, className, borderRadius, shapeRendering, selected: selected2, onClick }) {
   const { background, backgroundColor } = style2 || {};
   const fill = color2 || background || backgroundColor;
-  return jsxRuntime.jsx("rect", { className: cc(["react-flow__minimap-node", { selected: selected2 }, className]), x, y, rx: borderRadius, ry: borderRadius, width, height, style: {
+  return jsxRuntime.jsx("rect", { className: cc(["react-flow__minimap-node", { selected: selected2 }, className]), x: x2, y, rx: borderRadius, ry: borderRadius, width, height, style: {
     fill,
     stroke: strokeColor,
     strokeWidth
@@ -8897,17 +10607,17 @@ function MiniMapNodes({
   )) });
 }
 function NodeComponentWrapperInner({ id: id2, nodeColorFunc, nodeStrokeColorFunc, nodeClassNameFunc, nodeBorderRadius, nodeStrokeWidth, shapeRendering, NodeComponent, onClick }) {
-  const { node, x, y, width, height } = useStore((s) => {
+  const { node, x: x2, y, width, height } = useStore((s) => {
     const node2 = s.nodeLookup.get(id2);
     if (!node2) {
       return { node: void 0, x: 0, y: 0, width: 0, height: 0 };
     }
     const userNode = node2.internals.userNode;
-    const { x: x2, y: y2 } = node2.internals.positionAbsolute;
+    const { x: x3, y: y2 } = node2.internals.positionAbsolute;
     const { width: width2, height: height2 } = getNodeDimensions(userNode);
     return {
       node: userNode,
-      x: x2,
+      x: x3,
       y: y2,
       width: width2,
       height: height2
@@ -8916,7 +10626,7 @@ function NodeComponentWrapperInner({ id: id2, nodeColorFunc, nodeStrokeColorFunc
   if (!node || node.hidden || !nodeHasDimensions(node)) {
     return null;
   }
-  return jsxRuntime.jsx(NodeComponent, { x, y, width, height, style: node.style, selected: !!node.selected, className: nodeClassNameFunc(node), color: nodeColorFunc(node), borderRadius: nodeBorderRadius, strokeColor: nodeStrokeColorFunc(node), strokeWidth: nodeStrokeWidth, shapeRendering, onClick, id: node.id });
+  return jsxRuntime.jsx(NodeComponent, { x: x2, y, width, height, style: node.style, selected: !!node.selected, className: nodeClassNameFunc(node), color: nodeColorFunc(node), borderRadius: nodeBorderRadius, strokeColor: nodeStrokeColorFunc(node), strokeWidth: nodeStrokeWidth, shapeRendering, onClick, id: node.id });
 }
 var NodeComponentWrapper = ReactExports.memo(NodeComponentWrapperInner);
 var MiniMapNodes$1 = ReactExports.memo(MiniMapNodes);
@@ -8980,7 +10690,7 @@ function MiniMapComponent({
   const viewWidth = viewScale * elementWidth;
   const viewHeight = viewScale * elementHeight;
   const offset = offsetScale * viewScale;
-  const x = boundingRect.x - (viewWidth - boundingRect.width) / 2 - offset;
+  const x2 = boundingRect.x - (viewWidth - boundingRect.width) / 2 - offset;
   const y = boundingRect.y - (viewHeight - boundingRect.height) / 2 - offset;
   const width = viewWidth + offset * 2;
   const height = viewHeight + offset * 2;
@@ -9013,8 +10723,8 @@ function MiniMapComponent({
     });
   }, [pannable, zoomable, inversePan, zoomStep, translateExtent, flowWidth, flowHeight]);
   const onSvgClick = onClick ? (event) => {
-    const [x2, y2] = minimapInstance.current?.pointer(event) || [0, 0];
-    onClick(event, { x: x2, y: y2 });
+    const [x3, y2] = minimapInstance.current?.pointer(event) || [0, 0];
+    onClick(event, { x: x3, y: y2 });
   } : void 0;
   const onSvgNodeClick = onNodeClick ? ReactExports.useCallback((event, nodeId) => {
     const node = store.getState().nodeLookup.get(nodeId).internals.userNode;
@@ -9030,7 +10740,7 @@ function MiniMapComponent({
     "--xy-minimap-node-background-color-props": typeof nodeColor === "string" ? nodeColor : void 0,
     "--xy-minimap-node-stroke-color-props": typeof nodeStrokeColor === "string" ? nodeStrokeColor : void 0,
     "--xy-minimap-node-stroke-width-props": typeof nodeStrokeWidth === "number" ? nodeStrokeWidth : void 0
-  }, className: cc(["react-flow__minimap", className]), "data-testid": "rf__minimap", children: jsxRuntime.jsxs("svg", { width: elementWidth, height: elementHeight, viewBox: `${x} ${y} ${width} ${height}`, className: "react-flow__minimap-svg", role: "img", "aria-labelledby": labelledBy, ref: svg, onClick: onSvgClick, children: [_ariaLabel && jsxRuntime.jsx("title", { id: labelledBy, children: _ariaLabel }), jsxRuntime.jsx(MiniMapNodes$1, { onClick: onSvgNodeClick, nodeColor, nodeStrokeColor, nodeBorderRadius, nodeClassName, nodeStrokeWidth, nodeComponent }), jsxRuntime.jsx("path", { className: "react-flow__minimap-mask", d: `M${x - offset},${y - offset}h${width + offset * 2}v${height + offset * 2}h${-width - offset * 2}z
+  }, className: cc(["react-flow__minimap", className]), "data-testid": "rf__minimap", children: jsxRuntime.jsxs("svg", { width: elementWidth, height: elementHeight, viewBox: `${x2} ${y} ${width} ${height}`, className: "react-flow__minimap-svg", role: "img", "aria-labelledby": labelledBy, ref: svg, onClick: onSvgClick, children: [_ariaLabel && jsxRuntime.jsx("title", { id: labelledBy, children: _ariaLabel }), jsxRuntime.jsx(MiniMapNodes$1, { onClick: onSvgNodeClick, nodeColor, nodeStrokeColor, nodeBorderRadius, nodeClassName, nodeStrokeWidth, nodeComponent }), jsxRuntime.jsx("path", { className: "react-flow__minimap-mask", d: `M${x2 - offset},${y - offset}h${width + offset * 2}v${height + offset * 2}h${-width - offset * 2}z
         M${viewBB.x},${viewBB.y}h${viewBB.width}v${viewBB.height}h${-viewBB.width}z`, fillRule: "evenodd", pointerEvents: "none" })] }) });
 }
 MiniMapComponent.displayName = "MiniMap";
@@ -9223,7 +10933,7 @@ function NodeToolbar({ nodeId, children: children2, className, style: style2, is
     return internalNodes;
   }, [nodeId, contextNodeId]);
   const nodes = useStore(nodesSelector, nodesEqualityFn);
-  const { x, y, zoom, selectedNodesCount } = useStore(storeSelector, shallow$1);
+  const { x: x2, y, zoom, selectedNodesCount } = useStore(storeSelector, shallow$1);
   const isActive = typeof isVisible === "boolean" ? isVisible : nodes.size === 1 && nodes.values().next().value?.selected && selectedNodesCount === 1;
   if (!isActive || !nodes.size) {
     return null;
@@ -9233,7 +10943,7 @@ function NodeToolbar({ nodeId, children: children2, className, style: style2, is
   const zIndex = Math.max(...nodesArray.map((node) => node.internals.z + 1));
   const wrapperStyle2 = {
     position: "absolute",
-    transform: getNodeToolbarTransform(nodeRect, { x, y, zoom }, position, offset, align),
+    transform: getNodeToolbarTransform(nodeRect, { x: x2, y, zoom }, position, offset, align),
     zIndex,
     ...style2
   };
@@ -9488,7 +11198,7 @@ function activatedPorts(node, result) {
     }
   }
   const kind = getNodeKind(node.data?.kind ?? node.type ?? "") ?? void 0;
-  const declared = resolveNodePorts(node, kind).outputs?.map((p) => p.id);
+  const declared = resolveNodePorts(node, kind).outputs?.map((p2) => p2.id);
   return { ports: declared?.length ? declared : ["out"], value: result };
 }
 
@@ -10338,7 +12048,7 @@ var KINDS = [
   }
 ];
 function registerBuiltinKinds() {
-  for (const k of KINDS) registerNodeKind(k);
+  for (const k2 of KINDS) registerNodeKind(k2);
 }
 var BUILTIN_KINDS = KINDS;
 function NodeShellInner({
@@ -10369,27 +12079,27 @@ function NodeShellInner({
         data.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__desc", children: data.description }),
         children2 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-node__body", children: children2 }),
         data.statusText && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__status-text", children: data.statusText }),
-        inputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        inputs.map((p2, i) => /* @__PURE__ */ jsxRuntime.jsx(
           Handle,
           {
             type: "target",
             position: Position.Left,
-            id: p.id,
+            id: p2.id,
             style: portStyle(i, inputs.length),
-            title: p.label ?? p.id
+            title: p2.label ?? p2.id
           },
-          p.id
+          p2.id
         )),
-        outputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        outputs.map((p2, i) => /* @__PURE__ */ jsxRuntime.jsx(
           Handle,
           {
             type: "source",
             position: Position.Right,
-            id: p.id,
+            id: p2.id,
             style: portStyle(i, outputs.length),
-            title: p.label ?? p.id
+            title: p2.label ?? p2.id
           },
-          p.id
+          p2.id
         ))
       ]
     }
@@ -10481,7 +12191,7 @@ function portsFor(node, side) {
 }
 function findPort(ports, handleId) {
   if (handleId == null) return ports.length === 1 ? ports[0] : void 0;
-  return ports.find((p) => p.id === handleId);
+  return ports.find((p2) => p2.id === handleId);
 }
 function createConnectionValidator(getNodes, options = {}) {
   const compatible = options.compatible ?? defaultPortCompatibility;
@@ -10561,14 +12271,14 @@ function alignNodes(nodes, edge) {
   const cx = (minL + maxR) / 2;
   const cy = (minT + maxB) / 2;
   return nodes.map((n) => {
-    let { x, y } = n.position;
-    if (edge === "left") x = minL;
-    else if (edge === "right") x = maxR - nodeW(n);
-    else if (edge === "hcenter") x = cx - nodeW(n) / 2;
+    let { x: x2, y } = n.position;
+    if (edge === "left") x2 = minL;
+    else if (edge === "right") x2 = maxR - nodeW(n);
+    else if (edge === "hcenter") x2 = cx - nodeW(n) / 2;
     else if (edge === "top") y = minT;
     else if (edge === "bottom") y = maxB - nodeH(n);
     else if (edge === "vcenter") y = cy - nodeH(n) / 2;
-    return { ...n, position: { x, y } };
+    return { ...n, position: { x: x2, y } };
   });
 }
 function sortNodesParentFirst(nodes) {
@@ -10607,7 +12317,7 @@ function removeFromLane(nodes, nodeId) {
   const abs = absolutePosition(node, nodes);
   return nodes.map((n) => {
     if (n.id !== nodeId) return n;
-    const { parentId: _p, extent: _e, ...rest } = n;
+    const { parentId: _p, extent: _e2, ...rest } = n;
     return { ...rest, position: abs };
   });
 }
@@ -10628,8 +12338,8 @@ function distributeNodes(nodes, axis) {
     cursor += size(n) + gap;
   }
   return nodes.map((n) => {
-    const p = posById.get(n.id);
-    return { ...n, position: axis === "h" ? { ...n.position, x: p } : { ...n.position, y: p } };
+    const p2 = posById.get(n.id);
+    return { ...n, position: axis === "h" ? { ...n.position, x: p2 } : { ...n.position, y: p2 } };
   });
 }
 var DEFAULT_FIT_VIEW = { padding: 0.2 };
@@ -10717,13 +12427,13 @@ function NodePalette({ categories, onPick, className, style: style2 }) {
   const visibleCats = categories ?? CATEGORY_ORDER;
   const grouped = ReactExports.useMemo(() => {
     const all = listNodeKinds();
-    const q = query.trim().toLowerCase();
-    const filtered = q ? all.filter((k) => k.name.includes(q) || k.label.toLowerCase().includes(q) || (k.description ?? "").toLowerCase().includes(q)) : all;
+    const q2 = query.trim().toLowerCase();
+    const filtered = q2 ? all.filter((k2) => k2.name.includes(q2) || k2.label.toLowerCase().includes(q2) || (k2.description ?? "").toLowerCase().includes(q2)) : all;
     const map = /* @__PURE__ */ new Map();
     for (const cat of visibleCats) map.set(cat, []);
-    for (const k of filtered) {
-      if (!map.has(k.category)) map.set(k.category, []);
-      map.get(k.category).push(k);
+    for (const k2 of filtered) {
+      if (!map.has(k2.category)) map.set(k2.category, []);
+      map.get(k2.category).push(k2);
     }
     return map;
   }, [query, visibleCats]);
@@ -10740,7 +12450,7 @@ function NodePalette({ categories, onPick, className, style: style2 }) {
     /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-palette__list", children: Array.from(grouped.entries()).map(
       ([cat, kinds2]) => kinds2.length === 0 ? null : /* @__PURE__ */ jsxRuntime.jsxs("section", { className: "ff-palette__group", children: [
         /* @__PURE__ */ jsxRuntime.jsx("header", { className: "ff-palette__group-label", children: CATEGORY_LABELS[cat] ?? cat }),
-        kinds2.map((k) => /* @__PURE__ */ jsxRuntime.jsx(KindRow, { kind: k, onPick }, k.name))
+        kinds2.map((k2) => /* @__PURE__ */ jsxRuntime.jsx(KindRow, { kind: k2, onPick }, k2.name))
       ] }, cat)
     ) })
   ] });
@@ -10961,7 +12671,7 @@ function RepeaterField({
     }
     replace([...rows, blank]);
   };
-  const removeRow = (i) => replace(rows.filter((_, idx) => idx !== i));
+  const removeRow = (i) => replace(rows.filter((_2, idx) => idx !== i));
   const moveRow = (i, delta) => {
     const target = i + delta;
     if (target < 0 || target >= rows.length) return;
@@ -11059,15 +12769,15 @@ function KeyValueField({
   const entries = Object.entries(map);
   const commit = (next) => {
     const obj = {};
-    for (const [k, v] of next) {
-      if (k === "") continue;
-      obj[k] = v;
+    for (const [k2, v2] of next) {
+      if (k2 === "") continue;
+      obj[k2] = v2;
     }
     onChange(obj);
   };
-  const setKey = (i, key) => commit(entries.map(([k, v], idx) => idx === i ? [key, v] : [k, v]));
-  const setVal = (i, val) => commit(entries.map(([k, v], idx) => idx === i ? [k, val] : [k, v]));
-  const remove2 = (i) => commit(entries.filter((_, idx) => idx !== i));
+  const setKey = (i, key) => commit(entries.map(([k2, v2], idx) => idx === i ? [key, v2] : [k2, v2]));
+  const setVal = (i, val) => commit(entries.map(([k2, v2], idx) => idx === i ? [k2, val] : [k2, v2]));
+  const remove2 = (i) => commit(entries.filter((_2, idx) => idx !== i));
   const add = () => commit([...entries, ["", ""]]);
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-keyvalue", "data-ff-keyvalue": field.key, children: [
     entries.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-keyvalue__head", children: [
@@ -11075,12 +12785,12 @@ function KeyValueField({
       /* @__PURE__ */ jsxRuntime.jsx("span", { children: field.valueLabel ?? "Value" }),
       /* @__PURE__ */ jsxRuntime.jsx("span", {})
     ] }),
-    entries.map(([k, v], i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-keyvalue__row", "data-ff-keyvalue-row": i, children: [
+    entries.map(([k2, v2], i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ff-keyvalue__row", "data-ff-keyvalue-row": i, children: [
       /* @__PURE__ */ jsxRuntime.jsx(
         "input",
         {
           className: "ff-panel__input",
-          value: k,
+          value: k2,
           placeholder: field.keyPlaceholder,
           "aria-label": `${field.keyLabel ?? "Key"} ${i + 1}`,
           onChange: (e) => setKey(i, e.target.value)
@@ -11090,7 +12800,7 @@ function KeyValueField({
         "select",
         {
           className: "ff-panel__input",
-          value: v ?? "",
+          value: v2 ?? "",
           "aria-label": `${field.valueLabel ?? "Value"} ${i + 1}`,
           onChange: (e) => setVal(i, e.target.value),
           children: [
@@ -11102,7 +12812,7 @@ function KeyValueField({
         "input",
         {
           className: "ff-panel__input",
-          value: v ?? "",
+          value: v2 ?? "",
           placeholder: field.valuePlaceholder,
           "aria-label": `${field.valueLabel ?? "Value"} ${i + 1}`,
           onChange: (e) => setVal(i, e.target.value)
@@ -11114,7 +12824,7 @@ function KeyValueField({
           type: "button",
           className: "ff-repeater__btn ff-repeater__btn--danger",
           onClick: () => remove2(i),
-          "aria-label": `Remove ${k || `entry ${i + 1}`}`,
+          "aria-label": `Remove ${k2 || `entry ${i + 1}`}`,
           children: "\u2715"
         }
       )
@@ -11250,7 +12960,7 @@ function NodeConfigPanel({
           {
             field,
             value: config[field.key],
-            onChange: (v) => setConfigValue(field.key, v),
+            onChange: (v2) => setConfigValue(field.key, v2),
             renderCredentialField,
             renderDocumentField: documentField
           }
@@ -11295,8 +13005,8 @@ function FlowRunFeed({ entries, className, style: style2 }) {
     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-run-feed__text", children: e.text })
   ] }, e.id)) });
 }
-function formatTime(at) {
-  const d = new Date(at);
+function formatTime(at2) {
+  const d = new Date(at2);
   return `${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${Math.floor(d.getMilliseconds() / 100)}`;
 }
 function useFlowState(initial) {
@@ -11506,12 +13216,12 @@ function applyStatusesToNodes(nodes, statuses, statusText) {
     }
   }));
 }
-function preview(v) {
+function preview(v2) {
   try {
-    const s = JSON.stringify(v);
-    return s && s.length > 60 ? s.slice(0, 57) + "\u2026" : s ?? String(v);
+    const s = JSON.stringify(v2);
+    return s && s.length > 60 ? s.slice(0, 57) + "\u2026" : s ?? String(v2);
   } catch {
-    return String(v);
+    return String(v2);
   }
 }
 
@@ -11736,27 +13446,27 @@ function RegistryNodeInner(props) {
         data.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__desc", children: data.description }),
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ff-node__body", children: kind.renderBody ? kind.renderBody({ nodeId: props.id, config, selected: props.selected ?? false }) : /* @__PURE__ */ jsxRuntime.jsx(DefaultBody, { config, kind: kind.configSchema }) }),
         data.statusText && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ff-node__status-text", children: data.statusText }),
-        inputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        inputs.map((p2, i) => /* @__PURE__ */ jsxRuntime.jsx(
           Handle,
           {
             type: "target",
             position: Position.Left,
-            id: p.id,
+            id: p2.id,
             style: portStyle2(i, inputs.length),
-            title: p.label ?? p.id
+            title: p2.label ?? p2.id
           },
-          p.id
+          p2.id
         )),
-        outputs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+        outputs.map((p2, i) => /* @__PURE__ */ jsxRuntime.jsx(
           Handle,
           {
             type: "source",
             position: Position.Right,
-            id: p.id,
+            id: p2.id,
             style: portStyle2(i, outputs.length),
-            title: p.label ?? p.id
+            title: p2.label ?? p2.id
           },
-          p.id
+          p2.id
         ))
       ]
     }
@@ -11806,18 +13516,18 @@ function itemLabel(item) {
   }
   return String(item ?? "");
 }
-function previewValue(v) {
-  if (v === null || v === void 0) return "";
-  if (typeof v === "string") return truncate(v);
-  if (typeof v === "number" || typeof v === "boolean") return String(v);
-  if (Array.isArray(v)) {
-    if (v.length === 0) return "none";
-    const names = v.slice(0, 3).map(itemLabel).filter(Boolean).join(", ");
-    const rest = v.length > 3 ? `, +${v.length - 3}` : "";
-    return names ? truncate(names + rest) : `${v.length} item${v.length === 1 ? "" : "s"}`;
-  }
-  if (typeof v === "object") {
-    const keys = Object.keys(v);
+function previewValue(v2) {
+  if (v2 === null || v2 === void 0) return "";
+  if (typeof v2 === "string") return truncate(v2);
+  if (typeof v2 === "number" || typeof v2 === "boolean") return String(v2);
+  if (Array.isArray(v2)) {
+    if (v2.length === 0) return "none";
+    const names = v2.slice(0, 3).map(itemLabel).filter(Boolean).join(", ");
+    const rest = v2.length > 3 ? `, +${v2.length - 3}` : "";
+    return names ? truncate(names + rest) : `${v2.length} item${v2.length === 1 ? "" : "s"}`;
+  }
+  if (typeof v2 === "object") {
+    const keys = Object.keys(v2);
     return keys.length === 0 ? "empty" : `${keys.length} field${keys.length === 1 ? "" : "s"}`;
   }
   return "\u2026";
@@ -11826,9 +13536,9 @@ function previewValue(v) {
 // src/registry/index.ts
 function buildNodeTypes() {
   const map = {};
-  for (const k of listNodeKinds()) {
-    const renderer = k.component ?? RegistryNode;
-    for (const id2 of kindIds(k)) map[id2] = renderer;
+  for (const k2 of listNodeKinds()) {
+    const renderer = k2.component ?? RegistryNode;
+    for (const id2 of kindIds(k2)) map[id2] = renderer;
   }
   return map;
 }
@@ -11896,7 +13606,7 @@ function FlowEditorInner({
     () => flow.edges.find((e) => e.id === selectedEdgeId) ?? null,
     [flow.edges, selectedEdgeId]
   );
-  const handleNodeClick2 = (_e, node) => {
+  const handleNodeClick2 = (_e2, node) => {
     setSelectedId(node.id);
     setSelectedEdgeId(null);
   };
@@ -11909,7 +13619,7 @@ function FlowEditorInner({
     setSelectedEdgeId(null);
     setMenu({ x: event.clientX, y: event.clientY, target: { type: "node", id: node.id } });
   };
-  const handleEdgeClick = (_e, edge) => {
+  const handleEdgeClick = (_e2, edge) => {
     setSelectedEdgeId(edge.id);
   };
   const handleEdgeContextMenu = (event, edge) => {
@@ -11957,14 +13667,14 @@ function FlowEditorInner({
     (kindName, position) => {
       const kind = getNodeKind(kindName);
       if (!kind) return null;
-      const at = position ?? { x: 80, y: 80 };
+      const at2 = position ?? { x: 80, y: 80 };
       const id2 = newNodeId();
       flow.setNodes((all) => [
         ...all,
         {
           id: id2,
           type: kind.name,
-          position: at,
+          position: at2,
           data: { kind: kind.name, label: kind.label, config: defaultConfigFor(kind) }
         }
       ]);
@@ -12012,15 +13722,15 @@ function FlowEditorInner({
     clipboard.current = { nodes: sel.map((n) => ({ ...n })), edges: edges.map((e) => ({ ...e })) };
   }, [flow]);
   const pasteClipboard = ReactExports.useCallback(
-    (at) => {
+    (at2) => {
       const clip = clipboard.current;
       if (!clip || clip.nodes.length === 0) return;
       const { nodes: clones, edges: cloneEdges } = cloneSubgraph(clip.nodes, clip.edges, { makeId: newNodeId, offset: 40 });
       let placed = clones;
-      if (at) {
+      if (at2) {
         const minX = Math.min(...clones.map((n) => n.position.x));
         const minY = Math.min(...clones.map((n) => n.position.y));
-        placed = clones.map((n) => ({ ...n, position: { x: n.position.x - minX + at.x, y: n.position.y - minY + at.y } }));
+        placed = clones.map((n) => ({ ...n, position: { x: n.position.x - minX + at2.x, y: n.position.y - minY + at2.y } }));
       }
       flow.setGraph({
         nodes: [...flow.nodes.map((n) => ({ ...n, selected: false })), ...placed.map((n) => ({ ...n, selected: true }))],
@@ -12070,10 +13780,10 @@ function FlowEditorInner({
     (orientation = "horizontal", title) => {
       const vertical = orientation === "vertical";
       const lanes = flow.nodes.filter(isLaneNode);
-      const w = vertical ? 280 : 680;
+      const w2 = vertical ? 280 : 680;
       const h = vertical ? 480 : 168;
       const end = lanes.reduce(
-        (m, l) => Math.max(m, vertical ? l.position.x + (l.width ?? w) : l.position.y + (l.height ?? h)),
+        (m, l) => Math.max(m, vertical ? l.position.x + (l.width ?? w2) : l.position.y + (l.height ?? h)),
         0
       );
       const id2 = newNodeId();
@@ -12082,7 +13792,7 @@ function FlowEditorInner({
         id: id2,
         type: "@particle-academy/lane",
         position: vertical ? { x: lanes.length ? end + 12 : 0, y: 0 } : { x: 0, y: lanes.length ? end + 12 : 0 },
-        width: w,
+        width: w2,
         height: h,
         data: { kind: "@particle-academy/lane", label: name, config: { title: name, orientation } }
       };
@@ -12093,7 +13803,7 @@ function FlowEditorInner({
     [flow, isLaneNode]
   );
   const handleNodeDragStop = ReactExports.useCallback(
-    (_e, node) => {
+    (_e2, node) => {
       if (isLaneNode(node)) return;
       const overLane = rf.getIntersectingNodes(node).find((n) => isLaneNode(n));
       const currentParent = node.parentId;
@@ -12144,7 +13854,7 @@ function FlowEditorInner({
       select: setSelectedId,
       selectEdge: setSelectedEdgeId,
       addNode,
-      updateNode: (next) => flow.setNodes((all) => all.map((x) => x.id === next.id ? next : x)),
+      updateNode: (next) => flow.setNodes((all) => all.map((x2) => x2.id === next.id ? next : x2)),
       deleteNodes,
       deleteSelected: () => deleteNodes(selectedId ? [selectedId] : []),
       deleteEdges,
@@ -12171,6 +13881,18 @@ function FlowEditorInner({
       addLane,
       assignToLane: (nodeId, laneId) => flow.setNodes((all) => assignToLane(all, nodeId, laneId)),
       removeFromLane: (nodeId) => flow.setNodes((all) => removeFromLane(all, nodeId)),
+      // dagre is loaded lazily so it stays out of the eager bundle — consumers
+      // who never tidy pay nothing for it.
+      autoLayout: (opts) => {
+        void Promise.resolve().then(() => (init_layout(), layout_exports)).then(
+          ({ autoLayout: autoLayout2 }) => flow.setGraph({ nodes: autoLayout2({ nodes: flow.nodes, edges: flow.edges }, opts), edges: flow.edges })
+        );
+      },
+      tidyLane: (laneId) => {
+        void Promise.resolve().then(() => (init_layout(), layout_exports)).then(
+          ({ autoLayout: autoLayout2 }) => flow.setGraph({ nodes: autoLayout2({ nodes: flow.nodes, edges: flow.edges }, { scope: laneId }), edges: flow.edges })
+        );
+      },
       run: () => runner.run({ nodes: flow.nodes, edges: flow.edges }, executors),
       cancel: runner.cancel,
       reset: runner.reset,
@@ -12223,6 +13945,7 @@ function FlowEditorInner({
       /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-editor__sep" }),
       /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", "data-action": "add-lane", title: "Add a swimlane", onClick: () => api.addLane(), children: "\u25A4 Lane" })
     ] }),
+    builtins.autoLayout !== false && /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", "data-action": "auto-layout", title: "Tidy \u2014 auto-arrange", onClick: () => api.autoLayout(), children: "\u2922 Tidy" }),
     (builtins.export !== false || builtins.import !== false) && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ff-editor__sep" }),
     builtins.export !== false && /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", "data-action": "export", onClick: api.exportWorkflow, children: "\u2193 Export" }),
     builtins.import !== false && /* @__PURE__ */ jsxRuntime.jsx("button", { className: "ff-editor__btn", "data-action": "import", onClick: api.importWorkflow, children: "\u2191 Import" }),
@@ -12443,7 +14166,7 @@ function makeControlledFlowAdapter(value, onChange) {
   };
 }
 function EdgeLabelEditor({
-  x,
+  x: x2,
   y,
   initial,
   onCommit,
@@ -12459,7 +14182,7 @@ function EdgeLabelEditor({
     "div",
     {
       className: "ff-editor__ctx ff-editor__edge-label",
-      style: { top: y, left: x },
+      style: { top: y, left: x2 },
       onClick: (e) => e.stopPropagation(),
       children: /* @__PURE__ */ jsxRuntime.jsx(
         "input",
@@ -12515,6 +14238,11 @@ function NodePort({ side, type, id: id2, style: style2, title, className }) {
 
 // src/index.ts
 registerBuiltinKinds();
+/*! Bundled license information:
+
+@dagrejs/dagre/dist/dagre.esm.js:
+  (*! For license information please see dagre.esm.js.LEGAL.txt *)
+*/
 
 exports.ANY_PORT_TYPE = ANY_PORT_TYPE;
 exports.ActionNode = ActionNode;