vue-data-ui 3.7.16 → 3.8.0

package/dist/vue-ui-dag-tle30Ehr.js

@@ -0,0 +1,2727 @@
+import { ref as E, watchEffect as Yo, unref as b, createElementBlock as _, openBlock as k, normalizeStyle as H, normalizeClass as tt, createElementVNode as B, createCommentVNode as L, createVNode as le, toDisplayString as ie, defineAsyncComponent as Ye, toRefs as Ho, computed as W, onMounted as Rt, watch as He, onBeforeUnmount as Zo, createBlock as Y, withCtx as R, renderSlot as S, normalizeProps as P, guardReactiveProps as F, createSlots as Uo, Fragment as re, renderList as Te, withModifiers as Xo, mergeProps as Tt, createTextVNode as qo, Transition as Mt, Teleport as $t, nextTick as Dt } from "vue";
+import { c as ot, ay as Ko, l as ye, n as Jo, r as Qo, h as en, t as Kt, o as tn, g as Pt, X as on, a8 as nn } from "./lib-qMPkcvmh.js";
+import { u as sn } from "./usePanZoom-DMfuOfaC.js";
+import { u as rn, a as Ze } from "./useNestedProp-DOOBu_sL.js";
+import { u as ln, B as an } from "./BaseScanner-BgWxam9d.js";
+import { u as cn } from "./usePrinter-CjGh4mFJ.js";
+import { u as un } from "./useSvgExport-DrjCWun4.js";
+import { u as dn } from "./useThemeCheck-DGJ31Vi5.js";
+import { u as fn } from "./useUserOptionState-BIvW1Kz7.js";
+import { u as hn } from "./useChartAccessibility-9icAAmYg.js";
+import mn from "./Title-CgkWUXeV.js";
+import Ue from "./BaseIcon-CALhpING.js";
+import { _ as Jt } from "./_plugin-vue_export-helper-CHgC5LLL.js";
+const gn = "\0", Q = "\0", Ft = "
";
+class Z {
+  _isDirected = !0;
+  _isMultigraph = !1;
+  _isCompound = !1;
+  // Label for the graph itself
+  _label;
+  // Defaults to be set when creating a new node
+  _defaultNodeLabelFn = () => {
+  };
+  // Defaults to be set when creating a new edge
+  _defaultEdgeLabelFn = () => {
+  };
+  // v -> label
+  _nodes = {};
+  // v -> edgeObj
+  _in = {};
+  // u -> v -> Number
+  _preds = {};
+  // v -> edgeObj
+  _out = {};
+  // v -> w -> Number
+  _sucs = {};
+  // e -> edgeObj
+  _edgeObjs = {};
+  // e -> label
+  _edgeLabels = {};
+  /* Number of nodes in the graph. Should only be changed by the implementation. */
+  _nodeCount = 0;
+  /* Number of edges in the graph. Should only be changed by the implementation. */
+  _edgeCount = 0;
+  _parent;
+  _children;
+  constructor(t) {
+    t && (this._isDirected = Object.hasOwn(t, "directed") ? t.directed : !0, this._isMultigraph = Object.hasOwn(t, "multigraph") ? t.multigraph : !1, this._isCompound = Object.hasOwn(t, "compound") ? t.compound : !1), this._isCompound && (this._parent = {}, this._children = {}, this._children[Q] = {});
+  }
+  /* === Graph functions ========= */
+  /**
+   * Whether graph was created with 'directed' flag set to true or not.
+   */
+  isDirected() {
+    return this._isDirected;
+  }
+  /**
+   * Whether graph was created with 'multigraph' flag set to true or not.
+   */
+  isMultigraph() {
+    return this._isMultigraph;
+  }
+  /**
+   * Whether graph was created with 'compound' flag set to true or not.
+   */
+  isCompound() {
+    return this._isCompound;
+  }
+  /**
+   * Sets the label of the graph.
+   */
+  setGraph(t) {
+    return this._label = t, this;
+  }
+  /**
+   * Gets the graph label.
+   */
+  graph() {
+    return this._label;
+  }
+  /* === Node functions ========== */
+  /**
+   * Sets the default node label. If newDefault is a function, it will be
+   * invoked each time when setting a label for a node. Otherwise, this label
+   * will be assigned as default label in case if no label was specified while
+   * setting a node.
+   * Complexity: O(1).
+   */
+  setDefaultNodeLabel(t) {
+    return this._defaultNodeLabelFn = t, typeof t != "function" && (this._defaultNodeLabelFn = () => t), this;
+  }
+  /**
+   * Gets the number of nodes in the graph.
+   * Complexity: O(1).
+   */
+  nodeCount() {
+    return this._nodeCount;
+  }
+  /**
+   * Gets all nodes of the graph. Note, the in case of compound graph subnodes are
+   * not included in list.
+   * Complexity: O(1).
+   */
+  nodes() {
+    return Object.keys(this._nodes);
+  }
+  /**
+   * Gets list of nodes without in-edges.
+   * Complexity: O(|V|).
+   */
+  sources() {
+    const t = this;
+    return this.nodes().filter((o) => Object.keys(t._in[o]).length === 0);
+  }
+  /**
+   * Gets list of nodes without out-edges.
+   * Complexity: O(|V|).
+   */
+  sinks() {
+    const t = this;
+    return this.nodes().filter((o) => Object.keys(t._out[o]).length === 0);
+  }
+  /**
+   * Invokes setNode method for each node in names list.
+   * Complexity: O(|names|).
+   */
+  setNodes(t, o) {
+    const n = arguments, s = this;
+    return t.forEach((r) => {
+      n.length > 1 ? s.setNode(r, o) : s.setNode(r);
+    }), this;
+  }
+  /**
+   * Creates or updates the value for the node v in the graph. If value is supplied
+   * it is set as the value for the node. If value is not supplied and the node was
+   * created by this call then the default node label will be assigned.
+   * Complexity: O(1).
+   */
+  setNode(t, o) {
+    return Object.hasOwn(this._nodes, t) ? (arguments.length > 1 && (this._nodes[t] = o), this) : (this._nodes[t] = arguments.length > 1 ? o : this._defaultNodeLabelFn(t), this._isCompound && (this._parent[t] = Q, this._children[t] = {}, this._children[Q][t] = !0), this._in[t] = {}, this._preds[t] = {}, this._out[t] = {}, this._sucs[t] = {}, ++this._nodeCount, this);
+  }
+  /**
+   * Gets the label of node with specified name.
+   * Complexity: O(1).
+   */
+  node(t) {
+    return this._nodes[t];
+  }
+  /**
+   * Detects whether graph has a node with specified name or not.
+   */
+  hasNode(t) {
+    return Object.hasOwn(this._nodes, t);
+  }
+  /**
+   * Remove the node with the name from the graph or do nothing if the node is not in
+   * the graph. If the node was removed this function also removes any incident
+   * edges.
+   * Complexity: O(1).
+   */
+  removeNode(t) {
+    const o = this;
+    if (Object.hasOwn(this._nodes, t)) {
+      const n = (s) => o.removeEdge(o._edgeObjs[s]);
+      delete this._nodes[t], this._isCompound && (this._removeFromParentsChildList(t), delete this._parent[t], this.children(t).forEach((s) => {
+        o.setParent(s);
+      }), delete this._children[t]), Object.keys(this._in[t]).forEach(n), delete this._in[t], delete this._preds[t], Object.keys(this._out[t]).forEach(n), delete this._out[t], delete this._sucs[t], --this._nodeCount;
+    }
+    return this;
+  }
+  /**
+   * Sets node parentId as a parent for node nodeId if it is defined, or removes the
+   * parent for nodeId if parentId is undefined. Method throws an exception in case of
+   * invoking it in context of noncompound graph.
+   * Average-case complexity: O(1).
+   */
+  setParent(t, o) {
+    if (!this._isCompound)
+      throw new Error("Cannot set parent in a non-compound graph");
+    if (o === void 0)
+      o = Q;
+    else {
+      o += "";
+      for (let n = o; n !== void 0; n = this.parent(n))
+        if (n === t)
+          throw new Error(
+            "Setting " + o + " as parent of " + t + " would create a cycle"
+          );
+      this.setNode(o);
+    }
+    return this.setNode(t), this._removeFromParentsChildList(t), this._parent[t] = o, this._children[o][t] = !0, this;
+  }
+  _removeFromParentsChildList(t) {
+    delete this._children[this._parent[t]][t];
+  }
+  /**
+   * Gets parent node for node nodeId.
+   * Complexity: O(1).
+   */
+  parent(t) {
+    if (this._isCompound) {
+      const o = this._parent[t];
+      if (o !== Q)
+        return o;
+    }
+  }
+  /**
+   * Gets list of direct children of node nodeId.
+   * Complexity: O(1).
+   */
+  children(t = Q) {
+    if (this._isCompound) {
+      const o = this._children[t];
+      if (o)
+        return Object.keys(o);
+    } else {
+      if (t === Q)
+        return this.nodes();
+      if (this.hasNode(t))
+        return [];
+    }
+  }
+  /**
+   * Return all nodes that are predecessors of the specified node or undefined if nodeId is not in
+   * the graph. Behavior is undefined for undirected graphs - use neighbors instead.
+   * Complexity: O(|V|).
+   */
+  predecessors(t) {
+    const o = this._preds[t];
+    if (o)
+      return Object.keys(o);
+  }
+  /**
+   * Return all nodes that are successors of the specified node or undefined if nodeId is not in
+   * the graph. Behavior is undefined for undirected graphs - use neighbors instead.
+   * Complexity: O(|V|).
+   */
+  successors(t) {
+    const o = this._sucs[t];
+    if (o)
+      return Object.keys(o);
+  }
+  /**
+   * Return all nodes that are predecessors or successors of the specified node or undefined if
+   * nodeId is not in the graph.
+   * Complexity: O(|V|).
+   */
+  neighbors(t) {
+    const o = this.predecessors(t);
+    if (o) {
+      const n = new Set(o);
+      for (const s of this.successors(t))
+        n.add(s);
+      return Array.from(n.values());
+    }
+  }
+  isLeaf(t) {
+    let o;
+    return this.isDirected() ? o = this.successors(t) : o = this.neighbors(t), o.length === 0;
+  }
+  /**
+   * Creates new graph with nodes filtered via filter. Edges incident to rejected node
+   * are also removed. In case of compound graph, if parent is rejected by filter,
+   * then all its children are rejected too.
+   * Average-case complexity: O(|E|+|V|).
+   */
+  filterNodes(t) {
+    const o = new this.constructor({
+      directed: this._isDirected,
+      multigraph: this._isMultigraph,
+      compound: this._isCompound
+    });
+    o.setGraph(this.graph());
+    const n = this;
+    Object.entries(this._nodes).forEach(([i, l]) => {
+      t(i) && o.setNode(i, l);
+    }), Object.values(this._edgeObjs).forEach((i) => {
+      o.hasNode(i.v) && o.hasNode(i.w) && o.setEdge(i, n.edge(i));
+    });
+    const s = {};
+    function r(i) {
+      const l = n.parent(i);
+      return l === void 0 || o.hasNode(l) ? (s[i] = l, l) : l in s ? s[l] : r(l);
+    }
+    return this._isCompound && o.nodes().forEach((i) => o.setParent(i, r(i))), o;
+  }
+  /* === Edge functions ========== */
+  /**
+   * Sets the default edge label or factory function. This label will be
+   * assigned as default label in case if no label was specified while setting
+   * an edge or this function will be invoked each time when setting an edge
+   * with no label specified and returned value will be used as a label for edge.
+   * Complexity: O(1).
+   */
+  setDefaultEdgeLabel(t) {
+    return this._defaultEdgeLabelFn = t, typeof t != "function" && (this._defaultEdgeLabelFn = () => t), this;
+  }
+  /**
+   * Gets the number of edges in the graph.
+   * Complexity: O(1).
+   */
+  edgeCount() {
+    return this._edgeCount;
+  }
+  /**
+   * Gets edges of the graph. In case of compound graph subgraphs are not considered.
+   * Complexity: O(|E|).
+   */
+  edges() {
+    return Object.values(this._edgeObjs);
+  }
+  /**
+   * Establish an edges path over the nodes in nodeIds list. If some edge already
+   * exists, it will update its label, otherwise it will create an edge between pair
+   * of nodes with label provided or default label if no label provided.
+   * Complexity: O(|nodeIds|).
+   */
+  setPath(t, o) {
+    const n = this, s = arguments;
+    return t.reduce((r, i) => (s.length > 1 ? n.setEdge(r, i, o) : n.setEdge(r, i), i)), this;
+  }
+  /**
+   * Creates or updates the label for the edge (v, w) with the optionally supplied
+   * name. If value is supplied it is set as the value for the edge. If value is not
+   * supplied and the edge was created by this call then the default edge label will
+   * be assigned. The name parameter is only useful with multigraphs.
+   */
+  setEdge() {
+    let t, o, n, s, r = !1;
+    const i = arguments[0];
+    typeof i == "object" && i !== null && "v" in i ? (t = i.v, o = i.w, n = i.name, arguments.length === 2 && (s = arguments[1], r = !0)) : (t = i, o = arguments[1], n = arguments[3], arguments.length > 2 && (s = arguments[2], r = !0)), t = "" + t, o = "" + o, n !== void 0 && (n = "" + n);
+    let l = ke(this._isDirected, t, o, n);
+    if (Object.hasOwn(this._edgeLabels, l))
+      return r && (this._edgeLabels[l] = s), this;
+    if (n !== void 0 && !this._isMultigraph)
+      throw new Error("Cannot set a named edge when isMultigraph = false");
+    this.setNode(t), this.setNode(o), this._edgeLabels[l] = r ? s : this._defaultEdgeLabelFn(t, o, n);
+    const a = bn(this._isDirected, t, o, n);
+    return t = a.v, o = a.w, Object.freeze(a), this._edgeObjs[l] = a, zt(this._preds[o], t), zt(this._sucs[t], o), this._in[o][l] = a, this._out[t][l] = a, this._edgeCount++, this;
+  }
+  /**
+   * Gets the label for the specified edge.
+   * Complexity: O(1).
+   */
+  edge(t, o, n) {
+    const s = arguments.length === 1 ? Xe(this._isDirected, arguments[0]) : ke(this._isDirected, t, o, n);
+    return this._edgeLabels[s];
+  }
+  /**
+   * Gets the label for the specified edge and converts it to an object.
+   * Complexity: O(1)
+   */
+  edgeAsObj() {
+    const t = this.edge(...arguments);
+    return typeof t != "object" ? { label: t } : t;
+  }
+  /**
+   * Detects whether the graph contains specified edge or not. No subgraphs are considered.
+   * Complexity: O(1).
+   */
+  hasEdge(t, o, n) {
+    const s = arguments.length === 1 ? Xe(this._isDirected, arguments[0]) : ke(this._isDirected, t, o, n);
+    return Object.hasOwn(this._edgeLabels, s);
+  }
+  /**
+   * Removes the specified edge from the graph. No subgraphs are considered.
+   * Complexity: O(1).
+   */
+  removeEdge(t, o, n) {
+    const s = arguments.length === 1 ? Xe(this._isDirected, arguments[0]) : ke(this._isDirected, t, o, n), r = this._edgeObjs[s];
+    return r && (t = r.v, o = r.w, delete this._edgeLabels[s], delete this._edgeObjs[s], Bt(this._preds[o], t), Bt(this._sucs[t], o), delete this._in[o][s], delete this._out[t][s], this._edgeCount--), this;
+  }
+  /**
+   * Return all edges that point to the node v. Optionally filters those edges down to just those
+   * coming from node u. Behavior is undefined for undirected graphs - use nodeEdges instead.
+   * Complexity: O(|E|).
+   */
+  inEdges(t, o) {
+    const n = this._in[t];
+    if (n) {
+      const s = Object.values(n);
+      return o ? s.filter((r) => r.v === o) : s;
+    }
+  }
+  /**
+   * Return all edges that are pointed at by node v. Optionally filters those edges down to just
+   * those pointing to w. Behavior is undefined for undirected graphs - use nodeEdges instead.
+   * Complexity: O(|E|).
+   */
+  outEdges(t, o) {
+    const n = this._out[t];
+    if (n) {
+      const s = Object.values(n);
+      return o ? s.filter((r) => r.w === o) : s;
+    }
+  }
+  /**
+   * Returns all edges to or from node v regardless of direction. Optionally filters those edges
+   * down to just those between nodes v and w regardless of direction.
+   * Complexity: O(|E|).
+   */
+  nodeEdges(t, o) {
+    const n = this.inEdges(t, o);
+    if (n)
+      return n.concat(this.outEdges(t, o));
+  }
+}
+function zt(e, t) {
+  e[t] ? e[t]++ : e[t] = 1;
+}
+function Bt(e, t) {
+  --e[t] || delete e[t];
+}
+function ke(e, t, o, n) {
+  let s = "" + t, r = "" + o;
+  if (!e && s > r) {
+    const i = s;
+    s = r, r = i;
+  }
+  return s + Ft + r + Ft + (n === void 0 ? gn : n);
+}
+function bn(e, t, o, n) {
+  let s = "" + t, r = "" + o;
+  if (!e && s > r) {
+    const l = s;
+    s = r, r = l;
+  }
+  const i = { v: s, w: r };
+  return n && (i.name = n), i;
+}
+function Xe(e, t) {
+  return ke(e, t.v, t.w, t.name);
+}
+class vn {
+  constructor() {
+    const t = {};
+    t._next = t._prev = t, this._sentinel = t;
+  }
+  dequeue() {
+    const t = this._sentinel, o = t._prev;
+    if (o !== t)
+      return Vt(o), o;
+  }
+  enqueue(t) {
+    const o = this._sentinel;
+    t._prev && t._next && Vt(t), t._next = o._next, o._next._prev = t, o._next = t, t._prev = o;
+  }
+  toString() {
+    const t = [], o = this._sentinel;
+    let n = o._prev;
+    for (; n !== o; )
+      t.push(JSON.stringify(n, pn)), n = n._prev;
+    return "[" + t.join(", ") + "]";
+  }
+}
+function Vt(e) {
+  e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
+}
+function pn(e, t) {
+  if (e !== "_next" && e !== "_prev")
+    return t;
+}
+const wn = () => 1;
+function kn(e, t) {
+  if (e.nodeCount() <= 1)
+    return [];
+  const o = En(e, t || wn);
+  return yn(o.graph, o.buckets, o.zeroIndex).flatMap((s) => e.outEdges(s.v, s.w));
+}
+function yn(e, t, o) {
+  let n = [];
+  const s = t[t.length - 1], r = t[0];
+  let i;
+  for (; e.nodeCount(); ) {
+    for (; i = r.dequeue(); )
+      qe(e, t, o, i);
+    for (; i = s.dequeue(); )
+      qe(e, t, o, i);
+    if (e.nodeCount()) {
+      for (let l = t.length - 2; l > 0; --l)
+        if (i = t[l].dequeue(), i) {
+          n = n.concat(qe(e, t, o, i, !0));
+          break;
+        }
+    }
+  }
+  return n;
+}
+function qe(e, t, o, n, s) {
+  const r = s ? [] : void 0;
+  return e.inEdges(n.v).forEach((i) => {
+    const l = e.edge(i), a = e.node(i.v);
+    s && r.push({ v: i.v, w: i.w }), a.out -= l, nt(t, o, a);
+  }), e.outEdges(n.v).forEach((i) => {
+    const l = e.edge(i), a = e.node(i.w);
+    a.in -= l, nt(t, o, a);
+  }), e.removeNode(n.v), r;
+}
+function En(e, t) {
+  const o = new Z();
+  let n = 0, s = 0;
+  e.nodes().forEach((l) => {
+    o.setNode(l, { v: l, in: 0, out: 0 });
+  }), e.edges().forEach((l) => {
+    const a = o.edge(l.v, l.w) || 0, c = t(l), u = a + c;
+    o.setEdge(l.v, l.w, u), s = Math.max(s, o.node(l.v).out += c), n = Math.max(n, o.node(l.w).in += c);
+  });
+  const r = Cn(s + n + 3).map(() => new vn()), i = n + 1;
+  return o.nodes().forEach((l) => {
+    nt(r, i, o.node(l));
+  }), {
+    graph: o,
+    buckets: r,
+    zeroIndex: i
+  };
+}
+function nt(e, t, o) {
+  o.out ? o.in ? e[o.out - o.in + t].enqueue(o) : e[e.length - 1].enqueue(o) : e[0].enqueue(o);
+}
+function Cn(e) {
+  const t = [];
+  for (let o = 0; o < e; o++)
+    t.push(o);
+  return t;
+}
+function ce(e, t, o, n) {
+  let s = n;
+  for (; e.hasNode(s); )
+    s = $e(n);
+  return o.dummy = t, e.setNode(s, o), s;
+}
+function Qt(e) {
+  const t = new Z().setGraph(e.graph());
+  return e.nodes().forEach((o) => {
+    t.setNode(o, e.node(o));
+  }), e.edges().forEach((o) => {
+    const n = t.edge(o.v, o.w) || { weight: 0, minlen: 1 }, s = e.edge(o);
+    t.setEdge(o.v, o.w, {
+      weight: n.weight + s.weight,
+      minlen: Math.max(n.minlen, s.minlen)
+    });
+  }), t;
+}
+function rt(e) {
+  const t = new Z({ multigraph: e.isMultigraph() }).setGraph(e.graph());
+  return e.nodes().forEach((o) => {
+    e.children(o).length || t.setNode(o, e.node(o));
+  }), e.edges().forEach((o) => {
+    t.setEdge(o, e.edge(o));
+  }), t;
+}
+function xn(e) {
+  const t = e.nodes().map((o) => {
+    const n = {};
+    return e.outEdges(o).forEach((s) => {
+      n[s.w] = (n[s.w] || 0) + e.edge(s).weight;
+    }), n;
+  });
+  return De(e.nodes(), t);
+}
+function _n(e) {
+  const t = e.nodes().map((o) => {
+    const n = {};
+    return e.inEdges(o).forEach((s) => {
+      n[s.v] = (n[s.v] || 0) + e.edge(s).weight;
+    }), n;
+  });
+  return De(e.nodes(), t);
+}
+function st(e, t) {
+  let o = e.x, n = e.y;
+  const s = t.x - o, r = t.y - n;
+  let i = e.width / 2, l = e.height / 2;
+  if (!s && !r)
+    throw new Error("Not possible to find intersection inside of the rectangle");
+  let a, c;
+  return Math.abs(r) * i > Math.abs(s) * l ? (r < 0 && (l = -l), a = l * s / r, c = l) : (s < 0 && (i = -i), a = i, c = i * r / s), { x: o + a, y: n + c };
+}
+function Ce(e) {
+  const t = ae(it(e) + 1).map(() => []);
+  return e.nodes().forEach((o) => {
+    const n = e.node(o), s = n.rank;
+    s !== void 0 && (t[s][n.order] = o);
+  }), t;
+}
+function eo(e) {
+  const t = e.nodes().map((n) => {
+    const s = e.node(n).rank;
+    return s === void 0 ? Number.MAX_VALUE : s;
+  }), o = V(Math.min, t);
+  e.nodes().forEach((n) => {
+    const s = e.node(n);
+    Object.hasOwn(s, "rank") && (s.rank -= o);
+  });
+}
+function to(e) {
+  const t = e.nodes().map((i) => e.node(i).rank).filter((i) => i !== void 0), o = V(Math.min, t), n = [];
+  e.nodes().forEach((i) => {
+    const l = e.node(i).rank - o;
+    n[l] || (n[l] = []), n[l].push(i);
+  });
+  let s = 0;
+  const r = e.graph().nodeRankFactor;
+  Array.from(n).forEach((i, l) => {
+    i === void 0 && l % r !== 0 ? --s : i !== void 0 && s && i.forEach((a) => {
+      e.node(a).rank += s;
+    });
+  });
+}
+function Nn(e, t, o, n) {
+  const s = {
+    width: 0,
+    height: 0
+  };
+  return arguments.length >= 4 && (s.rank = o, s.order = n), ce(e, "border", s, t);
+}
+const oo = 65535;
+function An(e, t = oo) {
+  const o = [];
+  for (let n = 0; n < e.length; n += t) {
+    const s = e.slice(n, n + t);
+    o.push(s);
+  }
+  return o;
+}
+function V(e, t) {
+  if (t.length > oo) {
+    const o = An(t);
+    return e.apply(
+      null,
+      o.map((n) => e.apply(null, n))
+    );
+  } else
+    return e.apply(null, t);
+}
+function it(e) {
+  const o = e.nodes().map((n) => {
+    const s = e.node(n).rank;
+    return s === void 0 ? Number.MIN_VALUE : s;
+  });
+  return V(Math.max, o);
+}
+function no(e, t) {
+  const o = { lhs: [], rhs: [] };
+  return e.forEach((n) => {
+    t(n) ? o.lhs.push(n) : o.rhs.push(n);
+  }), o;
+}
+function so(e, t) {
+  const o = Date.now();
+  try {
+    return t();
+  } finally {
+    console.log(e + " time: " + (Date.now() - o) + "ms");
+  }
+}
+function ro(e, t) {
+  return t();
+}
+let Sn = 0;
+function $e(e) {
+  const t = ++Sn;
+  return e + String(t);
+}
+function ae(e, t, o = 1) {
+  t == null && (t = e, e = 0);
+  let n = (r) => r < t;
+  o < 0 && (n = (r) => t < r);
+  const s = [];
+  for (let r = e; n(r); r += o)
+    s.push(r);
+  return s;
+}
+function Ee(e, t) {
+  const o = {};
+  for (const n of t)
+    e[n] !== void 0 && (o[n] = e[n]);
+  return o;
+}
+function xe(e, t) {
+  let o = t;
+  if (typeof t == "string") {
+    const n = t;
+    o = (s) => s[n];
+  }
+  return Object.entries(e).reduce((n, [s, r]) => (n[s] = o(r, s), n), {});
+}
+function De(e, t) {
+  return e.reduce((o, n, s) => (o[n] = t[s], o), {});
+}
+const Me = {
+  addBorderNode: Nn,
+  addDummyNode: ce,
+  applyWithChunking: V,
+  asNonCompoundGraph: rt,
+  buildLayerMatrix: Ce,
+  intersectRect: st,
+  mapValues: xe,
+  maxRank: it,
+  normalizeRanks: eo,
+  notime: ro,
+  partition: no,
+  pick: Ee,
+  predecessorWeights: _n,
+  range: ae,
+  removeEmptyRanks: to,
+  simplify: Qt,
+  successorWeights: xn,
+  time: so,
+  uniqueId: $e,
+  zipObject: De
+};
+function Ln(e) {
+  (e.graph().acyclicer === "greedy" ? kn(e, o(e)) : Rn(e)).forEach((n) => {
+    const s = e.edge(n);
+    e.removeEdge(n), s.forwardName = n.name, s.reversed = !0, e.setEdge(n.w, n.v, s, $e("rev"));
+  });
+  function o(n) {
+    return (s) => n.edge(s).weight;
+  }
+}
+function On(e) {
+  e.edges().forEach((t) => {
+    const o = e.edge(t);
+    if (o.reversed) {
+      e.removeEdge(t);
+      const n = o.forwardName;
+      delete o.reversed, delete o.forwardName, e.setEdge(t.w, t.v, o, n);
+    }
+  });
+}
+function Rn(e) {
+  const t = [], o = {}, n = {};
+  function s(r) {
+    Object.hasOwn(n, r) || (n[r] = !0, o[r] = !0, e.outEdges(r).forEach((i) => {
+      Object.hasOwn(o, i.w) ? t.push(i) : s(i.w);
+    }), delete o[r]);
+  }
+  return e.nodes().forEach(s), t;
+}
+function Tn(e) {
+  e.graph().dummyChains = [], e.edges().forEach((t) => Mn(e, t));
+}
+function Mn(e, t) {
+  let o = t.v, n = e.node(o).rank;
+  const s = t.w, r = e.node(s).rank, i = t.name, l = e.edge(t), a = l.labelRank;
+  if (r === n + 1)
+    return;
+  e.removeEdge(t);
+  let c, u, d;
+  for (d = 0, ++n; n < r; ++d, ++n)
+    l.points = [], u = {
+      width: 0,
+      height: 0,
+      edgeLabel: l,
+      edgeObj: t,
+      rank: n
+    }, c = ce(e, "edge", u, "_d"), n === a && (u.width = l.width, u.height = l.height, u.dummy = "edge-label", u.labelpos = l.labelpos), e.setEdge(o, c, { weight: l.weight }, i), d === 0 && e.graph().dummyChains.push(c), o = c;
+  e.setEdge(o, s, { weight: l.weight }, i);
+}
+function $n(e) {
+  e.graph().dummyChains.forEach((t) => {
+    let o = e.node(t);
+    const n = o.edgeLabel;
+    e.setEdge(o.edgeObj, n);
+    let s;
+    for (; o.dummy; )
+      s = e.successors(t)[0], e.removeNode(t), n.points.push({ x: o.x, y: o.y }), o.dummy === "edge-label" && (n.x = o.x, n.y = o.y, n.width = o.width, n.height = o.height), t = s, o = e.node(t);
+  });
+}
+function io(e) {
+  function t(o) {
+    const n = e.node(o);
+    if (n && Object.prototype.hasOwnProperty.call(n, "rank"))
+      return n.rank;
+    const s = e.outEdges(o) || [];
+    if (!s.length)
+      return n && (n.rank = 0), 0;
+    const r = s.map((l) => {
+      if (!e.node(l.w))
+        return Number.POSITIVE_INFINITY;
+      const c = t(l.w), u = e.edge(l).minlen;
+      return c - u;
+    });
+    let i = V(Math.min, r);
+    return i === Number.POSITIVE_INFINITY && (i = 0), n && (n.rank = i), i;
+  }
+  (e.sources() || []).forEach(t);
+}
+function Dn(e, t) {
+  return e.node(t.w).rank - e.node(t.v).rank - e.edge(t).minlen;
+}
+function Pn(e) {
+  Fn(e);
+  const t = new Z();
+  e.nodes().forEach((r) => {
+    t.setNode(r, {});
+  });
+  const o = e.nodes();
+  if (!o.length)
+    return t;
+  const n = o[0], s = /* @__PURE__ */ new Set([n]);
+  for (; s.size < o.length; ) {
+    const r = zn(e, s);
+    if (!r) {
+      const u = o.find((d) => !s.has(d));
+      s.add(u), t.setNode(u, {});
+      continue;
+    }
+    const { edgeObject: i, delta: l, attachFrom: a, attachTo: c } = r;
+    Bn(e, s, a, l), t.setEdge(i.v, i.w, {}), s.add(c);
+  }
+  return t;
+}
+function Fn(e) {
+  e.nodes().forEach((t) => {
+    const o = e.node(t) || {};
+    Object.prototype.hasOwnProperty.call(o, "rank") || (o.rank = 0, e.setNode(t, o));
+  });
+}
+function zn(e, t) {
+  let o = null;
+  return e.edges().forEach((n) => {
+    const s = t.has(n.v), r = t.has(n.w);
+    if (s === r)
+      return;
+    const i = Dn(e, n), l = Math.abs(i);
+    if (!o || l < o.absoluteSlack) {
+      const a = s ? n.v : n.w, c = s ? n.w : n.v, u = s ? i : -i;
+      o = {
+        edgeObject: n,
+        delta: u,
+        attachFrom: a,
+        attachTo: c,
+        absoluteSlack: l
+      };
+    }
+  }), o;
+}
+function Bn(e, t, o, n) {
+  n && e.nodes().forEach((s) => {
+    if (!t.has(s)) {
+      const r = e.node(s);
+      r.rank += n;
+    }
+  });
+}
+function ue(e) {
+  const t = Qt(e);
+  return io(t), t.nodes().forEach((o) => {
+    const n = t.node(o), s = e.node(o) || {};
+    s.rank = n.rank, e.setNode(o, s);
+  }), e;
+}
+function Vn(e, t) {
+}
+function jn(e, t) {
+}
+function Gn(e, t, o) {
+  return 0;
+}
+function In(e) {
+  return null;
+}
+function Wn(e, t) {
+  return null;
+}
+ue.initLowLimValues = Vn;
+ue.initCutValues = jn;
+ue.calcCutValue = Gn;
+ue.leaveEdge = In;
+ue.enterEdge = Wn;
+const lo = io;
+function Yn(e) {
+  const t = e.graph().ranker;
+  if (t instanceof Function)
+    return t(e);
+  switch (e.graph().ranker) {
+    case "network-simplex":
+      jt(e);
+      break;
+    case "tight-tree":
+      Zn(e);
+      break;
+    case "longest-path":
+      Hn(e);
+      break;
+    case "none":
+      break;
+    default:
+      jt(e);
+  }
+}
+const Hn = lo;
+function Zn(e) {
+  lo(e), Pn(e);
+}
+function jt(e) {
+  ue(e);
+}
+function Un(e) {
+  const t = qn(e);
+  e.graph().dummyChains.forEach((o) => {
+    let n = e.node(o);
+    const s = n.edgeObj, r = Xn(e, t, s.v, s.w), i = r.path, l = r.lca;
+    let a = 0, c = i[a], u = !0, d = o;
+    for (; d !== s.w; ) {
+      if (n = e.node(d), u) {
+        for (; (c = i[a]) !== l && e.node(c).maxRank < n.rank; )
+          a++;
+        c === l && (u = !1);
+      }
+      if (!u) {
+        for (; a < i.length - 1 && e.node(c = i[a + 1]).minRank <= n.rank; )
+          a++;
+        c = i[a];
+      }
+      e.setParent(d, c), d = e.successors(d)[0];
+    }
+  });
+}
+function Xn(e, t, o, n) {
+  const s = [], r = [], i = Math.min(t[o].low, t[n].low), l = Math.max(t[o].lim, t[n].lim);
+  let a, c;
+  a = o;
+  do
+    a = e.parent(a), s.push(a);
+  while (a && (t[a].low > i || l > t[a].lim));
+  for (c = a, a = n; (a = e.parent(a)) !== c; )
+    r.push(a);
+  return {
+    path: s.concat(r.reverse()),
+    lca: c
+  };
+}
+function qn(e) {
+  const t = {};
+  let o = 0;
+  function n(s) {
+    const r = o;
+    e.children(s).forEach(n), t[s] = { low: r, lim: o++ };
+  }
+  return e.children().forEach(n), t;
+}
+function Kn(e) {
+  const t = Me.addDummyNode(e, "root", {}, "_root"), o = Jn(e), n = Object.values(o), s = Me.applyWithChunking(Math.max, n) - 1, r = 2 * s + 1;
+  e.graph().nestingRoot = t, e.edges().forEach((l) => {
+    e.edge(l).minlen *= r;
+  });
+  const i = Qn(e) + 1;
+  e.children().forEach((l) => {
+    ao(e, t, r, i, s, o, l);
+  }), e.graph().nodeRankFactor = r;
+}
+function ao(e, t, o, n, s, r, i) {
+  const l = e.children(i);
+  if (!l.length) {
+    i !== t && e.setEdge(t, i, { weight: 0, minlen: o });
+    return;
+  }
+  const a = Me.addBorderNode(e, "_bt"), c = Me.addBorderNode(e, "_bb"), u = e.node(i);
+  e.setParent(a, i), u.borderTop = a, e.setParent(c, i), u.borderBottom = c, l.forEach((d) => {
+    ao(e, t, o, n, s, r, d);
+    const g = e.node(d), v = g.borderTop ? g.borderTop : d, A = g.borderBottom ? g.borderBottom : d, N = g.borderTop ? n : 2 * n, M = v !== A ? 1 : s - r[i] + 1;
+    e.setEdge(a, v, {
+      weight: N,
+      minlen: M,
+      nestingEdge: !0
+    }), e.setEdge(A, c, {
+      weight: N,
+      minlen: M,
+      nestingEdge: !0
+    });
+  }), e.parent(i) || e.setEdge(t, a, {
+    weight: 0,
+    minlen: s + r[i]
+  });
+}
+function Jn(e) {
+  const t = {};
+  function o(n, s) {
+    const r = e.children(n);
+    r && r.length && r.forEach((i) => o(i, s + 1)), t[n] = s;
+  }
+  return e.children().forEach((n) => o(n, 1)), t;
+}
+function Qn(e) {
+  return e.edges().reduce((t, o) => t + e.edge(o).weight, 0);
+}
+function es(e) {
+  const t = e.graph();
+  e.removeNode(t.nestingRoot), delete t.nestingRoot, e.edges().forEach((o) => {
+    e.edge(o).nestingEdge && e.removeEdge(o);
+  });
+}
+function ts(e) {
+  function t(o) {
+    const n = e.children(o), s = e.node(o);
+    if (n.length && n.forEach(t), Object.hasOwn(s, "minRank")) {
+      s.borderLeft = [], s.borderRight = [];
+      for (let r = s.minRank, i = s.maxRank + 1; r < i; ++r)
+        Gt(e, "borderLeft", "_bl", o, s, r), Gt(e, "borderRight", "_br", o, s, r);
+    }
+  }
+  e.children().forEach(t);
+}
+function Gt(e, t, o, n, s, r) {
+  const i = {
+    width: 0,
+    height: 0,
+    rank: r,
+    borderType: t
+  }, l = s[t][r - 1], a = ce(e, "border", i, o);
+  s[t][r] = a, e.setParent(a, n), l && e.setEdge(l, a, { weight: 1 });
+}
+function os(e) {
+  const t = e.graph().rankdir.toLowerCase();
+  (t === "lr" || t === "rl") && co(e);
+}
+function ns(e) {
+  const t = e.graph().rankdir.toLowerCase();
+  (t === "bt" || t === "rl") && ss(e), (t === "lr" || t === "rl") && (rs(e), co(e));
+}
+function co(e) {
+  e.nodes().forEach((t) => {
+    It(e.node(t));
+  }), e.edges().forEach((t) => {
+    It(e.edge(t));
+  });
+}
+function It(e) {
+  const t = e.width;
+  e.width = e.height, e.height = t;
+}
+function ss(e) {
+  e.nodes().forEach((t) => {
+    Ke(e.node(t));
+  }), e.edges().forEach((t) => {
+    const o = e.edge(t);
+    o.points.forEach(Ke), Object.hasOwn(o, "y") && Ke(o);
+  });
+}
+function Ke(e) {
+  e.y = -e.y;
+}
+function rs(e) {
+  e.nodes().forEach((t) => {
+    Je(e.node(t));
+  }), e.edges().forEach((t) => {
+    const o = e.edge(t);
+    o.points.forEach(Je), Object.hasOwn(o, "x") && Je(o);
+  });
+}
+function Je(e) {
+  const t = e.x;
+  e.x = e.y, e.y = t;
+}
+const Wt = {
+  adjust: os,
+  undo: ns
+};
+function is(e) {
+  const t = {}, o = e.nodes().filter((a) => e.children(a).length === 0), n = o.map((a) => e.node(a).rank), s = V(Math.max, n), r = ae(s + 1).map(() => []);
+  function i(a) {
+    if (t[a]) return;
+    t[a] = !0;
+    const c = e.node(a);
+    r[c.rank].push(a), e.successors(a).forEach(i);
+  }
+  return o.sort(
+    (a, c) => e.node(a).rank - e.node(c).rank
+  ).forEach(i), r;
+}
+function ls(e, t) {
+  let o = 0;
+  for (let n = 1; n < t.length; ++n)
+    o += as(e, t[n - 1], t[n]);
+  return o;
+}
+function as(e, t, o) {
+  const n = De(
+    o,
+    o.map((c, u) => u)
+  ), s = t.flatMap((c) => e.outEdges(c).map((u) => ({
+    pos: n[u.w],
+    weight: e.edge(u).weight
+  })).sort((u, d) => u.pos - d.pos));
+  let r = 1;
+  for (; r < o.length; ) r <<= 1;
+  const i = 2 * r - 1;
+  r -= 1;
+  const l = new Array(i).fill(0);
+  let a = 0;
+  return s.forEach((c) => {
+    let u = c.pos + r;
+    l[u] += c.weight;
+    let d = 0;
+    for (; u > 0; )
+      u % 2 && (d += l[u + 1]), u = u - 1 >> 1, l[u] += c.weight;
+    a += c.weight * d;
+  }), a;
+}
+function cs(e, t = []) {
+  return t.map((o) => {
+    const n = e.inEdges(o);
+    if (!n.length)
+      return { v: o };
+    const s = n.reduce(
+      (r, i) => {
+        const l = e.edge(i), a = e.node(i.v);
+        return {
+          sum: r.sum + l.weight * a.order,
+          weight: r.weight + l.weight
+        };
+      },
+      { sum: 0, weight: 0 }
+    );
+    return {
+      v: o,
+      barycenter: s.sum / s.weight,
+      weight: s.weight
+    };
+  });
+}
+function us(e, t) {
+  const o = {};
+  e.forEach((s, r) => {
+    const i = o[s.v] = {
+      indegree: 0,
+      in: [],
+      out: [],
+      vs: [s.v],
+      i: r
+    };
+    s.barycenter !== void 0 && (i.barycenter = s.barycenter, i.weight = s.weight);
+  }), t.edges().forEach((s) => {
+    const r = o[s.v], i = o[s.w];
+    r !== void 0 && i !== void 0 && (i.indegree++, r.out.push(i));
+  });
+  const n = Object.values(o).filter((s) => !s.indegree);
+  return ds(n);
+}
+function ds(e) {
+  const t = [];
+  function o(s) {
+    return (r) => {
+      r.merged || (r.barycenter === void 0 || s.barycenter === void 0 || r.barycenter >= s.barycenter) && fs(s, r);
+    };
+  }
+  function n(s) {
+    return (r) => {
+      r.in.push(s), --r.indegree === 0 && e.push(r);
+    };
+  }
+  for (; e.length; ) {
+    const s = e.pop();
+    t.push(s), s.in.reverse().forEach(o(s)), s.out.forEach(n(s));
+  }
+  return t.filter((s) => !s.merged).map((s) => Ee(s, ["vs", "i", "barycenter", "weight"]));
+}
+function fs(e, t) {
+  let o = 0, n = 0;
+  e.weight && (o += e.barycenter * e.weight, n += e.weight), t.weight && (o += t.barycenter * t.weight, n += t.weight), e.vs = t.vs.concat(e.vs), e.barycenter = o / n, e.weight = n, e.i = Math.min(t.i, e.i), t.merged = !0;
+}
+function hs(e, t) {
+  const o = no(e, (u) => Object.hasOwn(u, "barycenter")), n = o.lhs, s = o.rhs.sort((u, d) => d.i - u.i), r = [];
+  let i = 0, l = 0, a = 0;
+  n.sort(ms(!!t)), a = Yt(r, s, a), n.forEach((u) => {
+    a += u.vs.length, r.push(u.vs), i += u.barycenter * u.weight, l += u.weight, a = Yt(r, s, a);
+  });
+  const c = { vs: r.flat(!0) };
+  return l && (c.barycenter = i / l, c.weight = l), c;
+}
+function Yt(e, t, o) {
+  let n;
+  for (; t.length && (n = t[t.length - 1]).i <= o; )
+    t.pop(), e.push(n.vs), o++;
+  return o;
+}
+function ms(e) {
+  return (t, o) => t.barycenter < o.barycenter ? -1 : t.barycenter > o.barycenter ? 1 : e ? o.i - t.i : t.i - o.i;
+}
+function uo(e, t, o, n) {
+  let s = e.children(t);
+  const r = e.node(t), i = r ? r.borderLeft : void 0, l = r ? r.borderRight : void 0, a = {};
+  i && (s = s.filter((g) => g !== i && g !== l));
+  const c = cs(e, s);
+  c.forEach((g) => {
+    if (e.children(g.v).length) {
+      const v = uo(e, g.v, o, n);
+      a[g.v] = v, Object.hasOwn(v, "barycenter") && bs(g, v);
+    }
+  });
+  let u = us(c, o);
+  gs(u, a);
+  const d = hs(u, n);
+  if (i && (d.vs = [i, d.vs, l].flat(!0), e.predecessors(i).length)) {
+    const g = e.node(e.predecessors(i)[0]), v = e.node(e.predecessors(l)[0]);
+    Object.hasOwn(d, "barycenter") || (d.barycenter = 0, d.weight = 0), d.barycenter = (d.barycenter * d.weight + g.order + v.order) / (d.weight + 2), d.weight += 2;
+  }
+  return d;
+}
+function gs(e, t) {
+  e.forEach((o) => {
+    o.vs = o.vs.flatMap((n) => t[n] ? t[n].vs : n);
+  });
+}
+function bs(e, t) {
+  e.barycenter !== void 0 ? (e.barycenter = (e.barycenter * e.weight + t.barycenter * t.weight) / (e.weight + t.weight), e.weight += t.weight) : (e.barycenter = t.barycenter, e.weight = t.weight);
+}
+function vs(e, t, o, n) {
+  n || (n = e.nodes());
+  const s = ps(e), r = new Z({ compound: !0 }).setGraph({ root: s }).setDefaultNodeLabel((i) => e.node(i));
+  return n.forEach((i) => {
+    const l = e.node(i), a = e.parent(i);
+    (l.rank === t || l.minRank <= t && t <= l.maxRank) && (r.setNode(i), r.setParent(i, a || s), e[o](i).forEach((u) => {
+      const d = u.v === i ? u.w : u.v, g = r.edge(d, i), v = g ? g.weight : 0;
+      r.setEdge(d, i, {
+        weight: e.edge(u).weight + v
+      });
+    }), Object.hasOwn(l, "minRank") && r.setNode(i, {
+      borderLeft: l.borderLeft[t],
+      borderRight: l.borderRight[t]
+    }));
+  }), r;
+}
+function ps(e) {
+  let t;
+  for (; e.hasNode(t = $e("_root")); ) ;
+  return t;
+}
+function ws(e, t, o) {
+  let n = {}, s;
+  o.forEach((r) => {
+    let i = e.parent(r), l, a;
+    for (; i; ) {
+      if (l = e.parent(i), l ? (a = n[l], n[l] = i) : (a = s, s = i), a && a !== i) {
+        t.setEdge(a, i);
+        return;
+      }
+      i = l;
+    }
+  });
+}
+function fo(e, t = {}) {
+  if (typeof t.customOrder == "function") {
+    t.customOrder(e, fo);
+    return;
+  }
+  const o = it(e), n = Ht(
+    e,
+    ae(1, o + 1),
+    "inEdges"
+  ), s = Ht(
+    e,
+    ae(o - 1, -1, -1),
+    "outEdges"
+  );
+  let r = is(e);
+  if (Zt(e, r), t.disableOptimalOrderHeuristic)
+    return;
+  let i = Number.POSITIVE_INFINITY, l;
+  const a = t.constraints || [];
+  for (let c = 0, u = 0; u < 4; ++c, ++u) {
+    const d = c % 2 === 0 ? n : s, g = c % 4 >= 2;
+    ks(d, g, a), r = Ce(e);
+    const v = ls(e, r);
+    v < i ? (i = v, u = 0, l = structuredClone(r)) : v === i && (l = structuredClone(r));
+  }
+  Zt(e, l);
+}
+function Ht(e, t, o) {
+  const n = /* @__PURE__ */ new Map();
+  function s(r, i) {
+    n.has(r) || n.set(r, []), n.get(r).push(i);
+  }
+  for (const r of e.nodes()) {
+    const i = e.node(r);
+    if (typeof i.rank == "number" && s(i.rank, r), typeof i.minRank == "number" && typeof i.maxRank == "number")
+      for (let l = i.minRank; l <= i.maxRank; l++)
+        l !== i.rank && s(l, r);
+  }
+  return t.map(
+    (r) => vs(
+      e,
+      r,
+      o,
+      n.get(r) || []
+    )
+  );
+}
+function ks(e, t, o) {
+  const n = new Z();
+  e.forEach((s) => {
+    o.forEach((l) => n.setEdge(l.left, l.right));
+    const r = s.graph().root, i = uo(s, r, n, t);
+    i.vs.forEach((l, a) => {
+      s.node(l).order = a;
+    }), ws(s, n, i.vs);
+  });
+}
+function Zt(e, t) {
+  Object.values(t).forEach((o) => {
+    o.forEach((n, s) => {
+      e.node(n).order = s;
+    });
+  });
+}
+function ys(e, t) {
+  const o = {};
+  function n(s, r) {
+    let i = 0, l = 0;
+    const a = s.length, c = r[r.length - 1];
+    return r.forEach((u, d) => {
+      const g = Cs(e, u), v = g ? e.node(g).order : a;
+      (g || u === c) && (r.slice(l, d + 1).forEach((A) => {
+        e.predecessors(A).forEach((N) => {
+          const M = e.node(N), G = M.order;
+          (G < i || v < G) && !(M.dummy && e.node(A).dummy) && ho(o, N, A);
+        });
+      }), l = d + 1, i = v);
+    }), r;
+  }
+  return t.length && t.reduce(n), o;
+}
+function Es(e, t) {
+  const o = {};
+  function n(r, i, l, a, c) {
+    let u;
+    ae(i, l).forEach((d) => {
+      u = r[d], e.node(u).dummy && e.predecessors(u).forEach((g) => {
+        const v = e.node(g);
+        v.dummy && (v.order < a || v.order > c) && ho(o, g, u);
+      });
+    });
+  }
+  function s(r, i) {
+    let l = -1, a, c = 0;
+    return i.forEach((u, d) => {
+      if (e.node(u).dummy === "border") {
+        const g = e.predecessors(u);
+        g.length && (a = e.node(g[0]).order, n(i, c, d, l, a), c = d, l = a);
+      }
+      n(i, c, i.length, a, r.length);
+    }), i;
+  }
+  return t.length && t.reduce(s), o;
+}
+function Cs(e, t) {
+  if (e.node(t).dummy)
+    return e.predecessors(t).find((o) => e.node(o).dummy);
+}
+function ho(e, t, o) {
+  if (t > o) {
+    const s = t;
+    t = o, o = s;
+  }
+  let n = e[t];
+  n || (e[t] = n = {}), n[o] = !0;
+}
+function xs(e, t, o) {
+  if (t > o) {
+    const n = t;
+    t = o, o = n;
+  }
+  return !!e[t] && Object.hasOwn(e[t], o);
+}
+function _s(e, t, o, n) {
+  const s = {}, r = {}, i = {};
+  return t.forEach((l) => {
+    l.forEach((a, c) => {
+      s[a] = a, r[a] = a, i[a] = c;
+    });
+  }), t.forEach((l) => {
+    let a = -1;
+    l.forEach((c) => {
+      let u = n(c);
+      if (u.length) {
+        u = u.sort((g, v) => i[g] - i[v]);
+        const d = (u.length - 1) / 2;
+        for (let g = Math.floor(d), v = Math.ceil(d); g <= v; ++g) {
+          const A = u[g];
+          r[c] === c && a < i[A] && !xs(o, c, A) && (r[A] = c, r[c] = s[c] = s[A], a = i[A]);
+        }
+      }
+    });
+  }), { root: s, align: r };
+}
+function Ns(e, t, o, n, s) {
+  const r = {}, i = As(e, t, o, s), l = s ? "borderLeft" : "borderRight";
+  function a(d, g) {
+    const v = i.nodes().slice(), A = {};
+    let N = v.pop();
+    for (; N; ) {
+      if (A[N])
+        d(N);
+      else {
+        A[N] = !0, v.push(N);
+        for (const M of g(N))
+          v.push(M);
+      }
+      N = v.pop();
+    }
+  }
+  function c(d) {
+    r[d] = i.inEdges(d).reduce((g, v) => Math.max(g, r[v.v] + i.edge(v)), 0);
+  }
+  function u(d) {
+    const g = i.outEdges(d).reduce((A, N) => Math.min(A, r[N.w] - i.edge(N)), Number.POSITIVE_INFINITY), v = e.node(d);
+    g !== Number.POSITIVE_INFINITY && v.borderType !== l && (r[d] = Math.max(r[d], g));
+  }
+  return a(c, i.predecessors.bind(i)), a(u, i.successors.bind(i)), Object.keys(n).forEach((d) => {
+    r[d] = r[o[d]];
+  }), r;
+}
+function As(e, t, o, n) {
+  const s = new e.constructor(), r = e.graph(), i = Ts(r.nodesep, r.edgesep, n);
+  return t.forEach((l) => {
+    let a;
+    l.forEach((c) => {
+      const u = o[c];
+      if (s.setNode(u), a) {
+        const d = o[a], g = s.edge(d, u);
+        s.setEdge(
+          d,
+          u,
+          Math.max(i(e, c, a), g || 0)
+        );
+      }
+      a = c;
+    });
+  }), s;
+}
+function Ss(e, t) {
+  return Object.values(t).reduce(
+    (o, n) => {
+      let s = Number.NEGATIVE_INFINITY, r = Number.POSITIVE_INFINITY;
+      Object.entries(n).forEach(([l, a]) => {
+        const c = Ms(e, l) / 2;
+        s = Math.max(a + c, s), r = Math.min(a - c, r);
+      });
+      const i = s - r;
+      return i < o[0] && (o = [i, n]), o;
+    },
+    [Number.POSITIVE_INFINITY, null]
+  )[1];
+}
+function Ls(e, t) {
+  const o = Object.values(t), n = V(Math.min, o), s = V(Math.max, o);
+  ["u", "d"].forEach((r) => {
+    ["l", "r"].forEach((i) => {
+      const l = r + i;
+      let a = e[l];
+      if (a === t) return;
+      const c = Object.values(a);
+      let u = n - V(Math.min, c);
+      i !== "l" && (u = s - V(Math.max, c)), u && (a = xe(a, (d) => d + u), e[l] = a);
+    });
+  });
+}
+function Os(e, t) {
+  return xe(e.ul, (o, n) => {
+    if (t)
+      return e[t.toLowerCase()][n];
+    const s = Object.values(e).map((r) => r[n]).sort((r, i) => r - i);
+    return (s[1] + s[2]) / 2;
+  });
+}
+function Rs(e) {
+  const t = Ce(e), o = Object.assign(
+    ys(e, t),
+    Es(e, t)
+  ), n = {};
+  let s;
+  ["u", "d"].forEach((i) => {
+    s = i === "u" ? t : Object.values(t).reverse(), ["l", "r"].forEach((l) => {
+      let a = s;
+      l === "r" && (a = a.map(
+        (g) => Object.values(g).reverse()
+      ));
+      const c = (i === "u" ? e.predecessors : e.successors).bind(e), u = _s(
+        e,
+        a,
+        o,
+        c
+      );
+      let d = Ns(
+        e,
+        a,
+        u.root,
+        u.align,
+        l === "r"
+      );
+      l === "r" && (d = xe(d, (g) => -g)), n[i + l] = d;
+    });
+  });
+  const r = Ss(e, n);
+  return Ls(n, r), Os(n, e.graph().align);
+}
+function Ts(e, t, o) {
+  return (n, s, r) => {
+    const i = n.node(s), l = n.node(r);
+    let a = 0, c;
+    if (a += i.width / 2, Object.hasOwn(i, "labelpos"))
+      switch (i.labelpos.toLowerCase()) {
+        case "l":
+          c = -i.width / 2;
+          break;
+        case "r":
+          c = i.width / 2;
+          break;
+      }
+    if (c && (a += o ? c : -c), c = 0, a += (i.dummy ? t : e) / 2, a += (l.dummy ? t : e) / 2, a += l.width / 2, Object.hasOwn(l, "labelpos"))
+      switch (l.labelpos.toLowerCase()) {
+        case "l":
+          c = l.width / 2;
+          break;
+        case "r":
+          c = -l.width / 2;
+          break;
+      }
+    return c && (a += o ? c : -c), c = 0, a;
+  };
+}
+function Ms(e, t) {
+  return e.node(t).width;
+}
+function $s(e) {
+  const t = rt(e);
+  Ds(t);
+  const o = Rs(t);
+  Object.entries(o).forEach(([n, s]) => {
+    e.node(n).x = s;
+  });
+}
+function Ds(e) {
+  const t = Ce(e), o = e.graph().ranksep;
+  let n = 0;
+  t.forEach((s) => {
+    const r = s.reduce((i, l) => {
+      const a = e.node(l).height;
+      return i > a ? i : a;
+    }, 0);
+    s.forEach((i) => {
+      e.node(i).y = n + r / 2;
+    }), n += r + o;
+  });
+}
+function Ps(e, t = {}) {
+  const o = t.debugTiming ? so : ro;
+  return o("layout", () => {
+    const n = o("  buildLayoutGraph", () => Hs(e));
+    return o("  runLayout", () => Fs(n, o, t)), o("  updateInputGraph", () => zs(e, n)), n;
+  });
+}
+function Fs(e, t, o) {
+  t("    makeSpaceForEdgeLabels", () => Zs(e)), t("    removeSelfEdges", () => or(e)), t("    acyclic", () => Ln(e)), t("    nestingGraph.run", () => Kn(e)), t("    rank", () => Yn(rt(e))), t("    injectEdgeLabelProxies", () => Us(e)), t("    removeEmptyRanks", () => to(e)), t("    nestingGraph.cleanup", () => es(e)), t("    normalizeRanks", () => eo(e)), t("    assignRankMinMax", () => Xs(e)), t("    removeEdgeLabelProxies", () => qs(e)), t("    normalize.run", () => Tn(e)), t("    parentDummyChains", () => Un(e)), t("    addBorderSegments", () => ts(e)), t("    order", () => fo(e, o)), t("    insertSelfEdges", () => nr(e)), t("    adjustCoordinateSystem", () => Wt.adjust(e)), t("    position", () => $s(e)), t("    positionSelfEdges", () => sr(e)), t("    removeBorderNodes", () => tr(e)), t("    normalize.undo", () => $n(e)), t("    fixupEdgeLabelCoords", () => Qs(e)), t("    undoCoordinateSystem", () => Wt.undo(e)), t("    translateGraph", () => Ks(e)), t("    assignNodeIntersects", () => Js(e)), t("    reversePoints", () => er(e)), t("    acyclic.undo", () => On(e));
+}
+function zs(e, t) {
+  e.nodes().forEach((s) => {
+    const r = e.node(s), i = t.node(s);
+    r && (r.x = i.x, r.y = i.y, r.order = i.order, r.rank = i.rank, t.children(s).length && (r.width = i.width, r.height = i.height));
+  }), e.edges().forEach((s) => {
+    const r = e.edge(s), i = t.edge(s);
+    r.points = i.points, Object.hasOwn(i, "x") && (r.x = i.x, r.y = i.y);
+  });
+  const o = t.graph(), n = e.graph();
+  n.width = o.width, n.height = o.height;
+}
+const Bs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"], Vs = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" }, js = ["acyclicer", "ranker", "rankdir", "align"], Gs = ["width", "height", "rank"], Ut = { width: 0, height: 0 }, Is = ["minlen", "weight", "width", "height", "labeloffset"], Ws = {
+  minlen: 1,
+  weight: 1,
+  width: 0,
+  height: 0,
+  labeloffset: 10,
+  labelpos: "r"
+}, Ys = ["labelpos"];
+function Hs(e) {
+  const t = et(e.graph()), o = {
+    ...Vs,
+    ...Qe(t, Bs),
+    ...Ee(t, js)
+  }, n = new Z({ multigraph: !0, compound: !0 });
+  return n.setGraph(o), e.nodes().forEach((s) => {
+    const r = et(e.node(s)), i = Qe(r, Gs);
+    Object.keys(Ut).forEach((l) => {
+      i[l] === void 0 && (i[l] = Ut[l]);
+    }), n.setNode(s, i), n.setParent(s, e.parent(s));
+  }), e.edges().forEach((s) => {
+    const r = et(e.edge(s));
+    n.setEdge(
+      s,
+      {
+        ...Ws,
+        ...Qe(r, Is),
+        ...Ee(r, Ys)
+      }
+    );
+  }), n;
+}
+function Zs(e) {
+  const t = e.graph();
+  t.ranksep /= 2, e.edges().forEach((o) => {
+    const n = e.edge(o);
+    n.minlen *= 2, n.labelpos.toLowerCase() !== "c" && (t.rankdir === "TB" || t.rankdir === "BT" ? n.width += n.labeloffset : n.height += n.labeloffset);
+  });
+}
+function Us(e) {
+  e.edges().forEach((t) => {
+    const o = e.edge(t);
+    if (o.width && o.height) {
+      const n = e.node(t.v), r = { rank: (e.node(t.w).rank - n.rank) / 2 + n.rank, e: t };
+      ce(e, "edge-proxy", r, "_ep");
+    }
+  });
+}
+function Xs(e) {
+  let t = 0;
+  e.nodes().forEach((o) => {
+    const n = e.node(o);
+    n.borderTop && (n.minRank = e.node(n.borderTop).rank, n.maxRank = e.node(n.borderBottom).rank, t = Math.max(t, n.maxRank));
+  }), e.graph().maxRank = t;
+}
+function qs(e) {
+  e.nodes().forEach((t) => {
+    const o = e.node(t);
+    o.dummy === "edge-proxy" && (e.edge(o.e).labelRank = o.rank, e.removeNode(t));
+  });
+}
+function Ks(e) {
+  let t = Number.POSITIVE_INFINITY, o = 0, n = Number.POSITIVE_INFINITY, s = 0;
+  const r = e.graph(), i = r.marginx || 0, l = r.marginy || 0;
+  function a(c) {
+    const u = c.x, d = c.y, g = c.width, v = c.height;
+    t = Math.min(t, u - g / 2), o = Math.max(o, u + g / 2), n = Math.min(n, d - v / 2), s = Math.max(s, d + v / 2);
+  }
+  e.nodes().forEach((c) => a(e.node(c))), e.edges().forEach((c) => {
+    const u = e.edge(c);
+    Object.hasOwn(u, "x") && a(u);
+  }), t -= i, n -= l, e.nodes().forEach((c) => {
+    const u = e.node(c);
+    u.x -= t, u.y -= n;
+  }), e.edges().forEach((c) => {
+    const u = e.edge(c);
+    u.points.forEach((d) => {
+      d.x -= t, d.y -= n;
+    }), Object.hasOwn(u, "x") && (u.x -= t), Object.hasOwn(u, "y") && (u.y -= n);
+  }), r.width = o - t + i, r.height = s - n + l;
+}
+function Js(e) {
+  e.edges().forEach((t) => {
+    const o = e.edge(t), n = e.node(t.v), s = e.node(t.w);
+    let r, i;
+    !o.points || !o.points.length ? (o.points = [], r = s, i = n) : (r = o.points[0], i = o.points[o.points.length - 1]), o.points.unshift(st(n, r)), o.points.push(st(s, i));
+  });
+}
+function Qs(e) {
+  e.edges().forEach((t) => {
+    const o = e.edge(t);
+    if (Object.hasOwn(o, "x"))
+      switch ((o.labelpos === "l" || o.labelpos === "r") && (o.width -= o.labeloffset), o.labelpos) {
+        case "l":
+          o.x -= o.width / 2 + o.labeloffset;
+          break;
+        case "r":
+          o.x += o.width / 2 + o.labeloffset;
+          break;
+      }
+  });
+}
+function er(e) {
+  e.edges().forEach((t) => {
+    const o = e.edge(t);
+    o.reversed && o.points.reverse();
+  });
+}
+function tr(e) {
+  e.nodes().forEach((t) => {
+    if (e.children(t).length) {
+      const o = e.node(t), n = e.node(o.borderTop), s = e.node(o.borderBottom), r = e.node(o.borderLeft[o.borderLeft.length - 1]), i = e.node(o.borderRight[o.borderRight.length - 1]);
+      o.width = Math.abs(i.x - r.x), o.height = Math.abs(s.y - n.y), o.x = r.x + o.width / 2, o.y = n.y + o.height / 2;
+    }
+  }), e.nodes().forEach((t) => {
+    e.node(t).dummy === "border" && e.removeNode(t);
+  });
+}
+function or(e) {
+  e.edges().forEach((t) => {
+    if (t.v === t.w) {
+      const o = e.node(t.v);
+      o.selfEdges || (o.selfEdges = []), o.selfEdges.push({ e: t, label: e.edge(t) }), e.removeEdge(t);
+    }
+  });
+}
+function nr(e) {
+  Ce(e).forEach((o) => {
+    let n = 0;
+    o.forEach((s, r) => {
+      const i = e.node(s);
+      i.order = r + n, (i.selfEdges || []).forEach((l) => {
+        ce(e, "selfedge", {
+          width: l.label.width,
+          height: l.label.height,
+          rank: i.rank,
+          order: r + ++n,
+          e: l.e,
+          label: l.label
+        }, "_se");
+      }), delete i.selfEdges;
+    });
+  });
+}
+function sr(e) {
+  e.nodes().forEach((t) => {
+    const o = e.node(t);
+    if (o.dummy === "selfedge") {
+      const n = e.node(o.e.v), s = n.x + n.width / 2, r = n.y, i = o.x - s, l = n.height / 2;
+      e.setEdge(o.e, o.label), e.removeNode(t), o.label.points = [
+        { x: s + 2 * i / 3, y: r - l },
+        { x: s + 5 * i / 6, y: r - l },
+        { x: s + i, y: r },
+        { x: s + 5 * i / 6, y: r + l },
+        { x: s + 2 * i / 3, y: r + l }
+      ], o.label.x = o.x, o.label.y = o.y;
+    }
+  });
+}
+function Qe(e, t) {
+  return xe(Ee(e, t), Number);
+}
+function et(e) {
+  const t = {};
+  return e && Object.entries(e).forEach(([o, n]) => {
+    let s = o;
+    typeof s == "string" && (s = s.toLowerCase()), t[s] = n;
+  }), t;
+}
+const rr = {
+  rankDirection: "TB",
+  // "TB", "BT", "LR", "RL"
+  nodeSeparation: 50,
+  rankSeparation: 50,
+  edgeSeparation: 10,
+  // "UL", "UR", "DL", "DR" or undefined force one of four extreme alignment strategies (Up/Down × Left/Right).
+  align: void 0,
+  nodeWidth: 100,
+  nodeHeight: 40,
+  curvedEdges: !1,
+  padding: 20,
+  // "undirected" | "normal" | "vee"
+  arrowShape: "normal",
+  arrowSize: 10
+};
+function ir(e) {
+  return e.length ? e.map(
+    (t, o) => `${o === 0 ? "M" : "L"} ${t.x} ${t.y}`
+  ).join(" ") : "";
+}
+function lr(e) {
+  if (!e.length) return "";
+  if (e.length === 1) {
+    const s = e[0];
+    return `M ${s.x} ${s.y}`;
+  }
+  if (e.length === 2)
+    return `M ${e[0].x} ${e[0].y} L ${e[1].x} ${e[1].y}`;
+  const [t] = e;
+  let o = `M ${t.x} ${t.y}`;
+  for (let s = 1; s < e.length - 1; s += 1) {
+    e[s - 1];
+    const r = e[s], i = e[s + 1], l = r.x, a = r.y, c = (r.x + i.x) / 2, u = (r.y + i.y) / 2;
+    o += ` Q ${l} ${a} ${c} ${u}`;
+  }
+  const n = e[e.length - 1];
+  return o += ` L ${n.x} ${n.y}`, o;
+}
+function ar(e) {
+  const { nodes: t, edges: o, configuration: n } = e, s = E(null), r = E(null), i = `dag-arrow-${ot()}`;
+  function l(a, c, u) {
+    r.value = null, s.value = null;
+    const d = {
+      ...rr,
+      ...u
+    }, g = new Z({ multigraph: !0, compound: !0 });
+    g.setGraph({
+      rankdir: d.rankDirection,
+      nodesep: d.nodeSeparation,
+      ranksep: d.rankSeparation,
+      edgesep: d.edgeSeparation,
+      align: d.align
+    }), a.forEach((p) => {
+      g.setNode(p.id, {
+        label: p.label,
+        width: p.width ?? d.nodeWidth,
+        height: p.height ?? d.nodeHeight
+      });
+    }), c.forEach((p) => {
+      g.setEdge(p.from, p.to, {
+        weight: p.weight ?? 1,
+        minlen: p.minLength ?? 1
+      });
+    }), Ps(g);
+    const v = a.map((p) => {
+      const z = g.node(p.id);
+      return {
+        id: p.id,
+        label: p.label,
+        x: z.x,
+        y: z.y,
+        width: z.width,
+        height: z.height,
+        original: p
+      };
+    }), A = g.edges().map((p) => {
+      const z = g.edge(p), U = z.points || [];
+      if (!U.length)
+        return null;
+      const j = d.curvedEdges ? lr(U) : ir(U), _e = d.arrowShape !== "undirected" ? `url(#${i})` : null, X = c.find((te) => te?.from === p.v && te?.to === p.w);
+      return {
+        id: `${p.v}->${p.w}->${ot()}`,
+        from: p.v,
+        to: p.w,
+        points: U,
+        pathData: j,
+        markerEnd: _e,
+        original: {
+          ...X,
+          ...z
+        }
+      };
+    }).filter(Boolean), N = d.padding;
+    if (!v.length) {
+      s.value = {
+        nodes: [],
+        edges: A,
+        viewBox: "0 0 0 0",
+        arrowShape: d.arrowShape,
+        arrowSize: d.arrowSize
+      };
+      return;
+    }
+    const M = v.flatMap((p) => [
+      p.x - p.width / 2,
+      p.x + p.width / 2
+    ]), G = v.flatMap((p) => [
+      p.y - p.height / 2,
+      p.y + p.height / 2
+    ]), de = Math.min(...M) - N, ee = Math.max(...M) + N, fe = Math.min(...G) - N, $ = Math.max(...G) + N;
+    s.value = {
+      nodes: v,
+      edges: A.map((p) => ({
+        ...p,
+        midpoint: p.pathData ? Ko(p.pathData) : { x: 0, y: 0 }
+      })),
+      viewBox: `${de} ${fe} ${ee - de} ${$ - fe}`,
+      arrowShape: d.arrowShape,
+      arrowSize: d.arrowSize
+    };
+  }
+  return Yo(() => {
+    try {
+      const a = b(t) || [], c = b(o) || [], u = b(n) || {};
+      l(a, c, u);
+    } catch (a) {
+      console.error("[useDag] layout error:", a), r.value = a, s.value = null;
+    }
+  }), {
+    layoutData: s,
+    lastError: r,
+    arrowMarkerIdentifier: i,
+    recomputeLayout: () => {
+      const a = b(t) || [], c = b(o) || [], u = b(n) || {};
+      l(a, c, u);
+    }
+  };
+}
+const mo = { style: { chart: { backgroundColor: "#1A1A1A", color: "#CCCCCC", nodes: { stroke: "#6A6A6A", backgroundColor: "#2A2A2A", labels: { color: "#CCCCCC" }, tooltip: { backgroundColor: "#3A3A3A", color: "#CCCCCC" } }, edges: { stroke: "#6A6A6A" }, midpoints: { stroke: "#6A6A6A", fill: "#1A1A1A", tooltip: { backgroundColor: "#3A3A3A", color: "#CCCCCC" } }, controls: { backgroundColor: "#2A2A2A", buttonColor: "#2A2A2A", color: "#CCCCCC", border: "1px solid #4A4A4A" }, title: { color: "#CCCCCC", subtitle: { color: "#757575" } } } } }, go = { style: { chart: { backgroundColor: "#FFF8E1", color: "#424242", nodes: { stroke: "#5D4037", backgroundColor: "#fcf9f0", labels: { color: "#424242" }, tooltip: { backgroundColor: "#5D4037", color: "#FFF8E1" } }, edges: { stroke: "#5D4037" }, midpoints: { stroke: "#5D4037", fill: "#FFF8E1", tooltip: { backgroundColor: "#5D4037", color: "#FFF8E1" } }, controls: { backgroundColor: "#FFF8E1", buttonColor: "#FFF8E1", color: "#424242", border: "1px solid #d9bbb2" }, title: { color: "#424242", subtitle: { color: "#757575" } } } } }, bo = { style: { chart: { backgroundColor: "#1E1E1E", color: "#BDBDBD", nodes: { stroke: "#965039", backgroundColor: "#2A2A2A", labels: { color: "#BDBDBD" }, tooltip: { backgroundColor: "#3A3A3A", color: "#FFF8E1" } }, edges: { stroke: "#965039" }, midpoints: { stroke: "#965039", fill: "#1E1E1E", tooltip: { backgroundColor: "#3A3A3A", color: "#FFF8E1" } }, controls: { backgroundColor: "#1E1E1E", buttonColor: "#1E1E1E", color: "#BDBDBD", border: "1px solid #3A3A3A" }, title: { color: "#FFF8E1", subtitle: { color: "#BDBDBD" } } } } }, vo = { style: { chart: { backgroundColor: "#1A1A1A", color: "#99AA99", nodes: { stroke: "#66CC66", backgroundColor: "#2A2A2A", labels: { color: "#99AA99" }, tooltip: { backgroundColor: "#3A3A3A", color: "#99AA99" } }, edges: { stroke: "#66CC66" }, midpoints: { stroke: "#66CC66", fill: "#1A1A1A", tooltip: { backgroundColor: "#3A3A3A", color: "#99AA99" } }, controls: { backgroundColor: "#1A1A1A", buttonColor: "#1A1A1A", color: "#99AA99", border: "1px solid #1e361e" }, title: { color: "#66CC66", subtitle: { color: "#99AA99" } } } } }, po = { style: { chart: { backgroundColor: "#fbfafa", color: "#8A9892", nodes: { stroke: "#8F837A", backgroundColor: "#ffffff", labels: { color: "#8A9892" }, tooltip: { backgroundColor: "#8F837A", color: "#fbfafa" } }, edges: { stroke: "#8F837A" }, midpoints: { stroke: "#8F837A", fill: "#fbfafa", tooltip: { backgroundColor: "#8F837A", color: "#fbfafa" } }, controls: { backgroundColor: "#fbfafa", buttonColor: "#fbfafa", color: "#99AA99", border: "1px solid #ebded3" }, title: { color: "#8A9892", subtitle: { color: "#99AA99" } } } } }, wo = { style: { chart: { backgroundColor: "#f6f6fb", color: "#50606C", layout: { arrowShape: "normal", curvedEdges: !1 }, nodes: { stroke: "#50606C", backgroundColor: "#ffffff", borderRadius: 0, labels: { color: "#50606C" }, tooltip: { backgroundColor: "#50606C", color: "#f6f6fb" } }, edges: { stroke: "#50606C" }, midpoints: { stroke: "#50606C", fill: "#fbfafa", tooltip: { backgroundColor: "#50606C", color: "#f6f6fb" } }, controls: { backgroundColor: "#f6f6fb", buttonColor: "#f6f6fb", color: "#50606C", border: "1px solid #98aab8", borderRadius: "0" }, title: { color: "#50606C", subtitle: { color: "#718890" } } } } }, ko = {
+  default: {},
+  dark: mo,
+  celebration: go,
+  celebrationNight: bo,
+  hack: vo,
+  zen: po,
+  concrete: wo
+}, qr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  celebration: go,
+  celebrationNight: bo,
+  concrete: wo,
+  dark: mo,
+  default: ko,
+  hack: vo,
+  zen: po
+}, Symbol.toStringTag, { value: "Module" }));
+function cr(e, t) {
+  const o = ye(e);
+  return Jo(o, t);
+}
+function Kr(e, t) {
+  const o = ye(e);
+  return Qo(o, t);
+}
+function Jr(e, t) {
+  const o = ye(e);
+  return en(o, t);
+}
+function Qr({ defaultConfig: e, userConfig: t }) {
+  return Kt({ defaultConfig: e, userConfig: t });
+}
+const ur = {
+  __name: "BaseZoomControls",
+  props: {
+    config: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    scale: {
+      type: Number,
+      default: 0
+    },
+    withDirection: {
+      type: Boolean,
+      default: !1
+    },
+    isFullscreen: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["zoomIn", "zoomOut", "resetZoom", "switchDirection"],
+  setup(e, { emit: t }) {
+    const o = t;
+    return (n, s) => (k(), _("div", {
+      class: tt({ "vue-data-ui-zoom-controls": !0, "vue-data-ui-zoom-controls-fullscreen": e.isFullscreen }),
+      "data-dom-to-png-ignore": "",
+      style: H({
+        border: e.config.style.chart.controls.border,
+        backgroundColor: e.config.style.chart.controls.backgroundColor,
+        padding: e.config.style.chart.controls.padding,
+        borderRadius: e.config.style.chart.controls.borderRadius,
+        "--vue-data-ui-zoom-control-button-color": e.config.style.chart.controls.buttonColor,
+        "--vue-data-ui-zoom-control-button-color-hover": b(cr)(e.config.style.chart.controls.buttonColor, 0.2)
+      })
+    }, [
+      B("button", {
+        onClick: s[0] || (s[0] = (r) => o("zoomOut")),
+        class: "vue-data-ui-zoom-controls-button",
+        "data-cy-zoom-out": ""
+      }, [
+        le(Ue, {
+          name: "zoomMinus",
+          stroke: e.config.style.chart.controls.color,
+          size: e.config.style.chart.controls.fontSize * 1.2
+        }, null, 8, ["stroke", "size"])
+      ]),
+      B("button", {
+        class: "vue-data-ui-zoom-controls-button-zoom",
+        onClick: s[1] || (s[1] = (r) => o("resetZoom")),
+        "data-cy-zoom-reset": "",
+        style: H({
+          color: e.config.style.chart.controls.color,
+          width: e.config.style.chart.controls.fontSize * 4 + "px",
+          borderRadius: e.config.style.chart.controls.borderRadius,
+          fontSize: e.config.style.chart.controls.fontSize + "px"
+        })
+      }, ie(Math.round(e.scale * 100)) + "% ", 5),
+      B("button", {
+        onClick: s[2] || (s[2] = (r) => o("zoomIn")),
+        class: "vue-data-ui-zoom-controls-button",
+        "data-cy-zoom-in": ""
+      }, [
+        le(Ue, {
+          name: "zoomPlus",
+          stroke: e.config.style.chart.controls.color,
+          size: e.config.style.chart.controls.fontSize * 1.2
+        }, null, 8, ["stroke", "size"])
+      ]),
+      e.withDirection ? (k(), _("button", {
+        key: 0,
+        onClick: s[3] || (s[3] = (r) => o("switchDirection")),
+        class: "vue-data-ui-zoom-controls-button"
+      }, [
+        le(Ue, {
+          name: "direction",
+          stroke: e.config.style.chart.controls.color,
+          size: e.config.style.chart.controls.fontSize * 1.2
+        }, null, 8, ["stroke", "size"])
+      ])) : L("", !0)
+    ], 6));
+  }
+}, Xt = /* @__PURE__ */ Jt(ur, [["__scopeId", "data-v-e4479474"]]), dr = ["id"], fr = {
+  key: 0,
+  class: "dag-chart-error"
+}, hr = ["viewBox", "xmlns"], mr = { key: 0 }, gr = ["id", "markerWidth", "markerHeight", "refX", "refY"], br = ["d", "fill", "stroke"], vr = ["d", "fill", "stroke"], pr = { class: "vue-ui-dag-edges" }, wr = ["d", "stroke", "stroke-width"], kr = ["cx", "cy", "r", "fill", "stroke", "stroke-width", "onMouseenter"], yr = { class: "vue-ui-dag-nodes" }, Er = ["onClick", "onMouseenter"], Cr = ["x", "y", "width", "height", "rx", "fill", "stroke", "stroke-width"], xr = ["x", "y", "font-size", "fill", "font-weight"], _r = ["x", "y", "font-size", "fill", "font-weight", "innerHTML"], Nr = ["x", "y", "width", "height"], Ar = { class: "vue-ui-dag-edges" }, Sr = ["d", "stroke-width", "marker-end"], Lr = {
+  key: 6,
+  class: "vue-data-ui-watermark"
+}, Or = ["data-position"], Rr = { key: 0 }, Tr = ["data-position"], Mr = { key: 0 }, qt = 1.5, $r = {
+  __name: "vue-ui-dag",
+  props: {
+    dataset: {
+      type: Object,
+      default() {
+        return {
+          nodes: [],
+          edges: []
+        };
+      }
+    },
+    config: {
+      type: Object,
+      default() {
+        return {};
+      }
+    }
+  },
+  emits: ["onNodeClick", "onMidpointEnter", "onMidpointLeave"],
+  setup(e, { expose: t, emit: o }) {
+    const n = Ye(() => import("./PenAndPaper-DscVdZ1u.js")), s = Ye(() => import("./UserOptions-ChRXLqps.js")), r = Ye(() => import("./PackageVersion-B9RA2_BM.js")), { vue_ui_dag: i } = rn(), { isThemeValid: l, warnInvalidTheme: a } = dn(), c = e, u = o, d = E(null), g = E(ot()), v = E(null), A = E(null), N = E(null), M = E(0), G = E(0), de = E(!1), ee = E(!1), fe = E({ x: 0, y: 0 }), $ = E(null), p = E(null), z = E({ left: "0px", top: "0px" }), U = E("top"), j = E(!1), Pe = E({ x: 0, y: 0 }), _e = E({ x: 0, y: 0 }), X = E(null), te = E(null), Fe = E({ left: "0px", top: "0px" }), lt = E("top"), Ne = E(!1), he = E(!1), m = E(Be()), { svgRef: q } = hn({ config: m.value.style.chart.title }), { userOptionsVisible: ze, setUserOptionsVisibility: at, keepUserOptionState: ct } = fn({ config: m.value }), Ae = E(m.value.style.chart.layout.rankDirection), { loading: me, FINAL_DATASET: ut, manualLoading: dt } = ln({
+      ...Ho(c),
+      FINAL_CONFIG: m,
+      prepareConfig: Be,
+      skeletonDataset: {
+        nodes: [
+          { id: "A", label: "" },
+          { id: "B", label: "" },
+          { id: "C", label: "" }
+        ],
+        edges: [
+          { from: "A", to: "B" },
+          { from: "A", to: "C" }
+        ]
+      },
+      skeletonConfig: Kt({
+        defaultConfig: m.value,
+        userConfig: {
+          userOptions: { show: !1 },
+          style: {
+            chart: {
+              backgroundColor: "#99999930",
+              nodes: {
+                stroke: "#CCCCCC",
+                backgroundColor: "#DDDDDD50"
+              },
+              edges: {
+                stroke: "#CCCCCC"
+              },
+              midpoints: {
+                stroke: "#CCCCCC",
+                fill: "#CCCCCC"
+              }
+            }
+          }
+        }
+      })
+    });
+    function Be() {
+      const h = Ze({
+        userConfig: c.config,
+        defaultConfig: i
+      }), w = h.theme;
+      if (!w) return h;
+      if (!l.value(h))
+        return a(h), h;
+      const f = Ze({
+        userConfig: ko[w] || c.config,
+        defaultConfig: h
+      });
+      return Ze({
+        userConfig: c.config,
+        defaultConfig: f
+      });
+    }
+    const ft = W(() => !!m.value.debug);
+    Rt(() => {
+      tn(c.dataset) && (Pt({
+        componentName: "VueUiDag",
+        type: "dataset",
+        debug: ft.value
+      }), ee.value = !1, dt.value = !0), c.dataset.nodes || (Pt({
+        componentName: "VueUiDag",
+        type: "datasetAttributeEmpty",
+        property: "nodes",
+        index: 0,
+        debug: ft.value
+      }), ee.value = !1, dt.value = !0), ee.value = !0;
+    }), He(() => c.config, (h) => {
+      me.value || (m.value = Be()), ze.value = !m.value.userOptions.showOnChartHover, M.value += 1, Ae.value = m.value.style.chart.layout.rankDirection, oe.value = m.value.style.chart.zoom.active;
+    }, { deep: !0 });
+    const { isPrinting: ht, isImaging: mt, generatePdf: gt, generateImage: bt } = cn({
+      elementId: `dag_${g.value}`,
+      fileName: m.value.style.chart.title.text || "vue-ui-dag",
+      options: m.value.userOptions.print
+    }), yo = W(() => m.value.style.chart.backgroundColor), Eo = W(() => m.value.style.chart.title), { exportSvg: Co, getSvg: xo } = un({
+      svg: q,
+      title: Eo,
+      legend: void 0,
+      legendItems: void 0,
+      backgroundColor: yo
+    });
+    async function vt({ isCb: h }) {
+      if (h) {
+        const { blob: w, url: f, text: y, dataUrl: T } = await xo();
+        m.value.userOptions.callbacks.svg({ blob: w, url: f, text: y, dataUrl: T });
+      } else
+        Co();
+    }
+    function _o() {
+      de.value = !0, at(!0);
+    }
+    function No() {
+      at(!1), de.value = !1;
+    }
+    function pt({
+      tooltipRef: h,
+      isVisibleRef: w,
+      anchorRef: f,
+      styleRef: y,
+      placementRef: T,
+      offsetRef: ne,
+      margin: x = 24
+    }) {
+      return function() {
+        const Le = h.value;
+        if (!Le || !w.value) return;
+        const O = Le.getBoundingClientRect(), J = window.innerWidth, be = window.innerHeight, ve = f.value.x, Oe = f.value.y, Re = ne?.value?.x ?? 0, Ot = ne?.value?.y ?? 0;
+        let D = Oe - Ot - O.height - x, I = ve - O.width / 2, pe = "top";
+        if (D < x) {
+          const se = Oe + Ot + x;
+          se + O.height <= be - x ? (D = se, pe = "bottom") : (D = Oe - O.height / 2, D < x && (D = x), D + O.height > be - x && (D = be - O.height - x), pe = "center");
+        }
+        I < x && (I = x), I + O.width > J - x && (I = J - O.width - x);
+        const Go = I <= x, Io = I + O.width >= J - x;
+        if ((Go || Io) && pe !== "center") {
+          let se, we;
+          const Wo = ve - Re - x;
+          J - (ve + Re) - x >= Wo ? (se = "right", we = ve + Re + x) : (se = "left", we = ve - Re - x - O.width), we >= x && we + O.width <= J - x && (I = we, D = Oe - O.height / 2, D < x && (D = x), D + O.height > be - x && (D = be - O.height - x), pe = se);
+        }
+        T.value = pe, y.value = {
+          left: `${I}px`,
+          top: `${D}px`
+        };
+      };
+    }
+    const Ao = W(() => ut.value.nodes.map((h) => ({
+      ...h,
+      backgroundColor: h.backgroundColor ? ye(h.backgroundColor) : m.value.style.chart.nodes.backgroundColor,
+      color: h.color ? ye(h.color) : m.value.style.chart.nodes.labels.color
+    }))), So = W(() => ut.value.edges), Lo = W(() => ({
+      ...m.value.style.chart.layout,
+      rankDirection: Ae.value
+    })), { layoutData: C, lastError: wt, arrowMarkerIdentifier: Oo } = ar({
+      nodes: Ao,
+      edges: So,
+      configuration: Lo
+    });
+    function kt(h) {
+      return C.value ? C.value.nodes.find((w) => w.id === h) : null;
+    }
+    const Ro = W(() => {
+      if (!C.value) return [];
+      const h = m.value.style.chart.edges.stroke, w = /* @__PURE__ */ new Set();
+      return C.value.edges.forEach((f) => {
+        w.add(f.original?.color || h);
+      }), Array.from(w);
+    });
+    function yt(h) {
+      return `${Oo}-${String(h).replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+    }
+    const ge = E(null), oe = E(m.value.style.chart.zoom.active), {
+      viewBox: Et,
+      resetZoom: Se,
+      setInitialViewBox: To,
+      scale: Ct,
+      zoomByFactor: xt
+    } = sn(
+      q,
+      { x: 0, y: 0, width: 100, height: 100 },
+      1,
+      oe,
+      () => {
+        j.value = !1;
+      }
+    );
+    function Mo() {
+      oe.value = !oe.value;
+    }
+    He(
+      () => C.value && C.value.viewBox,
+      (h) => {
+        if (!h) return;
+        const [w, f, y, T] = h.split(" ").map(Number);
+        Number.isFinite(w) && Number.isFinite(f) && Number.isFinite(y) && Number.isFinite(T) && To(
+          { x: w, y: f, width: y, height: T },
+          { overwriteCurrentIfNotZoomed: !0 }
+        );
+      },
+      {
+        immediate: !0
+      }
+    ), He(() => he.value, (h) => {
+      oe.value = !h;
+    });
+    const $o = W(() => {
+      const h = Et.value;
+      return h ? `${h.x} ${h.y} ${h.width} ${h.height}` : "0 0 0 0";
+    }), K = E(!1);
+    function _t(h) {
+      K.value = h, G.value += 1;
+    }
+    function Ve() {
+      he.value = !he.value;
+    }
+    function je() {
+      xt(qt, !0);
+    }
+    function Ge() {
+      xt(1 / qt, !0);
+    }
+    const Ie = ["TB", "RL", "BT", "LR"];
+    function We() {
+      Ae.value = Ie[(Ie.indexOf(Ae.value) + 1) % Ie.length], Se();
+    }
+    const Do = pt({
+      tooltipRef: p,
+      isVisibleRef: Ne,
+      anchorRef: fe,
+      styleRef: z,
+      placementRef: U
+    }), Po = pt({
+      tooltipRef: te,
+      isVisibleRef: j,
+      anchorRef: Pe,
+      styleRef: Fe,
+      placementRef: lt,
+      offsetRef: _e
+    });
+    async function Fo(h) {
+      u("onMidpointEnter", h);
+      const w = q.value;
+      if (!w || !h?.midpoint) return;
+      const f = w.createSVGPoint();
+      f.x = h.midpoint.x, f.y = h.midpoint.y;
+      const y = w.getScreenCTM();
+      if (!y) return;
+      const T = f.matrixTransform(y);
+      fe.value = {
+        x: T.x,
+        y: T.y
+      }, $.value = h, Ne.value = !0, await Dt(), Do();
+    }
+    function zo() {
+      Ne.value = !1, $.value = null, u("onMidpointLeave");
+    }
+    async function Bo(h) {
+      if (u("onNodeClick", h), !m.value.style.chart.nodes.tooltip.showOnClick) return;
+      const w = q.value;
+      if (!w) return;
+      const f = w.createSVGPoint();
+      f.x = h.x, f.y = h.y;
+      const y = w.getScreenCTM();
+      if (!y) return;
+      const T = f.matrixTransform(y), ne = m.value.style.chart.layout.nodeWidth, x = m.value.style.chart.layout.nodeHeight, Lt = y.a, Le = y.d, O = ne * Lt, J = x * Le;
+      _e.value = {
+        x: O / 2,
+        y: J / 2
+      }, Pe.value = {
+        x: T.x,
+        y: T.y
+      }, X.value = h, j.value = !0, await Dt(), Po();
+    }
+    function Nt() {
+      j.value = !1, X.value = null;
+    }
+    function At(h) {
+      if (!j.value) return;
+      const w = te.value;
+      if (w && w.contains(h.target))
+        return;
+      const f = q.value;
+      f && f.contains(h.target) && h.target.closest(".vue-ui-dag-node") || Nt();
+    }
+    function St(h) {
+      h.key === "Escape" && j.value && Nt();
+    }
+    Rt(() => {
+      document.addEventListener("mousedown", At), document.addEventListener("keydown", St);
+    }), Zo(() => {
+      document.removeEventListener("mousedown", At), document.removeEventListener("keydown", St);
+    });
+    async function Vo({ scale: h = 2 } = {}) {
+      if (!d.value) return;
+      const { width: w, height: f } = d.value.getBoundingClientRect(), y = w / f, { imageUri: T, base64: ne } = await img({ domElement: d.value, base64: !0, img: !0, scale: h });
+      return {
+        imageUri: T,
+        base64: ne,
+        title: m.value.style.chart.title.text ?? "vue-ui-dag",
+        width: w,
+        height: f,
+        aspectRatio: y
+      };
+    }
+    function jo() {
+      return C.value;
+    }
+    return t({
+      getData: jo,
+      getImage: Vo,
+      generatePdf: gt,
+      generateSvg: vt,
+      generateImage: bt,
+      toggleAnnotator: Ve,
+      toggleFullscreen: _t,
+      zoomIn: je,
+      zoomOut: Ge,
+      resetZoom: Se,
+      switchDirection: We
+    }), (h, w) => (k(), _("div", {
+      class: tt(`vue-data-ui-component vue-ui-dag ${K.value ? "vue-data-ui-wrapper-fullscreen" : ""}`),
+      id: `dag_${g.value}`,
+      ref_key: "dagChart",
+      ref: d,
+      style: H({
+        fontFamily: m.value.style.fontFamily,
+        backgroundColor: m.value.style.chart.backgroundColor,
+        padding: "0.5rem"
+      }),
+      onMouseenter: _o,
+      onMouseleave: No
+    }, [
+      b(wt) ? (k(), _("div", fr, ie(String(b(wt))), 1)) : L("", !0),
+      m.value.userOptions.buttons.annotator ? (k(), Y(b(n), {
+        key: 1,
+        svgRef: b(q),
+        backgroundColor: m.value.style.chart.backgroundColor,
+        color: m.value.style.chart.color,
+        active: he.value,
+        onClose: Ve
+      }, {
+        "annotator-action-close": R(() => [
+          S(h.$slots, "annotator-action-close", {}, void 0, !0)
+        ]),
+        "annotator-action-color": R(({ color: f }) => [
+          S(h.$slots, "annotator-action-color", P(F({ color: f })), void 0, !0)
+        ]),
+        "annotator-action-draw": R(({ mode: f }) => [
+          S(h.$slots, "annotator-action-draw", P(F({ mode: f })), void 0, !0)
+        ]),
+        "annotator-action-undo": R(({ disabled: f }) => [
+          S(h.$slots, "annotator-action-undo", P(F({ disabled: f })), void 0, !0)
+        ]),
+        "annotator-action-redo": R(({ disabled: f }) => [
+          S(h.$slots, "annotator-action-redo", P(F({ disabled: f })), void 0, !0)
+        ]),
+        "annotator-action-delete": R(({ disabled: f }) => [
+          S(h.$slots, "annotator-action-delete", P(F({ disabled: f })), void 0, !0)
+        ]),
+        _: 3
+      }, 8, ["svgRef", "backgroundColor", "color", "active"])) : L("", !0),
+      m.value.userOptions.show && ee.value && (b(ct) || b(ze)) ? (k(), Y(b(s), {
+        ref_key: "userOptionsRef",
+        ref: N,
+        key: `user_option_${G.value}`,
+        backgroundColor: m.value.style.chart.backgroundColor,
+        color: m.value.style.chart.color,
+        isPrinting: b(ht),
+        isImaging: b(mt),
+        uid: g.value,
+        hasTooltip: !1,
+        hasTable: !1,
+        hasXls: !1,
+        hasLabel: !1,
+        hasPdf: m.value.userOptions.buttons.pdf,
+        hasImg: m.value.userOptions.buttons.img,
+        hasSvg: m.value.userOptions.buttons.svg,
+        hasFullscreen: m.value.userOptions.buttons.fullscreen,
+        isFullscreen: K.value,
+        chartElement: d.value,
+        position: m.value.userOptions.position,
+        titles: { ...m.value.userOptions.buttonTitles },
+        hasAnnotator: m.value.userOptions.buttons.annotator,
+        isAnnotation: he.value,
+        callbacks: m.value.userOptions.callbacks,
+        printScale: m.value.userOptions.print.scale,
+        hasZoom: m.value.userOptions.buttons.zoom,
+        isZoom: oe.value,
+        onToggleFullscreen: _t,
+        onGeneratePdf: b(gt),
+        onGenerateImage: b(bt),
+        onGenerateSvg: vt,
+        onToggleAnnotator: Ve,
+        onToggleZoom: Mo,
+        style: H({
+          visibility: b(ct) ? b(ze) ? "visible" : "hidden" : "visible"
+        })
+      }, Uo({ _: 2 }, [
+        h.$slots.menuIcon ? {
+          name: "menuIcon",
+          fn: R(({ isOpen: f, color: y }) => [
+            S(h.$slots, "menuIcon", P(F({ isOpen: f, color: y })), void 0, !0)
+          ]),
+          key: "0"
+        } : void 0,
+        h.$slots.optionPdf ? {
+          name: "optionPdf",
+          fn: R(() => [
+            S(h.$slots, "optionPdf", {}, void 0, !0)
+          ]),
+          key: "1"
+        } : void 0,
+        h.$slots.optionImg ? {
+          name: "optionImg",
+          fn: R(() => [
+            S(h.$slots, "optionImg", {}, void 0, !0)
+          ]),
+          key: "2"
+        } : void 0,
+        h.$slots.optionSvg ? {
+          name: "optionSvg",
+          fn: R(() => [
+            S(h.$slots, "optionSvg", {}, void 0, !0)
+          ]),
+          key: "3"
+        } : void 0,
+        h.$slots.optionFullscreen ? {
+          name: "optionFullscreen",
+          fn: R(({ toggleFullscreen: f, isFullscreen: y }) => [
+            S(h.$slots, "optionFullscreen", P(F({ toggleFullscreen: f, isFullscreen: y })), void 0, !0)
+          ]),
+          key: "4"
+        } : void 0,
+        h.$slots.optionAnnotator ? {
+          name: "optionAnnotator",
+          fn: R(({ toggleAnnotator: f, isAnnotator: y }) => [
+            S(h.$slots, "optionAnnotator", P(F({ toggleAnnotator: f, isAnnotator: y })), void 0, !0)
+          ]),
+          key: "5"
+        } : void 0,
+        h.$slots.optionZoom ? {
+          name: "optionZoom",
+          fn: R(({ toggleZoom: f, isZoomLocked: y }) => [
+            S(h.$slots, "optionZoom", P(F({ toggleZoom: f, isZoomLocked: y })), void 0, !0)
+          ]),
+          key: "6"
+        } : void 0
+      ]), 1032, ["backgroundColor", "color", "isPrinting", "isImaging", "uid", "hasPdf", "hasImg", "hasSvg", "hasFullscreen", "isFullscreen", "chartElement", "position", "titles", "hasAnnotator", "isAnnotation", "callbacks", "printScale", "hasZoom", "isZoom", "onGeneratePdf", "onGenerateImage", "style"])) : L("", !0),
+      m.value.style.chart.title.text ? (k(), _("div", {
+        key: 3,
+        ref_key: "chartTitle",
+        ref: v,
+        style: "width:100%;background:transparent;"
+      }, [
+        (k(), Y(mn, {
+          key: `title_${M.value}`,
+          config: {
+            title: {
+              cy: "dag-title",
+              ...m.value.style.chart.title
+            },
+            subtitle: {
+              cy: "dag-subtitle",
+              ...m.value.style.chart.title.subtitle
+            }
+          }
+        }, null, 8, ["config"]))
+      ], 512)) : L("", !0),
+      m.value.style.chart.controls.position === "top" && !b(me) && m.value.style.chart.controls.show ? (k(), Y(Xt, {
+        key: 4,
+        config: m.value,
+        scale: b(Ct),
+        isFullscreen: K.value,
+        withDirection: "",
+        onZoomIn: je,
+        onZoomOut: Ge,
+        onResetZoom: w[0] || (w[0] = () => b(Se)(!0)),
+        onSwitchDirection: We
+      }, null, 8, ["config", "scale", "isFullscreen"])) : L("", !0),
+      b(C) ? (k(), _("svg", {
+        key: 5,
+        ref_key: "svgRef",
+        ref: q,
+        class: tt({ "vue-ui-dag-svg": !0, "vue-data-ui-loading": b(me) }),
+        viewBox: $o.value,
+        xmlns: b(on),
+        style: H({
+          backgroundColor: m.value.style.chart.backgroundColor,
+          height: "100%",
+          width: "100%"
+        })
+      }, [
+        le(b(r)),
+        b(C).arrowShape !== "undirected" ? (k(), _("defs", mr, [
+          (k(!0), _(re, null, Te(Ro.value, (f) => (k(), _("marker", {
+            key: f,
+            id: yt(f),
+            markerWidth: b(C).arrowSize,
+            markerHeight: b(C).arrowSize,
+            refX: b(C).arrowSize - 1,
+            refY: b(C).arrowSize / 2,
+            orient: "auto",
+            markerUnits: "strokeWidth"
+          }, [
+            b(C).arrowShape === "normal" ? (k(), _("path", {
+              key: 0,
+              d: `M 0 0 L ${b(C).arrowSize} ${b(C).arrowSize / 2} L 0 ${b(C).arrowSize} Z`,
+              fill: f,
+              stroke: f,
+              "stroke-width": "0"
+            }, null, 8, br)) : (k(), _("path", {
+              key: 1,
+              d: `M 0 0 L ${b(C).arrowSize} ${b(C).arrowSize / 2} L 0 ${b(C).arrowSize} L ${b(C).arrowSize / 3} ${b(C).arrowSize / 2} Z`,
+              fill: f,
+              stroke: f,
+              "stroke-width": "0"
+            }, null, 8, vr))
+          ], 8, gr))), 128))
+        ])) : L("", !0),
+        B("g", pr, [
+          (k(!0), _(re, null, Te(b(C).edges, (f) => (k(), _(re, {
+            key: f.id
+          }, [
+            B("path", {
+              "data-cy-edge": "",
+              d: f.pathData,
+              fill: "none",
+              stroke: f.original.color ?? m.value.style.chart.edges.stroke,
+              "stroke-width": m.value.style.chart.edges.strokeWidth * (f.from === ge.value || f.id === $.value?.id ? 2 : 1),
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              style: { "pointer-events": "none", transition: "stroke-width 0.2s ease-in-out" }
+            }, null, 8, wr),
+            m.value.style.chart.midpoints.show ? (k(), _("circle", {
+              key: 0,
+              "data-cy-midpoint": "",
+              class: "vue-ui-dag-edge-midpoint",
+              cx: f.midpoint.x,
+              cy: f.midpoint.y,
+              r: m.value.style.chart.midpoints.radius,
+              fill: m.value.style.chart.midpoints.fill,
+              stroke: f.original.color ?? m.value.style.chart.midpoints.stroke,
+              "stroke-width": m.value.style.chart.midpoints.strokeWidth * (f.from === ge.value || f.id === $.value?.id ? 2 : 1),
+              style: { transition: "stroke-width 0.2s ease-in-out" },
+              onMouseenter: (y) => Fo(f),
+              onMouseleave: zo
+            }, null, 40, kr)) : L("", !0)
+          ], 64))), 128))
+        ]),
+        B("g", yr, [
+          (k(!0), _(re, null, Te(b(C).nodes, (f) => (k(), _("g", {
+            key: f.id,
+            class: "vue-ui-dag-node",
+            onClick: Xo((y) => m.value.style.chart.nodes.tooltip.showOnClick && Bo(f), ["stop"]),
+            onMouseenter: (y) => ge.value = f.id,
+            onMouseleave: w[1] || (w[1] = (y) => ge.value = null)
+          }, [
+            h.$slots.node ? L("", !0) : (k(), _(re, { key: 0 }, [
+              B("rect", {
+                "data-cy-node": "",
+                x: f.x - f.width / 2,
+                y: f.y - f.height / 2,
+                width: f.width,
+                height: f.height,
+                rx: m.value.style.chart.nodes.borderRadius,
+                fill: f.original.backgroundColor,
+                stroke: m.value.style.chart.nodes.stroke,
+                "stroke-width": m.value.style.chart.nodes.strokeWidth,
+                style: H({
+                  cursor: m.value.style.chart.nodes.tooltip.showOnClick ? "pointer" : "default"
+                })
+              }, null, 12, Cr),
+              h.$slots["node-label"] ? (k(), _("text", {
+                key: 0,
+                x: f.x,
+                y: f.y + m.value.style.chart.nodes.labels.fontSize / 3,
+                "text-anchor": "middle",
+                "font-size": m.value.style.chart.nodes.labels.fontSize,
+                fill: f.original.color,
+                "font-weight": m.value.style.chart.nodes.labels.bold ? "bold" : "normal"
+              }, [
+                S(h.$slots, "node-label", Tt({ ref_for: !0 }, { node: f }), () => [
+                  qo(ie(f.label), 1)
+                ], !0)
+              ], 8, xr)) : (k(), _("text", {
+                key: 1,
+                "data-cy-node-label": "",
+                x: f.x,
+                y: f.y + m.value.style.chart.nodes.labels.fontSize / 3,
+                "text-anchor": "middle",
+                "font-size": m.value.style.chart.nodes.labels.fontSize,
+                fill: f.original.color,
+                "font-weight": m.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                innerHTML: b(nn)({
+                  content: f.label,
+                  fontSize: m.value.style.chart.nodes.labels.fontSize,
+                  fontWeight: m.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                  fill: f.original.color,
+                  x: f.x,
+                  y: f.y,
+                  autoOffset: !0
+                })
+              }, null, 8, _r))
+            ], 64)),
+            h.$slots.node ? (k(), _("foreignObject", {
+              key: 1,
+              x: f.x - f.width / 2,
+              y: f.y - f.height / 2,
+              width: f.width,
+              height: f.height
+            }, [
+              S(h.$slots, "node", Tt({ ref_for: !0 }, { node: f }), void 0, !0)
+            ], 8, Nr)) : L("", !0)
+          ], 40, Er))), 128))
+        ]),
+        B("g", Ar, [
+          (k(!0), _(re, null, Te(b(C).edges, (f) => (k(), _("path", {
+            key: f.id,
+            d: f.pathData,
+            fill: "none",
+            stroke: "transparent",
+            "stroke-width": m.value.style.chart.edges.strokeWidth * (f.from === ge.value || f.id === $.value?.id ? 1.3 : 1),
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "marker-end": b(C).arrowShape === "undirected" ? null : `url(#${yt(f.original?.color || m.value.style.chart.edges.stroke)})`,
+            style: { "pointer-events": "none", transition: "stroke-width 0.2s ease-in-out" }
+          }, null, 8, Sr))), 128))
+        ]),
+        S(h.$slots, "svg", {
+          svg: {
+            drawingArea: b(Et),
+            data: b(C)
+          }
+        }, void 0, !0)
+      ], 14, hr)) : L("", !0),
+      h.$slots.watermark ? (k(), _("div", Lr, [
+        S(h.$slots, "watermark", P(F({ isPrinting: b(ht) || b(mt) })), void 0, !0)
+      ])) : L("", !0),
+      le(Mt, { name: "fade" }, {
+        default: R(() => [
+          Ne.value ? (k(), Y($t, {
+            key: 0,
+            to: K.value ? d.value : "body"
+          }, [
+            B("div", {
+              "data-cy-tooltip-midpoint": "",
+              ref_key: "tooltipRef",
+              ref: p,
+              class: "vue-ui-dag-tooltip",
+              style: H({
+                ...z.value,
+                maxWidth: m.value.style.chart.midpoints.tooltip.maxWidth,
+                "--vue-data-ui-dag-tooltip-background": m.value.style.chart.midpoints.tooltip.backgroundColor,
+                "--vue-data-ui-dag-tooltip-color": m.value.style.chart.midpoints.tooltip.color
+              }),
+              "data-position": U.value
+            }, [
+              S(h.$slots, "tooltip-midpoint", P(F({ edge: $.value, layoutData: b(C) })), () => [
+                $.value ? (k(), _("div", Rr, ie(kt($.value.from)?.label ?? $.value.from) + " → " + ie(kt($.value.to)?.label ?? $.value.to), 1)) : L("", !0)
+              ], !0)
+            ], 12, Or)
+          ], 8, ["to"])) : L("", !0)
+        ]),
+        _: 3
+      }),
+      le(Mt, { name: "fade" }, {
+        default: R(() => [
+          j.value ? (k(), Y($t, {
+            key: 0,
+            to: K.value ? d.value : "body"
+          }, [
+            B("div", {
+              "data-cy-tooltip-node": "",
+              ref_key: "nodeTooltipRef",
+              ref: te,
+              class: "vue-ui-dag-node-tooltip",
+              style: H({
+                maxWidth: m.value.style.chart.nodes.tooltip.maxWidth,
+                left: Fe.value.left,
+                top: Fe.value.top,
+                "--vue-data-ui-dag-node-tooltip-background": m.value.style.chart.nodes.tooltip.backgroundColor,
+                "--vue-data-ui-dag-node-tooltip-color": m.value.style.chart.nodes.tooltip.color
+              }),
+              "data-position": lt.value
+            }, [
+              S(h.$slots, "tooltip-node", P(F({ node: X.value, layoutData: b(C) })), () => [
+                X.value ? (k(), _("div", Mr, ie(X.value.label), 1)) : L("", !0)
+              ], !0)
+            ], 12, Tr)
+          ], 8, ["to"])) : L("", !0)
+        ]),
+        _: 3
+      }),
+      m.value.style.chart.controls.position === "bottom" && !b(me) && m.value.style.chart.controls.show ? (k(), Y(Xt, {
+        key: 7,
+        config: m.value,
+        scale: b(Ct),
+        isFullscreen: K.value,
+        withDirection: "",
+        onZoomIn: je,
+        onZoomOut: Ge,
+        onResetZoom: w[2] || (w[2] = () => b(Se)(!0)),
+        onSwitchDirection: We
+      }, null, 8, ["config", "scale", "isFullscreen"])) : L("", !0),
+      h.$slots.source ? (k(), _("div", {
+        key: 8,
+        ref_key: "source",
+        ref: A,
+        dir: "auto"
+      }, [
+        S(h.$slots, "source", {}, void 0, !0)
+      ], 512)) : L("", !0),
+      b(me) ? (k(), Y(an, { key: 9 })) : L("", !0)
+    ], 46, dr));
+  }
+}, Dr = /* @__PURE__ */ Jt($r, [["__scopeId", "data-v-1dd15065"]]), ei = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Dr
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  qr as a,
+  ei as b,
+  Kr as d,
+  cr as l,
+  Qr as m,
+  Jr as s,
+  Dr as v
+};