vue-data-ui 3.15.12 → 3.16.1

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

@@ -0,0 +1,3047 @@
+import { ref as C, watchEffect as Bo, unref as y, defineAsyncComponent as _t, computed as I, toRefs as zo, onMounted as vn, nextTick as Se, watch as ze, onBeforeUnmount as gn, openBlock as S, createElementBlock as L, normalizeStyle as Le, normalizeClass as pn, createElementVNode as X, toDisplayString as Me, createBlock as oe, createCommentVNode as $, withCtx as V, renderSlot as R, normalizeProps as H, guardReactiveProps as W, createSlots as Vo, createVNode as Ct, Fragment as ge, renderList as Ve, mergeProps as Te, withModifiers as yn, createTextVNode as Ho, Transition as wn, Teleport as bn } from "vue";
+import { j as $t, aF as Wo, t as kn, o as Go, q as En, s as _n, X as jo, as as Yo } from "./lib-DBptbyyI.js";
+import { t as Uo, u as Zo } from "./useResponsive-DfdjqQps.js";
+import { u as Xo } from "./usePanZoom-CDF7rb3o.js";
+import { u as Ko } from "./useConfig-DO94Aj5s.js";
+import { u as qo, B as Jo } from "./BaseScanner-BhhkKVoj.js";
+import { u as Qo } from "./usePrinter-CEpYU3r5.js";
+import { u as es } from "./useSvgExport-ByUukOZt.js";
+import { u as xt } from "./useNestedProp-Bf5XFbs8.js";
+import { u as ts } from "./useThemeCheck-D1ZYXUwG.js";
+import { u as ns } from "./useUserOptionState-BIvW1Kz7.js";
+import { u as os } from "./useChartAccessibility-9icAAmYg.js";
+import ss from "./img-LXxMLmCg.js";
+import is from "./Title-BeMKE1cj.js";
+import rs from "./vue_ui_dag-ZOwuDBZ8.js";
+import { A as as } from "./A11yDataTable-KcVAX2cP.js";
+import { B as Cn } from "./BaseZoomControls-DievbOeJ.js";
+import { _ as ls } from "./_plugin-vue_export-helper-CHgC5LLL.js";
+const us = "\0", pe = "\0", xn = "
";
+class ue {
+  _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[pe] = {});
+  }
+  /* === 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((n) => Object.keys(t._in[n]).length === 0);
+  }
+  /**
+   * Gets list of nodes without out-edges.
+   * Complexity: O(|V|).
+   */
+  sinks() {
+    const t = this;
+    return this.nodes().filter((n) => Object.keys(t._out[n]).length === 0);
+  }
+  /**
+   * Invokes setNode method for each node in names list.
+   * Complexity: O(|names|).
+   */
+  setNodes(t, n) {
+    const o = arguments, s = this;
+    return t.forEach((r) => {
+      o.length > 1 ? s.setNode(r, n) : 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, n) {
+    return Object.hasOwn(this._nodes, t) ? (arguments.length > 1 && (this._nodes[t] = n), this) : (this._nodes[t] = arguments.length > 1 ? n : this._defaultNodeLabelFn(t), this._isCompound && (this._parent[t] = pe, this._children[t] = {}, this._children[pe][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 n = this;
+    if (Object.hasOwn(this._nodes, t)) {
+      const o = (s) => n.removeEdge(n._edgeObjs[s]);
+      delete this._nodes[t], this._isCompound && (this._removeFromParentsChildList(t), delete this._parent[t], this.children(t).forEach((s) => {
+        n.setParent(s);
+      }), delete this._children[t]), Object.keys(this._in[t]).forEach(o), delete this._in[t], delete this._preds[t], Object.keys(this._out[t]).forEach(o), 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, n) {
+    if (!this._isCompound)
+      throw new Error("Cannot set parent in a non-compound graph");
+    if (n === void 0)
+      n = pe;
+    else {
+      n += "";
+      for (let o = n; o !== void 0; o = this.parent(o))
+        if (o === t)
+          throw new Error(
+            "Setting " + n + " as parent of " + t + " would create a cycle"
+          );
+      this.setNode(n);
+    }
+    return this.setNode(t), this._removeFromParentsChildList(t), this._parent[t] = n, this._children[n][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 n = this._parent[t];
+      if (n !== pe)
+        return n;
+    }
+  }
+  /**
+   * Gets list of direct children of node nodeId.
+   * Complexity: O(1).
+   */
+  children(t = pe) {
+    if (this._isCompound) {
+      const n = this._children[t];
+      if (n)
+        return Object.keys(n);
+    } else {
+      if (t === pe)
+        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 n = this._preds[t];
+    if (n)
+      return Object.keys(n);
+  }
+  /**
+   * 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 n = this._sucs[t];
+    if (n)
+      return Object.keys(n);
+  }
+  /**
+   * 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 n = this.predecessors(t);
+    if (n) {
+      const o = new Set(n);
+      for (const s of this.successors(t))
+        o.add(s);
+      return Array.from(o.values());
+    }
+  }
+  isLeaf(t) {
+    let n;
+    return this.isDirected() ? n = this.successors(t) : n = this.neighbors(t), n.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 n = new this.constructor({
+      directed: this._isDirected,
+      multigraph: this._isMultigraph,
+      compound: this._isCompound
+    });
+    n.setGraph(this.graph());
+    const o = this;
+    Object.entries(this._nodes).forEach(([i, l]) => {
+      t(i) && n.setNode(i, l);
+    }), Object.values(this._edgeObjs).forEach((i) => {
+      n.hasNode(i.v) && n.hasNode(i.w) && n.setEdge(i, o.edge(i));
+    });
+    const s = {};
+    function r(i) {
+      const l = o.parent(i);
+      return l === void 0 || n.hasNode(l) ? (s[i] = l, l) : l in s ? s[l] : r(l);
+    }
+    return this._isCompound && n.nodes().forEach((i) => n.setParent(i, r(i))), n;
+  }
+  /* === 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, n) {
+    const o = this, s = arguments;
+    return t.reduce((r, i) => (s.length > 1 ? o.setEdge(r, i, n) : o.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, n, o, s, r = !1;
+    const i = arguments[0];
+    typeof i == "object" && i !== null && "v" in i ? (t = i.v, n = i.w, o = i.name, arguments.length === 2 && (s = arguments[1], r = !0)) : (t = i, n = arguments[1], o = arguments[3], arguments.length > 2 && (s = arguments[2], r = !0)), t = "" + t, n = "" + n, o !== void 0 && (o = "" + o);
+    let l = He(this._isDirected, t, n, o);
+    if (Object.hasOwn(this._edgeLabels, l))
+      return r && (this._edgeLabels[l] = s), this;
+    if (o !== void 0 && !this._isMultigraph)
+      throw new Error("Cannot set a named edge when isMultigraph = false");
+    this.setNode(t), this.setNode(n), this._edgeLabels[l] = r ? s : this._defaultEdgeLabelFn(t, n, o);
+    const u = cs(this._isDirected, t, n, o);
+    return t = u.v, n = u.w, Object.freeze(u), this._edgeObjs[l] = u, Nn(this._preds[n], t), Nn(this._sucs[t], n), this._in[n][l] = u, this._out[t][l] = u, this._edgeCount++, this;
+  }
+  /**
+   * Gets the label for the specified edge.
+   * Complexity: O(1).
+   */
+  edge(t, n, o) {
+    const s = arguments.length === 1 ? Nt(this._isDirected, arguments[0]) : He(this._isDirected, t, n, o);
+    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, n, o) {
+    const s = arguments.length === 1 ? Nt(this._isDirected, arguments[0]) : He(this._isDirected, t, n, o);
+    return Object.hasOwn(this._edgeLabels, s);
+  }
+  /**
+   * Removes the specified edge from the graph. No subgraphs are considered.
+   * Complexity: O(1).
+   */
+  removeEdge(t, n, o) {
+    const s = arguments.length === 1 ? Nt(this._isDirected, arguments[0]) : He(this._isDirected, t, n, o), r = this._edgeObjs[s];
+    return r && (t = r.v, n = r.w, delete this._edgeLabels[s], delete this._edgeObjs[s], Sn(this._preds[n], t), Sn(this._sucs[t], n), delete this._in[n][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, n) {
+    const o = this._in[t];
+    if (o) {
+      const s = Object.values(o);
+      return n ? s.filter((r) => r.v === n) : 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, n) {
+    const o = this._out[t];
+    if (o) {
+      const s = Object.values(o);
+      return n ? s.filter((r) => r.w === n) : 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, n) {
+    const o = this.inEdges(t, n);
+    if (o)
+      return o.concat(this.outEdges(t, n));
+  }
+}
+function Nn(e, t) {
+  e[t] ? e[t]++ : e[t] = 1;
+}
+function Sn(e, t) {
+  --e[t] || delete e[t];
+}
+function He(e, t, n, o) {
+  let s = "" + t, r = "" + n;
+  if (!e && s > r) {
+    const i = s;
+    s = r, r = i;
+  }
+  return s + xn + r + xn + (o === void 0 ? us : o);
+}
+function cs(e, t, n, o) {
+  let s = "" + t, r = "" + n;
+  if (!e && s > r) {
+    const l = s;
+    s = r, r = l;
+  }
+  const i = { v: s, w: r };
+  return o && (i.name = o), i;
+}
+function Nt(e, t) {
+  return He(e, t.v, t.w, t.name);
+}
+class ds {
+  constructor() {
+    const t = {};
+    t._next = t._prev = t, this._sentinel = t;
+  }
+  dequeue() {
+    const t = this._sentinel, n = t._prev;
+    if (n !== t)
+      return Ln(n), n;
+  }
+  enqueue(t) {
+    const n = this._sentinel;
+    t._prev && t._next && Ln(t), t._next = n._next, n._next._prev = t, n._next = t, t._prev = n;
+  }
+  toString() {
+    const t = [], n = this._sentinel;
+    let o = n._prev;
+    for (; o !== n; )
+      t.push(JSON.stringify(o, fs)), o = o._prev;
+    return "[" + t.join(", ") + "]";
+  }
+}
+function Ln(e) {
+  e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
+}
+function fs(e, t) {
+  if (e !== "_next" && e !== "_prev")
+    return t;
+}
+const hs = () => 1;
+function ms(e, t) {
+  if (e.nodeCount() <= 1)
+    return [];
+  const n = gs(e, t || hs);
+  return vs(n.graph, n.buckets, n.zeroIndex).flatMap((s) => e.outEdges(s.v, s.w));
+}
+function vs(e, t, n) {
+  let o = [];
+  const s = t[t.length - 1], r = t[0];
+  let i;
+  for (; e.nodeCount(); ) {
+    for (; i = r.dequeue(); )
+      St(e, t, n, i);
+    for (; i = s.dequeue(); )
+      St(e, t, n, i);
+    if (e.nodeCount()) {
+      for (let l = t.length - 2; l > 0; --l)
+        if (i = t[l].dequeue(), i) {
+          o = o.concat(St(e, t, n, i, !0));
+          break;
+        }
+    }
+  }
+  return o;
+}
+function St(e, t, n, o, s) {
+  const r = s ? [] : void 0;
+  return e.inEdges(o.v).forEach((i) => {
+    const l = e.edge(i), u = e.node(i.v);
+    s && r.push({ v: i.v, w: i.w }), u.out -= l, Rt(t, n, u);
+  }), e.outEdges(o.v).forEach((i) => {
+    const l = e.edge(i), u = e.node(i.w);
+    u.in -= l, Rt(t, n, u);
+  }), e.removeNode(o.v), r;
+}
+function gs(e, t) {
+  const n = new ue();
+  let o = 0, s = 0;
+  e.nodes().forEach((l) => {
+    n.setNode(l, { v: l, in: 0, out: 0 });
+  }), e.edges().forEach((l) => {
+    const u = n.edge(l.v, l.w) || 0, f = t(l), h = u + f;
+    n.setEdge(l.v, l.w, h), s = Math.max(s, n.node(l.v).out += f), o = Math.max(o, n.node(l.w).in += f);
+  });
+  const r = ps(s + o + 3).map(() => new ds()), i = o + 1;
+  return n.nodes().forEach((l) => {
+    Rt(r, i, n.node(l));
+  }), {
+    graph: n,
+    buckets: r,
+    zeroIndex: i
+  };
+}
+function Rt(e, t, n) {
+  n.out ? n.in ? e[n.out - n.in + t].enqueue(n) : e[e.length - 1].enqueue(n) : e[0].enqueue(n);
+}
+function ps(e) {
+  const t = [];
+  for (let n = 0; n < e; n++)
+    t.push(n);
+  return t;
+}
+function $e(e, t, n, o) {
+  let s = o;
+  for (; e.hasNode(s); )
+    s = Je(o);
+  return n.dummy = t, e.setNode(s, n), s;
+}
+function Bn(e) {
+  const t = new ue().setGraph(e.graph());
+  return e.nodes().forEach((n) => {
+    t.setNode(n, e.node(n));
+  }), e.edges().forEach((n) => {
+    const o = t.edge(n.v, n.w) || { weight: 0, minlen: 1 }, s = e.edge(n);
+    t.setEdge(n.v, n.w, {
+      weight: o.weight + s.weight,
+      minlen: Math.max(o.minlen, s.minlen)
+    });
+  }), t;
+}
+function Dt(e) {
+  const t = new ue({ multigraph: e.isMultigraph() }).setGraph(e.graph());
+  return e.nodes().forEach((n) => {
+    e.children(n).length || t.setNode(n, e.node(n));
+  }), e.edges().forEach((n) => {
+    t.setEdge(n, e.edge(n));
+  }), t;
+}
+function ys(e) {
+  const t = e.nodes().map((n) => {
+    const o = {};
+    return e.outEdges(n).forEach((s) => {
+      o[s.w] = (o[s.w] || 0) + e.edge(s).weight;
+    }), o;
+  });
+  return Qe(e.nodes(), t);
+}
+function ws(e) {
+  const t = e.nodes().map((n) => {
+    const o = {};
+    return e.inEdges(n).forEach((s) => {
+      o[s.v] = (o[s.v] || 0) + e.edge(s).weight;
+    }), o;
+  });
+  return Qe(e.nodes(), t);
+}
+function Pt(e, t) {
+  let n = e.x, o = e.y;
+  const s = t.x - n, r = t.y - o;
+  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 u, f;
+  return Math.abs(r) * i > Math.abs(s) * l ? (r < 0 && (l = -l), u = l * s / r, f = l) : (s < 0 && (i = -i), u = i, f = i * r / s), { x: n + u, y: o + f };
+}
+function Ge(e) {
+  const t = Oe(At(e) + 1).map(() => []);
+  return e.nodes().forEach((n) => {
+    const o = e.node(n), s = o.rank;
+    s !== void 0 && (t[s][o.order] = n);
+  }), t;
+}
+function zn(e) {
+  const t = e.nodes().map((o) => {
+    const s = e.node(o).rank;
+    return s === void 0 ? Number.MAX_VALUE : s;
+  }), n = J(Math.min, t);
+  e.nodes().forEach((o) => {
+    const s = e.node(o);
+    Object.hasOwn(s, "rank") && (s.rank -= n);
+  });
+}
+function Vn(e) {
+  const t = e.nodes().map((i) => e.node(i).rank).filter((i) => i !== void 0), n = J(Math.min, t), o = [];
+  e.nodes().forEach((i) => {
+    const l = e.node(i).rank - n;
+    o[l] || (o[l] = []), o[l].push(i);
+  });
+  let s = 0;
+  const r = e.graph().nodeRankFactor;
+  Array.from(o).forEach((i, l) => {
+    i === void 0 && l % r !== 0 ? --s : i !== void 0 && s && i.forEach((u) => {
+      e.node(u).rank += s;
+    });
+  });
+}
+function bs(e, t, n, o) {
+  const s = {
+    width: 0,
+    height: 0
+  };
+  return arguments.length >= 4 && (s.rank = n, s.order = o), $e(e, "border", s, t);
+}
+const Hn = 65535;
+function ks(e, t = Hn) {
+  const n = [];
+  for (let o = 0; o < e.length; o += t) {
+    const s = e.slice(o, o + t);
+    n.push(s);
+  }
+  return n;
+}
+function J(e, t) {
+  if (t.length > Hn) {
+    const n = ks(t);
+    return e.apply(
+      null,
+      n.map((o) => e.apply(null, o))
+    );
+  } else
+    return e.apply(null, t);
+}
+function At(e) {
+  const n = e.nodes().map((o) => {
+    const s = e.node(o).rank;
+    return s === void 0 ? Number.MIN_VALUE : s;
+  });
+  return J(Math.max, n);
+}
+function Wn(e, t) {
+  const n = { lhs: [], rhs: [] };
+  return e.forEach((o) => {
+    t(o) ? n.lhs.push(o) : n.rhs.push(o);
+  }), n;
+}
+function Gn(e, t) {
+  const n = Date.now();
+  try {
+    return t();
+  } finally {
+    console.log(e + " time: " + (Date.now() - n) + "ms");
+  }
+}
+function jn(e, t) {
+  return t();
+}
+let Es = 0;
+function Je(e) {
+  const t = ++Es;
+  return e + String(t);
+}
+function Oe(e, t, n = 1) {
+  t == null && (t = e, e = 0);
+  let o = (r) => r < t;
+  n < 0 && (o = (r) => t < r);
+  const s = [];
+  for (let r = e; o(r); r += n)
+    s.push(r);
+  return s;
+}
+function We(e, t) {
+  const n = {};
+  for (const o of t)
+    e[o] !== void 0 && (n[o] = e[o]);
+  return n;
+}
+function je(e, t) {
+  let n = t;
+  if (typeof t == "string") {
+    const o = t;
+    n = (s) => s[o];
+  }
+  return Object.entries(e).reduce((o, [s, r]) => (o[s] = n(r, s), o), {});
+}
+function Qe(e, t) {
+  return e.reduce((n, o, s) => (n[o] = t[s], n), {});
+}
+const qe = {
+  addBorderNode: bs,
+  addDummyNode: $e,
+  applyWithChunking: J,
+  asNonCompoundGraph: Dt,
+  buildLayerMatrix: Ge,
+  intersectRect: Pt,
+  mapValues: je,
+  maxRank: At,
+  normalizeRanks: zn,
+  notime: jn,
+  partition: Wn,
+  pick: We,
+  predecessorWeights: ws,
+  range: Oe,
+  removeEmptyRanks: Vn,
+  simplify: Bn,
+  successorWeights: ys,
+  time: Gn,
+  uniqueId: Je,
+  zipObject: Qe
+};
+function _s(e) {
+  (e.graph().acyclicer === "greedy" ? ms(e, n(e)) : xs(e)).forEach((o) => {
+    const s = e.edge(o);
+    e.removeEdge(o), s.forwardName = o.name, s.reversed = !0, e.setEdge(o.w, o.v, s, Je("rev"));
+  });
+  function n(o) {
+    return (s) => o.edge(s).weight;
+  }
+}
+function Cs(e) {
+  e.edges().forEach((t) => {
+    const n = e.edge(t);
+    if (n.reversed) {
+      e.removeEdge(t);
+      const o = n.forwardName;
+      delete n.reversed, delete n.forwardName, e.setEdge(t.w, t.v, n, o);
+    }
+  });
+}
+function xs(e) {
+  const t = [], n = {}, o = {};
+  function s(r) {
+    Object.hasOwn(o, r) || (o[r] = !0, n[r] = !0, e.outEdges(r).forEach((i) => {
+      Object.hasOwn(n, i.w) ? t.push(i) : s(i.w);
+    }), delete n[r]);
+  }
+  return e.nodes().forEach(s), t;
+}
+function Ns(e) {
+  e.graph().dummyChains = [], e.edges().forEach((t) => Ss(e, t));
+}
+function Ss(e, t) {
+  let n = t.v, o = e.node(n).rank;
+  const s = t.w, r = e.node(s).rank, i = t.name, l = e.edge(t), u = l.labelRank;
+  if (r === o + 1)
+    return;
+  e.removeEdge(t);
+  let f, h, m;
+  for (m = 0, ++o; o < r; ++m, ++o)
+    l.points = [], h = {
+      width: 0,
+      height: 0,
+      edgeLabel: l,
+      edgeObj: t,
+      rank: o
+    }, f = $e(e, "edge", h, "_d"), o === u && (h.width = l.width, h.height = l.height, h.dummy = "edge-label", h.labelpos = l.labelpos), e.setEdge(n, f, { weight: l.weight }, i), m === 0 && e.graph().dummyChains.push(f), n = f;
+  e.setEdge(n, s, { weight: l.weight }, i);
+}
+function Ls(e) {
+  e.graph().dummyChains.forEach((t) => {
+    let n = e.node(t);
+    const o = n.edgeLabel;
+    e.setEdge(n.edgeObj, o);
+    let s;
+    for (; n.dummy; )
+      s = e.successors(t)[0], e.removeNode(t), o.points.push({ x: n.x, y: n.y }), n.dummy === "edge-label" && (o.x = n.x, o.y = n.y, o.width = n.width, o.height = n.height), t = s, n = e.node(t);
+  });
+}
+function Yn(e) {
+  function t(n) {
+    const o = e.node(n);
+    if (o && Object.prototype.hasOwnProperty.call(o, "rank"))
+      return o.rank;
+    const s = e.outEdges(n) || [];
+    if (!s.length)
+      return o && (o.rank = 0), 0;
+    const r = s.map((l) => {
+      if (!e.node(l.w))
+        return Number.POSITIVE_INFINITY;
+      const f = t(l.w), h = e.edge(l).minlen;
+      return f - h;
+    });
+    let i = J(Math.min, r);
+    return i === Number.POSITIVE_INFINITY && (i = 0), o && (o.rank = i), i;
+  }
+  (e.sources() || []).forEach(t);
+}
+function Ms(e, t) {
+  return e.node(t.w).rank - e.node(t.v).rank - e.edge(t).minlen;
+}
+function Ts(e) {
+  Os(e);
+  const t = new ue();
+  e.nodes().forEach((r) => {
+    t.setNode(r, {});
+  });
+  const n = e.nodes();
+  if (!n.length)
+    return t;
+  const o = n[0], s = /* @__PURE__ */ new Set([o]);
+  for (; s.size < n.length; ) {
+    const r = $s(e, s);
+    if (!r) {
+      const h = n.find((m) => !s.has(m));
+      s.add(h), t.setNode(h, {});
+      continue;
+    }
+    const { edgeObject: i, delta: l, attachFrom: u, attachTo: f } = r;
+    Rs(e, s, u, l), t.setEdge(i.v, i.w, {}), s.add(f);
+  }
+  return t;
+}
+function Os(e) {
+  e.nodes().forEach((t) => {
+    const n = e.node(t) || {};
+    Object.prototype.hasOwnProperty.call(n, "rank") || (n.rank = 0, e.setNode(t, n));
+  });
+}
+function $s(e, t) {
+  let n = null;
+  return e.edges().forEach((o) => {
+    const s = t.has(o.v), r = t.has(o.w);
+    if (s === r)
+      return;
+    const i = Ms(e, o), l = Math.abs(i);
+    if (!n || l < n.absoluteSlack) {
+      const u = s ? o.v : o.w, f = s ? o.w : o.v, h = s ? i : -i;
+      n = {
+        edgeObject: o,
+        delta: h,
+        attachFrom: u,
+        attachTo: f,
+        absoluteSlack: l
+      };
+    }
+  }), n;
+}
+function Rs(e, t, n, o) {
+  o && e.nodes().forEach((s) => {
+    if (!t.has(s)) {
+      const r = e.node(s);
+      r.rank += o;
+    }
+  });
+}
+function Re(e) {
+  const t = Bn(e);
+  return Yn(t), t.nodes().forEach((n) => {
+    const o = t.node(n), s = e.node(n) || {};
+    s.rank = o.rank, e.setNode(n, s);
+  }), e;
+}
+function Ps(e, t) {
+}
+function Ds(e, t) {
+}
+function As(e, t, n) {
+  return 0;
+}
+function Fs(e) {
+  return null;
+}
+function Is(e, t) {
+  return null;
+}
+Re.initLowLimValues = Ps;
+Re.initCutValues = Ds;
+Re.calcCutValue = As;
+Re.leaveEdge = Fs;
+Re.enterEdge = Is;
+const Un = Yn;
+function Bs(e) {
+  const t = e.graph().ranker;
+  if (t instanceof Function)
+    return t(e);
+  switch (e.graph().ranker) {
+    case "network-simplex":
+      Mn(e);
+      break;
+    case "tight-tree":
+      Vs(e);
+      break;
+    case "longest-path":
+      zs(e);
+      break;
+    case "none":
+      break;
+    default:
+      Mn(e);
+  }
+}
+const zs = Un;
+function Vs(e) {
+  Un(e), Ts(e);
+}
+function Mn(e) {
+  Re(e);
+}
+function Hs(e) {
+  const t = Gs(e);
+  e.graph().dummyChains.forEach((n) => {
+    let o = e.node(n);
+    const s = o.edgeObj, r = Ws(e, t, s.v, s.w), i = r.path, l = r.lca;
+    let u = 0, f = i[u], h = !0, m = n;
+    for (; m !== s.w; ) {
+      if (o = e.node(m), h) {
+        for (; (f = i[u]) !== l && e.node(f).maxRank < o.rank; )
+          u++;
+        f === l && (h = !1);
+      }
+      if (!h) {
+        for (; u < i.length - 1 && e.node(f = i[u + 1]).minRank <= o.rank; )
+          u++;
+        f = i[u];
+      }
+      e.setParent(m, f), m = e.successors(m)[0];
+    }
+  });
+}
+function Ws(e, t, n, o) {
+  const s = [], r = [], i = Math.min(t[n].low, t[o].low), l = Math.max(t[n].lim, t[o].lim);
+  let u, f;
+  u = n;
+  do
+    u = e.parent(u), s.push(u);
+  while (u && (t[u].low > i || l > t[u].lim));
+  for (f = u, u = o; (u = e.parent(u)) !== f; )
+    r.push(u);
+  return {
+    path: s.concat(r.reverse()),
+    lca: f
+  };
+}
+function Gs(e) {
+  const t = {};
+  let n = 0;
+  function o(s) {
+    const r = n;
+    e.children(s).forEach(o), t[s] = { low: r, lim: n++ };
+  }
+  return e.children().forEach(o), t;
+}
+function js(e) {
+  const t = qe.addDummyNode(e, "root", {}, "_root"), n = Ys(e), o = Object.values(n), s = qe.applyWithChunking(Math.max, o) - 1, r = 2 * s + 1;
+  e.graph().nestingRoot = t, e.edges().forEach((l) => {
+    e.edge(l).minlen *= r;
+  });
+  const i = Us(e) + 1;
+  e.children().forEach((l) => {
+    Zn(e, t, r, i, s, n, l);
+  }), e.graph().nodeRankFactor = r;
+}
+function Zn(e, t, n, o, s, r, i) {
+  const l = e.children(i);
+  if (!l.length) {
+    i !== t && e.setEdge(t, i, { weight: 0, minlen: n });
+    return;
+  }
+  const u = qe.addBorderNode(e, "_bt"), f = qe.addBorderNode(e, "_bb"), h = e.node(i);
+  e.setParent(u, i), h.borderTop = u, e.setParent(f, i), h.borderBottom = f, l.forEach((m) => {
+    Zn(e, t, n, o, s, r, m);
+    const p = e.node(m), _ = p.borderTop ? p.borderTop : m, O = p.borderBottom ? p.borderBottom : m, M = p.borderTop ? o : 2 * o, z = _ !== O ? 1 : s - r[i] + 1;
+    e.setEdge(u, _, {
+      weight: M,
+      minlen: z,
+      nestingEdge: !0
+    }), e.setEdge(O, f, {
+      weight: M,
+      minlen: z,
+      nestingEdge: !0
+    });
+  }), e.parent(i) || e.setEdge(t, u, {
+    weight: 0,
+    minlen: s + r[i]
+  });
+}
+function Ys(e) {
+  const t = {};
+  function n(o, s) {
+    const r = e.children(o);
+    r && r.length && r.forEach((i) => n(i, s + 1)), t[o] = s;
+  }
+  return e.children().forEach((o) => n(o, 1)), t;
+}
+function Us(e) {
+  return e.edges().reduce((t, n) => t + e.edge(n).weight, 0);
+}
+function Zs(e) {
+  const t = e.graph();
+  e.removeNode(t.nestingRoot), delete t.nestingRoot, e.edges().forEach((n) => {
+    e.edge(n).nestingEdge && e.removeEdge(n);
+  });
+}
+function Xs(e) {
+  function t(n) {
+    const o = e.children(n), s = e.node(n);
+    if (o.length && o.forEach(t), Object.hasOwn(s, "minRank")) {
+      s.borderLeft = [], s.borderRight = [];
+      for (let r = s.minRank, i = s.maxRank + 1; r < i; ++r)
+        Tn(e, "borderLeft", "_bl", n, s, r), Tn(e, "borderRight", "_br", n, s, r);
+    }
+  }
+  e.children().forEach(t);
+}
+function Tn(e, t, n, o, s, r) {
+  const i = {
+    width: 0,
+    height: 0,
+    rank: r,
+    borderType: t
+  }, l = s[t][r - 1], u = $e(e, "border", i, n);
+  s[t][r] = u, e.setParent(u, o), l && e.setEdge(l, u, { weight: 1 });
+}
+function Ks(e) {
+  const t = e.graph().rankdir.toLowerCase();
+  (t === "lr" || t === "rl") && Xn(e);
+}
+function qs(e) {
+  const t = e.graph().rankdir.toLowerCase();
+  (t === "bt" || t === "rl") && Js(e), (t === "lr" || t === "rl") && (Qs(e), Xn(e));
+}
+function Xn(e) {
+  e.nodes().forEach((t) => {
+    On(e.node(t));
+  }), e.edges().forEach((t) => {
+    On(e.edge(t));
+  });
+}
+function On(e) {
+  const t = e.width;
+  e.width = e.height, e.height = t;
+}
+function Js(e) {
+  e.nodes().forEach((t) => {
+    Lt(e.node(t));
+  }), e.edges().forEach((t) => {
+    const n = e.edge(t);
+    n.points.forEach(Lt), Object.hasOwn(n, "y") && Lt(n);
+  });
+}
+function Lt(e) {
+  e.y = -e.y;
+}
+function Qs(e) {
+  e.nodes().forEach((t) => {
+    Mt(e.node(t));
+  }), e.edges().forEach((t) => {
+    const n = e.edge(t);
+    n.points.forEach(Mt), Object.hasOwn(n, "x") && Mt(n);
+  });
+}
+function Mt(e) {
+  const t = e.x;
+  e.x = e.y, e.y = t;
+}
+const $n = {
+  adjust: Ks,
+  undo: qs
+};
+function ei(e) {
+  const t = {}, n = e.nodes().filter((u) => e.children(u).length === 0), o = n.map((u) => e.node(u).rank), s = J(Math.max, o), r = Oe(s + 1).map(() => []);
+  function i(u) {
+    if (t[u]) return;
+    t[u] = !0;
+    const f = e.node(u);
+    r[f.rank].push(u), e.successors(u).forEach(i);
+  }
+  return n.sort(
+    (u, f) => e.node(u).rank - e.node(f).rank
+  ).forEach(i), r;
+}
+function ti(e, t) {
+  let n = 0;
+  for (let o = 1; o < t.length; ++o)
+    n += ni(e, t[o - 1], t[o]);
+  return n;
+}
+function ni(e, t, n) {
+  const o = Qe(
+    n,
+    n.map((f, h) => h)
+  ), s = t.flatMap((f) => e.outEdges(f).map((h) => ({
+    pos: o[h.w],
+    weight: e.edge(h).weight
+  })).sort((h, m) => h.pos - m.pos));
+  let r = 1;
+  for (; r < n.length; ) r <<= 1;
+  const i = 2 * r - 1;
+  r -= 1;
+  const l = new Array(i).fill(0);
+  let u = 0;
+  return s.forEach((f) => {
+    let h = f.pos + r;
+    l[h] += f.weight;
+    let m = 0;
+    for (; h > 0; )
+      h % 2 && (m += l[h + 1]), h = h - 1 >> 1, l[h] += f.weight;
+    u += f.weight * m;
+  }), u;
+}
+function oi(e, t = []) {
+  return t.map((n) => {
+    const o = e.inEdges(n);
+    if (!o.length)
+      return { v: n };
+    const s = o.reduce(
+      (r, i) => {
+        const l = e.edge(i), u = e.node(i.v);
+        return {
+          sum: r.sum + l.weight * u.order,
+          weight: r.weight + l.weight
+        };
+      },
+      { sum: 0, weight: 0 }
+    );
+    return {
+      v: n,
+      barycenter: s.sum / s.weight,
+      weight: s.weight
+    };
+  });
+}
+function si(e, t) {
+  const n = {};
+  e.forEach((s, r) => {
+    const i = n[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 = n[s.v], i = n[s.w];
+    r !== void 0 && i !== void 0 && (i.indegree++, r.out.push(i));
+  });
+  const o = Object.values(n).filter((s) => !s.indegree);
+  return ii(o);
+}
+function ii(e) {
+  const t = [];
+  function n(s) {
+    return (r) => {
+      r.merged || (r.barycenter === void 0 || s.barycenter === void 0 || r.barycenter >= s.barycenter) && ri(s, r);
+    };
+  }
+  function o(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(n(s)), s.out.forEach(o(s));
+  }
+  return t.filter((s) => !s.merged).map((s) => We(s, ["vs", "i", "barycenter", "weight"]));
+}
+function ri(e, t) {
+  let n = 0, o = 0;
+  e.weight && (n += e.barycenter * e.weight, o += e.weight), t.weight && (n += t.barycenter * t.weight, o += t.weight), e.vs = t.vs.concat(e.vs), e.barycenter = n / o, e.weight = o, e.i = Math.min(t.i, e.i), t.merged = !0;
+}
+function ai(e, t) {
+  const n = Wn(e, (h) => Object.hasOwn(h, "barycenter")), o = n.lhs, s = n.rhs.sort((h, m) => m.i - h.i), r = [];
+  let i = 0, l = 0, u = 0;
+  o.sort(li(!!t)), u = Rn(r, s, u), o.forEach((h) => {
+    u += h.vs.length, r.push(h.vs), i += h.barycenter * h.weight, l += h.weight, u = Rn(r, s, u);
+  });
+  const f = { vs: r.flat(!0) };
+  return l && (f.barycenter = i / l, f.weight = l), f;
+}
+function Rn(e, t, n) {
+  let o;
+  for (; t.length && (o = t[t.length - 1]).i <= n; )
+    t.pop(), e.push(o.vs), n++;
+  return n;
+}
+function li(e) {
+  return (t, n) => t.barycenter < n.barycenter ? -1 : t.barycenter > n.barycenter ? 1 : e ? n.i - t.i : t.i - n.i;
+}
+function Kn(e, t, n, o) {
+  let s = e.children(t);
+  const r = e.node(t), i = r ? r.borderLeft : void 0, l = r ? r.borderRight : void 0, u = {};
+  i && (s = s.filter((p) => p !== i && p !== l));
+  const f = oi(e, s);
+  f.forEach((p) => {
+    if (e.children(p.v).length) {
+      const _ = Kn(e, p.v, n, o);
+      u[p.v] = _, Object.hasOwn(_, "barycenter") && ci(p, _);
+    }
+  });
+  let h = si(f, n);
+  ui(h, u);
+  const m = ai(h, o);
+  if (i && (m.vs = [i, m.vs, l].flat(!0), e.predecessors(i).length)) {
+    const p = e.node(e.predecessors(i)[0]), _ = e.node(e.predecessors(l)[0]);
+    Object.hasOwn(m, "barycenter") || (m.barycenter = 0, m.weight = 0), m.barycenter = (m.barycenter * m.weight + p.order + _.order) / (m.weight + 2), m.weight += 2;
+  }
+  return m;
+}
+function ui(e, t) {
+  e.forEach((n) => {
+    n.vs = n.vs.flatMap((o) => t[o] ? t[o].vs : o);
+  });
+}
+function ci(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 di(e, t, n, o) {
+  o || (o = e.nodes());
+  const s = fi(e), r = new ue({ compound: !0 }).setGraph({ root: s }).setDefaultNodeLabel((i) => e.node(i));
+  return o.forEach((i) => {
+    const l = e.node(i), u = e.parent(i);
+    (l.rank === t || l.minRank <= t && t <= l.maxRank) && (r.setNode(i), r.setParent(i, u || s), e[n](i).forEach((h) => {
+      const m = h.v === i ? h.w : h.v, p = r.edge(m, i), _ = p ? p.weight : 0;
+      r.setEdge(m, i, {
+        weight: e.edge(h).weight + _
+      });
+    }), Object.hasOwn(l, "minRank") && r.setNode(i, {
+      borderLeft: l.borderLeft[t],
+      borderRight: l.borderRight[t]
+    }));
+  }), r;
+}
+function fi(e) {
+  let t;
+  for (; e.hasNode(t = Je("_root")); ) ;
+  return t;
+}
+function hi(e, t, n) {
+  let o = {}, s;
+  n.forEach((r) => {
+    let i = e.parent(r), l, u;
+    for (; i; ) {
+      if (l = e.parent(i), l ? (u = o[l], o[l] = i) : (u = s, s = i), u && u !== i) {
+        t.setEdge(u, i);
+        return;
+      }
+      i = l;
+    }
+  });
+}
+function qn(e, t = {}) {
+  if (typeof t.customOrder == "function") {
+    t.customOrder(e, qn);
+    return;
+  }
+  const n = At(e), o = Pn(
+    e,
+    Oe(1, n + 1),
+    "inEdges"
+  ), s = Pn(
+    e,
+    Oe(n - 1, -1, -1),
+    "outEdges"
+  );
+  let r = ei(e);
+  if (Dn(e, r), t.disableOptimalOrderHeuristic)
+    return;
+  let i = Number.POSITIVE_INFINITY, l;
+  const u = t.constraints || [];
+  for (let f = 0, h = 0; h < 4; ++f, ++h) {
+    const m = f % 2 === 0 ? o : s, p = f % 4 >= 2;
+    mi(m, p, u), r = Ge(e);
+    const _ = ti(e, r);
+    _ < i ? (i = _, h = 0, l = structuredClone(r)) : _ === i && (l = structuredClone(r));
+  }
+  Dn(e, l);
+}
+function Pn(e, t, n) {
+  const o = /* @__PURE__ */ new Map();
+  function s(r, i) {
+    o.has(r) || o.set(r, []), o.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) => di(
+      e,
+      r,
+      n,
+      o.get(r) || []
+    )
+  );
+}
+function mi(e, t, n) {
+  const o = new ue();
+  e.forEach((s) => {
+    n.forEach((l) => o.setEdge(l.left, l.right));
+    const r = s.graph().root, i = Kn(s, r, o, t);
+    i.vs.forEach((l, u) => {
+      s.node(l).order = u;
+    }), hi(s, o, i.vs);
+  });
+}
+function Dn(e, t) {
+  Object.values(t).forEach((n) => {
+    n.forEach((o, s) => {
+      e.node(o).order = s;
+    });
+  });
+}
+function vi(e, t) {
+  const n = {};
+  function o(s, r) {
+    let i = 0, l = 0;
+    const u = s.length, f = r[r.length - 1];
+    return r.forEach((h, m) => {
+      const p = pi(e, h), _ = p ? e.node(p).order : u;
+      (p || h === f) && (r.slice(l, m + 1).forEach((O) => {
+        e.predecessors(O).forEach((M) => {
+          const z = e.node(M), se = z.order;
+          (se < i || _ < se) && !(z.dummy && e.node(O).dummy) && Jn(n, M, O);
+        });
+      }), l = m + 1, i = _);
+    }), r;
+  }
+  return t.length && t.reduce(o), n;
+}
+function gi(e, t) {
+  const n = {};
+  function o(r, i, l, u, f) {
+    let h;
+    Oe(i, l).forEach((m) => {
+      h = r[m], e.node(h).dummy && e.predecessors(h).forEach((p) => {
+        const _ = e.node(p);
+        _.dummy && (_.order < u || _.order > f) && Jn(n, p, h);
+      });
+    });
+  }
+  function s(r, i) {
+    let l = -1, u, f = 0;
+    return i.forEach((h, m) => {
+      if (e.node(h).dummy === "border") {
+        const p = e.predecessors(h);
+        p.length && (u = e.node(p[0]).order, o(i, f, m, l, u), f = m, l = u);
+      }
+      o(i, f, i.length, u, r.length);
+    }), i;
+  }
+  return t.length && t.reduce(s), n;
+}
+function pi(e, t) {
+  if (e.node(t).dummy)
+    return e.predecessors(t).find((n) => e.node(n).dummy);
+}
+function Jn(e, t, n) {
+  if (t > n) {
+    const s = t;
+    t = n, n = s;
+  }
+  let o = e[t];
+  o || (e[t] = o = {}), o[n] = !0;
+}
+function yi(e, t, n) {
+  if (t > n) {
+    const o = t;
+    t = n, n = o;
+  }
+  return !!e[t] && Object.hasOwn(e[t], n);
+}
+function wi(e, t, n, o) {
+  const s = {}, r = {}, i = {};
+  return t.forEach((l) => {
+    l.forEach((u, f) => {
+      s[u] = u, r[u] = u, i[u] = f;
+    });
+  }), t.forEach((l) => {
+    let u = -1;
+    l.forEach((f) => {
+      let h = o(f);
+      if (h.length) {
+        h = h.sort((p, _) => i[p] - i[_]);
+        const m = (h.length - 1) / 2;
+        for (let p = Math.floor(m), _ = Math.ceil(m); p <= _; ++p) {
+          const O = h[p];
+          r[f] === f && u < i[O] && !yi(n, f, O) && (r[O] = f, r[f] = s[f] = s[O], u = i[O]);
+        }
+      }
+    });
+  }), { root: s, align: r };
+}
+function bi(e, t, n, o, s) {
+  const r = {}, i = ki(e, t, n, s), l = s ? "borderLeft" : "borderRight";
+  function u(m, p) {
+    const _ = i.nodes().slice(), O = {};
+    let M = _.pop();
+    for (; M; ) {
+      if (O[M])
+        m(M);
+      else {
+        O[M] = !0, _.push(M);
+        for (const z of p(M))
+          _.push(z);
+      }
+      M = _.pop();
+    }
+  }
+  function f(m) {
+    r[m] = i.inEdges(m).reduce((p, _) => Math.max(p, r[_.v] + i.edge(_)), 0);
+  }
+  function h(m) {
+    const p = i.outEdges(m).reduce((O, M) => Math.min(O, r[M.w] - i.edge(M)), Number.POSITIVE_INFINITY), _ = e.node(m);
+    p !== Number.POSITIVE_INFINITY && _.borderType !== l && (r[m] = Math.max(r[m], p));
+  }
+  return u(f, i.predecessors.bind(i)), u(h, i.successors.bind(i)), Object.keys(o).forEach((m) => {
+    r[m] = r[n[m]];
+  }), r;
+}
+function ki(e, t, n, o) {
+  const s = new e.constructor(), r = e.graph(), i = Ni(r.nodesep, r.edgesep, o);
+  return t.forEach((l) => {
+    let u;
+    l.forEach((f) => {
+      const h = n[f];
+      if (s.setNode(h), u) {
+        const m = n[u], p = s.edge(m, h);
+        s.setEdge(
+          m,
+          h,
+          Math.max(i(e, f, u), p || 0)
+        );
+      }
+      u = f;
+    });
+  }), s;
+}
+function Ei(e, t) {
+  return Object.values(t).reduce(
+    (n, o) => {
+      let s = Number.NEGATIVE_INFINITY, r = Number.POSITIVE_INFINITY;
+      Object.entries(o).forEach(([l, u]) => {
+        const f = Si(e, l) / 2;
+        s = Math.max(u + f, s), r = Math.min(u - f, r);
+      });
+      const i = s - r;
+      return i < n[0] && (n = [i, o]), n;
+    },
+    [Number.POSITIVE_INFINITY, null]
+  )[1];
+}
+function _i(e, t) {
+  const n = Object.values(t), o = J(Math.min, n), s = J(Math.max, n);
+  ["u", "d"].forEach((r) => {
+    ["l", "r"].forEach((i) => {
+      const l = r + i;
+      let u = e[l];
+      if (u === t) return;
+      const f = Object.values(u);
+      let h = o - J(Math.min, f);
+      i !== "l" && (h = s - J(Math.max, f)), h && (u = je(u, (m) => m + h), e[l] = u);
+    });
+  });
+}
+function Ci(e, t) {
+  return je(e.ul, (n, o) => {
+    if (t)
+      return e[t.toLowerCase()][o];
+    const s = Object.values(e).map((r) => r[o]).sort((r, i) => r - i);
+    return (s[1] + s[2]) / 2;
+  });
+}
+function xi(e) {
+  const t = Ge(e), n = Object.assign(
+    vi(e, t),
+    gi(e, t)
+  ), o = {};
+  let s;
+  ["u", "d"].forEach((i) => {
+    s = i === "u" ? t : Object.values(t).reverse(), ["l", "r"].forEach((l) => {
+      let u = s;
+      l === "r" && (u = u.map(
+        (p) => Object.values(p).reverse()
+      ));
+      const f = (i === "u" ? e.predecessors : e.successors).bind(e), h = wi(
+        e,
+        u,
+        n,
+        f
+      );
+      let m = bi(
+        e,
+        u,
+        h.root,
+        h.align,
+        l === "r"
+      );
+      l === "r" && (m = je(m, (p) => -p)), o[i + l] = m;
+    });
+  });
+  const r = Ei(e, o);
+  return _i(o, r), Ci(o, e.graph().align);
+}
+function Ni(e, t, n) {
+  return (o, s, r) => {
+    const i = o.node(s), l = o.node(r);
+    let u = 0, f;
+    if (u += i.width / 2, Object.hasOwn(i, "labelpos"))
+      switch (i.labelpos.toLowerCase()) {
+        case "l":
+          f = -i.width / 2;
+          break;
+        case "r":
+          f = i.width / 2;
+          break;
+      }
+    if (f && (u += n ? f : -f), f = 0, u += (i.dummy ? t : e) / 2, u += (l.dummy ? t : e) / 2, u += l.width / 2, Object.hasOwn(l, "labelpos"))
+      switch (l.labelpos.toLowerCase()) {
+        case "l":
+          f = l.width / 2;
+          break;
+        case "r":
+          f = -l.width / 2;
+          break;
+      }
+    return f && (u += n ? f : -f), f = 0, u;
+  };
+}
+function Si(e, t) {
+  return e.node(t).width;
+}
+function Li(e) {
+  const t = Dt(e);
+  Mi(t);
+  const n = xi(t);
+  Object.entries(n).forEach(([o, s]) => {
+    e.node(o).x = s;
+  });
+}
+function Mi(e) {
+  const t = Ge(e), n = e.graph().ranksep;
+  let o = 0;
+  t.forEach((s) => {
+    const r = s.reduce((i, l) => {
+      const u = e.node(l).height;
+      return i > u ? i : u;
+    }, 0);
+    s.forEach((i) => {
+      e.node(i).y = o + r / 2;
+    }), o += r + n;
+  });
+}
+function Ti(e, t = {}) {
+  const n = t.debugTiming ? Gn : jn;
+  return n("layout", () => {
+    const o = n("  buildLayoutGraph", () => zi(e));
+    return n("  runLayout", () => Oi(o, n, t)), n("  updateInputGraph", () => $i(e, o)), o;
+  });
+}
+function Oi(e, t, n) {
+  t("    makeSpaceForEdgeLabels", () => Vi(e)), t("    removeSelfEdges", () => Ki(e)), t("    acyclic", () => _s(e)), t("    nestingGraph.run", () => js(e)), t("    rank", () => Bs(Dt(e))), t("    injectEdgeLabelProxies", () => Hi(e)), t("    removeEmptyRanks", () => Vn(e)), t("    nestingGraph.cleanup", () => Zs(e)), t("    normalizeRanks", () => zn(e)), t("    assignRankMinMax", () => Wi(e)), t("    removeEdgeLabelProxies", () => Gi(e)), t("    normalize.run", () => Ns(e)), t("    parentDummyChains", () => Hs(e)), t("    addBorderSegments", () => Xs(e)), t("    order", () => qn(e, n)), t("    insertSelfEdges", () => qi(e)), t("    adjustCoordinateSystem", () => $n.adjust(e)), t("    position", () => Li(e)), t("    positionSelfEdges", () => Ji(e)), t("    removeBorderNodes", () => Xi(e)), t("    normalize.undo", () => Ls(e)), t("    fixupEdgeLabelCoords", () => Ui(e)), t("    undoCoordinateSystem", () => $n.undo(e)), t("    translateGraph", () => ji(e)), t("    assignNodeIntersects", () => Yi(e)), t("    reversePoints", () => Zi(e)), t("    acyclic.undo", () => Cs(e));
+}
+function $i(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 n = t.graph(), o = e.graph();
+  o.width = n.width, o.height = n.height;
+}
+const Ri = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"], Pi = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" }, Di = ["acyclicer", "ranker", "rankdir", "align"], Ai = ["width", "height", "rank"], An = { width: 0, height: 0 }, Fi = ["minlen", "weight", "width", "height", "labeloffset"], Ii = {
+  minlen: 1,
+  weight: 1,
+  width: 0,
+  height: 0,
+  labeloffset: 10,
+  labelpos: "r"
+}, Bi = ["labelpos", "arrowshape"];
+function zi(e) {
+  const t = Ot(e.graph()), n = {
+    ...Pi,
+    ...Tt(t, Ri),
+    ...We(t, Di)
+  }, o = new ue({ multigraph: !0, compound: !0 });
+  return o.setGraph(n), e.nodes().forEach((s) => {
+    const r = Ot(e.node(s)), i = Tt(r, Ai);
+    Object.keys(An).forEach((l) => {
+      i[l] === void 0 && (i[l] = An[l]);
+    }), o.setNode(s, i), o.setParent(s, e.parent(s));
+  }), e.edges().forEach((s) => {
+    const r = Ot(e.edge(s));
+    o.setEdge(
+      s,
+      {
+        ...Ii,
+        ...Tt(r, Fi),
+        ...We(r, Bi)
+      }
+    );
+  }), o;
+}
+function Vi(e) {
+  const t = e.graph();
+  t.ranksep /= 2, e.edges().forEach((n) => {
+    const o = e.edge(n);
+    o.minlen *= 2, o.labelpos.toLowerCase() !== "c" && (t.rankdir === "TB" || t.rankdir === "BT" ? o.width += o.labeloffset : o.height += o.labeloffset);
+  });
+}
+function Hi(e) {
+  e.edges().forEach((t) => {
+    const n = e.edge(t);
+    if (n.width && n.height) {
+      const o = e.node(t.v), r = { rank: (e.node(t.w).rank - o.rank) / 2 + o.rank, e: t };
+      $e(e, "edge-proxy", r, "_ep");
+    }
+  });
+}
+function Wi(e) {
+  let t = 0;
+  e.nodes().forEach((n) => {
+    const o = e.node(n);
+    o.borderTop && (o.minRank = e.node(o.borderTop).rank, o.maxRank = e.node(o.borderBottom).rank, t = Math.max(t, o.maxRank));
+  }), e.graph().maxRank = t;
+}
+function Gi(e) {
+  e.nodes().forEach((t) => {
+    const n = e.node(t);
+    n.dummy === "edge-proxy" && (e.edge(n.e).labelRank = n.rank, e.removeNode(t));
+  });
+}
+function ji(e) {
+  let t = Number.POSITIVE_INFINITY, n = 0, o = Number.POSITIVE_INFINITY, s = 0;
+  const r = e.graph(), i = r.marginx || 0, l = r.marginy || 0;
+  function u(f) {
+    const h = f.x, m = f.y, p = f.width, _ = f.height;
+    t = Math.min(t, h - p / 2), n = Math.max(n, h + p / 2), o = Math.min(o, m - _ / 2), s = Math.max(s, m + _ / 2);
+  }
+  e.nodes().forEach((f) => u(e.node(f))), e.edges().forEach((f) => {
+    const h = e.edge(f);
+    Object.hasOwn(h, "x") && u(h);
+  }), t -= i, o -= l, e.nodes().forEach((f) => {
+    const h = e.node(f);
+    h.x -= t, h.y -= o;
+  }), e.edges().forEach((f) => {
+    const h = e.edge(f);
+    h.points.forEach((m) => {
+      m.x -= t, m.y -= o;
+    }), Object.hasOwn(h, "x") && (h.x -= t), Object.hasOwn(h, "y") && (h.y -= o);
+  }), r.width = n - t + i, r.height = s - o + l;
+}
+function Fn(e, t, n) {
+  if (!t)
+    return e;
+  const o = t.x - e.x, s = t.y - e.y, r = Math.sqrt(o * o + s * s);
+  if (!r || r <= n)
+    return e;
+  const i = n / r;
+  return {
+    x: e.x + o * i,
+    y: e.y + s * i
+  };
+}
+function Yi(e) {
+  e.edges().forEach((n) => {
+    const o = e.edge(n), s = e.node(n.v), r = e.node(n.w);
+    let i, l;
+    !o.points || !o.points.length ? (o.points = [], i = r, l = s) : (i = o.points[0], l = o.points[o.points.length - 1]);
+    const u = Pt(s, i), f = Pt(r, l), h = o.points.length ? o.points[0] : i, m = o.points.length ? o.points[o.points.length - 1] : l, p = o.arrowshape, _ = p === "normal" || p === "vee", O = !!o.reversed;
+    let M = u, z = f;
+    _ && (O ? M = Fn(u, h, 4) : z = Fn(f, m, 4)), o.points.unshift(M), o.points.push(z);
+  });
+}
+function Ui(e) {
+  e.edges().forEach((t) => {
+    const n = e.edge(t);
+    if (Object.hasOwn(n, "x"))
+      switch ((n.labelpos === "l" || n.labelpos === "r") && (n.width -= n.labeloffset), n.labelpos) {
+        case "l":
+          n.x -= n.width / 2 + n.labeloffset;
+          break;
+        case "r":
+          n.x += n.width / 2 + n.labeloffset;
+          break;
+      }
+  });
+}
+function Zi(e) {
+  e.edges().forEach((t) => {
+    const n = e.edge(t);
+    n.reversed && n.points.reverse();
+  });
+}
+function Xi(e) {
+  e.nodes().forEach((t) => {
+    if (e.children(t).length) {
+      const n = e.node(t), o = e.node(n.borderTop), s = e.node(n.borderBottom), r = e.node(n.borderLeft[n.borderLeft.length - 1]), i = e.node(n.borderRight[n.borderRight.length - 1]);
+      n.width = Math.abs(i.x - r.x), n.height = Math.abs(s.y - o.y), n.x = r.x + n.width / 2, n.y = o.y + n.height / 2;
+    }
+  }), e.nodes().forEach((t) => {
+    e.node(t).dummy === "border" && e.removeNode(t);
+  });
+}
+function Ki(e) {
+  e.edges().forEach((t) => {
+    if (t.v === t.w) {
+      const n = e.node(t.v);
+      n.selfEdges || (n.selfEdges = []), n.selfEdges.push({ e: t, label: e.edge(t) }), e.removeEdge(t);
+    }
+  });
+}
+function qi(e) {
+  Ge(e).forEach((n) => {
+    let o = 0;
+    n.forEach((s, r) => {
+      const i = e.node(s);
+      i.order = r + o, (i.selfEdges || []).forEach((l) => {
+        $e(e, "selfedge", {
+          width: l.label.width,
+          height: l.label.height,
+          rank: i.rank,
+          order: r + ++o,
+          e: l.e,
+          label: l.label
+        }, "_se");
+      }), delete i.selfEdges;
+    });
+  });
+}
+function Ji(e) {
+  e.nodes().forEach((t) => {
+    const n = e.node(t);
+    if (n.dummy === "selfedge") {
+      const o = e.node(n.e.v), s = o.x + o.width / 2, r = o.y, i = n.x - s, l = o.height / 2;
+      e.setEdge(n.e, n.label), e.removeNode(t), n.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 }
+      ], n.label.x = n.x, n.label.y = n.y;
+    }
+  });
+}
+function Tt(e, t) {
+  return je(We(e, t), Number);
+}
+function Ot(e) {
+  const t = {};
+  return e && Object.entries(e).forEach(([n, o]) => {
+    let s = n;
+    typeof s == "string" && (s = s.toLowerCase()), t[s] = o;
+  }), t;
+}
+const Qi = {
+  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 er(e) {
+  return e.length ? e.map(
+    (t, n) => `${n === 0 ? "M" : "L"} ${t.x} ${t.y}`
+  ).join(" ") : "";
+}
+function tr(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 n = `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, u = r.y, f = (r.x + i.x) / 2, h = (r.y + i.y) / 2;
+    n += ` Q ${l} ${u} ${f} ${h}`;
+  }
+  const o = e[e.length - 1];
+  return n += ` L ${o.x} ${o.y}`, n;
+}
+function nr(e) {
+  const { nodes: t, edges: n, configuration: o } = e, s = C(null), r = C(null), i = `dag-arrow-${$t()}`;
+  function l(u, f, h) {
+    r.value = null, s.value = null;
+    const m = {
+      ...Qi,
+      ...h
+    }, p = new ue({ multigraph: !0, compound: !0 });
+    p.setGraph({
+      rankdir: m.rankDirection,
+      nodesep: m.nodeSeparation,
+      ranksep: m.rankSeparation,
+      edgesep: m.edgeSeparation,
+      align: m.align
+    }), u.forEach((k) => {
+      p.setNode(k.id, {
+        label: k.label,
+        width: k.width ?? m.nodeWidth,
+        height: k.height ?? m.nodeHeight
+      });
+    }), f.forEach((k) => {
+      p.setEdge(k.from, k.to, {
+        weight: k.weight ?? 1,
+        minlen: k.minLength ?? 1,
+        arrowShape: m.arrowShape ?? "normal"
+      });
+    }), Ti(p);
+    const _ = u.map((k) => {
+      const F = p.node(k.id);
+      return {
+        id: k.id,
+        label: k.label,
+        x: F.x,
+        y: F.y,
+        width: F.width,
+        height: F.height,
+        original: k
+      };
+    }), O = p.edges().map((k) => {
+      const F = p.edge(k), G = F.points || [];
+      if (!G.length)
+        return null;
+      const K = m.curvedEdges ? tr(G) : er(G), De = m.arrowShape !== "undirected" ? `url(#${i})` : null, be = f.find((c) => c?.from === k.v && c?.to === k.w);
+      return {
+        id: `${k.v}->${k.w}->${$t()}`,
+        from: k.v,
+        to: k.w,
+        points: G,
+        pathData: K,
+        markerEnd: De,
+        original: {
+          ...be,
+          ...F
+        }
+      };
+    }).filter(Boolean), M = m.padding;
+    if (!_.length) {
+      s.value = {
+        nodes: [],
+        edges: O,
+        viewBox: "0 0 0 0",
+        arrowShape: m.arrowShape,
+        arrowSize: m.arrowSize
+      };
+      return;
+    }
+    const z = _.flatMap((k) => [
+      k.x - k.width / 2,
+      k.x + k.width / 2
+    ]), se = _.flatMap((k) => [
+      k.y - k.height / 2,
+      k.y + k.height / 2
+    ]), Pe = Math.min(...z) - M, ye = Math.max(...z) + M, ce = Math.min(...se) - M, we = Math.max(...se) + M;
+    s.value = {
+      nodes: _,
+      edges: O.map((k) => ({
+        ...k,
+        midpoint: k.pathData ? Wo(k.pathData) : { x: 0, y: 0 }
+      })),
+      viewBox: `${Pe} ${ce} ${ye - Pe} ${we - ce}`,
+      arrowShape: m.arrowShape,
+      arrowSize: m.arrowSize
+    };
+  }
+  return Bo(() => {
+    try {
+      const u = y(t) || [], f = y(n) || [], h = y(o) || {};
+      l(u, f, h);
+    } catch (u) {
+      console.error("[useDag] layout error:", u), r.value = u, s.value = null;
+    }
+  }), {
+    layoutData: s,
+    lastError: r,
+    arrowMarkerIdentifier: i,
+    recomputeLayout: () => {
+      const u = y(t) || [], f = y(n) || [], h = y(o) || {};
+      l(u, f, h);
+    }
+  };
+}
+const or = ["id"], sr = ["id"], ir = {
+  key: 1,
+  class: "dag-chart-error"
+}, rr = { style: { position: "relative" } }, ar = ["viewBox", "xmlns", "aria-describedby"], lr = { key: 0 }, ur = ["id", "width", "height"], cr = ["cx", "cy", "r", "fill"], dr = ["x", "y", "width", "height", "fill"], fr = { key: 2 }, hr = ["id", "markerWidth", "markerHeight", "refX", "refY"], mr = ["d", "fill", "stroke"], vr = ["d", "fill", "stroke"], gr = { class: "vue-ui-dag-edges" }, pr = ["data-a11y-midpoint-id", "aria-label", "onMouseenter"], yr = { class: "vue-ui-dag-nodes" }, wr = ["onClick", "onMouseenter", "onMouseleave"], br = ["data-a11y-node-id", "aria-label"], kr = ["x", "y", "width", "height"], Er = { class: "vue-ui-dag-edges" }, _r = ["d", "stroke-width", "marker-end"], Cr = { class: "vue-ui-dag-node-labels" }, xr = ["onClick", "onMouseenter", "onMouseleave"], Nr = ["x", "y", "font-size", "fill", "font-weight"], Sr = ["x", "y", "font-size", "fill", "font-weight", "innerHTML"], Lr = { key: 1 }, Mr = {
+  key: 1,
+  style: { position: "absolute", top: "100%", left: "0", width: "100%" },
+  "data-dom-to-png-ignore": "",
+  "aria-hidden": "true"
+}, Tr = {
+  key: 6,
+  class: "vue-data-ui-watermark"
+}, Or = ["data-position"], $r = { key: 0 }, Rr = ["data-position"], Pr = { key: 0 }, In = 1.5, Dr = {
+  __name: "vue-ui-dag",
+  props: {
+    dataset: {
+      type: Object,
+      default() {
+        return {
+          nodes: [],
+          edges: []
+        };
+      }
+    },
+    config: {
+      type: Object,
+      default() {
+        return {};
+      }
+    }
+  },
+  emits: ["onNodeClick", "onMidpointEnter", "onMidpointLeave", "copyAlt", "rotate"],
+  setup(e, { expose: t, emit: n }) {
+    const o = _t(() => import("./PenAndPaper-Ct3qJ4lA.js")), s = _t(() => import("./UserOptions-rW2fRf3V.js")), r = _t(() => import("./PackageVersion-DPO-OOVI.js")), { vue_ui_dag: i } = Ko(), { isThemeValid: l, warnInvalidTheme: u } = ts(), f = e, h = n, m = C(null), p = C($t()), _ = C(null), O = C(null), M = C(null), z = C(0), se = C(0), Pe = C(!1), ye = C(!1), ce = C(!1), we = C(!1), k = C(null), F = C(null), G = C(null), K = C(null), et = C(null), De = C("pointer"), be = C(!1), c = C(lt()), tt = I(() => c.value.userOptions.useCursorPointer), nt = C(c.value.style.chart.width), ot = C(c.value.style.chart.height), Ft = C({ x: 0, y: 0 }), Y = C(null), st = C(null), It = C({ left: "0px", top: "0px" }), Bt = C("top"), ie = C(!1), zt = C({ x: 0, y: 0 }), Vt = C({ x: 0, y: 0 }), Ae = C(null), it = C(null), rt = C({ left: "0px", top: "0px" }), Ht = C("top"), de = C(!1), ke = C(!1), { svgRef: Q } = os({ config: c.value.style.chart.title }), { userOptionsVisible: at, setUserOptionsVisibility: Wt, keepUserOptionState: Gt } = ns({ config: c.value }), ee = C(c.value.style.chart.layout.rankDirection), Qn = I(() => kn({
+      defaultConfig: {
+        userOptions: { show: !1 },
+        style: {
+          chart: {
+            backgroundColor: "#99999930",
+            nodes: {
+              stroke: "#CCCCCC",
+              backgroundColor: "#DDDDDD50"
+            },
+            edges: {
+              stroke: "#CCCCCC"
+            },
+            midpoints: {
+              stroke: "#CCCCCC",
+              fill: "#CCCCCC"
+            }
+          }
+        }
+      },
+      userConfig: c.value.skeletonConfig ?? {}
+    })), { loading: Fe, FINAL_DATASET: Ye, manualLoading: jt } = qo({
+      ...zo(f),
+      FINAL_CONFIG: c,
+      prepareConfig: lt,
+      skeletonDataset: f.config?.skeletonDataset ?? {
+        nodes: [
+          { id: "A", label: "" },
+          { id: "B", label: "" },
+          { id: "C", label: "" }
+        ],
+        edges: [
+          { from: "A", to: "B" },
+          { from: "A", to: "C" }
+        ]
+      },
+      skeletonConfig: kn({
+        defaultConfig: c.value,
+        userConfig: Qn.value
+      })
+    });
+    function lt() {
+      const a = xt({
+        userConfig: f.config,
+        defaultConfig: i
+      }), v = a.theme;
+      if (!v) return a;
+      if (!l.value(a))
+        return u(a), a;
+      const d = xt({
+        userConfig: rs[v] || f.config,
+        defaultConfig: a
+      });
+      return xt({
+        userConfig: f.config,
+        defaultConfig: d
+      });
+    }
+    const ut = I(() => !!c.value.debug);
+    vn(async () => {
+      Go(f.dataset) && (En({
+        componentName: "VueUiDag",
+        type: "dataset",
+        debug: ut.value
+      }), ye.value = !1, jt.value = !0), f.dataset.nodes || (En({
+        componentName: "VueUiDag",
+        type: "datasetAttributeEmpty",
+        property: "nodes",
+        index: 0,
+        debug: ut.value
+      }), ye.value = !1, jt.value = !0), ye.value = !0, await Se(), rn();
+    }), ze(() => f.config, async (a) => {
+      Fe.value || (c.value = lt()), at.value = !c.value.userOptions.showOnChartHover, z.value += 1, ee.value = c.value.style.chart.layout.rankDirection, nt.value = c.value.style.chart.width, ot.value = c.value.style.chart.height, Ee.value = c.value.style.chart.zoom.active, await Se(), rn();
+    }, { deep: !0 });
+    const { isPrinting: ct, isImaging: dt, generatePdf: Yt, generateImage: Ut } = Qo({
+      elementId: `dag_${p.value}`,
+      fileName: c.value.style.chart.title.text || "vue-ui-dag",
+      options: c.value.userOptions.print
+    }), eo = I(() => c.value.style.chart.backgroundColor), to = I(() => c.value.style.chart.title), { exportSvg: no, getSvg: oo } = es({
+      svg: Q,
+      title: to,
+      legend: void 0,
+      legendItems: void 0,
+      backgroundColor: eo
+    });
+    async function Zt({ isCb: a }) {
+      we.value = !0, await Se();
+      try {
+        if (a) {
+          const { blob: v, url: d, text: g, dataUrl: b } = await oo();
+          await Promise.resolve(c.value.userOptions.callbacks.svg({ blob: v, url: d, text: g, dataUrl: b }));
+        } else
+          await Promise.resolve(no());
+      } finally {
+        we.value = !1;
+      }
+    }
+    function so() {
+      Pe.value = !0, Wt(!0);
+    }
+    function io() {
+      Wt(!1), Pe.value = !1;
+    }
+    function Xt({
+      tooltipRef: a,
+      isVisibleRef: v,
+      anchorRef: d,
+      styleRef: g,
+      placementRef: b,
+      offsetRef: E,
+      margin: w = 24
+    }) {
+      return function() {
+        const A = a.value;
+        if (!A || !v.value) return;
+        const T = A.getBoundingClientRect(), B = window.innerWidth, j = window.innerHeight, te = d.value.x, U = d.value.y, ne = E?.value?.x ?? 0, ve = E?.value?.y ?? 0;
+        let P = U - ve - T.height - w, Z = te - T.width / 2, Ie = "top";
+        if (P < w) {
+          const Ne = U + ve + w;
+          Ne + T.height <= j - w ? (P = Ne, Ie = "bottom") : (P = U - T.height / 2, P < w && (P = w), P + T.height > j - w && (P = j - T.height - w), Ie = "center");
+        }
+        Z < w && (Z = w), Z + T.width > B - w && (Z = B - T.width - w);
+        const Ao = Z <= w, Fo = Z + T.width >= B - w;
+        if ((Ao || Fo) && Ie !== "center") {
+          let Ne, Be;
+          const Io = te - ne - w;
+          B - (te + ne) - w >= Io ? (Ne = "right", Be = te + ne + w) : (Ne = "left", Be = te - ne - w - T.width), Be >= w && Be + T.width <= B - w && (Z = Be, P = U - T.height / 2, P < w && (P = w), P + T.height > j - w && (P = j - T.height - w), Ie = Ne);
+        }
+        b.value = Ie, g.value = {
+          left: `${Z}px`,
+          top: `${P}px`
+        };
+      };
+    }
+    const ro = I(() => Ye.value.nodes.map((a) => ({
+      ...a,
+      backgroundColor: a.backgroundColor ? _n(a.backgroundColor) : c.value.style.chart.nodes.backgroundColor,
+      color: a.color ? _n(a.color) : c.value.style.chart.nodes.labels.color
+    }))), ao = I(() => Ye.value.edges), lo = I(() => ({
+      ...c.value.style.chart.layout,
+      rankDirection: ee.value
+    })), { layoutData: x, lastError: Kt, arrowMarkerIdentifier: uo } = nr({
+      nodes: ro,
+      edges: ao,
+      configuration: lo
+    });
+    function re(a) {
+      return x.value ? x.value.nodes.find((v) => v.id === a) : null;
+    }
+    I(() => {
+      if (!x.value) return [];
+      const a = c.value.style.chart.edges.stroke, v = /* @__PURE__ */ new Set();
+      return x.value.edges.forEach((d) => {
+        v.add({
+          id: d.id,
+          from: d.from,
+          to: d.to,
+          color: d.original?.color || a
+        });
+      }), Array.from(v);
+    });
+    const qt = I(() => {
+      const a = nt.value, v = ot.value, d = Number(a), g = Number(v), b = Number.isFinite(d) && d > 0, E = Number.isFinite(g) && g > 0;
+      return !b && !E ? null : {
+        width: b ? d : null,
+        height: E ? g : null
+      };
+    }), Ee = C(c.value.style.chart.zoom.active), {
+      viewBox: _e,
+      resetZoom: Ue,
+      setInitialViewBox: co,
+      scale: Jt,
+      zoomByFactor: Qt
+    } = Xo(
+      Q,
+      { x: 0, y: 0, width: 100, height: 100 },
+      1,
+      Ee,
+      () => {
+        ie.value = !1;
+      }
+    );
+    function fo() {
+      Ee.value = !Ee.value;
+    }
+    function en() {
+      const a = x.value && x.value.viewBox;
+      if (!a) return;
+      const v = String(a).split(" ").map(Number);
+      if (v.length !== 4) return;
+      const [d, g, b, E] = v;
+      if (!Number.isFinite(d) || !Number.isFinite(g) || !Number.isFinite(b) || !Number.isFinite(E))
+        return;
+      let w = b, N = E, A = d, T = g;
+      const B = qt.value;
+      B && (B.width !== null && (w = B.width), B.height !== null && (N = B.height), A = d - (w - b) / 2, T = g - (N - E) / 2), co(
+        { x: A, y: T, width: w, height: N },
+        { overwriteCurrentIfNotZoomed: !0 }
+      );
+    }
+    ze(
+      () => x.value && x.value.viewBox,
+      () => {
+        en();
+      },
+      { immediate: !0 }
+    ), ze(
+      () => qt.value,
+      () => {
+        en();
+      }
+    ), ze(() => ke.value, (a) => {
+      Ee.value = !a;
+    });
+    const ho = I(() => {
+      const a = _e.value;
+      return a ? `${a.x} ${a.y} ${a.width} ${a.height}` : "0 0 0 0";
+    }), fe = C(!1);
+    function tn(a) {
+      fe.value = a, se.value += 1;
+    }
+    function ft() {
+      ke.value = !ke.value;
+    }
+    function ht() {
+      Qt(In, !0);
+    }
+    function mt() {
+      Qt(1 / In, !0);
+    }
+    const vt = ["TB", "RL", "BT", "LR"];
+    function gt() {
+      ee.value = vt[(vt.indexOf(ee.value) + 1) % vt.length], Ue(), h("rotate", ee.value);
+    }
+    const mo = Xt({
+      tooltipRef: st,
+      isVisibleRef: de,
+      anchorRef: Ft,
+      styleRef: It,
+      placementRef: Bt
+    }), vo = Xt({
+      tooltipRef: it,
+      isVisibleRef: ie,
+      anchorRef: zt,
+      styleRef: rt,
+      placementRef: Ht,
+      offsetRef: Vt
+    }), q = C(null);
+    async function nn(a) {
+      h("onMidpointEnter", a);
+      const v = Q.value;
+      if (!v || !a?.midpoint) return;
+      const d = v.createSVGPoint();
+      d.x = a.midpoint.x, d.y = a.midpoint.y;
+      const g = v.getScreenCTM();
+      if (!g) return;
+      const b = d.matrixTransform(g);
+      Ft.value = {
+        x: b.x,
+        y: b.y
+      }, Y.value = a, de.value = !0, c.value.style.chart.midpoints.selectedEdge.animated === !0 && (q.value = a.id, he()), await Se(), mo();
+    }
+    function ae() {
+      de.value = !1, Y.value = null, h("onMidpointLeave"), c.value.style.chart.midpoints.selectedEdge.animated === !0 && (q.value = null, he());
+    }
+    async function pt(a) {
+      if (h("onNodeClick", a), !c.value.style.chart.nodes.tooltip.showOnClick) return;
+      const v = Q.value;
+      if (!v) return;
+      const d = v.createSVGPoint();
+      d.x = a.x, d.y = a.y;
+      const g = v.getScreenCTM();
+      if (!g) return;
+      const b = d.matrixTransform(g), E = c.value.style.chart.layout.nodeWidth, w = c.value.style.chart.layout.nodeHeight, N = g.a, A = g.d, T = E * N, B = w * A;
+      Vt.value = {
+        x: T / 2,
+        y: B / 2
+      }, zt.value = {
+        x: b.x,
+        y: b.y
+      }, Ae.value = a, ie.value = !0, await Se(), vo();
+    }
+    function Ce() {
+      ie.value = !1, Ae.value = null;
+    }
+    function on(a) {
+      if (!(ie.value || de.value)) return;
+      const d = it.value;
+      if (d && d.contains(a.target))
+        return;
+      const g = st.value;
+      if (g && g.contains(a.target))
+        return;
+      const b = Q.value;
+      if (b && b.contains(a.target)) {
+        const E = a.target.closest(".vue-ui-dag-node"), w = a.target.closest(".vue-ui-dag-edge-midpoint");
+        if (E || w)
+          return;
+      }
+      Ce(), ae(), be.value || Xe();
+    }
+    function sn(a) {
+      a.key === "Escape" && (ie.value && Ce(), de.value && ae());
+    }
+    vn(() => {
+      document.addEventListener("mousedown", on), document.addEventListener("keydown", sn);
+    }), gn(() => {
+      document.removeEventListener("mousedown", on), document.removeEventListener("keydown", sn), k.value && (F.value && k.value.unobserve(F.value), k.value.disconnect());
+    });
+    function rn() {
+      if (!c.value.responsive) {
+        k.value && (F.value && k.value.unobserve(F.value), k.value.disconnect(), k.value = null, F.value = null);
+        return;
+      }
+      const a = Uo(() => {
+        if (!m.value) return;
+        const { width: v, height: d } = Zo({
+          chart: m.value,
+          title: c.value.style.chart.title.text ? _.value : null,
+          legend: c.value.style.chart.controls.show ? M.value?.$el : null,
+          source: O.value
+        });
+        requestAnimationFrame(() => {
+          nt.value = Math.max(0.1, v), ot.value = Math.max(0.1, d - 12);
+        });
+      });
+      k.value && (F.value && k.value.unobserve(F.value), k.value.disconnect()), k.value = new ResizeObserver(a), F.value = m.value ? m.value.parentNode : null, F.value && k.value.observe(F.value), a();
+    }
+    function go(a, v = {}) {
+      const {
+        direction: d = -1,
+        mode: g = "oneLapNearest",
+        dasharray: b = null
+      } = v;
+      if (!a || typeof a.getTotalLength != "function")
+        return ut.value && console.warn(
+          "VueUiDag @getIdealDashoffsetDelta: invalid path element",
+          a
+        ), 0;
+      const E = a.getTotalLength(), w = b ?? a.getAttribute("stroke-dasharray") ?? (typeof getComputedStyle == "function" ? getComputedStyle(a).strokeDasharray : ""), N = te(w);
+      if (!Number.isFinite(N) || N <= 0)
+        return d * E;
+      const A = Math.max(1, Math.round(E / N)), T = Math.max(1, Math.ceil(E / N)), B = Math.max(1, Math.floor(E / N));
+      let j;
+      return g === "pattern" ? j = N : g === "oneLapCeil" ? j = T * N : g === "oneLapFloor" ? j = B * N : j = A * N, d * j;
+      function te(U) {
+        if (!U || U === "none") return NaN;
+        const ne = String(U).replace(/,/g, " ").trim().split(/\s+/).map((P) => Number.parseFloat(P)).filter((P) => Number.isFinite(P));
+        if (!ne.length) return NaN;
+        const ve = ne.reduce((P, Z) => P + Z, 0);
+        return ne.length % 2 === 1 ? ve * 2 : ve;
+      }
+    }
+    const yt = C(/* @__PURE__ */ new Map()), wt = C(/* @__PURE__ */ new Map());
+    function po(a) {
+      return function(d) {
+        d ? yt.value.set(a, d) : yt.value.delete(a);
+      };
+    }
+    function an() {
+      wt.value.forEach((a) => {
+        try {
+          a.cancel();
+        } catch {
+        }
+      }), wt.value.clear();
+    }
+    function he() {
+      an();
+      const a = x.value?.edges ?? [];
+      if (!a.length) return;
+      const v = c.value.style.chart.edges.animations, d = Number(v.referenceDistance) > 0 ? Number(v.referenceDistance) : 24;
+      a.forEach((g) => {
+        const b = c.value.style.chart.midpoints.selectedEdge.animated === !0 && q.value != null && g.id === q.value, E = !!g?.original?.animated || !!g?.animated || b, w = yt.value.get(g.id);
+        if (!w) return;
+        if (!E) {
+          w.style.strokeDasharray = "0", w.style.strokeDashoffset = "0";
+          return;
+        }
+        const N = g?.original?.dasharray ?? v.dasharray;
+        w.style.strokeDasharray = String(N), w.style.strokeDashoffset = "0";
+        const A = ![void 0, null].includes(g?.original?.animationDirection), T = ![void 0, null].includes(v.animationDirection), B = A ? Number(g.original.animationDirection) : T ? Number(v.animationDirection) : -1, j = go(w, {
+          direction: B,
+          mode: "oneLapNearest",
+          dasharray: String(N)
+        }), te = g?.original?.animationDurationMs ?? v.animationDurationMs ?? 1e3, U = Number(te), ve = Number.isFinite(U) && U > 0 ? d / U : d / 1e3, P = Math.max(1, Math.round(Math.abs(j) / Math.max(1e-9, ve))), Z = w.animate([{ strokeDashoffset: 0 }, { strokeDashoffset: j }], { duration: P, iterations: 1 / 0, easing: "linear" });
+        wt.value.set(g.id, Z);
+      });
+    }
+    ze(
+      () => x.value && x.value.edges,
+      async () => {
+        await Se(), he();
+      },
+      { deep: !0, immediate: !0 }
+    ), gn(() => {
+      an();
+    });
+    async function yo({ scale: a = 2 } = {}) {
+      if (!m.value) return;
+      const { width: v, height: d } = m.value.getBoundingClientRect(), g = v / d, { imageUri: b, base64: E } = await ss({ domElement: m.value, base64: !0, img: !0, scale: a });
+      return {
+        imageUri: b,
+        base64: E,
+        title: c.value.style.chart.title.text ?? "vue-ui-dag",
+        width: v,
+        height: d,
+        aspectRatio: g
+      };
+    }
+    const me = I(() => {
+      const a = Number(c.value.style.chart.layout.nodeHeight);
+      return Number.isFinite(a) && a > 0 ? a / c.value.style.chart.backgroundPattern.spacingRatio : 12;
+    }), wo = I(() => me.value * (c.value.style.chart.backgroundPattern.dotRadiusRatio / 100)), D = C(null);
+    let xe = null, ln = 0;
+    function bt(a) {
+      xe && (clearTimeout(xe), xe = null), D.value !== a && (D.value = a, (c.value.style.chart.nodes.selected.downstreamEdges.animated === !0 || c.value.style.chart.nodes.selected.upstreamEdges.animated === !0) && he());
+    }
+    function bo(a) {
+      De.value = "pointer", q.value = null, bt(a);
+    }
+    async function ko(a) {
+      De.value = "pointer", D.value = null, await nn(a);
+    }
+    function un(a) {
+      const v = ++ln;
+      xe && clearTimeout(xe), xe = setTimeout(() => {
+        v === ln && D.value === a && (D.value = null, (c.value.style.chart.nodes.selected.downstreamEdges.animated === !0 || c.value.style.chart.nodes.selected.upstreamEdges.animated === !0) && he());
+      }, 20);
+    }
+    function Eo(a) {
+      const v = a.from === D.value, d = a.to === D.value, g = K.value === "midpoint" && G.value === a.id, b = q.value === a.id || Y.value?.id === a.id || g;
+      let E = a.original.color ?? c.value.style.chart.edges.stroke;
+      if (b && c.value.style.chart.midpoints.selectedEdge.stroke != null ? E = c.value.style.chart.midpoints.selectedEdge.stroke : v && c.value.style.chart.nodes.selected.downstreamEdges.stroke != null ? E = c.value.style.chart.nodes.selected.downstreamEdges.stroke : d && c.value.style.chart.nodes.selected.upstreamEdges.stroke != null && (E = c.value.style.chart.nodes.selected.upstreamEdges.stroke), v && c.value.style.chart.nodes.selected.downstreamEdges.animated === !0)
+        a.animated = !0;
+      else if (d && c.value.style.chart.nodes.selected.upstreamEdges.animated === !0)
+        a.animated = !0;
+      else if (g && c.value.style.chart.midpoints.selectedEdge.animated === !0)
+        a.animated = !0;
+      else {
+        const w = x.value?.edges.find((N) => N.id === a.id);
+        a.animated = w?.original?.animated ?? !1;
+      }
+      return {
+        d: a.pathData,
+        fill: "none",
+        stroke: E,
+        "stroke-width": c.value.style.chart.edges.strokeWidth * (b || a.from === D.value ? 2 : 1),
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      };
+    }
+    function cn(a) {
+      return K.value === "node" && G.value === a;
+    }
+    function _o(a) {
+      const v = D.value === a.id, d = K.value === "node" && G.value === a.id, g = v || d, b = g && c.value.style.chart.nodes.selected.backgroundColor != null ? c.value.style.chart.nodes.selected.backgroundColor : a.original.backgroundColor, E = g && c.value.style.chart.nodes.selected.stroke != null ? c.value.style.chart.nodes.selected.stroke : c.value.style.chart.nodes.stroke, w = g && c.value.style.chart.nodes.selected.strokeWidth != null ? c.value.style.chart.nodes.selected.strokeWidth : c.value.style.chart.nodes.strokeWidth;
+      return {
+        x: a.x - a.width / 2,
+        y: a.y - a.height / 2,
+        width: a.width,
+        height: a.height,
+        rx: c.value.style.chart.nodes.borderRadius,
+        fill: b,
+        stroke: E,
+        "stroke-width": w
+      };
+    }
+    function Co(a) {
+      const v = a.from === D.value, d = a.to === D.value, g = K.value === "midpoint" && G.value === a.id, b = q.value === a.id || Y.value?.id === a.id || g;
+      let E = a.original.color ?? c.value.style.chart.edges.stroke;
+      return b && c.value.style.chart.midpoints.selectedEdge.stroke != null ? E = c.value.style.chart.midpoints.selectedEdge.stroke : v && c.value.style.chart.nodes.selected.downstreamEdges.stroke != null ? E = c.value.style.chart.nodes.selected.downstreamEdges.stroke : d && c.value.style.chart.nodes.selected.upstreamEdges.stroke != null && (E = c.value.style.chart.nodes.selected.upstreamEdges.stroke), {
+        cx: a.midpoint.x,
+        cy: a.midpoint.y,
+        r: c.value.style.chart.midpoints.radius,
+        fill: g ? c.value.style.chart.midpoints.selectedEdge.stroke ?? c.value.style.chart.midpoints.fill : c.value.style.chart.midpoints.fill,
+        stroke: E,
+        "stroke-width": c.value.style.chart.edges.strokeWidth * (b || a.from === D.value ? 2 : 1)
+      };
+    }
+    function Ze(a) {
+      const v = a.from === D.value, d = a.to === D.value, g = K.value === "midpoint" && G.value === a.id, b = q.value === a.id || Y.value?.id === a.id || g;
+      let E = a.color ?? a.original?.color ?? c.value.style.chart.edges.stroke;
+      return b && c.value.style.chart.midpoints.selectedEdge.stroke != null ? E = c.value.style.chart.midpoints.selectedEdge.stroke : v && c.value.style.chart.nodes.selected.downstreamEdges.stroke != null ? E = c.value.style.chart.nodes.selected.downstreamEdges.stroke : d && c.value.style.chart.nodes.selected.upstreamEdges.stroke != null && (E = c.value.style.chart.nodes.selected.upstreamEdges.stroke), E;
+    }
+    function dn(a) {
+      return `${uo}-${String(a).replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+    }
+    function xo() {
+      return x.value;
+    }
+    function No(a) {
+      if (a?.stage === "start") {
+        ce.value = !0;
+        return;
+      }
+      if (a?.stage === "end") {
+        ce.value = !1;
+        return;
+      }
+      Ut();
+    }
+    async function fn() {
+      if (h("copyAlt", {
+        config: c.value,
+        dataset: Ye.value
+      }), !c.value.userOptions.callbacks.altCopy) {
+        console.warn("Vue Data UI - A callback must be set for `altCopy` in userOptions.");
+        return;
+      }
+      await Promise.resolve(c.value.userOptions.callbacks.altCopy({
+        config: c.value,
+        dataset: Ye.value
+      }));
+    }
+    const So = I(() => (x.value?.nodes ?? []).map((v) => ({
+      id: v.id,
+      type: "node",
+      x: v.x,
+      y: v.y,
+      label: v.label ?? v.id,
+      raw: v
+    }))), Lo = I(() => c.value.style.chart.midpoints.show ? (x.value?.edges ?? []).filter((v) => v?.midpoint).map((v) => ({
+      id: v.id,
+      type: "midpoint",
+      x: v.midpoint.x,
+      y: v.midpoint.y,
+      label: `${re(v.from)?.label ?? v.from} → ${re(v.to)?.label ?? v.to}`,
+      raw: v
+    })) : []), le = I(() => [...So.value, ...Lo.value].sort((a, v) => a.x === v.x ? a.y - v.y : a.x - v.x)), Mo = I(() => {
+      const a = /* @__PURE__ */ new Map();
+      return le.value.forEach((v, d) => {
+        a.set(`${v.type}:${v.id}`, d);
+      }), a;
+    }), kt = I(() => {
+      const a = x.value?.nodes ?? [], v = x.value?.edges ?? [], d = [
+        c.value.a11y?.translations?.node ?? "Node",
+        c.value.a11y?.translations?.parents ?? "Parents",
+        c.value.a11y?.translations?.children ?? "Children"
+      ], g = a.map((b) => {
+        const E = v.filter((N) => N.to === b.id).map((N) => re(N.from)?.label ?? N.from).join(", "), w = v.filter((N) => N.from === b.id).map((N) => re(N.to)?.label ?? N.to).join(", ");
+        return [
+          b.label ?? b.id,
+          E || "—",
+          w || "—"
+        ];
+      });
+      return { headers: d, rows: g };
+    });
+    function Et(a) {
+      return `${a.type}:${a.id}`;
+    }
+    function To() {
+      return G.value == null || K.value == null ? null : le.value.find(
+        (a) => a.id === G.value && a.type === K.value
+      ) ?? null;
+    }
+    async function hn(a) {
+      if (a) {
+        if (a.type === "node") {
+          ae();
+          return;
+        }
+        a.type === "midpoint" && (Ce(), await nn(a.raw));
+      }
+    }
+    function mn(a) {
+      if (a) {
+        if (G.value = a.id, K.value = a.type, et.value = Mo.value.get(Et(a)) ?? null, a.type === "node") {
+          bt(a.id), q.value = null;
+          return;
+        }
+        a.type === "midpoint" && (D.value = null, q.value = a.id, c.value.style.chart.midpoints.selectedEdge.animated === !0 && he());
+      }
+    }
+    function Xe() {
+      G.value = null, K.value = null, et.value = null, ie.value || (D.value = null), de.value || (q.value = null, c.value.style.chart.midpoints.selectedEdge.animated === !0 && he());
+    }
+    function Oo() {
+      be.value = !0, Xe();
+    }
+    function $o() {
+      be.value = !1, Ce(), ae(), Xe();
+    }
+    function Ro(a, v, d) {
+      const g = v.x - a.x, b = v.y - a.y;
+      return d === "right" && g <= 0 || d === "left" && g >= 0 || d === "down" && b <= 0 || d === "up" && b >= 0 ? 1 / 0 : d === "right" || d === "left" ? Math.abs(g) * 1e3 + Math.abs(b) : Math.abs(b) * 1e3 + Math.abs(g);
+    }
+    function Ke(a, v) {
+      const d = le.value.filter((E) => Et(E) !== Et(a));
+      if (!d.length) return null;
+      let g = null, b = 1 / 0;
+      return d.forEach((E) => {
+        const w = Ro(a, E, v);
+        w < b && (b = w, g = E);
+      }), g || (v === "right" || v === "down" ? le.value[0] ?? null : le.value[le.value.length - 1] ?? null);
+    }
+    async function Po(a) {
+      a && (De.value = "keyboard", a.type === "node" && (ae(), await pt(a.raw)));
+    }
+    async function Do(a) {
+      if (!Q.value || ke.value || document.activeElement !== Q.value || !le.value.length) return;
+      const v = a.key === "ArrowLeft", d = a.key === "ArrowRight", g = a.key === "ArrowUp", b = a.key === "ArrowDown", E = a.key === "Enter" || a.key === " ", w = a.key === "Escape";
+      if (!v && !d && !g && !b && !E && !w)
+        return;
+      if (a.preventDefault(), a.stopPropagation(), w) {
+        Ce(), ae(), Xe();
+        return;
+      }
+      let N = To();
+      if (E) {
+        if (!N) return;
+        N.type === "node" && await Po(N);
+        return;
+      }
+      if (!N) {
+        const T = le.value[0];
+        if (!T) return;
+        mn(T), await hn(T);
+        return;
+      }
+      let A = null;
+      d ? A = Ke(N, "right") : v ? A = Ke(N, "left") : b ? A = Ke(N, "down") : g && (A = Ke(N, "up")), A && (Ce(), ae(), mn(A), await hn(A));
+    }
+    return t({
+      getData: xo,
+      getImage: yo,
+      generatePdf: Yt,
+      generateSvg: Zt,
+      generateImage: Ut,
+      toggleAnnotator: ft,
+      toggleFullscreen: tn,
+      zoomIn: ht,
+      zoomOut: mt,
+      resetZoom: Ue,
+      switchDirection: gt,
+      copyAlt: fn
+    }), (a, v) => (S(), L("div", {
+      class: pn(`vue-data-ui-component vue-ui-dag ${fe.value ? "vue-data-ui-wrapper-fullscreen" : ""} ${c.value.responsive ? "vue-ui-dag-responsive" : ""}`),
+      id: `dag_${p.value}`,
+      ref_key: "dagChart",
+      ref: m,
+      style: Le({
+        fontFamily: c.value.style.fontFamily,
+        backgroundColor: c.value.style.chart.backgroundColor,
+        padding: "0.5rem"
+      }),
+      onMouseenter: so,
+      onMouseleave: io
+    }, [
+      X("div", {
+        id: `chart-instructions-${p.value}`,
+        class: "sr-only"
+      }, [
+        X("p", null, Me(c.value.a11y.translations.keyboardNavigation), 1)
+      ], 8, sr),
+      kt.value?.rows?.length ? (S(), oe(as, {
+        key: 0,
+        uid: p.value,
+        head: kt.value.headers,
+        body: kt.value.rows,
+        notice: c.value.a11y.translations.tableAvailable,
+        caption: c.value.a11y.translations.tableCaption
+      }, null, 8, ["uid", "head", "body", "notice", "caption"])) : $("", !0),
+      y(Kt) ? (S(), L("div", ir, Me(String(y(Kt))), 1)) : $("", !0),
+      c.value.userOptions.buttons.annotator ? (S(), oe(y(o), {
+        key: 2,
+        svgRef: y(Q),
+        backgroundColor: c.value.style.chart.backgroundColor,
+        color: c.value.style.chart.color,
+        active: ke.value,
+        isCursorPointer: tt.value,
+        onClose: ft
+      }, {
+        "annotator-action-close": V(() => [
+          R(a.$slots, "annotator-action-close", {}, void 0, !0)
+        ]),
+        "annotator-action-color": V(({ color: d }) => [
+          R(a.$slots, "annotator-action-color", H(W({ color: d })), void 0, !0)
+        ]),
+        "annotator-action-draw": V(({ mode: d }) => [
+          R(a.$slots, "annotator-action-draw", H(W({ mode: d })), void 0, !0)
+        ]),
+        "annotator-action-undo": V(({ disabled: d }) => [
+          R(a.$slots, "annotator-action-undo", H(W({ disabled: d })), void 0, !0)
+        ]),
+        "annotator-action-redo": V(({ disabled: d }) => [
+          R(a.$slots, "annotator-action-redo", H(W({ disabled: d })), void 0, !0)
+        ]),
+        "annotator-action-delete": V(({ disabled: d }) => [
+          R(a.$slots, "annotator-action-delete", H(W({ disabled: d })), void 0, !0)
+        ]),
+        _: 3
+      }, 8, ["svgRef", "backgroundColor", "color", "active", "isCursorPointer"])) : $("", !0),
+      c.value.userOptions.show && ye.value && (y(Gt) || y(at)) ? (S(), oe(y(s), {
+        ref: "userOptionsRef",
+        key: `user_option_${se.value}`,
+        backgroundColor: c.value.style.chart.backgroundColor,
+        color: c.value.style.chart.color,
+        isPrinting: y(ct),
+        isImaging: y(dt),
+        uid: p.value,
+        hasTooltip: !1,
+        hasTable: !1,
+        hasXls: !1,
+        hasLabel: !1,
+        hasPdf: c.value.userOptions.buttons.pdf,
+        hasImg: c.value.userOptions.buttons.img,
+        hasSvg: c.value.userOptions.buttons.svg,
+        hasFullscreen: c.value.userOptions.buttons.fullscreen,
+        hasAltCopy: c.value.userOptions.buttons.altCopy,
+        isFullscreen: fe.value,
+        chartElement: m.value,
+        position: c.value.userOptions.position,
+        titles: { ...c.value.userOptions.buttonTitles },
+        hasAnnotator: c.value.userOptions.buttons.annotator,
+        isAnnotation: ke.value,
+        callbacks: c.value.userOptions.callbacks,
+        printScale: c.value.userOptions.print.scale,
+        hasZoom: c.value.userOptions.buttons.zoom,
+        isZoom: Ee.value,
+        isCursorPointer: tt.value,
+        onToggleFullscreen: tn,
+        onGeneratePdf: y(Yt),
+        onGenerateImage: No,
+        onGenerateSvg: Zt,
+        onToggleAnnotator: ft,
+        onToggleZoom: fo,
+        onCopyAlt: fn,
+        style: Le({
+          visibility: y(Gt) ? y(at) ? "visible" : "hidden" : "visible"
+        })
+      }, Vo({ _: 2 }, [
+        a.$slots.menuIcon ? {
+          name: "menuIcon",
+          fn: V(({ isOpen: d, color: g }) => [
+            R(a.$slots, "menuIcon", H(W({ isOpen: d, color: g })), void 0, !0)
+          ]),
+          key: "0"
+        } : void 0,
+        a.$slots.optionPdf ? {
+          name: "optionPdf",
+          fn: V(() => [
+            R(a.$slots, "optionPdf", {}, void 0, !0)
+          ]),
+          key: "1"
+        } : void 0,
+        a.$slots.optionImg ? {
+          name: "optionImg",
+          fn: V(() => [
+            R(a.$slots, "optionImg", {}, void 0, !0)
+          ]),
+          key: "2"
+        } : void 0,
+        a.$slots.optionSvg ? {
+          name: "optionSvg",
+          fn: V(() => [
+            R(a.$slots, "optionSvg", {}, void 0, !0)
+          ]),
+          key: "3"
+        } : void 0,
+        a.$slots.optionFullscreen ? {
+          name: "optionFullscreen",
+          fn: V(({ toggleFullscreen: d, isFullscreen: g }) => [
+            R(a.$slots, "optionFullscreen", H(W({ toggleFullscreen: d, isFullscreen: g })), void 0, !0)
+          ]),
+          key: "4"
+        } : void 0,
+        a.$slots.optionAnnotator ? {
+          name: "optionAnnotator",
+          fn: V(({ toggleAnnotator: d, isAnnotator: g }) => [
+            R(a.$slots, "optionAnnotator", H(W({ toggleAnnotator: d, isAnnotator: g })), void 0, !0)
+          ]),
+          key: "5"
+        } : void 0,
+        a.$slots.optionZoom ? {
+          name: "optionZoom",
+          fn: V(({ toggleZoom: d, isZoomLocked: g }) => [
+            R(a.$slots, "optionZoom", H(W({ toggleZoom: d, isZoomLocked: g })), void 0, !0)
+          ]),
+          key: "6"
+        } : void 0,
+        a.$slots.optionAltCopy ? {
+          name: "optionAltCopy",
+          fn: V(({ altCopy: d }) => [
+            R(a.$slots, "optionAltCopy", H(W({ altCopy: d })), void 0, !0)
+          ]),
+          key: "7"
+        } : void 0
+      ]), 1032, ["backgroundColor", "color", "isPrinting", "isImaging", "uid", "hasPdf", "hasImg", "hasSvg", "hasFullscreen", "hasAltCopy", "isFullscreen", "chartElement", "position", "titles", "hasAnnotator", "isAnnotation", "callbacks", "printScale", "hasZoom", "isZoom", "isCursorPointer", "onGeneratePdf", "style"])) : $("", !0),
+      c.value.style.chart.title.text ? (S(), L("div", {
+        key: 4,
+        ref_key: "chartTitle",
+        ref: _,
+        style: "width:100%;background:transparent;"
+      }, [
+        (S(), oe(is, {
+          key: `title_${z.value}`,
+          config: {
+            title: {
+              cy: "dag-title",
+              ...c.value.style.chart.title
+            },
+            subtitle: {
+              cy: "dag-subtitle",
+              ...c.value.style.chart.title.subtitle
+            }
+          }
+        }, null, 8, ["config"]))
+      ], 512)) : $("", !0),
+      c.value.style.chart.controls.position === "top" && !y(Fe) && c.value.style.chart.controls.show ? (S(), oe(Cn, {
+        key: 5,
+        ref_key: "zoomControls",
+        ref: M,
+        config: c.value,
+        scale: y(Jt),
+        isFullscreen: fe.value,
+        withDirection: "",
+        onZoomIn: ht,
+        onZoomOut: mt,
+        onResetZoom: v[0] || (v[0] = () => y(Ue)(!0)),
+        onSwitchDirection: gt
+      }, null, 8, ["config", "scale", "isFullscreen"])) : $("", !0),
+      X("div", rr, [
+        y(x) ? (S(), L("svg", {
+          key: 0,
+          ref_key: "svgRef",
+          ref: Q,
+          class: pn({ "vue-ui-dag-svg": !0, "vue-data-ui-loading": y(Fe) }),
+          viewBox: ho.value,
+          xmlns: y(jo),
+          style: Le({
+            backgroundColor: c.value.style.chart.backgroundColor,
+            height: "100%",
+            width: "100%"
+          }),
+          tabindex: "0",
+          "aria-describedby": `chart-instructions-${p.value}`,
+          onFocus: Oo,
+          onBlur: $o,
+          onKeydown: Do
+        }, [
+          Ct(y(r)),
+          c.value.style.chart.backgroundPattern.show ? (S(), L("defs", lr, [
+            X("pattern", {
+              id: `dag_bg_pattern_${p.value}`,
+              patternUnits: "userSpaceOnUse",
+              width: me.value,
+              height: me.value
+            }, [
+              R(a.$slots, "background-pattern", H(W({
+                x: me.value / 2,
+                y: me.value / 2,
+                color: c.value.style.chart.backgroundPattern.dotColor
+              })), () => [
+                X("circle", {
+                  cx: me.value / 2,
+                  cy: me.value / 2,
+                  r: wo.value,
+                  fill: c.value.style.chart.backgroundPattern.dotColor
+                }, null, 8, cr)
+              ], !0)
+            ], 8, ur)
+          ])) : $("", !0),
+          c.value.style.chart.backgroundPattern.show ? (S(), L("rect", {
+            key: 1,
+            x: y(_e)?.x ?? 0,
+            y: y(_e)?.y ?? 0,
+            width: y(_e)?.width ?? 0,
+            height: y(_e)?.height ?? 0,
+            fill: `url(#dag_bg_pattern_${p.value})`,
+            style: Le({
+              pointerEvents: "none",
+              opacity: c.value.style.chart.backgroundPattern.opacity
+            })
+          }, null, 12, dr)) : $("", !0),
+          y(x).arrowShape !== "undirected" ? (S(), L("defs", fr, [
+            (S(!0), L(ge, null, Ve(y(x).edges, (d) => (S(), L("marker", {
+              key: `marker_${d.id}`,
+              id: dn(d.id),
+              markerWidth: y(x).arrowSize,
+              markerHeight: y(x).arrowSize,
+              refX: y(x).arrowSize - 3,
+              refY: y(x).arrowSize / 2,
+              orient: "auto",
+              markerUnits: "strokeWidth"
+            }, [
+              y(x).arrowShape === "normal" ? (S(), L("path", {
+                key: 0,
+                d: `M 0 0 L ${y(x).arrowSize} ${y(x).arrowSize / 2} L 0 ${y(x).arrowSize} Z`,
+                fill: Ze(d),
+                stroke: Ze(d),
+                "stroke-width": "0",
+                style: { transition: "stroke 0.2s ease-in-out, fill 0.2s ease-in-out, stroke-width 0.2s ease-in-out" }
+              }, null, 8, mr)) : (S(), L("path", {
+                key: 1,
+                d: `M 0 0 L ${y(x).arrowSize} ${y(x).arrowSize / 2} L 0 ${y(x).arrowSize} L ${y(x).arrowSize / 3} ${y(x).arrowSize / 2} Z`,
+                fill: Ze(d),
+                stroke: Ze(d),
+                "stroke-width": "0",
+                style: { transition: "stroke 0.2s ease-in-out, fill 0.2s ease-in-out, stroke-width 0.2s ease-in-out" }
+              }, null, 8, vr))
+            ], 8, hr))), 128))
+          ])) : $("", !0),
+          X("g", gr, [
+            (S(!0), L(ge, null, Ve(y(x).edges, (d) => (S(), L(ge, {
+              key: d.id
+            }, [
+              X("path", Te({
+                "data-cy-edge": "",
+                ref_for: !0,
+                ref: po(d.id)
+              }, { ref_for: !0 }, Eo(d), { style: { "pointer-events": "none", transition: "stroke-width 0.2s ease-in-out, stroke 0.2s ease-in-out" } }), null, 16),
+              c.value.style.chart.midpoints.show ? (S(), L("circle", Te({
+                key: 0,
+                "data-cy-midpoint": "",
+                class: "vue-ui-dag-edge-midpoint",
+                "data-a11y-midpoint-id": d.id
+              }, { ref_for: !0 }, Co(d), {
+                "aria-label": `${re(d.from)?.label ?? d.from} to ${re(d.to)?.label ?? d.to}`,
+                style: { transition: "stroke-width 0.2s ease-in-out, stroke 0.2s ease-in-out, fill 0.2s ease-in-out" },
+                onMouseenter: (g) => ko(d),
+                onMouseleave: ae
+              }), null, 16, pr)) : $("", !0)
+            ], 64))), 128))
+          ]),
+          X("g", yr, [
+            (S(!0), L(ge, null, Ve(y(x).nodes, (d) => (S(), L("g", {
+              key: d.id,
+              class: "vue-ui-dag-node",
+              onClick: yn((g) => c.value.style.chart.nodes.tooltip.showOnClick && pt(d), ["stop"]),
+              onMouseenter: (g) => bo(d.id),
+              onMouseleave: (g) => un(d.id)
+            }, [
+              a.$slots.node ? $("", !0) : (S(), L("rect", Te({
+                key: 0,
+                "data-cy-node": ""
+              }, { ref_for: !0 }, _o(d), {
+                "data-a11y-node-id": d.id,
+                "aria-label": `${d.label ?? d.id}`,
+                style: {
+                  cursor: c.value.style.chart.nodes.tooltip.showOnClick && tt.value ? "pointer" : "default",
+                  transition: "stroke 0.2s ease-in-out, stroke-width 0.2s ease-in-out, fill 0.2s ease-in-out"
+                }
+              }), null, 16, br)),
+              a.$slots.node ? (S(), L("foreignObject", {
+                key: 1,
+                x: d.x - d.width / 2,
+                y: d.y - d.height / 2,
+                width: d.width,
+                height: d.height
+              }, [
+                R(a.$slots, "node", Te({ ref_for: !0 }, { node: d, orientation: ee.value }), void 0, !0)
+              ], 8, kr)) : $("", !0)
+            ], 40, wr))), 128))
+          ]),
+          X("g", Er, [
+            (S(!0), L(ge, null, Ve(y(x).edges, (d) => (S(), L("path", {
+              key: d.id,
+              d: d.pathData,
+              fill: "none",
+              stroke: "transparent",
+              "stroke-width": c.value.style.chart.edges.strokeWidth * (d.from === D.value || d.id === Y.value?.id ? 1.3 : 1),
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              "marker-end": y(x).arrowShape === "undirected" ? null : `url(#${dn(d.id)})`,
+              style: { "pointer-events": "none", transition: "stroke-width 0.2s ease-in-out, stroke 0.2s ease-in-out" }
+            }, null, 8, _r))), 128))
+          ]),
+          X("g", Cr, [
+            (S(!0), L(ge, null, Ve(y(x).nodes, (d) => (S(), L("g", {
+              key: d.id,
+              onClick: yn((g) => c.value.style.chart.nodes.tooltip.showOnClick && pt(d), ["stop"]),
+              onMouseenter: (g) => bt(d.id),
+              onMouseleave: (g) => un(d.id)
+            }, [
+              a.$slots["free-node-label"] ? $("", !0) : (S(), L(ge, { key: 0 }, [
+                a.$slots["node-label"] ? (S(), L("text", {
+                  key: 0,
+                  x: d.x,
+                  y: d.y + c.value.style.chart.nodes.labels.fontSize / 3,
+                  "text-anchor": "middle",
+                  "font-size": c.value.style.chart.nodes.labels.fontSize,
+                  fill: D.value === d.id && c.value.style.chart.nodes.selected.labelColor != null ? c.value.style.chart.nodes.selected.labelColor : d.original.color,
+                  "font-weight": c.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                  style: { transition: "fill 0.2s ease-in-out" }
+                }, [
+                  R(a.$slots, "node-label", Te({ ref_for: !0 }, { node: d, orientation: ee.value }), () => [
+                    Ho(Me(d.label), 1)
+                  ], !0)
+                ], 8, Nr)) : !a.$slots["free-node-label"] && !a.$slots.node ? (S(), L("text", {
+                  key: 1,
+                  "data-cy-node-label": "",
+                  x: d.x,
+                  y: d.y + c.value.style.chart.nodes.labels.fontSize / 3,
+                  "text-anchor": "middle",
+                  "font-size": c.value.style.chart.nodes.labels.fontSize,
+                  fill: (D.value === d.id || cn(d.id)) && c.value.style.chart.nodes.selected.labelColor != null ? c.value.style.chart.nodes.selected.labelColor : d.original.color,
+                  "font-weight": c.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                  style: { transition: "fill 0.2s ease-in-out" },
+                  innerHTML: y(Yo)({
+                    content: d.label,
+                    fontSize: c.value.style.chart.nodes.labels.fontSize,
+                    fontWeight: c.value.style.chart.nodes.labels.bold ? "bold" : "normal",
+                    fill: (D.value === d.id || cn(d.id)) && c.value.style.chart.nodes.selected.labelColor != null ? c.value.style.chart.nodes.selected.labelColor : d.original.color,
+                    x: d.x,
+                    y: d.y,
+                    autoOffset: !0
+                  })
+                }, null, 8, Sr)) : $("", !0)
+              ], 64)),
+              a.$slots["free-node-label"] ? (S(), L("g", Lr, [
+                R(a.$slots, "free-node-label", Te({ ref_for: !0 }, { node: d, layoutData: y(x), orientation: ee.value }), void 0, !0)
+              ])) : $("", !0)
+            ], 40, xr))), 128))
+          ]),
+          R(a.$slots, "svg", {
+            svg: {
+              drawingArea: y(_e),
+              data: y(x),
+              orientation: ee.value,
+              isPrintingImg: y(ct) | y(dt) | ce.value,
+              isPrintingSvg: we.value
+            }
+          }, void 0, !0)
+        ], 46, ar)) : $("", !0),
+        a.$slots.hint ? (S(), L("div", Mr, [
+          R(a.$slots, "hint", H(W({ hint: c.value.a11y.translations.keyboardNavigation, isVisible: be.value })), void 0, !0)
+        ])) : $("", !0)
+      ]),
+      a.$slots.watermark ? (S(), L("div", Tr, [
+        R(a.$slots, "watermark", H(W({ isPrinting: y(ct) || y(dt) || ce.value || we.value })), void 0, !0)
+      ])) : $("", !0),
+      Ct(wn, { name: "fade" }, {
+        default: V(() => [
+          de.value ? (S(), oe(bn, {
+            key: 0,
+            to: fe.value ? m.value : "body"
+          }, [
+            X("div", {
+              "data-cy-tooltip-midpoint": "",
+              ref_key: "tooltipRef",
+              ref: st,
+              class: "vue-ui-dag-tooltip",
+              style: Le({
+                ...It.value,
+                maxWidth: c.value.style.chart.midpoints.tooltip.maxWidth,
+                "--vue-data-ui-dag-tooltip-background": c.value.style.chart.midpoints.tooltip.backgroundColor,
+                "--vue-data-ui-dag-tooltip-color": c.value.style.chart.midpoints.tooltip.color
+              }),
+              "data-position": Bt.value
+            }, [
+              R(a.$slots, "tooltip-midpoint", H(W({ edge: Y.value, layoutData: y(x) })), () => [
+                Y.value ? (S(), L("div", $r, Me(re(Y.value.from)?.label ?? Y.value.from) + " → " + Me(re(Y.value.to)?.label ?? Y.value.to), 1)) : $("", !0)
+              ], !0)
+            ], 12, Or)
+          ], 8, ["to"])) : $("", !0)
+        ]),
+        _: 3
+      }),
+      Ct(wn, { name: "fade" }, {
+        default: V(() => [
+          ie.value ? (S(), oe(bn, {
+            key: 0,
+            to: fe.value ? m.value : "body"
+          }, [
+            X("div", {
+              "data-cy-tooltip-node": "",
+              ref_key: "nodeTooltipRef",
+              ref: it,
+              class: "vue-ui-dag-node-tooltip",
+              style: Le({
+                maxWidth: c.value.style.chart.nodes.tooltip.maxWidth,
+                left: rt.value.left,
+                top: rt.value.top,
+                "--vue-data-ui-dag-node-tooltip-background": c.value.style.chart.nodes.tooltip.backgroundColor,
+                "--vue-data-ui-dag-node-tooltip-color": c.value.style.chart.nodes.tooltip.color
+              }),
+              "data-position": Ht.value
+            }, [
+              R(a.$slots, "tooltip-node", H(W({ node: Ae.value, layoutData: y(x) })), () => [
+                Ae.value ? (S(), L("div", Pr, Me(Ae.value.label), 1)) : $("", !0)
+              ], !0)
+            ], 12, Rr)
+          ], 8, ["to"])) : $("", !0)
+        ]),
+        _: 3
+      }),
+      c.value.style.chart.controls.position === "bottom" && !y(Fe) && c.value.style.chart.controls.show ? (S(), oe(Cn, {
+        key: 7,
+        ref_key: "zoomControls",
+        ref: M,
+        config: c.value,
+        scale: y(Jt),
+        isFullscreen: fe.value,
+        withDirection: "",
+        onZoomIn: ht,
+        onZoomOut: mt,
+        onResetZoom: v[1] || (v[1] = () => y(Ue)(!0)),
+        onSwitchDirection: gt
+      }, null, 8, ["config", "scale", "isFullscreen"])) : $("", !0),
+      a.$slots.source ? (S(), L("div", {
+        key: 8,
+        ref_key: "source",
+        ref: O,
+        dir: "auto"
+      }, [
+        R(a.$slots, "source", {}, void 0, !0)
+      ], 512)) : $("", !0),
+      R(a.$slots, "skeleton", {}, () => [
+        y(Fe) ? (S(), oe(Jo, { key: 0 })) : $("", !0)
+      ], !0)
+    ], 46, or));
+  }
+}, ta = /* @__PURE__ */ ls(Dr, [["__scopeId", "data-v-b2f198cc"]]);
+export {
+  ta as default
+};