vue-data-ui 3.7.16 → 3.8.1

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

@@ -0,0 +1,2770 @@
+import { ref as y, watchEffect as Jo, unref as v, createElementBlock as x, openBlock as k, normalizeStyle as X, normalizeClass as st, createElementVNode as G, createCommentVNode as L, createVNode as ae, toDisplayString as le, defineAsyncComponent as Xe, toRefs as Qo, computed as W, onMounted as zt, watch as De, onBeforeUnmount as en, createBlock as U, withCtx as T, renderSlot as A, normalizeProps as B, guardReactiveProps as V, createSlots as tn, Fragment as ie, renderList as Fe, withModifiers as on, mergeProps as Bt, createTextVNode as nn, Transition as Vt, Teleport as It, nextTick as Gt } from "vue";
+import { c as rt, ay as sn, l as Ce, n as rn, r as ln, h as an, t as so, o as cn, g as jt, X as un, a8 as dn } from "./lib-qMPkcvmh.js";
+import { t as fn, u as hn } from "./useResponsive-DfdjqQps.js";
+import { u as mn } from "./usePanZoom-DMfuOfaC.js";
+import { u as gn, a as qe } from "./useNestedProp-DH2Pjkde.js";
+import { u as vn, B as bn } from "./BaseScanner-BgWxam9d.js";
+import { u as pn } from "./usePrinter-CjGh4mFJ.js";
+import { u as wn } from "./useSvgExport-DrjCWun4.js";
+import { u as yn } from "./useThemeCheck-DGJ31Vi5.js";
+import { u as kn } from "./useUserOptionState-BIvW1Kz7.js";
+import { u as En } from "./useChartAccessibility-9icAAmYg.js";
+import Cn from "./Title-CWX8otQg.js";
+import Ke from "./BaseIcon-CALhpING.js";
+import { _ as ro } from "./_plugin-vue_export-helper-CHgC5LLL.js";
+import xn from "./img-CwrkWkkl.js";
+const _n = "\0", te = "\0", Wt = "
";
+class q {
+  _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[te] = {});
+  }
+  /* === 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] = te, this._children[t] = {}, this._children[te][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 = te;
+    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 !== te)
+        return o;
+    }
+  }
+  /**
+   * Gets list of direct children of node nodeId.
+   * Complexity: O(1).
+   */
+  children(t = te) {
+    if (this._isCompound) {
+      const o = this._children[t];
+      if (o)
+        return Object.keys(o);
+    } else {
+      if (t === te)
+        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 = Ee(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 = Nn(this._isDirected, t, o, n);
+    return t = a.v, o = a.w, Object.freeze(a), this._edgeObjs[l] = a, Yt(this._preds[o], t), Yt(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 ? Je(this._isDirected, arguments[0]) : Ee(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 ? Je(this._isDirected, arguments[0]) : Ee(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 ? Je(this._isDirected, arguments[0]) : Ee(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], Ht(this._preds[o], t), Ht(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 Yt(e, t) {
+  e[t] ? e[t]++ : e[t] = 1;
+}
+function Ht(e, t) {
+  --e[t] || delete e[t];
+}
+function Ee(e, t, o, n) {
+  let s = "" + t, r = "" + o;
+  if (!e && s > r) {
+    const i = s;
+    s = r, r = i;
+  }
+  return s + Wt + r + Wt + (n === void 0 ? _n : n);
+}
+function Nn(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 Je(e, t) {
+  return Ee(e, t.v, t.w, t.name);
+}
+class An {
+  constructor() {
+    const t = {};
+    t._next = t._prev = t, this._sentinel = t;
+  }
+  dequeue() {
+    const t = this._sentinel, o = t._prev;
+    if (o !== t)
+      return Zt(o), o;
+  }
+  enqueue(t) {
+    const o = this._sentinel;
+    t._prev && t._next && Zt(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, Sn)), n = n._prev;
+    return "[" + t.join(", ") + "]";
+  }
+}
+function Zt(e) {
+  e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
+}
+function Sn(e, t) {
+  if (e !== "_next" && e !== "_prev")
+    return t;
+}
+const Ln = () => 1;
+function On(e, t) {
+  if (e.nodeCount() <= 1)
+    return [];
+  const o = Tn(e, t || Ln);
+  return Rn(o.graph, o.buckets, o.zeroIndex).flatMap((s) => e.outEdges(s.v, s.w));
+}
+function Rn(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, it(t, o, a);
+  }), e.outEdges(n.v).forEach((i) => {
+    const l = e.edge(i), a = e.node(i.w);
+    a.in -= l, it(t, o, a);
+  }), e.removeNode(n.v), r;
+}
+function Tn(e, t) {
+  const o = new q();
+  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), d = a + c;
+    o.setEdge(l.v, l.w, d), s = Math.max(s, o.node(l.v).out += c), n = Math.max(n, o.node(l.w).in += c);
+  });
+  const r = Mn(s + n + 3).map(() => new An()), i = n + 1;
+  return o.nodes().forEach((l) => {
+    it(r, i, o.node(l));
+  }), {
+    graph: o,
+    buckets: r,
+    zeroIndex: i
+  };
+}
+function it(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 Mn(e) {
+  const t = [];
+  for (let o = 0; o < e; o++)
+    t.push(o);
+  return t;
+}
+function ue(e, t, o, n) {
+  let s = n;
+  for (; e.hasNode(s); )
+    s = ze(n);
+  return o.dummy = t, e.setNode(s, o), s;
+}
+function io(e) {
+  const t = new q().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 at(e) {
+  const t = new q({ 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 $n(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 Be(e.nodes(), t);
+}
+function Dn(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 Be(e.nodes(), t);
+}
+function lt(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 _e(e) {
+  const t = ce(ct(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 lo(e) {
+  const t = e.nodes().map((n) => {
+    const s = e.node(n).rank;
+    return s === void 0 ? Number.MAX_VALUE : s;
+  }), o = j(Math.min, t);
+  e.nodes().forEach((n) => {
+    const s = e.node(n);
+    Object.hasOwn(s, "rank") && (s.rank -= o);
+  });
+}
+function ao(e) {
+  const t = e.nodes().map((i) => e.node(i).rank).filter((i) => i !== void 0), o = j(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 Fn(e, t, o, n) {
+  const s = {
+    width: 0,
+    height: 0
+  };
+  return arguments.length >= 4 && (s.rank = o, s.order = n), ue(e, "border", s, t);
+}
+const co = 65535;
+function Pn(e, t = co) {
+  const o = [];
+  for (let n = 0; n < e.length; n += t) {
+    const s = e.slice(n, n + t);
+    o.push(s);
+  }
+  return o;
+}
+function j(e, t) {
+  if (t.length > co) {
+    const o = Pn(t);
+    return e.apply(
+      null,
+      o.map((n) => e.apply(null, n))
+    );
+  } else
+    return e.apply(null, t);
+}
+function ct(e) {
+  const o = e.nodes().map((n) => {
+    const s = e.node(n).rank;
+    return s === void 0 ? Number.MIN_VALUE : s;
+  });
+  return j(Math.max, o);
+}
+function uo(e, t) {
+  const o = { lhs: [], rhs: [] };
+  return e.forEach((n) => {
+    t(n) ? o.lhs.push(n) : o.rhs.push(n);
+  }), o;
+}
+function fo(e, t) {
+  const o = Date.now();
+  try {
+    return t();
+  } finally {
+    console.log(e + " time: " + (Date.now() - o) + "ms");
+  }
+}
+function ho(e, t) {
+  return t();
+}
+let zn = 0;
+function ze(e) {
+  const t = ++zn;
+  return e + String(t);
+}
+function ce(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 xe(e, t) {
+  const o = {};
+  for (const n of t)
+    e[n] !== void 0 && (o[n] = e[n]);
+  return o;
+}
+function Ne(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 Be(e, t) {
+  return e.reduce((o, n, s) => (o[n] = t[s], o), {});
+}
+const Pe = {
+  addBorderNode: Fn,
+  addDummyNode: ue,
+  applyWithChunking: j,
+  asNonCompoundGraph: at,
+  buildLayerMatrix: _e,
+  intersectRect: lt,
+  mapValues: Ne,
+  maxRank: ct,
+  normalizeRanks: lo,
+  notime: ho,
+  partition: uo,
+  pick: xe,
+  predecessorWeights: Dn,
+  range: ce,
+  removeEmptyRanks: ao,
+  simplify: io,
+  successorWeights: $n,
+  time: fo,
+  uniqueId: ze,
+  zipObject: Be
+};
+function Bn(e) {
+  (e.graph().acyclicer === "greedy" ? On(e, o(e)) : In(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, ze("rev"));
+  });
+  function o(n) {
+    return (s) => n.edge(s).weight;
+  }
+}
+function Vn(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 In(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 Gn(e) {
+  e.graph().dummyChains = [], e.edges().forEach((t) => jn(e, t));
+}
+function jn(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, d, f;
+  for (f = 0, ++n; n < r; ++f, ++n)
+    l.points = [], d = {
+      width: 0,
+      height: 0,
+      edgeLabel: l,
+      edgeObj: t,
+      rank: n
+    }, c = ue(e, "edge", d, "_d"), n === a && (d.width = l.width, d.height = l.height, d.dummy = "edge-label", d.labelpos = l.labelpos), e.setEdge(o, c, { weight: l.weight }, i), f === 0 && e.graph().dummyChains.push(c), o = c;
+  e.setEdge(o, s, { weight: l.weight }, i);
+}
+function Wn(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 mo(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), d = e.edge(l).minlen;
+      return c - d;
+    });
+    let i = j(Math.min, r);
+    return i === Number.POSITIVE_INFINITY && (i = 0), n && (n.rank = i), i;
+  }
+  (e.sources() || []).forEach(t);
+}
+function Yn(e, t) {
+  return e.node(t.w).rank - e.node(t.v).rank - e.edge(t).minlen;
+}
+function Hn(e) {
+  Zn(e);
+  const t = new q();
+  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 = Un(e, s);
+    if (!r) {
+      const d = o.find((f) => !s.has(f));
+      s.add(d), t.setNode(d, {});
+      continue;
+    }
+    const { edgeObject: i, delta: l, attachFrom: a, attachTo: c } = r;
+    Xn(e, s, a, l), t.setEdge(i.v, i.w, {}), s.add(c);
+  }
+  return t;
+}
+function Zn(e) {
+  e.nodes().forEach((t) => {
+    const o = e.node(t) || {};
+    Object.prototype.hasOwnProperty.call(o, "rank") || (o.rank = 0, e.setNode(t, o));
+  });
+}
+function Un(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 = Yn(e, n), l = Math.abs(i);
+    if (!o || l < o.absoluteSlack) {
+      const a = s ? n.v : n.w, c = s ? n.w : n.v, d = s ? i : -i;
+      o = {
+        edgeObject: n,
+        delta: d,
+        attachFrom: a,
+        attachTo: c,
+        absoluteSlack: l
+      };
+    }
+  }), o;
+}
+function Xn(e, t, o, n) {
+  n && e.nodes().forEach((s) => {
+    if (!t.has(s)) {
+      const r = e.node(s);
+      r.rank += n;
+    }
+  });
+}
+function de(e) {
+  const t = io(e);
+  return mo(t), t.nodes().forEach((o) => {
+    const n = t.node(o), s = e.node(o) || {};
+    s.rank = n.rank, e.setNode(o, s);
+  }), e;
+}
+function qn(e, t) {
+}
+function Kn(e, t) {
+}
+function Jn(e, t, o) {
+  return 0;
+}
+function Qn(e) {
+  return null;
+}
+function es(e, t) {
+  return null;
+}
+de.initLowLimValues = qn;
+de.initCutValues = Kn;
+de.calcCutValue = Jn;
+de.leaveEdge = Qn;
+de.enterEdge = es;
+const go = mo;
+function ts(e) {
+  const t = e.graph().ranker;
+  if (t instanceof Function)
+    return t(e);
+  switch (e.graph().ranker) {
+    case "network-simplex":
+      Ut(e);
+      break;
+    case "tight-tree":
+      ns(e);
+      break;
+    case "longest-path":
+      os(e);
+      break;
+    case "none":
+      break;
+    default:
+      Ut(e);
+  }
+}
+const os = go;
+function ns(e) {
+  go(e), Hn(e);
+}
+function Ut(e) {
+  de(e);
+}
+function ss(e) {
+  const t = is(e);
+  e.graph().dummyChains.forEach((o) => {
+    let n = e.node(o);
+    const s = n.edgeObj, r = rs(e, t, s.v, s.w), i = r.path, l = r.lca;
+    let a = 0, c = i[a], d = !0, f = o;
+    for (; f !== s.w; ) {
+      if (n = e.node(f), d) {
+        for (; (c = i[a]) !== l && e.node(c).maxRank < n.rank; )
+          a++;
+        c === l && (d = !1);
+      }
+      if (!d) {
+        for (; a < i.length - 1 && e.node(c = i[a + 1]).minRank <= n.rank; )
+          a++;
+        c = i[a];
+      }
+      e.setParent(f, c), f = e.successors(f)[0];
+    }
+  });
+}
+function rs(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 is(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 ls(e) {
+  const t = Pe.addDummyNode(e, "root", {}, "_root"), o = as(e), n = Object.values(o), s = Pe.applyWithChunking(Math.max, n) - 1, r = 2 * s + 1;
+  e.graph().nestingRoot = t, e.edges().forEach((l) => {
+    e.edge(l).minlen *= r;
+  });
+  const i = cs(e) + 1;
+  e.children().forEach((l) => {
+    vo(e, t, r, i, s, o, l);
+  }), e.graph().nodeRankFactor = r;
+}
+function vo(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 = Pe.addBorderNode(e, "_bt"), c = Pe.addBorderNode(e, "_bb"), d = e.node(i);
+  e.setParent(a, i), d.borderTop = a, e.setParent(c, i), d.borderBottom = c, l.forEach((f) => {
+    vo(e, t, o, n, s, r, f);
+    const g = e.node(f), b = g.borderTop ? g.borderTop : f, N = g.borderBottom ? g.borderBottom : f, _ = g.borderTop ? n : 2 * n, M = b !== N ? 1 : s - r[i] + 1;
+    e.setEdge(a, b, {
+      weight: _,
+      minlen: M,
+      nestingEdge: !0
+    }), e.setEdge(N, c, {
+      weight: _,
+      minlen: M,
+      nestingEdge: !0
+    });
+  }), e.parent(i) || e.setEdge(t, a, {
+    weight: 0,
+    minlen: s + r[i]
+  });
+}
+function as(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 cs(e) {
+  return e.edges().reduce((t, o) => t + e.edge(o).weight, 0);
+}
+function us(e) {
+  const t = e.graph();
+  e.removeNode(t.nestingRoot), delete t.nestingRoot, e.edges().forEach((o) => {
+    e.edge(o).nestingEdge && e.removeEdge(o);
+  });
+}
+function ds(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)
+        Xt(e, "borderLeft", "_bl", o, s, r), Xt(e, "borderRight", "_br", o, s, r);
+    }
+  }
+  e.children().forEach(t);
+}
+function Xt(e, t, o, n, s, r) {
+  const i = {
+    width: 0,
+    height: 0,
+    rank: r,
+    borderType: t
+  }, l = s[t][r - 1], a = ue(e, "border", i, o);
+  s[t][r] = a, e.setParent(a, n), l && e.setEdge(l, a, { weight: 1 });
+}
+function fs(e) {
+  const t = e.graph().rankdir.toLowerCase();
+  (t === "lr" || t === "rl") && bo(e);
+}
+function hs(e) {
+  const t = e.graph().rankdir.toLowerCase();
+  (t === "bt" || t === "rl") && ms(e), (t === "lr" || t === "rl") && (gs(e), bo(e));
+}
+function bo(e) {
+  e.nodes().forEach((t) => {
+    qt(e.node(t));
+  }), e.edges().forEach((t) => {
+    qt(e.edge(t));
+  });
+}
+function qt(e) {
+  const t = e.width;
+  e.width = e.height, e.height = t;
+}
+function ms(e) {
+  e.nodes().forEach((t) => {
+    et(e.node(t));
+  }), e.edges().forEach((t) => {
+    const o = e.edge(t);
+    o.points.forEach(et), Object.hasOwn(o, "y") && et(o);
+  });
+}
+function et(e) {
+  e.y = -e.y;
+}
+function gs(e) {
+  e.nodes().forEach((t) => {
+    tt(e.node(t));
+  }), e.edges().forEach((t) => {
+    const o = e.edge(t);
+    o.points.forEach(tt), Object.hasOwn(o, "x") && tt(o);
+  });
+}
+function tt(e) {
+  const t = e.x;
+  e.x = e.y, e.y = t;
+}
+const Kt = {
+  adjust: fs,
+  undo: hs
+};
+function vs(e) {
+  const t = {}, o = e.nodes().filter((a) => e.children(a).length === 0), n = o.map((a) => e.node(a).rank), s = j(Math.max, n), r = ce(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 bs(e, t) {
+  let o = 0;
+  for (let n = 1; n < t.length; ++n)
+    o += ps(e, t[n - 1], t[n]);
+  return o;
+}
+function ps(e, t, o) {
+  const n = Be(
+    o,
+    o.map((c, d) => d)
+  ), s = t.flatMap((c) => e.outEdges(c).map((d) => ({
+    pos: n[d.w],
+    weight: e.edge(d).weight
+  })).sort((d, f) => d.pos - f.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 d = c.pos + r;
+    l[d] += c.weight;
+    let f = 0;
+    for (; d > 0; )
+      d % 2 && (f += l[d + 1]), d = d - 1 >> 1, l[d] += c.weight;
+    a += c.weight * f;
+  }), a;
+}
+function ws(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 ys(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 ks(n);
+}
+function ks(e) {
+  const t = [];
+  function o(s) {
+    return (r) => {
+      r.merged || (r.barycenter === void 0 || s.barycenter === void 0 || r.barycenter >= s.barycenter) && Es(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) => xe(s, ["vs", "i", "barycenter", "weight"]));
+}
+function Es(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 Cs(e, t) {
+  const o = uo(e, (d) => Object.hasOwn(d, "barycenter")), n = o.lhs, s = o.rhs.sort((d, f) => f.i - d.i), r = [];
+  let i = 0, l = 0, a = 0;
+  n.sort(xs(!!t)), a = Jt(r, s, a), n.forEach((d) => {
+    a += d.vs.length, r.push(d.vs), i += d.barycenter * d.weight, l += d.weight, a = Jt(r, s, a);
+  });
+  const c = { vs: r.flat(!0) };
+  return l && (c.barycenter = i / l, c.weight = l), c;
+}
+function Jt(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 xs(e) {
+  return (t, o) => t.barycenter < o.barycenter ? -1 : t.barycenter > o.barycenter ? 1 : e ? o.i - t.i : t.i - o.i;
+}
+function po(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 = ws(e, s);
+  c.forEach((g) => {
+    if (e.children(g.v).length) {
+      const b = po(e, g.v, o, n);
+      a[g.v] = b, Object.hasOwn(b, "barycenter") && Ns(g, b);
+    }
+  });
+  let d = ys(c, o);
+  _s(d, a);
+  const f = Cs(d, n);
+  if (i && (f.vs = [i, f.vs, l].flat(!0), e.predecessors(i).length)) {
+    const g = e.node(e.predecessors(i)[0]), b = e.node(e.predecessors(l)[0]);
+    Object.hasOwn(f, "barycenter") || (f.barycenter = 0, f.weight = 0), f.barycenter = (f.barycenter * f.weight + g.order + b.order) / (f.weight + 2), f.weight += 2;
+  }
+  return f;
+}
+function _s(e, t) {
+  e.forEach((o) => {
+    o.vs = o.vs.flatMap((n) => t[n] ? t[n].vs : n);
+  });
+}
+function Ns(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 As(e, t, o, n) {
+  n || (n = e.nodes());
+  const s = Ss(e), r = new q({ 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((d) => {
+      const f = d.v === i ? d.w : d.v, g = r.edge(f, i), b = g ? g.weight : 0;
+      r.setEdge(f, i, {
+        weight: e.edge(d).weight + b
+      });
+    }), Object.hasOwn(l, "minRank") && r.setNode(i, {
+      borderLeft: l.borderLeft[t],
+      borderRight: l.borderRight[t]
+    }));
+  }), r;
+}
+function Ss(e) {
+  let t;
+  for (; e.hasNode(t = ze("_root")); ) ;
+  return t;
+}
+function Ls(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 wo(e, t = {}) {
+  if (typeof t.customOrder == "function") {
+    t.customOrder(e, wo);
+    return;
+  }
+  const o = ct(e), n = Qt(
+    e,
+    ce(1, o + 1),
+    "inEdges"
+  ), s = Qt(
+    e,
+    ce(o - 1, -1, -1),
+    "outEdges"
+  );
+  let r = vs(e);
+  if (eo(e, r), t.disableOptimalOrderHeuristic)
+    return;
+  let i = Number.POSITIVE_INFINITY, l;
+  const a = t.constraints || [];
+  for (let c = 0, d = 0; d < 4; ++c, ++d) {
+    const f = c % 2 === 0 ? n : s, g = c % 4 >= 2;
+    Os(f, g, a), r = _e(e);
+    const b = bs(e, r);
+    b < i ? (i = b, d = 0, l = structuredClone(r)) : b === i && (l = structuredClone(r));
+  }
+  eo(e, l);
+}
+function Qt(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) => As(
+      e,
+      r,
+      o,
+      n.get(r) || []
+    )
+  );
+}
+function Os(e, t, o) {
+  const n = new q();
+  e.forEach((s) => {
+    o.forEach((l) => n.setEdge(l.left, l.right));
+    const r = s.graph().root, i = po(s, r, n, t);
+    i.vs.forEach((l, a) => {
+      s.node(l).order = a;
+    }), Ls(s, n, i.vs);
+  });
+}
+function eo(e, t) {
+  Object.values(t).forEach((o) => {
+    o.forEach((n, s) => {
+      e.node(n).order = s;
+    });
+  });
+}
+function Rs(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((d, f) => {
+      const g = Ms(e, d), b = g ? e.node(g).order : a;
+      (g || d === c) && (r.slice(l, f + 1).forEach((N) => {
+        e.predecessors(N).forEach((_) => {
+          const M = e.node(_), Y = M.order;
+          (Y < i || b < Y) && !(M.dummy && e.node(N).dummy) && yo(o, _, N);
+        });
+      }), l = f + 1, i = b);
+    }), r;
+  }
+  return t.length && t.reduce(n), o;
+}
+function Ts(e, t) {
+  const o = {};
+  function n(r, i, l, a, c) {
+    let d;
+    ce(i, l).forEach((f) => {
+      d = r[f], e.node(d).dummy && e.predecessors(d).forEach((g) => {
+        const b = e.node(g);
+        b.dummy && (b.order < a || b.order > c) && yo(o, g, d);
+      });
+    });
+  }
+  function s(r, i) {
+    let l = -1, a, c = 0;
+    return i.forEach((d, f) => {
+      if (e.node(d).dummy === "border") {
+        const g = e.predecessors(d);
+        g.length && (a = e.node(g[0]).order, n(i, c, f, l, a), c = f, l = a);
+      }
+      n(i, c, i.length, a, r.length);
+    }), i;
+  }
+  return t.length && t.reduce(s), o;
+}
+function Ms(e, t) {
+  if (e.node(t).dummy)
+    return e.predecessors(t).find((o) => e.node(o).dummy);
+}
+function yo(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 $s(e, t, o) {
+  if (t > o) {
+    const n = t;
+    t = o, o = n;
+  }
+  return !!e[t] && Object.hasOwn(e[t], o);
+}
+function Ds(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 d = n(c);
+      if (d.length) {
+        d = d.sort((g, b) => i[g] - i[b]);
+        const f = (d.length - 1) / 2;
+        for (let g = Math.floor(f), b = Math.ceil(f); g <= b; ++g) {
+          const N = d[g];
+          r[c] === c && a < i[N] && !$s(o, c, N) && (r[N] = c, r[c] = s[c] = s[N], a = i[N]);
+        }
+      }
+    });
+  }), { root: s, align: r };
+}
+function Fs(e, t, o, n, s) {
+  const r = {}, i = Ps(e, t, o, s), l = s ? "borderLeft" : "borderRight";
+  function a(f, g) {
+    const b = i.nodes().slice(), N = {};
+    let _ = b.pop();
+    for (; _; ) {
+      if (N[_])
+        f(_);
+      else {
+        N[_] = !0, b.push(_);
+        for (const M of g(_))
+          b.push(M);
+      }
+      _ = b.pop();
+    }
+  }
+  function c(f) {
+    r[f] = i.inEdges(f).reduce((g, b) => Math.max(g, r[b.v] + i.edge(b)), 0);
+  }
+  function d(f) {
+    const g = i.outEdges(f).reduce((N, _) => Math.min(N, r[_.w] - i.edge(_)), Number.POSITIVE_INFINITY), b = e.node(f);
+    g !== Number.POSITIVE_INFINITY && b.borderType !== l && (r[f] = Math.max(r[f], g));
+  }
+  return a(c, i.predecessors.bind(i)), a(d, i.successors.bind(i)), Object.keys(n).forEach((f) => {
+    r[f] = r[o[f]];
+  }), r;
+}
+function Ps(e, t, o, n) {
+  const s = new e.constructor(), r = e.graph(), i = Gs(r.nodesep, r.edgesep, n);
+  return t.forEach((l) => {
+    let a;
+    l.forEach((c) => {
+      const d = o[c];
+      if (s.setNode(d), a) {
+        const f = o[a], g = s.edge(f, d);
+        s.setEdge(
+          f,
+          d,
+          Math.max(i(e, c, a), g || 0)
+        );
+      }
+      a = c;
+    });
+  }), s;
+}
+function zs(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 = js(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 Bs(e, t) {
+  const o = Object.values(t), n = j(Math.min, o), s = j(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 d = n - j(Math.min, c);
+      i !== "l" && (d = s - j(Math.max, c)), d && (a = Ne(a, (f) => f + d), e[l] = a);
+    });
+  });
+}
+function Vs(e, t) {
+  return Ne(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 Is(e) {
+  const t = _e(e), o = Object.assign(
+    Rs(e, t),
+    Ts(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), d = Ds(
+        e,
+        a,
+        o,
+        c
+      );
+      let f = Fs(
+        e,
+        a,
+        d.root,
+        d.align,
+        l === "r"
+      );
+      l === "r" && (f = Ne(f, (g) => -g)), n[i + l] = f;
+    });
+  });
+  const r = zs(e, n);
+  return Bs(n, r), Vs(n, e.graph().align);
+}
+function Gs(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 js(e, t) {
+  return e.node(t).width;
+}
+function Ws(e) {
+  const t = at(e);
+  Ys(t);
+  const o = Is(t);
+  Object.entries(o).forEach(([n, s]) => {
+    e.node(n).x = s;
+  });
+}
+function Ys(e) {
+  const t = _e(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 Hs(e, t = {}) {
+  const o = t.debugTiming ? fo : ho;
+  return o("layout", () => {
+    const n = o("  buildLayoutGraph", () => or(e));
+    return o("  runLayout", () => Zs(n, o, t)), o("  updateInputGraph", () => Us(e, n)), n;
+  });
+}
+function Zs(e, t, o) {
+  t("    makeSpaceForEdgeLabels", () => nr(e)), t("    removeSelfEdges", () => fr(e)), t("    acyclic", () => Bn(e)), t("    nestingGraph.run", () => ls(e)), t("    rank", () => ts(at(e))), t("    injectEdgeLabelProxies", () => sr(e)), t("    removeEmptyRanks", () => ao(e)), t("    nestingGraph.cleanup", () => us(e)), t("    normalizeRanks", () => lo(e)), t("    assignRankMinMax", () => rr(e)), t("    removeEdgeLabelProxies", () => ir(e)), t("    normalize.run", () => Gn(e)), t("    parentDummyChains", () => ss(e)), t("    addBorderSegments", () => ds(e)), t("    order", () => wo(e, o)), t("    insertSelfEdges", () => hr(e)), t("    adjustCoordinateSystem", () => Kt.adjust(e)), t("    position", () => Ws(e)), t("    positionSelfEdges", () => mr(e)), t("    removeBorderNodes", () => dr(e)), t("    normalize.undo", () => Wn(e)), t("    fixupEdgeLabelCoords", () => cr(e)), t("    undoCoordinateSystem", () => Kt.undo(e)), t("    translateGraph", () => lr(e)), t("    assignNodeIntersects", () => ar(e)), t("    reversePoints", () => ur(e)), t("    acyclic.undo", () => Vn(e));
+}
+function Us(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 Xs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"], qs = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" }, Ks = ["acyclicer", "ranker", "rankdir", "align"], Js = ["width", "height", "rank"], to = { width: 0, height: 0 }, Qs = ["minlen", "weight", "width", "height", "labeloffset"], er = {
+  minlen: 1,
+  weight: 1,
+  width: 0,
+  height: 0,
+  labeloffset: 10,
+  labelpos: "r"
+}, tr = ["labelpos"];
+function or(e) {
+  const t = nt(e.graph()), o = {
+    ...qs,
+    ...ot(t, Xs),
+    ...xe(t, Ks)
+  }, n = new q({ multigraph: !0, compound: !0 });
+  return n.setGraph(o), e.nodes().forEach((s) => {
+    const r = nt(e.node(s)), i = ot(r, Js);
+    Object.keys(to).forEach((l) => {
+      i[l] === void 0 && (i[l] = to[l]);
+    }), n.setNode(s, i), n.setParent(s, e.parent(s));
+  }), e.edges().forEach((s) => {
+    const r = nt(e.edge(s));
+    n.setEdge(
+      s,
+      {
+        ...er,
+        ...ot(r, Qs),
+        ...xe(r, tr)
+      }
+    );
+  }), n;
+}
+function nr(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 sr(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 };
+      ue(e, "edge-proxy", r, "_ep");
+    }
+  });
+}
+function rr(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 ir(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 lr(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 d = c.x, f = c.y, g = c.width, b = c.height;
+    t = Math.min(t, d - g / 2), o = Math.max(o, d + g / 2), n = Math.min(n, f - b / 2), s = Math.max(s, f + b / 2);
+  }
+  e.nodes().forEach((c) => a(e.node(c))), e.edges().forEach((c) => {
+    const d = e.edge(c);
+    Object.hasOwn(d, "x") && a(d);
+  }), t -= i, n -= l, e.nodes().forEach((c) => {
+    const d = e.node(c);
+    d.x -= t, d.y -= n;
+  }), e.edges().forEach((c) => {
+    const d = e.edge(c);
+    d.points.forEach((f) => {
+      f.x -= t, f.y -= n;
+    }), Object.hasOwn(d, "x") && (d.x -= t), Object.hasOwn(d, "y") && (d.y -= n);
+  }), r.width = o - t + i, r.height = s - n + l;
+}
+function ar(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(lt(n, r)), o.points.push(lt(s, i));
+  });
+}
+function cr(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 ur(e) {
+  e.edges().forEach((t) => {
+    const o = e.edge(t);
+    o.reversed && o.points.reverse();
+  });
+}
+function dr(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 fr(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 hr(e) {
+  _e(e).forEach((o) => {
+    let n = 0;
+    o.forEach((s, r) => {
+      const i = e.node(s);
+      i.order = r + n, (i.selfEdges || []).forEach((l) => {
+        ue(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 mr(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 ot(e, t) {
+  return Ne(xe(e, t), Number);
+}
+function nt(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 gr = {
+  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 vr(e) {
+  return e.length ? e.map(
+    (t, o) => `${o === 0 ? "M" : "L"} ${t.x} ${t.y}`
+  ).join(" ") : "";
+}
+function br(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, d = (r.y + i.y) / 2;
+    o += ` Q ${l} ${a} ${c} ${d}`;
+  }
+  const n = e[e.length - 1];
+  return o += ` L ${n.x} ${n.y}`, o;
+}
+function pr(e) {
+  const { nodes: t, edges: o, configuration: n } = e, s = y(null), r = y(null), i = `dag-arrow-${rt()}`;
+  function l(a, c, d) {
+    r.value = null, s.value = null;
+    const f = {
+      ...gr,
+      ...d
+    }, g = new q({ multigraph: !0, compound: !0 });
+    g.setGraph({
+      rankdir: f.rankDirection,
+      nodesep: f.nodeSeparation,
+      ranksep: f.rankSeparation,
+      edgesep: f.edgeSeparation,
+      align: f.align
+    }), a.forEach((u) => {
+      g.setNode(u.id, {
+        label: u.label,
+        width: u.width ?? f.nodeWidth,
+        height: u.height ?? f.nodeHeight
+      });
+    }), c.forEach((u) => {
+      g.setEdge(u.from, u.to, {
+        weight: u.weight ?? 1,
+        minlen: u.minLength ?? 1
+      });
+    }), Hs(g);
+    const b = a.map((u) => {
+      const I = g.node(u.id);
+      return {
+        id: u.id,
+        label: u.label,
+        x: I.x,
+        y: I.y,
+        width: I.width,
+        height: I.height,
+        original: u
+      };
+    }), N = g.edges().map((u) => {
+      const I = g.edge(u), H = I.points || [];
+      if (!H.length)
+        return null;
+      const Ae = f.curvedEdges ? br(H) : vr(H), Se = f.arrowShape !== "undirected" ? `url(#${i})` : null, Le = c.find((he) => he?.from === u.v && he?.to === u.w);
+      return {
+        id: `${u.v}->${u.w}->${rt()}`,
+        from: u.v,
+        to: u.w,
+        points: H,
+        pathData: Ae,
+        markerEnd: Se,
+        original: {
+          ...Le,
+          ...I
+        }
+      };
+    }).filter(Boolean), _ = f.padding;
+    if (!b.length) {
+      s.value = {
+        nodes: [],
+        edges: N,
+        viewBox: "0 0 0 0",
+        arrowShape: f.arrowShape,
+        arrowSize: f.arrowSize
+      };
+      return;
+    }
+    const M = b.flatMap((u) => [
+      u.x - u.width / 2,
+      u.x + u.width / 2
+    ]), Y = b.flatMap((u) => [
+      u.y - u.height / 2,
+      u.y + u.height / 2
+    ]), fe = Math.min(...M) - _, oe = Math.max(...M) + _, R = Math.min(...Y) - _, P = Math.max(...Y) + _;
+    s.value = {
+      nodes: b,
+      edges: N.map((u) => ({
+        ...u,
+        midpoint: u.pathData ? sn(u.pathData) : { x: 0, y: 0 }
+      })),
+      viewBox: `${fe} ${R} ${oe - fe} ${P - R}`,
+      arrowShape: f.arrowShape,
+      arrowSize: f.arrowSize
+    };
+  }
+  return Jo(() => {
+    try {
+      const a = v(t) || [], c = v(o) || [], d = v(n) || {};
+      l(a, c, d);
+    } catch (a) {
+      console.error("[useDag] layout error:", a), r.value = a, s.value = null;
+    }
+  }), {
+    layoutData: s,
+    lastError: r,
+    arrowMarkerIdentifier: i,
+    recomputeLayout: () => {
+      const a = v(t) || [], c = v(o) || [], d = v(n) || {};
+      l(a, c, d);
+    }
+  };
+}
+const ko = { 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" } } } } }, Eo = { 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" } } } } }, Co = { 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" } } } } }, xo = { 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" } } } } }, _o = { 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" } } } } }, No = { 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" } } } } }, Ao = {
+  default: {},
+  dark: ko,
+  celebration: Eo,
+  celebrationNight: Co,
+  hack: xo,
+  zen: _o,
+  concrete: No
+}, ai = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  celebration: Eo,
+  celebrationNight: Co,
+  concrete: No,
+  dark: ko,
+  default: Ao,
+  hack: xo,
+  zen: _o
+}, Symbol.toStringTag, { value: "Module" }));
+function wr(e, t) {
+  const o = Ce(e);
+  return rn(o, t);
+}
+function ci(e, t) {
+  const o = Ce(e);
+  return ln(o, t);
+}
+function ui(e, t) {
+  const o = Ce(e);
+  return an(o, t);
+}
+function di({ defaultConfig: e, userConfig: t }) {
+  return so({ defaultConfig: e, userConfig: t });
+}
+const yr = {
+  __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(), x("div", {
+      class: st({ "vue-data-ui-zoom-controls": !0, "vue-data-ui-zoom-controls-fullscreen": e.isFullscreen }),
+      "data-dom-to-png-ignore": "",
+      style: X({
+        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": v(wr)(e.config.style.chart.controls.buttonColor, 0.2)
+      })
+    }, [
+      G("button", {
+        onClick: s[0] || (s[0] = (r) => o("zoomOut")),
+        class: "vue-data-ui-zoom-controls-button",
+        "data-cy-zoom-out": ""
+      }, [
+        ae(Ke, {
+          name: "zoomMinus",
+          stroke: e.config.style.chart.controls.color,
+          size: e.config.style.chart.controls.fontSize * 1.2
+        }, null, 8, ["stroke", "size"])
+      ]),
+      G("button", {
+        class: "vue-data-ui-zoom-controls-button-zoom",
+        onClick: s[1] || (s[1] = (r) => o("resetZoom")),
+        "data-cy-zoom-reset": "",
+        style: X({
+          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"
+        })
+      }, le(Math.round(e.scale * 100)) + "% ", 5),
+      G("button", {
+        onClick: s[2] || (s[2] = (r) => o("zoomIn")),
+        class: "vue-data-ui-zoom-controls-button",
+        "data-cy-zoom-in": ""
+      }, [
+        ae(Ke, {
+          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(), x("button", {
+        key: 0,
+        onClick: s[3] || (s[3] = (r) => o("switchDirection")),
+        class: "vue-data-ui-zoom-controls-button"
+      }, [
+        ae(Ke, {
+          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));
+  }
+}, oo = /* @__PURE__ */ ro(yr, [["__scopeId", "data-v-e4479474"]]), kr = ["id"], Er = {
+  key: 0,
+  class: "dag-chart-error"
+}, Cr = ["viewBox", "xmlns"], xr = { key: 0 }, _r = ["id", "markerWidth", "markerHeight", "refX", "refY"], Nr = ["d", "fill", "stroke"], Ar = ["d", "fill", "stroke"], Sr = { class: "vue-ui-dag-edges" }, Lr = ["d", "stroke", "stroke-width"], Or = ["cx", "cy", "r", "fill", "stroke", "stroke-width", "onMouseenter"], Rr = { class: "vue-ui-dag-nodes" }, Tr = ["onClick", "onMouseenter"], Mr = ["x", "y", "width", "height", "rx", "fill", "stroke", "stroke-width"], $r = ["x", "y", "font-size", "fill", "font-weight"], Dr = ["x", "y", "font-size", "fill", "font-weight", "innerHTML"], Fr = ["x", "y", "width", "height"], Pr = { class: "vue-ui-dag-edges" }, zr = ["d", "stroke-width", "marker-end"], Br = {
+  key: 6,
+  class: "vue-data-ui-watermark"
+}, Vr = ["data-position"], Ir = { key: 0 }, Gr = ["data-position"], jr = { key: 0 }, no = 1.5, Wr = {
+  __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 = Xe(() => import("./PenAndPaper-DscVdZ1u.js")), s = Xe(() => import("./UserOptions-ChRXLqps.js")), r = Xe(() => import("./PackageVersion-Dc4fCiDF.js")), { vue_ui_dag: i } = gn(), { isThemeValid: l, warnInvalidTheme: a } = yn(), c = e, d = o, f = y(null), g = y(rt()), b = y(null), N = y(null), _ = y(null), M = y(0), Y = y(0), fe = y(!1), oe = y(!1), R = y(null), P = y(null), u = y(je()), I = y(u.value.style.chart.width), H = y(u.value.style.chart.height), Ae = y({ x: 0, y: 0 }), z = y(null), Se = y(null), Le = y({ left: "0px", top: "0px" }), he = y("top"), K = y(!1), ut = y({ x: 0, y: 0 }), dt = y({ x: 0, y: 0 }), me = y(null), Ve = y(null), Ie = y({ left: "0px", top: "0px" }), ft = y("top"), Oe = y(!1), ge = y(!1), { svgRef: J } = En({ config: u.value.style.chart.title }), { userOptionsVisible: Ge, setUserOptionsVisibility: ht, keepUserOptionState: mt } = kn({ config: u.value }), Re = y(u.value.style.chart.layout.rankDirection), { loading: ve, FINAL_DATASET: gt, manualLoading: vt } = vn({
+      ...Qo(c),
+      FINAL_CONFIG: u,
+      prepareConfig: je,
+      skeletonDataset: {
+        nodes: [
+          { id: "A", label: "" },
+          { id: "B", label: "" },
+          { id: "C", label: "" }
+        ],
+        edges: [
+          { from: "A", to: "B" },
+          { from: "A", to: "C" }
+        ]
+      },
+      skeletonConfig: so({
+        defaultConfig: u.value,
+        userConfig: {
+          userOptions: { show: !1 },
+          style: {
+            chart: {
+              backgroundColor: "#99999930",
+              nodes: {
+                stroke: "#CCCCCC",
+                backgroundColor: "#DDDDDD50"
+              },
+              edges: {
+                stroke: "#CCCCCC"
+              },
+              midpoints: {
+                stroke: "#CCCCCC",
+                fill: "#CCCCCC"
+              }
+            }
+          }
+        }
+      })
+    });
+    function je() {
+      const m = qe({
+        userConfig: c.config,
+        defaultConfig: i
+      }), p = m.theme;
+      if (!p) return m;
+      if (!l.value(m))
+        return a(m), m;
+      const h = qe({
+        userConfig: Ao[p] || c.config,
+        defaultConfig: m
+      });
+      return qe({
+        userConfig: c.config,
+        defaultConfig: h
+      });
+    }
+    const bt = W(() => !!u.value.debug);
+    zt(() => {
+      cn(c.dataset) && (jt({
+        componentName: "VueUiDag",
+        type: "dataset",
+        debug: bt.value
+      }), oe.value = !1, vt.value = !0), c.dataset.nodes || (jt({
+        componentName: "VueUiDag",
+        type: "datasetAttributeEmpty",
+        property: "nodes",
+        index: 0,
+        debug: bt.value
+      }), oe.value = !1, vt.value = !0), oe.value = !0, Ft();
+    }), De(() => c.config, (m) => {
+      ve.value || (u.value = je()), Ge.value = !u.value.userOptions.showOnChartHover, M.value += 1, Re.value = u.value.style.chart.layout.rankDirection, I.value = u.value.style.chart.width, H.value = u.value.style.chart.height, ne.value = u.value.style.chart.zoom.active, Ft();
+    }, { deep: !0 });
+    const { isPrinting: pt, isImaging: wt, generatePdf: yt, generateImage: kt } = pn({
+      elementId: `dag_${g.value}`,
+      fileName: u.value.style.chart.title.text || "vue-ui-dag",
+      options: u.value.userOptions.print
+    }), So = W(() => u.value.style.chart.backgroundColor), Lo = W(() => u.value.style.chart.title), { exportSvg: Oo, getSvg: Ro } = wn({
+      svg: J,
+      title: Lo,
+      legend: void 0,
+      legendItems: void 0,
+      backgroundColor: So
+    });
+    async function Et({ isCb: m }) {
+      if (m) {
+        const { blob: p, url: h, text: w, dataUrl: O } = await Ro();
+        u.value.userOptions.callbacks.svg({ blob: p, url: h, text: w, dataUrl: O });
+      } else
+        Oo();
+    }
+    function To() {
+      fe.value = !0, ht(!0);
+    }
+    function Mo() {
+      ht(!1), fe.value = !1;
+    }
+    function Ct({
+      tooltipRef: m,
+      isVisibleRef: p,
+      anchorRef: h,
+      styleRef: w,
+      placementRef: O,
+      offsetRef: $,
+      margin: C = 24
+    }) {
+      return function() {
+        const ee = m.value;
+        if (!ee || !p.value) return;
+        const S = ee.getBoundingClientRect(), D = window.innerWidth, pe = window.innerHeight, we = h.value.x, Me = h.value.y, $e = $?.value?.x ?? 0, Pt = $?.value?.y ?? 0;
+        let F = Me - Pt - S.height - C, Z = we - S.width / 2, ye = "top";
+        if (F < C) {
+          const re = Me + Pt + C;
+          re + S.height <= pe - C ? (F = re, ye = "bottom") : (F = Me - S.height / 2, F < C && (F = C), F + S.height > pe - C && (F = pe - S.height - C), ye = "center");
+        }
+        Z < C && (Z = C), Z + S.width > D - C && (Z = D - S.width - C);
+        const Xo = Z <= C, qo = Z + S.width >= D - C;
+        if ((Xo || qo) && ye !== "center") {
+          let re, ke;
+          const Ko = we - $e - C;
+          D - (we + $e) - C >= Ko ? (re = "right", ke = we + $e + C) : (re = "left", ke = we - $e - C - S.width), ke >= C && ke + S.width <= D - C && (Z = ke, F = Me - S.height / 2, F < C && (F = C), F + S.height > pe - C && (F = pe - S.height - C), ye = re);
+        }
+        O.value = ye, w.value = {
+          left: `${Z}px`,
+          top: `${F}px`
+        };
+      };
+    }
+    const $o = W(() => gt.value.nodes.map((m) => ({
+      ...m,
+      backgroundColor: m.backgroundColor ? Ce(m.backgroundColor) : u.value.style.chart.nodes.backgroundColor,
+      color: m.color ? Ce(m.color) : u.value.style.chart.nodes.labels.color
+    }))), Do = W(() => gt.value.edges), Fo = W(() => ({
+      ...u.value.style.chart.layout,
+      rankDirection: Re.value
+    })), { layoutData: E, lastError: xt, arrowMarkerIdentifier: Po } = pr({
+      nodes: $o,
+      edges: Do,
+      configuration: Fo
+    });
+    function _t(m) {
+      return E.value ? E.value.nodes.find((p) => p.id === m) : null;
+    }
+    const zo = W(() => {
+      if (!E.value) return [];
+      const m = u.value.style.chart.edges.stroke, p = /* @__PURE__ */ new Set();
+      return E.value.edges.forEach((h) => {
+        p.add(h.original?.color || m);
+      }), Array.from(p);
+    });
+    function Nt(m) {
+      return `${Po}-${String(m).replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+    }
+    const At = W(() => {
+      const m = I.value, p = H.value, h = Number(m), w = Number(p), O = Number.isFinite(h) && h > 0, $ = Number.isFinite(w) && w > 0;
+      return !O && !$ ? null : {
+        width: O ? h : null,
+        height: $ ? w : null
+      };
+    }), be = y(null), ne = y(u.value.style.chart.zoom.active), {
+      viewBox: St,
+      resetZoom: Te,
+      setInitialViewBox: Bo,
+      scale: Lt,
+      zoomByFactor: Ot
+    } = mn(
+      J,
+      { x: 0, y: 0, width: 100, height: 100 },
+      1,
+      ne,
+      () => {
+        K.value = !1;
+      }
+    );
+    function Vo() {
+      ne.value = !ne.value;
+    }
+    function Rt() {
+      const m = E.value && E.value.viewBox;
+      if (!m) return;
+      const p = String(m).split(" ").map(Number);
+      if (p.length !== 4) return;
+      const [h, w, O, $] = p;
+      if (!Number.isFinite(h) || !Number.isFinite(w) || !Number.isFinite(O) || !Number.isFinite($))
+        return;
+      let C = O, se = $, ee = h, S = w;
+      const D = At.value;
+      D && (D.width !== null && (C = D.width), D.height !== null && (se = D.height), ee = h - (C - O) / 2, S = w - (se - $) / 2), Bo(
+        { x: ee, y: S, width: C, height: se },
+        { overwriteCurrentIfNotZoomed: !0 }
+      );
+    }
+    De(
+      () => E.value && E.value.viewBox,
+      () => {
+        Rt();
+      },
+      { immediate: !0 }
+    ), De(
+      () => At.value,
+      () => {
+        Rt();
+      }
+    ), De(() => ge.value, (m) => {
+      ne.value = !m;
+    });
+    const Io = W(() => {
+      const m = St.value;
+      return m ? `${m.x} ${m.y} ${m.width} ${m.height}` : "0 0 0 0";
+    }), Q = y(!1);
+    function Tt(m) {
+      Q.value = m, Y.value += 1;
+    }
+    function We() {
+      ge.value = !ge.value;
+    }
+    function Ye() {
+      Ot(no, !0);
+    }
+    function He() {
+      Ot(1 / no, !0);
+    }
+    const Ze = ["TB", "RL", "BT", "LR"];
+    function Ue() {
+      Re.value = Ze[(Ze.indexOf(Re.value) + 1) % Ze.length], Te();
+    }
+    const Go = Ct({
+      tooltipRef: Se,
+      isVisibleRef: Oe,
+      anchorRef: Ae,
+      styleRef: Le,
+      placementRef: he
+    }), jo = Ct({
+      tooltipRef: Ve,
+      isVisibleRef: K,
+      anchorRef: ut,
+      styleRef: Ie,
+      placementRef: ft,
+      offsetRef: dt
+    });
+    async function Wo(m) {
+      d("onMidpointEnter", m);
+      const p = J.value;
+      if (!p || !m?.midpoint) return;
+      const h = p.createSVGPoint();
+      h.x = m.midpoint.x, h.y = m.midpoint.y;
+      const w = p.getScreenCTM();
+      if (!w) return;
+      const O = h.matrixTransform(w);
+      Ae.value = {
+        x: O.x,
+        y: O.y
+      }, z.value = m, Oe.value = !0, await Gt(), Go();
+    }
+    function Yo() {
+      Oe.value = !1, z.value = null, d("onMidpointLeave");
+    }
+    async function Ho(m) {
+      if (d("onNodeClick", m), !u.value.style.chart.nodes.tooltip.showOnClick) return;
+      const p = J.value;
+      if (!p) return;
+      const h = p.createSVGPoint();
+      h.x = m.x, h.y = m.y;
+      const w = p.getScreenCTM();
+      if (!w) return;
+      const O = h.matrixTransform(w), $ = u.value.style.chart.layout.nodeWidth, C = u.value.style.chart.layout.nodeHeight, se = w.a, ee = w.d, S = $ * se, D = C * ee;
+      dt.value = {
+        x: S / 2,
+        y: D / 2
+      }, ut.value = {
+        x: O.x,
+        y: O.y
+      }, me.value = m, K.value = !0, await Gt(), jo();
+    }
+    function Mt() {
+      K.value = !1, me.value = null;
+    }
+    function $t(m) {
+      if (!K.value) return;
+      const p = Ve.value;
+      if (p && p.contains(m.target))
+        return;
+      const h = J.value;
+      h && h.contains(m.target) && m.target.closest(".vue-ui-dag-node") || Mt();
+    }
+    function Dt(m) {
+      m.key === "Escape" && K.value && Mt();
+    }
+    zt(() => {
+      document.addEventListener("mousedown", $t), document.addEventListener("keydown", Dt);
+    }), en(() => {
+      document.removeEventListener("mousedown", $t), document.removeEventListener("keydown", Dt), R.value && (P.value && R.value.unobserve(P.value), R.value.disconnect());
+    });
+    function Ft() {
+      if (!u.value.responsive) {
+        R.value && (P.value && R.value.unobserve(P.value), R.value.disconnect(), R.value = null, P.value = null);
+        return;
+      }
+      const m = fn(() => {
+        if (!f.value) return;
+        const { width: p, height: h } = hn({
+          chart: f.value,
+          title: u.value.style.chart.title.text ? b.value : null,
+          legend: u.value.style.chart.controls.show ? _.value.$el : null,
+          source: N.value
+        });
+        requestAnimationFrame(() => {
+          I.value = Math.max(0.1, p), H.value = Math.max(0.1, h - 12);
+        });
+      });
+      R.value && (P.value && R.value.unobserve(P.value), R.value.disconnect()), R.value = new ResizeObserver(m), P.value = f.value ? f.value.parentNode : null, P.value && R.value.observe(P.value), m();
+    }
+    async function Zo({ scale: m = 2 } = {}) {
+      if (!f.value) return;
+      const { width: p, height: h } = f.value.getBoundingClientRect(), w = p / h, { imageUri: O, base64: $ } = await xn({ domElement: f.value, base64: !0, img: !0, scale: m });
+      return {
+        imageUri: O,
+        base64: $,
+        title: u.value.style.chart.title.text ?? "vue-ui-dag",
+        width: p,
+        height: h,
+        aspectRatio: w
+      };
+    }
+    function Uo() {
+      return E.value;
+    }
+    return t({
+      getData: Uo,
+      getImage: Zo,
+      generatePdf: yt,
+      generateSvg: Et,
+      generateImage: kt,
+      toggleAnnotator: We,
+      toggleFullscreen: Tt,
+      zoomIn: Ye,
+      zoomOut: He,
+      resetZoom: Te,
+      switchDirection: Ue
+    }), (m, p) => (k(), x("div", {
+      class: st(`vue-data-ui-component vue-ui-dag ${Q.value ? "vue-data-ui-wrapper-fullscreen" : ""} ${u.value.responsive ? "vue-ui-dag-responsive" : ""}`),
+      id: `dag_${g.value}`,
+      ref_key: "dagChart",
+      ref: f,
+      style: X({
+        fontFamily: u.value.style.fontFamily,
+        backgroundColor: u.value.style.chart.backgroundColor,
+        padding: "0.5rem"
+      }),
+      onMouseenter: To,
+      onMouseleave: Mo
+    }, [
+      v(xt) ? (k(), x("div", Er, le(String(v(xt))), 1)) : L("", !0),
+      u.value.userOptions.buttons.annotator ? (k(), U(v(n), {
+        key: 1,
+        svgRef: v(J),
+        backgroundColor: u.value.style.chart.backgroundColor,
+        color: u.value.style.chart.color,
+        active: ge.value,
+        onClose: We
+      }, {
+        "annotator-action-close": T(() => [
+          A(m.$slots, "annotator-action-close", {}, void 0, !0)
+        ]),
+        "annotator-action-color": T(({ color: h }) => [
+          A(m.$slots, "annotator-action-color", B(V({ color: h })), void 0, !0)
+        ]),
+        "annotator-action-draw": T(({ mode: h }) => [
+          A(m.$slots, "annotator-action-draw", B(V({ mode: h })), void 0, !0)
+        ]),
+        "annotator-action-undo": T(({ disabled: h }) => [
+          A(m.$slots, "annotator-action-undo", B(V({ disabled: h })), void 0, !0)
+        ]),
+        "annotator-action-redo": T(({ disabled: h }) => [
+          A(m.$slots, "annotator-action-redo", B(V({ disabled: h })), void 0, !0)
+        ]),
+        "annotator-action-delete": T(({ disabled: h }) => [
+          A(m.$slots, "annotator-action-delete", B(V({ disabled: h })), void 0, !0)
+        ]),
+        _: 3
+      }, 8, ["svgRef", "backgroundColor", "color", "active"])) : L("", !0),
+      u.value.userOptions.show && oe.value && (v(mt) || v(Ge)) ? (k(), U(v(s), {
+        ref: "userOptionsRef",
+        key: `user_option_${Y.value}`,
+        backgroundColor: u.value.style.chart.backgroundColor,
+        color: u.value.style.chart.color,
+        isPrinting: v(pt),
+        isImaging: v(wt),
+        uid: g.value,
+        hasTooltip: !1,
+        hasTable: !1,
+        hasXls: !1,
+        hasLabel: !1,
+        hasPdf: u.value.userOptions.buttons.pdf,
+        hasImg: u.value.userOptions.buttons.img,
+        hasSvg: u.value.userOptions.buttons.svg,
+        hasFullscreen: u.value.userOptions.buttons.fullscreen,
+        isFullscreen: Q.value,
+        chartElement: f.value,
+        position: u.value.userOptions.position,
+        titles: { ...u.value.userOptions.buttonTitles },
+        hasAnnotator: u.value.userOptions.buttons.annotator,
+        isAnnotation: ge.value,
+        callbacks: u.value.userOptions.callbacks,
+        printScale: u.value.userOptions.print.scale,
+        hasZoom: u.value.userOptions.buttons.zoom,
+        isZoom: ne.value,
+        onToggleFullscreen: Tt,
+        onGeneratePdf: v(yt),
+        onGenerateImage: v(kt),
+        onGenerateSvg: Et,
+        onToggleAnnotator: We,
+        onToggleZoom: Vo,
+        style: X({
+          visibility: v(mt) ? v(Ge) ? "visible" : "hidden" : "visible"
+        })
+      }, tn({ _: 2 }, [
+        m.$slots.menuIcon ? {
+          name: "menuIcon",
+          fn: T(({ isOpen: h, color: w }) => [
+            A(m.$slots, "menuIcon", B(V({ isOpen: h, color: w })), void 0, !0)
+          ]),
+          key: "0"
+        } : void 0,
+        m.$slots.optionPdf ? {
+          name: "optionPdf",
+          fn: T(() => [
+            A(m.$slots, "optionPdf", {}, void 0, !0)
+          ]),
+          key: "1"
+        } : void 0,
+        m.$slots.optionImg ? {
+          name: "optionImg",
+          fn: T(() => [
+            A(m.$slots, "optionImg", {}, void 0, !0)
+          ]),
+          key: "2"
+        } : void 0,
+        m.$slots.optionSvg ? {
+          name: "optionSvg",
+          fn: T(() => [
+            A(m.$slots, "optionSvg", {}, void 0, !0)
+          ]),
+          key: "3"
+        } : void 0,
+        m.$slots.optionFullscreen ? {
+          name: "optionFullscreen",
+          fn: T(({ toggleFullscreen: h, isFullscreen: w }) => [
+            A(m.$slots, "optionFullscreen", B(V({ toggleFullscreen: h, isFullscreen: w })), void 0, !0)
+          ]),
+          key: "4"
+        } : void 0,
+        m.$slots.optionAnnotator ? {
+          name: "optionAnnotator",
+          fn: T(({ toggleAnnotator: h, isAnnotator: w }) => [
+            A(m.$slots, "optionAnnotator", B(V({ toggleAnnotator: h, isAnnotator: w })), void 0, !0)
+          ]),
+          key: "5"
+        } : void 0,
+        m.$slots.optionZoom ? {
+          name: "optionZoom",
+          fn: T(({ toggleZoom: h, isZoomLocked: w }) => [
+            A(m.$slots, "optionZoom", B(V({ toggleZoom: h, isZoomLocked: w })), 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),
+      u.value.style.chart.title.text ? (k(), x("div", {
+        key: 3,
+        ref_key: "chartTitle",
+        ref: b,
+        style: "width:100%;background:transparent;"
+      }, [
+        (k(), U(Cn, {
+          key: `title_${M.value}`,
+          config: {
+            title: {
+              cy: "dag-title",
+              ...u.value.style.chart.title
+            },
+            subtitle: {
+              cy: "dag-subtitle",
+              ...u.value.style.chart.title.subtitle
+            }
+          }
+        }, null, 8, ["config"]))
+      ], 512)) : L("", !0),
+      u.value.style.chart.controls.position === "top" && !v(ve) && u.value.style.chart.controls.show ? (k(), U(oo, {
+        key: 4,
+        ref_key: "zoomControls",
+        ref: _,
+        config: u.value,
+        scale: v(Lt),
+        isFullscreen: Q.value,
+        withDirection: "",
+        onZoomIn: Ye,
+        onZoomOut: He,
+        onResetZoom: p[0] || (p[0] = () => v(Te)(!0)),
+        onSwitchDirection: Ue
+      }, null, 8, ["config", "scale", "isFullscreen"])) : L("", !0),
+      v(E) ? (k(), x("svg", {
+        key: 5,
+        ref_key: "svgRef",
+        ref: J,
+        class: st({ "vue-ui-dag-svg": !0, "vue-data-ui-loading": v(ve) }),
+        viewBox: Io.value,
+        xmlns: v(un),
+        style: X({
+          backgroundColor: u.value.style.chart.backgroundColor,
+          height: "100%",
+          width: "100%"
+        })
+      }, [
+        ae(v(r)),
+        v(E).arrowShape !== "undirected" ? (k(), x("defs", xr, [
+          (k(!0), x(ie, null, Fe(zo.value, (h) => (k(), x("marker", {
+            key: h,
+            id: Nt(h),
+            markerWidth: v(E).arrowSize,
+            markerHeight: v(E).arrowSize,
+            refX: v(E).arrowSize - 1,
+            refY: v(E).arrowSize / 2,
+            orient: "auto",
+            markerUnits: "strokeWidth"
+          }, [
+            v(E).arrowShape === "normal" ? (k(), x("path", {
+              key: 0,
+              d: `M 0 0 L ${v(E).arrowSize} ${v(E).arrowSize / 2} L 0 ${v(E).arrowSize} Z`,
+              fill: h,
+              stroke: h,
+              "stroke-width": "0"
+            }, null, 8, Nr)) : (k(), x("path", {
+              key: 1,
+              d: `M 0 0 L ${v(E).arrowSize} ${v(E).arrowSize / 2} L 0 ${v(E).arrowSize} L ${v(E).arrowSize / 3} ${v(E).arrowSize / 2} Z`,
+              fill: h,
+              stroke: h,
+              "stroke-width": "0"
+            }, null, 8, Ar))
+          ], 8, _r))), 128))
+        ])) : L("", !0),
+        G("g", Sr, [
+          (k(!0), x(ie, null, Fe(v(E).edges, (h) => (k(), x(ie, {
+            key: h.id
+          }, [
+            G("path", {
+              "data-cy-edge": "",
+              d: h.pathData,
+              fill: "none",
+              stroke: h.original.color ?? u.value.style.chart.edges.stroke,
+              "stroke-width": u.value.style.chart.edges.strokeWidth * (h.from === be.value || h.id === z.value?.id ? 2 : 1),
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              style: { "pointer-events": "none", transition: "stroke-width 0.2s ease-in-out" }
+            }, null, 8, Lr),
+            u.value.style.chart.midpoints.show ? (k(), x("circle", {
+              key: 0,
+              "data-cy-midpoint": "",
+              class: "vue-ui-dag-edge-midpoint",
+              cx: h.midpoint.x,
+              cy: h.midpoint.y,
+              r: u.value.style.chart.midpoints.radius,
+              fill: u.value.style.chart.midpoints.fill,
+              stroke: h.original.color ?? u.value.style.chart.midpoints.stroke,
+              "stroke-width": u.value.style.chart.midpoints.strokeWidth * (h.from === be.value || h.id === z.value?.id ? 2 : 1),
+              style: { transition: "stroke-width 0.2s ease-in-out" },
+              onMouseenter: (w) => Wo(h),
+              onMouseleave: Yo
+            }, null, 40, Or)) : L("", !0)
+          ], 64))), 128))
+        ]),
+        G("g", Rr, [
+          (k(!0), x(ie, null, Fe(v(E).nodes, (h) => (k(), x("g", {
+            key: h.id,
+            class: "vue-ui-dag-node",
+            onClick: on((w) => u.value.style.chart.nodes.tooltip.showOnClick && Ho(h), ["stop"]),
+            onMouseenter: (w) => be.value = h.id,
+            onMouseleave: p[1] || (p[1] = (w) => be.value = null)
+          }, [
+            m.$slots.node ? L("", !0) : (k(), x(ie, { key: 0 }, [
+              G("rect", {
+                "data-cy-node": "",
+                x: h.x - h.width / 2,
+                y: h.y - h.height / 2,
+                width: h.width,
+                height: h.height,
+                rx: u.value.style.chart.nodes.borderRadius,
+                fill: h.original.backgroundColor,
+                stroke: u.value.style.chart.nodes.stroke,
+                "stroke-width": u.value.style.chart.nodes.strokeWidth,
+                style: X({
+                  cursor: u.value.style.chart.nodes.tooltip.showOnClick ? "pointer" : "default"
+                })
+              }, null, 12, Mr),
+              m.$slots["node-label"] ? (k(), x("text", {
+                key: 0,
+                x: h.x,
+                y: h.y + u.value.style.chart.nodes.labels.fontSize / 3,
+                "text-anchor": "middle",
+                "font-size": u.value.style.chart.nodes.labels.fontSize,
+                fill: h.original.color,
+                "font-weight": u.value.style.chart.nodes.labels.bold ? "bold" : "normal"
+              }, [
+                A(m.$slots, "node-label", Bt({ ref_for: !0 }, { node: h }), () => [
+                  nn(le(h.label), 1)
+                ], !0)
+              ], 8, $r)) : (k(), x("text", {
+                key: 1,
+                "data-cy-node-label": "",
+                x: h.x,
+                y: h.y + u.value.style.chart.nodes.labels.fontSize / 3,
+                "text-anchor": "middle",
+                "font-size": u.value.style.chart.nodes.labels.fontSize,
+                fill: h.original.color,
+                "font-weight": u.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                innerHTML: v(dn)({
+                  content: h.label,
+                  fontSize: u.value.style.chart.nodes.labels.fontSize,
+                  fontWeight: u.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                  fill: h.original.color,
+                  x: h.x,
+                  y: h.y,
+                  autoOffset: !0
+                })
+              }, null, 8, Dr))
+            ], 64)),
+            m.$slots.node ? (k(), x("foreignObject", {
+              key: 1,
+              x: h.x - h.width / 2,
+              y: h.y - h.height / 2,
+              width: h.width,
+              height: h.height
+            }, [
+              A(m.$slots, "node", Bt({ ref_for: !0 }, { node: h }), void 0, !0)
+            ], 8, Fr)) : L("", !0)
+          ], 40, Tr))), 128))
+        ]),
+        G("g", Pr, [
+          (k(!0), x(ie, null, Fe(v(E).edges, (h) => (k(), x("path", {
+            key: h.id,
+            d: h.pathData,
+            fill: "none",
+            stroke: "transparent",
+            "stroke-width": u.value.style.chart.edges.strokeWidth * (h.from === be.value || h.id === z.value?.id ? 1.3 : 1),
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "marker-end": v(E).arrowShape === "undirected" ? null : `url(#${Nt(h.original?.color || u.value.style.chart.edges.stroke)})`,
+            style: { "pointer-events": "none", transition: "stroke-width 0.2s ease-in-out" }
+          }, null, 8, zr))), 128))
+        ]),
+        A(m.$slots, "svg", {
+          svg: {
+            drawingArea: v(St),
+            data: v(E)
+          }
+        }, void 0, !0)
+      ], 14, Cr)) : L("", !0),
+      m.$slots.watermark ? (k(), x("div", Br, [
+        A(m.$slots, "watermark", B(V({ isPrinting: v(pt) || v(wt) })), void 0, !0)
+      ])) : L("", !0),
+      ae(Vt, { name: "fade" }, {
+        default: T(() => [
+          Oe.value ? (k(), U(It, {
+            key: 0,
+            to: Q.value ? f.value : "body"
+          }, [
+            G("div", {
+              "data-cy-tooltip-midpoint": "",
+              ref_key: "tooltipRef",
+              ref: Se,
+              class: "vue-ui-dag-tooltip",
+              style: X({
+                ...Le.value,
+                maxWidth: u.value.style.chart.midpoints.tooltip.maxWidth,
+                "--vue-data-ui-dag-tooltip-background": u.value.style.chart.midpoints.tooltip.backgroundColor,
+                "--vue-data-ui-dag-tooltip-color": u.value.style.chart.midpoints.tooltip.color
+              }),
+              "data-position": he.value
+            }, [
+              A(m.$slots, "tooltip-midpoint", B(V({ edge: z.value, layoutData: v(E) })), () => [
+                z.value ? (k(), x("div", Ir, le(_t(z.value.from)?.label ?? z.value.from) + " → " + le(_t(z.value.to)?.label ?? z.value.to), 1)) : L("", !0)
+              ], !0)
+            ], 12, Vr)
+          ], 8, ["to"])) : L("", !0)
+        ]),
+        _: 3
+      }),
+      ae(Vt, { name: "fade" }, {
+        default: T(() => [
+          K.value ? (k(), U(It, {
+            key: 0,
+            to: Q.value ? f.value : "body"
+          }, [
+            G("div", {
+              "data-cy-tooltip-node": "",
+              ref_key: "nodeTooltipRef",
+              ref: Ve,
+              class: "vue-ui-dag-node-tooltip",
+              style: X({
+                maxWidth: u.value.style.chart.nodes.tooltip.maxWidth,
+                left: Ie.value.left,
+                top: Ie.value.top,
+                "--vue-data-ui-dag-node-tooltip-background": u.value.style.chart.nodes.tooltip.backgroundColor,
+                "--vue-data-ui-dag-node-tooltip-color": u.value.style.chart.nodes.tooltip.color
+              }),
+              "data-position": ft.value
+            }, [
+              A(m.$slots, "tooltip-node", B(V({ node: me.value, layoutData: v(E) })), () => [
+                me.value ? (k(), x("div", jr, le(me.value.label), 1)) : L("", !0)
+              ], !0)
+            ], 12, Gr)
+          ], 8, ["to"])) : L("", !0)
+        ]),
+        _: 3
+      }),
+      u.value.style.chart.controls.position === "bottom" && !v(ve) && u.value.style.chart.controls.show ? (k(), U(oo, {
+        key: 7,
+        ref_key: "zoomControls",
+        ref: _,
+        config: u.value,
+        scale: v(Lt),
+        isFullscreen: Q.value,
+        withDirection: "",
+        onZoomIn: Ye,
+        onZoomOut: He,
+        onResetZoom: p[2] || (p[2] = () => v(Te)(!0)),
+        onSwitchDirection: Ue
+      }, null, 8, ["config", "scale", "isFullscreen"])) : L("", !0),
+      m.$slots.source ? (k(), x("div", {
+        key: 8,
+        ref_key: "source",
+        ref: N,
+        dir: "auto"
+      }, [
+        A(m.$slots, "source", {}, void 0, !0)
+      ], 512)) : L("", !0),
+      v(ve) ? (k(), U(bn, { key: 9 })) : L("", !0)
+    ], 46, kr));
+  }
+}, Yr = /* @__PURE__ */ ro(Wr, [["__scopeId", "data-v-224df313"]]), fi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Yr
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ai as a,
+  fi as b,
+  ci as d,
+  wr as l,
+  di as m,
+  ui as s,
+  Yr as v
+};