@salilvnair/dui 1.0.1 → 1.0.4

package/dist/vis-setup.js

@@ -0,0 +1,501 @@
+import { m as Xt, r as Yt } from "./chunks/vis-runtime-DkpA8K_T.js";
+import { jsxs as Ut, jsx as Mt } from "react/jsx-runtime";
+import { useRef as M, useEffect as Et } from "react";
+import { DataSet as Rt } from "vis-data/peer";
+import { Network as Kt } from "vis-network/peer";
+const ut = [
+  "#4E79A7",
+  "#F28E2B",
+  "#E15759",
+  "#76B7B2",
+  "#59A14F",
+  "#EDC948",
+  "#B07AA1",
+  "#FF9DA7",
+  "#9C755F",
+  "#BAB0AC"
+], at = 0.12, Vt = 300, Zt = 0.45, Tt = 220, qt = 120, lt = 96, kt = {
+  dark: {
+    text: "#d4d4d4",
+    chipBg: "rgba(37, 37, 38, 0.85)",
+    chipBorder: "rgba(255,255,255,0.12)",
+    minimapBg: "rgba(17, 24, 39, 0.85)",
+    minimapBorder: "rgba(255,255,255,0.2)",
+    viewportStroke: "#ffffff"
+  },
+  light: {
+    text: "#1f2328",
+    chipBg: "rgba(255, 255, 255, 0.9)",
+    chipBorder: "rgba(0,0,0,0.12)",
+    minimapBg: "rgba(249, 250, 251, 0.92)",
+    minimapBorder: "rgba(0,0,0,0.15)",
+    viewportStroke: "#1f2328"
+  }
+};
+function Wt(e) {
+  return e.color ? e.color : e.communityId != null ? ut[e.communityId % ut.length] : "#6B7280";
+}
+const Jt = (e, s) => e.left < s.right && e.right > s.left && e.top < s.bottom && e.bottom > s.top;
+function Qt() {
+  const e = /* @__PURE__ */ new Map(), s = (i, c) => i * 73856093 ^ c * 19349663, f = (i, c) => {
+    const m = Math.floor(i.left / lt), C = Math.floor(i.right / lt), O = Math.floor(i.top / lt), K = Math.floor(i.bottom / lt);
+    for (let N = m; N <= C; N++) for (let x = O; x <= K; x++) c(s(N, x));
+  };
+  return {
+    collides(i) {
+      let c = !1;
+      return f(i, (m) => {
+        if (c) return;
+        const C = e.get(m);
+        if (C) {
+          for (let O = 0; O < C.length; O++) if (Jt(i, C[O])) {
+            c = !0;
+            return;
+          }
+        }
+      }), c;
+    },
+    insert(i) {
+      f(i, (c) => {
+        const m = e.get(c);
+        m ? m.push(i) : e.set(c, [i]);
+      });
+    }
+  };
+}
+function te(e) {
+  const s = document.createElement("div");
+  return s.style.position = "absolute", s.style.borderRadius = "9999px", s.style.letterSpacing = "0.01em", s.style.whiteSpace = "nowrap", s.style.pointerEvents = "none", s.style.display = "none", e == null || e.appendChild(s), s;
+}
+function _t(e, s, f) {
+  e.textContent !== s && (e.textContent = s), e.style.padding !== f.padding && (e.style.padding = f.padding);
+  const i = `${f.fontSize}px`;
+  e.style.fontSize !== i && (e.style.fontSize = i);
+  const c = String(f.fontWeight);
+  e.style.fontWeight !== c && (e.style.fontWeight = c), e.style.background !== f.bg && (e.style.background = f.bg);
+  const m = `1px solid ${f.border}`;
+  e.style.border !== m && (e.style.border = m), e.style.color !== f.color && (e.style.color = f.color);
+}
+function ee(e) {
+  return {
+    color: e,
+    bg: `color-mix(in srgb, ${e} 16%, transparent)`,
+    border: `color-mix(in srgb, ${e} 40%, transparent)`,
+    fontSize: 12,
+    fontWeight: 600,
+    padding: "3px 9px"
+  };
+}
+function ne(e) {
+  return {
+    color: e.text,
+    bg: e.chipBg,
+    border: e.chipBorder,
+    fontSize: 10,
+    fontWeight: 500,
+    padding: "2px 7px"
+  };
+}
+function $t(e, s, f) {
+  const i = new Set(f.filter((x) => x.communityId === s).map((x) => x.id));
+  if (i.size < 2) return;
+  for (const x of i)
+    if (!e.findNode(x).length || e.isCluster(x)) return;
+  const c = ut[s % ut.length], m = `cluster:community:${s}`, C = `Community ${s} (${i.size})`, O = Math.min(20 + i.size * 2, 60), K = Math.max(11, Math.min(16, Math.round(O * 0.32))), N = -(O + K * 0.5);
+  e.cluster({
+    joinCondition: (x) => i.has(x.id),
+    // vis-network genuinely accepts `id` in clusterNodeProperties at runtime
+    // (it's how you address the cluster later via openCluster/isCluster) —
+    // the shipped .d.ts's NodeOptions type just doesn't declare it.
+    clusterNodeProperties: {
+      id: m,
+      // Member count only — the full name is tooltip + legend-panel only
+      // (see the doc comment above). Not empty string: vis-network defaults
+      // `label` to the literal "cluster" when it's `undefined`, which would
+      // otherwise draw a stray caption under every collapsed community.
+      label: String(i.size),
+      font: { color: "#ffffff", size: K, vadjust: N },
+      title: C,
+      shape: "dot",
+      // Larger + white-ringed so a collapsed community reads as a distinct
+      // "group" at a glance, not just another same-sized leaf node.
+      size: O,
+      borderWidth: 3,
+      color: { background: c, border: "#ffffff", highlight: { background: c, border: "#ffffff" } },
+      // Soft colored glow (a hint of the community's own color) instead of a
+      // flat plain circle — same "elevated card" depth language dui's own
+      // panels use, just expressed on canvas.
+      shadow: { enabled: !0, color: `${c}66`, size: 16, x: 0, y: 4 }
+    }
+  });
+}
+function oe({
+  nodes: e,
+  edges: s,
+  onNodeClick: f,
+  selectedId: i,
+  fitTrigger: c,
+  onReady: m,
+  colorBy: C,
+  sizeBy: O,
+  className: K = "",
+  style: N,
+  enableClustering: x = !1,
+  enableHoverDim: St = !1,
+  enableMinimap: q = !1,
+  theme: ft = "dark"
+}) {
+  const V = M(null), dt = M(null), j = M(null), Dt = M(null), Bt = M(null), Z = M(/* @__PURE__ */ new Map()), Ct = M(/* @__PURE__ */ new Map()), Ot = M(/* @__PURE__ */ new Map()), zt = M(null), pt = M([]), ht = M([]), gt = M(/* @__PURE__ */ new Map()), k = M(i);
+  k.current = i;
+  const X = M(!1);
+  Et(() => {
+    if (!V.current) return;
+    let u = null;
+    Z.current = new Map(e.map((t) => [t.id, t]));
+    const w = {}, y = /* @__PURE__ */ new Map(), z = /* @__PURE__ */ new Map();
+    s.forEach((t, n) => {
+      w[t.source] = (w[t.source] ?? 0) + 1, w[t.target] = (w[t.target] ?? 0) + 1, y.has(t.source) || y.set(t.source, /* @__PURE__ */ new Set()), y.has(t.target) || y.set(t.target, /* @__PURE__ */ new Set()), y.get(t.source).add(t.target), y.get(t.target).add(t.source);
+      const r = t.id ?? n;
+      z.has(t.source) || z.set(t.source, /* @__PURE__ */ new Set()), z.has(t.target) || z.set(t.target, /* @__PURE__ */ new Set()), z.get(t.source).add(r), z.get(t.target).add(r);
+    }), Ct.current = y, Ot.current = z;
+    const L = Math.max(1, ...Object.values(w)), R = kt[ft], J = /* @__PURE__ */ new Map(), bt = e.map((t) => {
+      const n = C ? C(t) : Wt(t);
+      J.set(t.id, n);
+      const r = w[t.id] ?? 1, a = O ? O(t, r, L) : 10 + 30 * (r / L);
+      return {
+        id: t.id,
+        title: t.label,
+        // No `label` here on purpose: every label is a pooled DOM chip
+        // positioned by syncAllChipPositions. Collapsed community nodes are
+        // the one exception and set their own label natively — see
+        // clusterCommunity.
+        // Selection keeps the node's own fill and flags it with a themed
+        // border instead — the old highlight swapped the fill to the theme
+        // text color, which read as a jarring near-black circle in light
+        // mode (and near-white in dark).
+        color: { background: n, border: n, highlight: { background: n, border: R.text } },
+        size: Math.round(a * 10) / 10,
+        shape: "dot"
+      };
+    }), nt = s.map((t, n) => ({
+      id: t.id ?? n,
+      from: t.source,
+      to: t.target,
+      title: t.type,
+      // Blends from the source node's color to the target's at the
+      // midpoint instead of a flat gray line — a vis-network-native
+      // stand-in for the gradient edges ck8t's ReactFlow canvas uses.
+      color: { inherit: "both", opacity: 0.55 },
+      arrows: { to: { enabled: !0, scaleFactor: 0.6 } }
+    })), F = new Rt(bt), W = new Rt(nt);
+    Dt.current = F, Bt.current = W;
+    const Q = e.length > Vt, wt = {
+      // vis-network defaults `layout.improvedLayout` to true, which runs a
+      // Kamada-Kawai pre-positioning pass whenever the graph exceeds its
+      // internal clusterThreshold (150 nodes). On graphs with many
+      // uneven-sized communities that pass regularly fails to reduce the
+      // graph within its own iteration budget: it logs "This network could
+      // not be positioned by this version of the improved layout
+      // algorithm" and falls back to leaving most nodes near their default
+      // circular starting positions with a ±35px jitter — the stray ring of
+      // dots around the outside that physics then can't pull in within its
+      // stabilization budget. Skipping the pre-pass (vis's own documented
+      // suggestion, printed in that same message) lets forceAtlas2Based
+      // position everything from a clean random start instead.
+      layout: { improvedLayout: !1 },
+      physics: {
+        enabled: !0,
+        solver: "forceAtlas2Based",
+        forceAtlas2Based: {
+          gravitationalConstant: -60,
+          centralGravity: 5e-3,
+          springLength: 120,
+          springConstant: 0.08,
+          damping: 0.4,
+          avoidOverlap: 0.8
+        },
+        stabilization: { iterations: 200, fit: !0 }
+      },
+      // hideEdgesOnZoom mirrors hideEdgesOnDrag below — edges (continuous
+      // smooth curves + shadows) are by far the most expensive thing on
+      // canvas to redraw every frame; hiding them for the duration of a
+      // zoom gesture (mouse wheel or pinch) is what actually fixes "zoom
+      // feels like a turtle" on a large graph, vs. anything in our own
+      // event handlers (which only ever ran custom code on TOP of vis's
+      // own native per-frame draw loop, never touched by throttling it).
+      interaction: {
+        hover: !0,
+        tooltipDelay: 100,
+        hideEdgesOnDrag: !0,
+        hideEdgesOnZoom: !0,
+        navigationButtons: !1
+      },
+      // Soft drop shadow on every node — same elevated-card depth cue dui's
+      // own panels use, expressed via canvas shadow instead of CSS box-shadow.
+      // Shadows aren't covered by hideEdgesOnZoom (nodes stay visible while
+      // zooming) and shadowBlur is one of canvas's most expensive per-shape
+      // operations — skip them above LARGE_GRAPH_NODE_THRESHOLD.
+      nodes: {
+        shape: "dot",
+        borderWidth: 1.5,
+        borderWidthSelected: 3,
+        shadow: { enabled: !Q, color: "rgba(0,0,0,0.35)", size: 8, x: 0, y: 3 }
+      },
+      edges: {
+        // 'continuous' recomputes bezier control points per edge per draw —
+        // the most expensive of vis-network's smooth types. Straight lines
+        // above the threshold; edges are hidden during zoom either way.
+        smooth: Q ? !1 : { enabled: !0, type: "continuous", roundness: 0.25 },
+        shadow: { enabled: !Q, color: "rgba(0,0,0,0.12)", size: 3, x: 0, y: 1 }
+      }
+    }, o = new Kt(V.current, { nodes: F, edges: W }, wt);
+    j.current = o;
+    const G = () => {
+      const t = dt.current;
+      if (!t || !q) return;
+      const n = t.getContext("2d");
+      if (!n) return;
+      const r = o.getPositions(), a = Object.values(r).map((l) => l.x), d = Object.values(r).map((l) => l.y);
+      if (a.length === 0) return;
+      const S = Math.min(...a), D = Math.max(...a), p = Math.min(...d), et = Math.max(...d), U = t.width, H = t.height, it = Math.max(1, D - S), st = Math.max(1, et - p), h = (l, v) => [
+        (l - S) / it * (U - 10) + 5,
+        (v - p) / st * (H - 10) + 5
+      ];
+      n.clearRect(0, 0, U, H), n.fillStyle = R.minimapBg, n.fillRect(0, 0, U, H), Object.entries(r).forEach(([l, v]) => {
+        const [B, b] = h(v.x, v.y), A = Z.current.get(l);
+        n.fillStyle = A ? C ? C(A) : Wt(A) : "#6B7280", n.beginPath();
+        const _ = w[l] ?? 0;
+        n.arc(B, b, 1 + 1.5 * (_ / L), 0, Math.PI * 2), n.fill();
+      });
+      const g = o.getScale(), E = o.getViewPosition(), T = V.current;
+      if (T && g > 0) {
+        const l = T.clientWidth / g, v = T.clientHeight / g, [B, b] = h(E.x - l / 2, E.y - v / 2), [A, _] = h(E.x + l / 2, E.y + v / 2);
+        n.strokeStyle = R.viewportStroke, n.lineWidth = 1, n.strokeRect(B, b, A - B, _ - b);
+      }
+    };
+    let I = null;
+    const ot = () => {
+      I = null;
+    };
+    let xt = null, vt = null;
+    const At = /* @__PURE__ */ new Map();
+    s.forEach((t, n) => {
+      t.type && At.set(t.id ?? n, t.type);
+    });
+    const Pt = (t, n) => {
+      let r = t[n];
+      return r || (r = te(zt.current), t[n] = r), r;
+    }, Lt = (t, n, r) => {
+      const a = `${n}\0${r}`;
+      let d = gt.current.get(a);
+      return d || (d = { w: t.offsetWidth, h: t.offsetHeight }, gt.current.set(a, d)), d;
+    }, rt = (t, n) => {
+      for (let r = n; r < t.length; r++)
+        t[r].style.display !== "none" && (t[r].style.display = "none");
+    }, Y = () => {
+      var it, st;
+      const t = pt.current, n = ht.current, r = ((it = V.current) == null ? void 0 : it.clientWidth) ?? 0, a = ((st = V.current) == null ? void 0 : st.clientHeight) ?? 0;
+      if (o.getScale() < Zt || !r || !a) {
+        rt(t, 0), rt(n, 0);
+        return;
+      }
+      I || (I = o.getPositions());
+      const d = o.DOMtoCanvas({ x: 0, y: 0 }), S = o.DOMtoCanvas({ x: r, y: a }), D = [];
+      for (const h in I) {
+        const g = I[h];
+        g.x < d.x || g.x > S.x || g.y < d.y || g.y > S.y || Z.current.has(h) && D.push({ id: h, deg: w[h] ?? 0 });
+      }
+      D.length > Tt && (D.sort((h, g) => g.deg - h.deg), D.length = Tt);
+      const p = Qt(), et = 12;
+      let U = 0;
+      for (const h of D) {
+        const g = Z.current.get(h.id);
+        if (!(g != null && g.label) || o.findNode(h.id).length !== 1) continue;
+        const E = o.getBoundingBox(h.id);
+        if (!E) continue;
+        const T = o.canvasToDOM({ x: (E.left + E.right) / 2, y: E.bottom }), l = Pt(t, U);
+        _t(l, g.label, ee(J.get(h.id) ?? "#6B7280")), l.style.display !== "" && (l.style.display = "");
+        const v = !xt || xt.has(h.id) ? "1" : String(at);
+        l.style.opacity !== v && (l.style.opacity = v);
+        const { w: B, h: b } = Lt(l, "n", g.label), A = T.x - B / 2, _ = T.y + 6;
+        let $ = A, P = _;
+        for (let ct = 0; ct < et; ct++) {
+          const Nt = Math.floor(ct / 3), jt = ct % 3 - 1;
+          if ($ = A + jt * (B + 6), P = _ + Nt * (b + 3), !p.collides({ left: $, top: P, right: $ + B, bottom: P + b })) break;
+        }
+        l.style.left = `${$}px`, l.style.top = `${P}px`, p.insert({ left: $, top: P, right: $ + B, bottom: P + b }), U++;
+      }
+      rt(t, U);
+      let H = 0;
+      for (const [h, g] of At) {
+        if (H >= qt) break;
+        const E = W.get(h);
+        if (!E) continue;
+        const T = I[E.from], l = I[E.to];
+        if (!T || !l) continue;
+        const v = { x: (T.x + l.x) / 2, y: (T.y + l.y) / 2 };
+        if (v.x < d.x || v.x > S.x || v.y < d.y || v.y > S.y || o.findNode(E.from).length !== 1 || o.findNode(E.to).length !== 1) continue;
+        const B = o.canvasToDOM(v), b = Pt(n, H);
+        _t(b, g, ne(R)), b.style.display !== "" && (b.style.display = "");
+        const A = !vt || vt.has(h) ? "1" : String(at);
+        b.style.opacity !== A && (b.style.opacity = A);
+        const { w: _, h: $ } = Lt(b, "e", g), P = { left: B.x - _ / 2, top: B.y - $ / 2, right: B.x + _ / 2, bottom: B.y + $ / 2 };
+        if (p.collides(P)) {
+          b.style.display = "none";
+          continue;
+        }
+        b.style.left = `${P.left}px`, b.style.top = `${P.top}px`, p.insert(P), H++;
+      }
+      rt(n, H);
+    };
+    let tt = null;
+    const Ht = () => {
+      X.current || tt === null && (tt = requestAnimationFrame(() => {
+        tt = null, Y();
+      }));
+    };
+    if (o.once("stabilizationIterationsDone", () => {
+      o.setOptions({ physics: { enabled: !1 } });
+      let t = !1;
+      if (x) {
+        const r = new Set(e.map((a) => a.communityId).filter((a) => a != null));
+        r.forEach((a) => $t(o, a, e)), r.size > 1 && (t = !0, o.once("stabilizationIterationsDone", () => {
+          o.setOptions({ physics: { enabled: !1 } }), G(), ot(), Y(), k.current && o.findNode(k.current).length > 0 && (o.selectNodes([k.current]), o.focus(k.current, { scale: 1.4, animation: !0 }), X.current = !0), m == null || m();
+        }), o.setOptions({
+          physics: { enabled: !0, stabilization: { iterations: 80, fit: !1 } }
+        }), o.stabilize(80));
+      }
+      const n = o.getScale();
+      n > 0 && o.moveTo({ scale: n * 0.92 }), G(), ot(), Y(), t || (k.current && o.findNode(k.current).length > 0 && (o.selectNodes([k.current]), o.focus(k.current, { scale: 1.4, animation: !0 }), X.current = !0), m == null || m());
+    }), o.on("afterDrawing", Ht), o.on("dragEnd", () => {
+      ot(), Y();
+    }), o.on("animationFinished", () => {
+      X.current = !1, Y(), q && G();
+    }), o.on("click", (t) => {
+      if (t.nodes.length === 0) return;
+      const n = t.nodes[0], r = Z.current.get(n);
+      if (r) {
+        f == null || f(r);
+        return;
+      }
+      o.isCluster(n) && (f == null || f({ id: n, label: n }));
+    }), x && o.on("doubleClick", (t) => {
+      if (t.nodes.length !== 1) return;
+      const n = t.nodes[0];
+      if (o.isCluster(n))
+        o.openCluster(n);
+      else {
+        const r = Z.current.get(n);
+        (r == null ? void 0 : r.communityId) != null && $t(o, r.communityId, e);
+      }
+      G(), ot(), Y();
+    }), St) {
+      let t = new Set(F.getIds()), n = new Set(W.getIds());
+      const r = (a, d) => {
+        const S = [];
+        for (const p of a) t.has(p) || S.push({ id: p, opacity: 1 });
+        for (const p of t) a.has(p) || S.push({ id: p, opacity: at });
+        S.length && F.update(S);
+        const D = [];
+        for (const p of d)
+          n.has(p) || D.push({ id: p, color: { inherit: "both", opacity: 0.9 } });
+        for (const p of n)
+          d.has(p) || D.push({ id: p, color: { inherit: "both", opacity: at } });
+        D.length && W.update(D), xt = a, vt = d, Y(), t = a, n = d;
+      };
+      o.on("hoverNode", (a) => {
+        u !== null && (clearTimeout(u), u = null);
+        const d = a.node, S = Ct.current.get(d) ?? /* @__PURE__ */ new Set(), D = new Set(
+          [d, ...S].filter((et) => F.get(et) != null)
+        ), p = Ot.current.get(d) ?? /* @__PURE__ */ new Set();
+        r(D, p);
+      }), o.on("blurNode", () => {
+        u = setTimeout(() => {
+          u = null, r(new Set(F.getIds()), new Set(W.getIds()));
+        }, 80);
+      });
+    }
+    if (q) {
+      o.on("dragEnd", G);
+      let t = 0;
+      const n = () => {
+        if (X.current) return;
+        const r = Date.now();
+        r - t < 100 || (t = r, G());
+      };
+      o.on("zoom", n), o.on("afterDrawing", n);
+    }
+    return () => {
+      u !== null && clearTimeout(u), tt !== null && cancelAnimationFrame(tt), o.destroy(), j.current = null, Dt.current = null, Bt.current = null;
+      for (const t of pt.current) t.remove();
+      pt.current = [];
+      for (const t of ht.current) t.remove();
+      ht.current = [], gt.current.clear();
+    };
+  }, [e, s, x, St, q, ft]), Et(() => {
+    const u = j.current;
+    !u || !i || u.findNode(i).length > 0 && (u.selectNodes([i]), u.focus(i, { scale: 1.4, animation: !0 }), X.current = !0);
+  }, [i, e]);
+  const mt = M(c);
+  Et(() => {
+    const u = j.current;
+    if (!u || c === void 0 || c === mt.current) {
+      mt.current = c;
+      return;
+    }
+    mt.current = c, u.unselectAll(), u.fit({ animation: !0 }), X.current = !0;
+  }, [c]);
+  const It = (u) => {
+    const w = j.current, y = dt.current;
+    if (!w || !y) return null;
+    const z = w.getPositions(), L = Object.values(z).map((I) => I.x), R = Object.values(z).map((I) => I.y);
+    if (L.length === 0) return null;
+    const J = Math.min(...L), bt = Math.max(...L), nt = Math.min(...R), F = Math.max(...R), W = y.getBoundingClientRect(), Q = u.clientX - W.left, wt = u.clientY - W.top, o = Math.max(1, bt - J), G = Math.max(1, F - nt);
+    return {
+      x: (Q - 5) / (y.width - 10) * o + J,
+      y: (wt - 5) / (y.height - 10) * G + nt
+    };
+  }, Ft = (u) => {
+    var y;
+    const w = It(u);
+    w && ((y = j.current) == null || y.moveTo({ position: w, animation: !0 }));
+  }, yt = M(!1), Gt = (u) => {
+    yt.current = !0;
+    const w = (z) => {
+      var R;
+      if (!yt.current) return;
+      const L = It(z);
+      L && ((R = j.current) == null || R.moveTo({ position: L }));
+    }, y = () => {
+      yt.current = !1, window.removeEventListener("mousemove", w), window.removeEventListener("mouseup", y);
+    };
+    window.addEventListener("mousemove", w), window.addEventListener("mouseup", y), u.preventDefault();
+  };
+  return /* @__PURE__ */ Ut("div", { className: K, style: { width: "100%", height: "100%", position: "relative", ...N }, children: [
+    /* @__PURE__ */ Mt("div", { ref: V, style: { width: "100%", height: "100%" } }),
+    /* @__PURE__ */ Mt("div", { ref: zt, style: { position: "absolute", inset: 0, overflow: "hidden", pointerEvents: "none" } }),
+    q && /* @__PURE__ */ Mt(
+      "canvas",
+      {
+        ref: dt,
+        width: 140,
+        height: 100,
+        onClick: Ft,
+        onMouseDown: Gt,
+        style: {
+          // bottom 72 (not 8): host apps commonly float a chat/action
+          // orb in the bottom-right corner — leave that spot free.
+          position: "absolute",
+          bottom: 72,
+          right: 8,
+          borderRadius: 4,
+          border: `1px solid ${kt[ft].minimapBorder}`,
+          cursor: "grab"
+        }
+      }
+    )
+  ] });
+}
+Yt(oe);
+Xt();
+//# sourceMappingURL=vis-setup.js.map