@jmbarzee/force-graph 0.0.1

package/dist-lib/index.js

@@ -0,0 +1,4895 @@
+var gi = Object.defineProperty;
+var pi = (e, t, n) => t in e ? gi(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var Ze = (e, t, n) => pi(e, typeof t != "symbol" ? t + "" : t, n);
+import { jsx as h, jsxs as C, Fragment as yn } from "react/jsx-runtime";
+import g from "react";
+const _n = g.createContext(null);
+function Bt() {
+  const e = g.useContext(_n);
+  if (e === null)
+    throw new Error(
+      "useTaxonomy() was called with no TaxonomyContext.Provider above it. The graph engine resolves styles, filter keys, spring categories and physics through the taxonomy, so there is no meaningful default — wrap the tree in <TaxonomyContext.Provider value={…}>."
+    );
+  return e;
+}
+function mi(e, t) {
+  const n = e.emptyMeans === "none", s = e.id === t.axis, o = e.labelFor ?? (s ? t.labelFor : (a) => a), i = e.abbreviationFor ?? (s ? t.abbreviationFor : (a) => o(a).slice(0, 2)), r = e.keepCamera ?? !n, c = e.iconFor ?? (s ? t.iconFor : () => "");
+  return {
+    id: e.id,
+    label: e.label ?? e.id,
+    emptyMeans: e.emptyMeans,
+    absentMeans: e.absentMeans ?? (n ? "hidden" : "visible"),
+    widens: e.widens ?? (n ? "always" : "whenActive"),
+    keepCamera: r,
+    labelFor: o,
+    abbreviationFor: i,
+    tooltipFor: e.tooltipFor,
+    iconFor: c,
+    chipsFor: e.chipsFor ?? ((a) => a.map((l) => {
+      var d;
+      return {
+        id: l,
+        label: o(l),
+        icon: c(l) || void 0,
+        tint: s ? l : void 0,
+        tooltip: (d = e.tooltipFor) == null ? void 0 : d.call(e, l),
+        values: [l]
+      };
+    })),
+    initialSelection: e.initialSelection ?? ((a) => n ? a : []),
+    presentation: e.presentation ?? "chip"
+  };
+}
+function vi(e) {
+  const t = /* @__PURE__ */ new Map(), n = [], s = /* @__PURE__ */ new Set();
+  for (const i of e.buckets) {
+    s.has(i.id) && n.push(`bucket id ${JSON.stringify(i.id)} is declared twice`), s.add(i.id), i.values.length === 0 && n.push(`bucket ${JSON.stringify(i.id)} has no values`);
+    for (const r of i.values) {
+      const c = t.get(r);
+      c !== void 0 && c !== i.id ? n.push(`${JSON.stringify(r)} is in both ${c} and ${i.id}`) : t.set(r, i.id);
+    }
+  }
+  if (n.length > 0)
+    throw new Error(
+      `axis mapping ${JSON.stringify(e.id)} is incoherent: ` + n.join("; ") + ". A value in two buckets has no defined answer for which one tunes it."
+    );
+  const o = /* @__PURE__ */ new Map();
+  for (const i of e.buckets)
+    for (const r of i.values) o.set(r, i);
+  return {
+    id: e.id,
+    label: e.label,
+    axis: e.axis,
+    buckets: e.buckets,
+    bucketFor: (i) => i === void 0 ? void 0 : o.get(i)
+  };
+}
+function Vn(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  return vi({
+    id: `${e.id}:identity`,
+    label: e.label,
+    axis: e.id,
+    buckets: t.map((s) => {
+      const o = e.abbreviationFor(s), i = (n.get(o) ?? 0) + 1;
+      return n.set(o, i), {
+        id: s,
+        label: e.labelFor(s),
+        abbreviation: i === 1 ? o : `${o}${i}`,
+        values: [s]
+      };
+    })
+  });
+}
+function Fs(e) {
+  return e.buckets.every((t) => t.values.length === 1 && t.values[0] === t.id);
+}
+function sn(e, t) {
+  const n = /* @__PURE__ */ new Set();
+  for (const s of e) {
+    const o = s.values[t];
+    o !== void 0 && n.add(o);
+  }
+  return [...n];
+}
+function _o(e, t) {
+  const n = new Map(t.map((i) => [i, /* @__PURE__ */ new Map()])), s = new Map(t.map((i) => [i, /* @__PURE__ */ new Map()]));
+  let o = 0;
+  for (const i of e) {
+    const r = i.copyKey ?? i.id ?? `\0${o++}`;
+    for (const c of t) {
+      const a = i.values[c];
+      if (a === void 0) continue;
+      const l = n.get(c);
+      let d = l.get(a);
+      if (d || (d = /* @__PURE__ */ new Set(), l.set(a, d)), d.has(r)) continue;
+      d.add(r);
+      const u = s.get(c);
+      u.set(a, (u.get(a) ?? 0) + 1);
+    }
+  }
+  return s;
+}
+function Rn(e, t) {
+  return Object.prototype.hasOwnProperty.call(e, t);
+}
+function yi(e) {
+  return { alpha: e.emptyMeans === "none" ? 0.5 : 0.3, seedRevealed: !e.keepCamera, refit: !e.keepCamera, resume: !0 };
+}
+function bi(e) {
+  let t = 0, n = !1, s = !1, o = !1;
+  for (const i of e) {
+    const r = yi(i);
+    t = Math.max(t, r.alpha), n = n || r.seedRevealed, s = s || r.refit, o = o || r.resume;
+  }
+  return { alpha: t, seedRevealed: n, refit: s, resume: o, changed: e.map((i) => i.id) };
+}
+function Mt(e, t, n, s) {
+  const [o, i] = g.useState(n), r = e !== void 0;
+  Bo(s, r);
+  const c = g.useRef(t);
+  c.current = t;
+  const a = g.useCallback((l) => {
+    var d;
+    r || i(l), (d = c.current) == null || d.call(c, l);
+  }, [r]);
+  return [r ? e : o, a];
+}
+function Bo(e, t) {
+  const n = g.useRef(t), s = g.useRef(!1);
+  g.useEffect(() => {
+    n.current !== t && !s.current && (s.current = !0, console.warn(`[force-graph] \`${e}\` changed from ${n.current ? "controlled to uncontrolled" : "uncontrolled to controlled"}: pass a value on every render (null for none), or on none.`)), n.current = t;
+  }, [t, e]);
+}
+function Ft(e, t) {
+  const n = g.useRef(e);
+  return n.current !== e && !t(n.current, e) && (n.current = e), n.current;
+}
+function Te(e) {
+  const t = g.useRef(e);
+  return t.current = e, t;
+}
+const Es = typeof window > "u" ? g.useEffect : g.useLayoutEffect, Ln = ["system", "light", "dark"];
+function Fl(e) {
+  return Ln.includes(e) ? e : "system";
+}
+const uo = "[data-theme]";
+function xi(e) {
+  if (!e) return;
+  const t = e.getAttribute("data-theme");
+  return t === "dark" || t === "light" ? t : void 0;
+}
+function fo(e) {
+  var n, s, o;
+  if (typeof window > "u") return "light";
+  let t = ((n = e == null ? void 0 : e.parentElement) == null ? void 0 : n.closest(uo)) ?? null;
+  for (; t; ) {
+    const i = xi(t);
+    if (i) return i;
+    t = ((s = t.parentElement) == null ? void 0 : s.closest(uo)) ?? null;
+  }
+  return (o = window.matchMedia) != null && o.call(window, "(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function wi(e, t = !0) {
+  const [n, s] = g.useState(() => t ? fo(e.current) : "light");
+  return Es(() => {
+    var c, a;
+    if (!t) return;
+    const o = () => s(fo(e.current));
+    if (o(), typeof MutationObserver > "u") return;
+    const i = new MutationObserver(o);
+    i.observe(document.documentElement, { attributes: !0, attributeFilter: ["data-theme"], subtree: !0 });
+    const r = (c = window.matchMedia) == null ? void 0 : c.call(window, "(prefers-color-scheme: dark)");
+    return (a = r == null ? void 0 : r.addEventListener) == null || a.call(r, "change", o), () => {
+      var l;
+      i.disconnect(), (l = r == null ? void 0 : r.removeEventListener) == null || l.call(r, "change", o);
+    };
+  }, [e, t]), n;
+}
+function Ho(e, t, n) {
+  const s = wi(e, n === void 0);
+  return t === "system" ? n ?? s : t;
+}
+function Tn(e) {
+  return e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function zo(e, t) {
+  const n = {};
+  for (const s of e.styleValues) {
+    const o = e.styleOf(s).color[t];
+    n[e.colorVar(s)] = o.fill, n[`${e.colorVar(s)}-border`] = o.border;
+  }
+  return n;
+}
+const Mi = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i, Si = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i, ki = /^rgba?\(\s*(\d{1,3})\s*[, ]\s*(\d{1,3})\s*[, ]\s*(\d{1,3})\s*(?:[,/]\s*[\d.]+%?\s*)?\)$/i, Ni = /^hsla?\(\s*(-?[\d.]+)(?:deg)?\s*[, ]\s*([\d.]+)%\s*[, ]\s*([\d.]+)%\s*(?:[,/]\s*[\d.]+%?\s*)?\)$/i;
+function Ei(e, t, n) {
+  const s = Math.min(100, Math.max(0, t)) / 100, o = Math.min(100, Math.max(0, n)) / 100, i = (e % 360 + 360) % 360, r = (1 - Math.abs(2 * o - 1)) * s, c = r * (1 - Math.abs(i / 60 % 2 - 1)), a = o - r / 2, [l, d, u] = i < 60 ? [r, c, 0] : i < 120 ? [c, r, 0] : i < 180 ? [0, r, c] : i < 240 ? [0, c, r] : i < 300 ? [c, 0, r] : [r, 0, c];
+  return [Math.round((l + a) * 255), Math.round((d + a) * 255), Math.round((u + a) * 255)];
+}
+function Vo(e) {
+  const t = e.trim();
+  let n = Si.exec(t);
+  if (n) return [parseInt(n[1], 16), parseInt(n[2], 16), parseInt(n[3], 16)];
+  if (n = Mi.exec(t), n) return [parseInt(n[1] + n[1], 16), parseInt(n[2] + n[2], 16), parseInt(n[3] + n[3], 16)];
+  if (n = ki.exec(t), n) return [Number(n[1]), Number(n[2]), Number(n[3])];
+  if (n = Ni.exec(t), n) return Ei(Number(n[1]), Number(n[2]), Number(n[3]));
+}
+const Ii = (e) => Vo(e) !== void 0, $i = [148, 163, 184], ho = /* @__PURE__ */ new Set();
+function fs(e, t) {
+  let n = Vo(e);
+  return n || (ho.has(e) || (ho.add(e), console.error(`[scheme] ${JSON.stringify(e)} is not a colour the canvas can read; drawing it neutral`)), n = $i), `rgba(${n[0]}, ${n[1]}, ${n[2]}, ${t})`;
+}
+function Ll(e, t = '[data-theme="dark"]') {
+  const n = [], s = [];
+  for (const i of e.styleValues) {
+    const { light: r, dark: c } = e.styleOf(i).color, a = e.colorVar(i);
+    n.push(`  ${a}: ${r.fill};`), n.push(`  ${a}-border: ${r.border};`), c.fill !== r.fill && s.push(`  ${a}: ${c.fill};`), c.border !== r.border && s.push(`  ${a}-border: ${c.border};`);
+  }
+  const o = [`:root {
+${n.join(`
+`)}
+}`];
+  return s.length > 0 && o.push(`${t} {
+${s.join(`
+`)}
+}`), o.join(`
+`);
+}
+function je(e) {
+  if (typeof e != "object" || e === null || Array.isArray(e)) return !1;
+  const t = Object.getPrototypeOf(e);
+  return t === Object.prototype || t === null;
+}
+function yt(e) {
+  return typeof e == "number" && Number.isFinite(e);
+}
+const Ci = /* @__PURE__ */ new Set();
+function ze(e, t) {
+  return e.get(t) ?? Ci;
+}
+function Gn(e, t) {
+  if (e === t) return !0;
+  if (e.size !== t.size) return !1;
+  for (const n of e) if (!t.has(n)) return !1;
+  return !0;
+}
+function on(e, t, n) {
+  if (Gn(ze(e, t), n)) return e;
+  const s = new Map(e);
+  return s.set(t, n), s;
+}
+function bn(e, t) {
+  if (e === t) return !0;
+  const n = /* @__PURE__ */ new Set([...e.keys(), ...t.keys()]);
+  for (const s of n)
+    if (!Gn(ze(e, s), ze(t, s))) return !1;
+  return !0;
+}
+function Go(e, t) {
+  if (e === t) return !0;
+  if (e.size !== t.size) return !1;
+  for (const [n, s] of e) if (t.get(n) !== s) return !1;
+  return !0;
+}
+function Xo(e, t) {
+  return e === t || e.length === t.length && e.every((n, s) => n === t[s]);
+}
+function Ai(e, t, n) {
+  const s = new Map(e);
+  return s.set(t, n), s;
+}
+function Ls(e, t) {
+  return e.get(t) ?? !1;
+}
+function Ps(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const s of e.filterAxes) {
+    const o = sn(t.nodes, s.id), i = new Set(s.initialSelection(o)), r = new Set(o);
+    for (const c of s.chipsFor(o)) {
+      const a = c.values.filter((d) => r.has(d)), l = a.filter((d) => i.has(d));
+      if (!(!c.values.some((d) => i.has(d)) || l.length === a.length)) {
+        for (const d of a) i.add(d);
+        Ri(e, s.id, c.id, a.filter((d) => !l.includes(d)));
+      }
+    }
+    n.set(s.id, i);
+  }
+  return n;
+}
+function Yo(e, t, n, s = /* @__PURE__ */ new Set()) {
+  const o = Ps(t, n);
+  let i = e;
+  for (const r of t.filterAxes)
+    s.has(r.id) || (i = on(i, r.id, ze(o, r.id)));
+  return i;
+}
+function Oi(e, t) {
+  const n = [];
+  for (const s of /* @__PURE__ */ new Set([...e.keys(), ...t.keys()]))
+    Gn(ze(e, s), ze(t, s)) || n.push(s);
+  return n;
+}
+const go = /* @__PURE__ */ new WeakMap();
+function Ri(e, t, n, s) {
+  let o = go.get(e);
+  o || (o = /* @__PURE__ */ new Set(), go.set(e, o));
+  const i = `${t}\0${n}`;
+  o.has(i) || (o.add(i), console.warn(`[filter] the initial selection on axis ${JSON.stringify(t)} splits the chip ${JSON.stringify(n)}; the whole chip is selected (${s.map((r) => JSON.stringify(r)).join(", ")} added). Choose a selection the chips can show.`));
+}
+function Pl(e) {
+  return Object.fromEntries([...e].map(([t, n]) => [t, [...n]]));
+}
+function Dl(e) {
+  if (!je(e)) return;
+  const t = /* @__PURE__ */ new Map();
+  for (const [n, s] of Object.entries(e)) {
+    if (!Array.isArray(s) || !s.every((o) => typeof o == "string")) return;
+    t.set(n, new Set(s));
+  }
+  return t;
+}
+function _l(e) {
+  return Object.fromEntries([...e]);
+}
+function Bl(e) {
+  if (!je(e)) return;
+  const t = /* @__PURE__ */ new Map();
+  for (const [n, s] of Object.entries(e)) {
+    if (typeof s != "boolean") return;
+    t.set(n, s);
+  }
+  return t;
+}
+function Hl(e, t) {
+  for (const [n, s] of Object.entries(t.values))
+    if (s !== void 0 && e.values[n] !== s) return !1;
+  return !0;
+}
+function Ti(e) {
+  return typeof e == "object" && e !== null;
+}
+function zl({ filter: e, taxonomy: t, axes: n, node: s, valueOn: o }) {
+  const i = o ?? ((r, c) => {
+    var a;
+    return Ti(r) ? (a = r.values) == null ? void 0 : a[c] : void 0;
+  });
+  for (const r of n) {
+    const c = t.axisFor(r);
+    if (c && !Xn(e, [c], (a) => i(s, a))) return !1;
+  }
+  return !0;
+}
+function Xn(e, t, n) {
+  for (const s of t) {
+    const o = ze(e, s.id);
+    if (o.size === 0) {
+      if (s.emptyMeans === "none") return !1;
+      continue;
+    }
+    const i = n(s.id);
+    if (i === void 0) {
+      if (s.absentMeans === "hidden") return !1;
+      continue;
+    }
+    if (!o.has(i)) return !1;
+  }
+  return !0;
+}
+function Fi({ nodes: e, filter: t, taxonomy: n, axes: s, visibleIds: o, matches: i, valueOn: r }) {
+  const c = r ?? ((v, M) => {
+    var S;
+    return (S = v.values) == null ? void 0 : S[M];
+  }), a = s.flatMap((v) => {
+    const M = n.axisFor(v);
+    return M ? [M] : [];
+  }), l = /* @__PURE__ */ new Set();
+  let d = 0;
+  const u = /* @__PURE__ */ new Map();
+  for (const v of e) {
+    if (!i(v)) continue;
+    if (o.has(v.id)) {
+      l.add(v.id);
+      continue;
+    }
+    d++;
+    const M = a.find(($) => !Xn(t, [$], (D) => c(v, D))), S = M ? c(v, M.id) : void 0;
+    if (!M || S === void 0) continue;
+    const p = u.get(M.id) ?? /* @__PURE__ */ new Map();
+    p.set(S, (p.get(S) ?? 0) + 1), u.set(M.id, p);
+  }
+  return { visible: l, hiddenCount: d, hiddenByAxis: u };
+}
+const po = /* @__PURE__ */ new Map();
+function Jo(e) {
+  const t = Ft(e, bn), n = g.useRef(t), [s, o] = g.useState(po);
+  return g.useEffect(() => {
+    const i = n.current;
+    if (bn(i, t)) return;
+    const r = /* @__PURE__ */ new Map();
+    for (const [a, l] of t) {
+      const d = ze(i, a);
+      for (const u of l) {
+        if (d.has(u)) continue;
+        const v = r.get(a) ?? /* @__PURE__ */ new Set();
+        v.add(u), r.set(a, v);
+      }
+    }
+    if (n.current = t, o(r), r.size === 0) return;
+    const c = setTimeout(() => o(po), 450);
+    return () => clearTimeout(c);
+  }, [t]), s;
+}
+function Vl(e, t, n) {
+  const s = ze(e, t), o = new Set(s);
+  return o.has(n) ? o.delete(n) : o.add(n), on(e, t, o);
+}
+function Li(e, t, n) {
+  const s = ze(e, t), o = n.some((r) => s.has(r)), i = new Set(s);
+  if (o) for (const r of n) i.delete(r);
+  else for (const r of n) i.add(r);
+  return on(e, t, i);
+}
+function Pi({ locked: e, onClick: t, flashing: n, label: s }) {
+  const o = e ? `${s} filter locked — held as it is; click to unlock` : `${s} filter unlocked — click to lock and hold it as it is`, i = [
+    "gv-lock-toggle",
+    e ? "locked" : "",
+    n ? "flashing" : ""
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ h(
+    "button",
+    {
+      className: i,
+      onClick: t,
+      title: o,
+      "aria-label": o,
+      "aria-pressed": e,
+      children: e ? /* @__PURE__ */ h(Di, {}) : /* @__PURE__ */ h(_i, {})
+    }
+  );
+}
+function Di() {
+  return /* @__PURE__ */ C("svg", { width: "14", height: "14", viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", children: [
+    /* @__PURE__ */ h("rect", { x: "3", y: "7", width: "10", height: "7", rx: "1.5" }),
+    /* @__PURE__ */ h("path", { d: "M5.5 7V5a2.5 2.5 0 0 1 5 0v2" })
+  ] });
+}
+function _i() {
+  return /* @__PURE__ */ C("svg", { width: "14", height: "14", viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", children: [
+    /* @__PURE__ */ h("rect", { x: "3", y: "7", width: "10", height: "7", rx: "1.5" }),
+    /* @__PURE__ */ h("path", { d: "M5.5 7V5a2.5 2.5 0 0 1 4.9-.6" })
+  ] });
+}
+function Bi({ size: e = 16 }) {
+  return /* @__PURE__ */ C(
+    "svg",
+    {
+      width: e,
+      height: e,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      style: { display: "block" },
+      children: [
+        /* @__PURE__ */ h("circle", { cx: "11", cy: "11", r: "7" }),
+        /* @__PURE__ */ h("line", { x1: "16.65", y1: "16.65", x2: "21", y2: "21" })
+      ]
+    }
+  );
+}
+function Hi(e, t, n, s) {
+  return n.styleValues.includes(t) || s.has(e) || (s.add(e), console.error(`[filter] chip ${JSON.stringify(e)} borrows the colour of ${JSON.stringify(t)}, which the taxonomy does not declare`)), t;
+}
+const hs = /* @__PURE__ */ new Set(), zi = {
+  chip: { sectionClass: "gv-chip-section", rowClass: "gv-chip-row", chipClass: "gv-chip", modifierPrefix: "gv-chip", activeClass: "active", iconClass: "gv-chip-icon", labelClass: "gv-chip-label" },
+  tag: { sectionClass: "gv-tag-section", rowClass: "gv-tag-row", chipClass: "gv-tag", modifierPrefix: "", activeClass: "selected", iconClass: "gv-tag-icon", labelClass: "gv-tag-label" }
+};
+function Vi({
+  taxonomy: e,
+  chrome: t,
+  theme: n = "system",
+  systemTheme: s,
+  counts: o,
+  values: i,
+  graph: r,
+  filter: c,
+  onFilterChange: a,
+  locks: l,
+  onLocksChange: d,
+  overriddenLocks: u = hs,
+  recentlyChanged: v,
+  search: M,
+  onSearchChange: S,
+  searchInputRef: p,
+  searchTitle: $ = "Search (/)",
+  searchPlaceholder: D = "Search…",
+  searchExtra: x,
+  hiddenMatches: V,
+  findings: F,
+  refreshFlash: L,
+  axes: y,
+  onAxesChange: I
+}) {
+  const E = g.useContext(_n), O = e ?? E;
+  if (!O) throw new Error("FilterBar has no taxonomy: pass `taxonomy`, or mount it inside <TaxonomyContext.Provider value={…}>.");
+  const X = g.useRef(/* @__PURE__ */ new Set()), N = Ft(c, bn), [k, w] = Mt(l, d, () => /* @__PURE__ */ new Map(), "locks"), R = Ft(k, Go), z = (t == null ? void 0 : t.locks) ?? (l !== void 0 && d !== void 0), pe = (t == null ? void 0 : t.search) ?? !0, [ke, St] = g.useState(hs);
+  g.useEffect(() => {
+    if (St(u), u.size === 0) return;
+    const Y = setTimeout(() => St(hs), 600);
+    return () => clearTimeout(Y);
+  }, [u]);
+  const [Ne, ct] = g.useState(!1);
+  g.useEffect(() => {
+    if (!L) return;
+    ct(!0);
+    const Y = setTimeout(() => ct(!1), 600);
+    return () => clearTimeout(Y);
+  }, [L]);
+  const [at, lt] = Mt(y, I, () => O.filterAxes.map((Y) => Y.id), "axes"), Ie = Ft(at, Xo), dt = y === void 0 || I !== void 0, [De, ht] = Mt(M, S, () => ({ query: "", active: !1 }), "search"), { query: b, active: T } = De, U = g.useRef(null), se = p ?? U, G = g.useRef(null), oe = Ho(G, n, s), B = g.useMemo(() => zo(O, oe), [O, oe]), [f, q] = g.useState(!1), te = (Y) => {
+    var re;
+    return ((re = O.axisFor(Y)) == null ? void 0 : re.label) ?? Y;
+  }, le = Jo(N), Ee = v ?? le, Me = g.useMemo(
+    () => i ?? new Map([.../* @__PURE__ */ new Set([...O.filterAxes.map((Y) => Y.id), ...Ie])].map((Y) => [Y, r ? sn(r.nodes, Y) : []])),
+    [i, r, Ie, O]
+  ), A = g.useMemo(
+    () => o ?? (r ? _o(r.nodes, Ie) : void 0),
+    [o, r, Ie]
+  ), Oe = (Y, re) => ({
+    values: [...Me.get(Y) ?? []],
+    counts: A == null ? void 0 : A.get(Y),
+    hidden: V == null ? void 0 : V.get(Y),
+    ...zi[(re == null ? void 0 : re.presentation) ?? "chip"]
+  }), xe = O.filterAxes.map((Y) => Y.id).filter((Y) => {
+    var re;
+    return !Ie.includes(Y) && (((re = Me.get(Y)) == null ? void 0 : re.length) ?? 0) > 0;
+  });
+  g.useEffect(() => {
+    xe.length < 2 && q(!1);
+  }, [xe.length]);
+  const xt = () => {
+    T ? ht({ query: "", active: !1 }) : (ht({ query: b, active: !0 }), setTimeout(() => {
+      var Y;
+      return (Y = se.current) == null ? void 0 : Y.focus();
+    }, 50));
+  };
+  return /* @__PURE__ */ C("div", { className: `gv-canvas-header${Ne ? " refresh-flash" : ""}`, ref: G, "data-theme": oe, style: B, children: [
+    Ie.map((Y) => {
+      const re = O.axisFor(Y), Qe = (re == null ? void 0 : re.label) ?? Y, Z = Oe(Y, re), _e = new Set(Z.values), Be = re ? re.chipsFor(Z.values).filter((ye) => ye.values.some((Ue) => _e.has(Ue))) : [], rn = Be.length === 0, kt = ze(N, Y), et = Ls(R, Y), Ve = kt.size === 0 && (re == null ? void 0 : re.emptyMeans) === "all";
+      return /* @__PURE__ */ C(g.Fragment, { children: [
+        /* @__PURE__ */ C("div", { className: `${Z.sectionClass}${et ? " section-locked" : ""}`, children: [
+          /* @__PURE__ */ C("div", { className: Z.rowClass, children: [
+            /* @__PURE__ */ h("span", { className: "gv-header-axis-label", children: Qe }),
+            rn && /* @__PURE__ */ h("span", { className: "gv-header-axis-empty", title: re ? `${Qe} has no values in this view` : `${Qe} is not an axis the taxonomy declares`, children: re ? `no ${Qe.toLowerCase()} values` : "not declared" }),
+            Be.map((ye) => {
+              const Ue = ye.values.some((H) => kt.has(H)), gt = ye.values.some((H) => {
+                var ne;
+                return (ne = Ee.get(Y)) == null ? void 0 : ne.has(H);
+              }), tt = ye.values.reduce((H, ne) => {
+                var J;
+                return H + (((J = Z.hidden) == null ? void 0 : J.get(ne)) ?? 0);
+              }, 0), _ = Z.counts === void 0 ? void 0 : ye.values.reduce((H, ne) => H + (Z.counts.get(ne) ?? 0), 0), K = [
+                Z.chipClass,
+                Ve ? "all-included" : Ue ? Z.activeClass : "",
+                Z.modifierPrefix ? `${Z.modifierPrefix}-${ye.id}` : "",
+                gt ? "recently-changed" : ""
+              ].filter(Boolean).join(" ");
+              return /* @__PURE__ */ C(
+                "button",
+                {
+                  className: K,
+                  style: ye.tint ? { "--gv-chip-tint": `var(${O.colorVar(Hi(ye.id, ye.tint, O, X.current))})` } : void 0,
+                  onClick: () => a(Li(N, Y, ye.values), [Y]),
+                  title: ye.tooltip ?? (Ue ? `Hide ${ye.label.toLowerCase()}` : `Show ${ye.label.toLowerCase()}`),
+                  children: [
+                    ye.icon && /* @__PURE__ */ h("span", { className: Z.iconClass, children: ye.icon }),
+                    /* @__PURE__ */ h("span", { className: Z.labelClass, children: ye.label }),
+                    _ !== void 0 && /* @__PURE__ */ h("span", { className: "gv-header-chip-count", children: _ }),
+                    tt > 0 && /* @__PURE__ */ h("span", { className: "gv-header-hidden-badge", title: `${tt} match${tt !== 1 ? "es" : ""} hidden by this filter`, children: tt })
+                  ]
+                },
+                ye.id
+              );
+            })
+          ] }),
+          z && re && /* @__PURE__ */ h(
+            Pi,
+            {
+              locked: et,
+              onClick: () => w(Ai(R, Y, !et)),
+              flashing: ke.has(Y),
+              label: Qe
+            }
+          ),
+          dt && /* @__PURE__ */ h(
+            "button",
+            {
+              className: "gv-header-remove",
+              onClick: () => {
+                a(on(
+                  N,
+                  Y,
+                  (re == null ? void 0 : re.emptyMeans) !== "none" ? /* @__PURE__ */ new Set() : new Set(Be.flatMap((ye) => [...ye.values]))
+                ), [Y]), lt(Ie.filter((ye) => ye !== Y));
+              },
+              title: `Remove the ${Qe} filter`,
+              children: "×"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ h("div", { className: "gv-header-divider" })
+      ] }, Y);
+    }),
+    dt && xe.length > 0 && /* @__PURE__ */ C("div", { className: "gv-header-add", children: [
+      /* @__PURE__ */ h(
+        "button",
+        {
+          className: "gv-header-add-button",
+          onClick: () => xe.length === 1 ? lt([...Ie, xe[0]]) : q((Y) => !Y),
+          title: xe.length === 1 ? `Add the ${te(xe[0])} filter` : "Add a filter",
+          "aria-haspopup": xe.length > 1 ? "menu" : void 0,
+          "aria-expanded": xe.length > 1 ? f : void 0,
+          children: "+"
+        }
+      ),
+      f && xe.length > 1 && /* @__PURE__ */ h("div", { className: "gv-header-add-menu", role: "menu", onKeyDown: (Y) => {
+        Y.key === "Escape" && q(!1);
+      }, children: xe.map((Y) => /* @__PURE__ */ h("button", { role: "menuitem", className: "gv-header-add-menu-item", onClick: () => {
+        lt([...Ie, Y]), q(!1);
+      }, children: te(Y) }, Y)) })
+    ] }),
+    /* @__PURE__ */ h("div", { className: "gv-header-divider" }),
+    pe && /* @__PURE__ */ h("div", { className: "gv-header-controls-section", children: /* @__PURE__ */ C("div", { className: `gv-header-search ${T ? "active" : ""}`, children: [
+      /* @__PURE__ */ h("button", { className: "gv-header-search-toggle", onClick: xt, title: $, children: /* @__PURE__ */ h(Bi, { size: 14 }) }),
+      T && /* @__PURE__ */ h(
+        "input",
+        {
+          ref: se,
+          className: "gv-header-search-input",
+          type: "text",
+          placeholder: D,
+          value: b,
+          onChange: (Y) => ht({ query: Y.target.value, active: !0 }),
+          onKeyDown: (Y) => {
+            Y.key === "Escape" && xt();
+          }
+        }
+      ),
+      x
+    ] }) }),
+    F
+  ] });
+}
+const Vt = (e) => e.copyKey ?? e.id;
+function Gi(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e.nodes) {
+    const s = Vt(n), o = t.get(s);
+    o ? o.add(n.id) : t.set(s, /* @__PURE__ */ new Set([n.id]));
+  }
+  return t;
+}
+function Gl(e, t) {
+  var s;
+  const n = (s = e.payload) == null ? void 0 : s[t];
+  return typeof n == "string" ? n : void 0;
+}
+function Xl(e, t) {
+  var s;
+  const n = (s = e.payload) == null ? void 0 : s[t];
+  return typeof n == "number" ? n : void 0;
+}
+function xn(e) {
+  return e.relation === "containment" ? "containment" : "dependency";
+}
+function it(e) {
+  return e.relation === "containment";
+}
+function Pt(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e) t.has(n.id) || t.set(n.id, n);
+  return t;
+}
+function Xi(e) {
+  var i;
+  const t = Pt(e.nodes), n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  for (const r of e.edges)
+    s.add(r.id), r.relation === "containment" && r.targetId === ((i = t.get(r.sourceId)) == null ? void 0 : i.parentId) && n.add(r.sourceId);
+  const o = [];
+  for (const r of e.nodes) {
+    if (r.parentId === void 0 || !t.has(r.parentId) || n.has(r.id)) continue;
+    let c = `in:${r.id}`;
+    for (let a = 2; s.has(c); a++) c = `in:${r.id}#${a}`;
+    s.add(c), o.push({ id: c, sourceId: r.id, targetId: r.parentId, relation: "containment" });
+  }
+  return o.length === 0 ? e : { nodes: e.nodes, edges: [...e.edges, ...o] };
+}
+function jo(e) {
+  const t = Pt(e.nodes);
+  return { nodes: e.nodes, edges: e.edges, getNode: (n) => t.get(n) };
+}
+const mo = (e, t) => {
+  if (e === t) return !0;
+  if (e === void 0 || t === void 0) return !1;
+  const n = Object.keys(e);
+  if (n.length !== Object.keys(t).length) return !1;
+  for (const s of n) if (e[s] !== t[s]) return !1;
+  return !0;
+}, Yi = (e, t) => e === t || e !== void 0 && t !== void 0 && e.length === t.length && e.every((n, s) => n === t[s]);
+function Ji(e, t) {
+  if (e === t) return !0;
+  if (e.nodes.length !== t.nodes.length || e.edges.length !== t.edges.length) return !1;
+  for (let n = 0; n < e.nodes.length; n++) {
+    const s = e.nodes[n], o = t.nodes[n];
+    if (s !== o && (s.id !== o.id || s.name !== o.name || s.parentId !== o.parentId || s.copyKey !== o.copyKey || s.ring !== o.ring || s.payload !== o.payload || !mo(s.values, o.values) || !Yi(s.badges, o.badges)))
+      return !1;
+  }
+  for (let n = 0; n < e.edges.length; n++) {
+    const s = e.edges[n], o = t.edges[n];
+    if (s !== o && (s.id !== o.id || s.sourceId !== o.sourceId || s.targetId !== o.targetId || s.relation !== o.relation || s.payload !== o.payload || !mo(s.values, o.values)))
+      return !1;
+  }
+  return !0;
+}
+function qo({ destination: e, source: t, locks: n, transition: s, taxonomy: o, axes: i, graph: r }) {
+  const c = i.flatMap((a) => {
+    const l = o.axisFor(a);
+    return l ? [l] : [];
+  });
+  switch (s.kind) {
+    case "manual":
+      return ji(e, t, n, c);
+    case "focus":
+      return qi(e, n, s.target, c, r);
+  }
+}
+function ji(e, t, n, s) {
+  let o = e;
+  for (const i of s)
+    Ls(n, i.id) || (o = on(o, i.id, ze(t, i.id)));
+  return { filter: o, overriddenLocks: /* @__PURE__ */ new Set() };
+}
+function qi(e, t, n, s, o) {
+  let i = e;
+  const r = /* @__PURE__ */ new Set();
+  for (const c of s) {
+    const a = n.values[c.id];
+    if (a === void 0) continue;
+    const l = ze(e, c.id);
+    l.has(a) || c.widens === "whenActive" && l.size === 0 || (i = on(i, c.id, /* @__PURE__ */ new Set([...l, ...Ui(c, a, o)])), Ls(t, c.id) && r.add(c.id));
+  }
+  return {
+    filter: bn(i, e) ? e : i,
+    overriddenLocks: r
+  };
+}
+function Ui(e, t, n) {
+  if (!n) return [t];
+  const s = sn(n.nodes, e.id), o = e.chipsFor(s).find((c) => c.values.includes(t));
+  if (!o) return [t];
+  const i = new Set(s), r = o.values.filter((c) => i.has(c));
+  return r.includes(t) ? r : [t, ...r];
+}
+function Ki(e) {
+  const t = e.label ?? e.id;
+  return { id: e.id, label: t, tooltip: e.tooltip ?? t, normalize: e.normalize, compute: (n) => e.compute(n) };
+}
+function Zt(e) {
+  return "scalar" in e;
+}
+function Uo(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const o of e.edges) {
+    if (it(o)) continue;
+    const i = t.get(o.sourceId);
+    i ? i.push(o.targetId) : t.set(o.sourceId, [o.targetId]);
+  }
+  const n = /* @__PURE__ */ new Map();
+  for (const o of e.nodes) {
+    const i = /* @__PURE__ */ new Set([o.id]);
+    let r = 0, c = [o.id];
+    for (; c.length > 0; ) {
+      const a = [];
+      for (const l of c) {
+        const d = t.get(l);
+        if (d)
+          for (const u of d)
+            i.has(u) || (i.add(u), a.push(u));
+      }
+      a.length > 0 && r++, c = a;
+    }
+    n.set(o.id, r);
+  }
+  const s = new Map(n);
+  for (const o of e.nodes) {
+    const i = n.get(o.id) ?? 0;
+    if (i <= 0) continue;
+    let r = o.parentId === void 0 ? void 0 : e.getNode(o.parentId), c = i;
+    const a = /* @__PURE__ */ new Set();
+    for (; r && !a.has(r.id) && (a.add(r.id), c += 1, !((s.get(r.id) ?? 0) >= c)); )
+      s.set(r.id, c), r = r.parentId === void 0 ? void 0 : e.getNode(r.parentId);
+  }
+  return Yn(s);
+}
+function Wi(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e.nodes) t.set(n.id, 0);
+  for (const n of e.edges)
+    it(n) || (e.getNode(n.sourceId) && t.set(n.sourceId, (t.get(n.sourceId) ?? 0) + 1), e.getNode(n.targetId) && t.set(n.targetId, (t.get(n.targetId) ?? 0) + 1));
+  return Yn(t);
+}
+function Zi(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e.nodes) {
+    let s = 0, o = n.parentId === void 0 ? void 0 : e.getNode(n.parentId);
+    const i = /* @__PURE__ */ new Set();
+    for (; o && !i.has(o.id); )
+      i.add(o.id), s++, o = o.parentId === void 0 ? void 0 : e.getNode(o.parentId);
+    t.set(n.id, s);
+  }
+  return Yn(t);
+}
+function Yn(e) {
+  let t = 0;
+  for (const s of e.values()) s > t && (t = s);
+  const n = /* @__PURE__ */ new Map();
+  for (const [s, o] of e) n.set(s, t === 0 ? 0 : o / t);
+  return n;
+}
+function Qi(e) {
+  let t = 1 / 0, n = -1 / 0;
+  for (const o of e.values())
+    o < t && (t = o), o > n && (n = o);
+  const s = /* @__PURE__ */ new Map();
+  for (const [o, i] of e) s.set(o, n > t ? (i - t) / (n - t) : 0);
+  return s;
+}
+const ec = {
+  id: "reach",
+  label: "Reach",
+  tooltip: "Downstream reach: how many dependency levels deep a node’s subtree runs, propagated up containment; leaves at 0",
+  compute: Uo,
+  normalize: "none"
+}, tc = {
+  id: "degree",
+  label: "Degree",
+  tooltip: "Dependency edges in and out, as a fraction of the busiest node’s",
+  compute: Wi,
+  normalize: "none"
+}, nc = {
+  id: "depth",
+  label: "Depth",
+  tooltip: "Containment depth: 0 at the top of the hierarchy, 1 at the deepest node",
+  compute: Zi,
+  normalize: "none"
+}, sc = [ec, tc, nc], wn = { color: { light: "#94A3B8", dark: "#64748B" }, alpha: 0.7, dash: [], width: 1.2 }, Ko = { color: { light: "#94A3B8", dark: "#64748B" }, alpha: 0.35, dash: [3, 4], width: 1 };
+function Mn(e) {
+  return typeof e == "string" ? [e] : e;
+}
+function hn(e) {
+  const t = Mn(e.targetValue);
+  return Mn(e.sourceValue).flatMap((n) => t.map((s) => [n, s]));
+}
+const Jt = { top: -300, bottom: 400, x: { min: 0, max: 380 } }, oc = 12, Wo = { strength: 0.5, distance: 120 };
+function rc(e, t) {
+  if (t <= 1) return { min: Jt.top, max: Jt.bottom };
+  const n = (Jt.bottom - Jt.top) / (t - 1), s = Jt.top + n * e, o = n * 0.6;
+  return { min: Math.round(s - o), max: Math.round(s + o) };
+}
+function vo(e, t, n) {
+  var o, i, r, c, a, l, d, u;
+  const s = ((o = e.size) == null ? void 0 : o.r) ?? oc;
+  return {
+    ...e,
+    abbreviation: e.abbreviation ?? e.label.slice(0, 2),
+    icon: e.icon ?? "",
+    size: { r: s, iconSize: ((i = e.size) == null ? void 0 : i.iconSize) ?? Math.max(9, Math.round(s * 0.9)) },
+    physics: {
+      charge: ((r = e.physics) == null ? void 0 : r.charge) ?? -40 * s,
+      coreRadius: ((c = e.physics) == null ? void 0 : c.coreRadius) ?? 4 * s,
+      band: {
+        x: ((l = (a = e.physics) == null ? void 0 : a.band) == null ? void 0 : l.x) ?? { ...Jt.x },
+        y: ((u = (d = e.physics) == null ? void 0 : d.band) == null ? void 0 : u.y) ?? rc(t, n)
+      }
+    },
+    whenHidden: e.whenHidden ?? "ascend",
+    summaryKind: e.summaryKind ?? "degree"
+  };
+}
+function ic(e) {
+  var s;
+  const t = e.relation === "containment" ? Ko : wn, n = e.label ?? e.id;
+  return {
+    ...e,
+    label: n,
+    sourceValue: Mn(e.sourceValue)[0],
+    targetValue: Mn(e.targetValue)[0],
+    pairs: hn(e),
+    physics: e.physics ?? { ...Wo },
+    style: { ...t, ...e.style, color: { ...t.color, ...(s = e.style) == null ? void 0 : s.color } },
+    tooltip: e.tooltip ?? n
+  };
+}
+const Zo = 2, Gt = {
+  charge: 0,
+  coreRadius: Zo,
+  /** On either axis: a point band at the axis's centre. */
+  band: { min: 0, max: 0 }
+}, ft = (e) => "scalar" in e;
+function Dt(e, t) {
+  var n;
+  return (n = e.mapping.bucketFor(t.values[e.mapping.axis])) == null ? void 0 : n.id;
+}
+function yo(e, t) {
+  let n = 0, s = 0;
+  for (const i of t) {
+    const r = e.styleOf(i).physics;
+    n += r.charge, s += r.coreRadius;
+  }
+  const o = Math.max(t.length, 1);
+  return { charge: n / o, coreRadius: s / o };
+}
+function Is(e, t, n) {
+  let s = 1 / 0, o = -1 / 0;
+  for (const i of t) {
+    const r = e.styleOf(i).physics.band[n];
+    s = Math.min(s, r.min), o = Math.max(o, r.max);
+  }
+  return t.length === 0 ? { ...Gt.band } : { min: s, max: o };
+}
+function cc(e, t) {
+  const n = Is(e, e.styleValues, t), s = (n.max - n.min) / 2;
+  return t === "y" ? { zero: s, one: -s } : { zero: -s, one: s };
+}
+function bo(e, t, n) {
+  const s = /* @__PURE__ */ new Map();
+  for (const o of e.buckets)
+    s.set(o.id, t.get(o.id) ?? n(o.values));
+  return { mapping: e, byBucket: s };
+}
+function $s(e, t) {
+  const n = t.styleAxis(), s = (r) => r.axis === n ? (c) => yo(t, c) : () => yo(t, t.styleValues), o = (r, c) => r.axis === n ? (a) => Is(t, a, c) : () => Is(t, t.styleValues, c), i = (r, c) => {
+    if (!Zt(r)) return bo(r.mapping, r.overrides, o(r.mapping, c));
+    const a = t.scalars.find((l) => l.id === r.scalar);
+    if (!a) throw new Error(`layout axis names scalar ${JSON.stringify(r.scalar)}, which the taxonomy does not declare`);
+    return { scalar: a, span: r.span ?? cc(t, c) };
+  };
+  return {
+    push: bo(e.pair.mapping, e.pair.push, s(e.pair.mapping)),
+    bandX: i(e.bandX, "x"),
+    bandY: i(e.bandY, "y"),
+    spring: _s(e.pair, t)
+  };
+}
+function Qo(e, t) {
+  var s;
+  const n = Dt(e, t);
+  return (n === void 0 || (s = e.byBucket.get(n)) == null ? void 0 : s.charge) ?? Gt.charge;
+}
+function er(e, t) {
+  var s;
+  const n = Dt(e, t);
+  return Math.max(
+    (n === void 0 || (s = e.byBucket.get(n)) == null ? void 0 : s.coreRadius) ?? Gt.coreRadius,
+    Zo
+  );
+}
+function gn(e, t) {
+  return e.byBucket.get(t) ?? { charge: Gt.charge, coreRadius: Gt.coreRadius };
+}
+function gs(e, t) {
+  return e.byBucket.get(t) ?? { ...Gt.band };
+}
+function Ds(e, t) {
+  return (t === void 0 ? void 0 : e.byBucket.get(t)) ?? Gt.band;
+}
+function Kt(e, t) {
+  const n = /* @__PURE__ */ new Set();
+  for (const s of e) {
+    const o = Dt(t, s);
+    o !== void 0 && n.add(o);
+  }
+  return [...n];
+}
+const tr = (e) => (e.min + e.max) / 2;
+function ac(e, t) {
+  return Kt(e, t).map((n) => tr(Ds(t, n)));
+}
+function lc(e, t) {
+  const n = ac(e, t).sort((o, i) => o - i), s = n.length;
+  return s === 0 ? 0 : s % 2 ? n[(s - 1) / 2] : (n[s / 2 - 1] + n[s / 2]) / 2;
+}
+function dc(e, t) {
+  const n = Kt(e, t), s = n.map((r) => tr(Ds(t, r))), o = s.length ? Math.min(...s) : 0, i = (s.length ? Math.max(...s) : 0) - o || 1;
+  return new Map(n.map((r, c) => [r, Bn + (s[c] - o) / i * (or - Bn)]));
+}
+const xo = { lo: 0, hi: 0 };
+function uc(e, t) {
+  const n = e.compute(t);
+  for (const [o, i] of n)
+    if (!Number.isFinite(i)) throw new Error(`scalar ${JSON.stringify(e.id)} answered ${String(i)} for node ${JSON.stringify(o)}; a scalar answers a finite number`);
+  const s = e.normalize === "none" ? n : e.normalize === "range" ? Qi(n) : Yn(n);
+  for (const [o, i] of s)
+    if (!(Number.isFinite(i) && i >= 0 && i <= 1))
+      throw new Error(`scalar ${JSON.stringify(e.id)} answered ${String(i)} for node ${JSON.stringify(o)}; a scalar answers in [0, 1]`);
+  return s;
+}
+function Cs(e, t) {
+  const n = [...e.nodes], s = (u) => ft(u) ? 0 : lc(n, u), o = (u) => ft(u) ? uc(u.scalar, e) : void 0, i = s(t.bandX), r = s(t.bandY), c = o(t.bandX), a = o(t.bandY), l = ft(t.bandY) ? /* @__PURE__ */ new Map() : dc(n, t.bandY), d = (u, v, M, S) => {
+    if (ft(u)) {
+      const D = M == null ? void 0 : M.get(S.id);
+      if (D === void 0) return xo;
+      const x = u.span.zero + D * (u.span.one - u.span.zero);
+      return { lo: x, hi: x };
+    }
+    const p = Dt(u, S), $ = p === void 0 ? void 0 : u.byBucket.get(p);
+    return $ === void 0 ? xo : { lo: $.min - v, hi: $.max - v };
+  };
+  return {
+    centerX: i,
+    centerY: r,
+    rings: l,
+    rest: (u, v) => u === "x" ? d(t.bandX, i, c, v) : d(t.bandY, r, a, v),
+    ringOf: (u) => {
+      if (ft(t.bandY)) {
+        if ((a == null ? void 0 : a.get(u.id)) === void 0) return 0;
+        const M = d(t.bandY, r, a, u), { zero: S, one: p } = t.bandY.span, $ = Math.min(S, p), D = Math.abs(p - S) || 1;
+        return Bn + (M.lo - $) / D * (or - Bn);
+      }
+      const v = Dt(t.bandY, u);
+      return (v === void 0 ? void 0 : l.get(v)) ?? 0;
+    }
+  };
+}
+function nr(e) {
+  return e.radial ? e.gravityY > 0 : e.gravityX > 0 || e.gravityY > 0;
+}
+function fc(e) {
+  return e.topologicalEnabled && e.gravityTopological > 0;
+}
+function hc(e, t, n, s, o) {
+  const i = [...e], r = nr(t), c = /* @__PURE__ */ new Map(), a = (d, u) => {
+    for (const v of u) for (const M of v.buckets) if (!c.has(M)) {
+      const S = o(d, M);
+      S !== void 0 && c.set(M, S);
+    }
+    return u;
+  };
+  if (!r) return { acting: r, x: [], y: [], rings: [], colors: c };
+  if (t.radial) {
+    if (ft(n.bandY)) return { acting: r, x: [], y: [], rings: [], colors: c };
+    const d = /* @__PURE__ */ new Map();
+    for (const [u, v] of s.rings) {
+      const M = d.get(v);
+      if (M ? M.push(u) : d.set(v, [u]), !c.has(u)) {
+        const S = o(n.bandY, u);
+        S !== void 0 && c.set(u, S);
+      }
+    }
+    return { acting: r, x: [], y: [], rings: [...d].map(([u, v]) => ({ radius: u, buckets: v })), colors: c };
+  }
+  const l = (d, u) => ft(d) ? [{ lo: Math.min(d.span.zero, d.span.one), hi: Math.max(d.span.zero, d.span.one), buckets: [], gradient: d.span }] : a(d, gc(i, d, u));
+  return {
+    acting: r,
+    x: t.gravityX > 0 ? l(n.bandX, s.centerX) : [],
+    y: t.gravityY > 0 ? l(n.bandY, s.centerY) : [],
+    rings: [],
+    colors: c
+  };
+}
+function gc(e, t, n) {
+  const s = /* @__PURE__ */ new Map();
+  for (const o of Kt(e, t)) {
+    const i = Ds(t, o), r = `${i.min}:${i.max}`, c = s.get(r);
+    c ? c.buckets.push(o) : s.set(r, { lo: i.min - n, hi: i.max - n, buckets: [o] });
+  }
+  return [...s.values()];
+}
+const sr = { strength: 0, distance: 0 };
+function pc(e, t, n) {
+  return JSON.stringify(t <= n ? [e, t, n] : [e, n, t]);
+}
+function mc(e) {
+  try {
+    const t = JSON.parse(e);
+    if (Array.isArray(t) && t.length === 3 && (t[0] === "containment" || t[0] === "dependency") && typeof t[1] == "string" && typeof t[2] == "string") return [t[0], t[1], t[2]];
+  } catch {
+  }
+}
+function _s(e, t) {
+  const { mapping: n, spring: s } = e;
+  if (n.axis === t.styleAxis() && Fs(n)) {
+    const r = new Map(t.edgeTypes.map((c) => [c.id, c]));
+    return {
+      mapping: n,
+      // An edge no declared type of its relation claims has no category here:
+      // it pulls nothing and draws in its relation's stroke, and the
+      // diagnostics have named it.
+      classify: (c, a, l) => {
+        const d = t.edgeTypeOf(c, a, l), u = d === void 0 ? void 0 : r.get(d);
+        return u !== void 0 && u.relation === xn(c) ? d : void 0;
+      },
+      physicsFor: (c) => {
+        var a;
+        return s.get(c) ?? ((a = r.get(c)) == null ? void 0 : a.physics) ?? sr;
+      },
+      describe: (c) => r.get(c)
+    };
+  }
+  const o = Wo, i = new Map(n.buckets.map((r) => [r.id, r]));
+  return {
+    mapping: n,
+    classify: (r, c, a) => c === void 0 || a === void 0 ? void 0 : pc(xn(r), c, a),
+    physicsFor: (r) => s.get(r) ?? o,
+    describe: (r) => {
+      const c = mc(r);
+      if (!c) return;
+      const [a, l, d] = c, u = i.get(l), v = i.get(d);
+      if (!(!u || !v))
+        return {
+          id: r,
+          label: `${u.abbreviation}↔${v.abbreviation}`,
+          sourceValue: l,
+          targetValue: d,
+          relation: a,
+          physics: o,
+          tooltip: `${u.label} ↔ ${v.label} ${a}`
+        };
+    }
+  };
+}
+function Bs(e, t, n, s) {
+  const o = e.classify(t, Dt(e, n), Dt(e, s)), i = o === void 0 ? sr : e.physicsFor(o);
+  return { strength: i.strength, distance: i.distance, key: o };
+}
+function Hs(e, t, n) {
+  const s = /* @__PURE__ */ new Set();
+  for (const o of t) {
+    const i = n(o.sourceId), r = n(o.targetId);
+    if (!i || !r) continue;
+    const c = Bs(e, o, i, r).key;
+    c !== void 0 && s.add(c);
+  }
+  return s;
+}
+function vc(e, t, n, s, o) {
+  const i = t.coreRadiusMultiplier, r = t.pushMultiplier, c = t.chargeExponent, a = e.length, l = new Float64Array(a), d = new Float64Array(a);
+  for (let u = 0; u < a; u++)
+    l[u] = Qo(n.push, e[u]), d[u] = i * er(n.push, e[u]);
+  for (let u = 0; u < a; u++)
+    for (let v = u + 1; v < a; v++) {
+      const M = e[u], S = e[v];
+      let p = S.x - M.x, $ = S.y - M.y, D = p * p + $ * $;
+      if (D < 0.01) {
+        const O = o() * Math.PI * 2;
+        p = Math.cos(O), $ = Math.sin(O), D = 1;
+      }
+      const x = Math.sqrt(D), V = (d[u] + d[v]) / 2, F = V * V, L = (l[u] + l[v]) / 2, y = -(s * r * L / Math.pow(D + F, c)), I = y * (p / x), E = y * ($ / x);
+      M.pinned || (M.vx -= I, M.vy -= E), S.pinned || (S.vx += I, S.vy += E);
+    }
+}
+function yc(e, t, n, s, o, i) {
+  const r = /* @__PURE__ */ new Map();
+  for (const d of e)
+    r.set(d.sourceId, (r.get(d.sourceId) ?? 0) + 1), r.set(d.targetId, (r.get(d.targetId) ?? 0) + 1);
+  const c = n.pullMultiplier, a = n.linkExponent, l = n.distanceMultiplier;
+  for (const d of e) {
+    const u = t.get(d.sourceId), v = t.get(d.targetId);
+    if (!u || !v) continue;
+    let M = v.x - u.x, S = v.y - u.y, p = Math.sqrt(M * M + S * S);
+    if (p < 0.1) {
+      const N = i() * Math.PI * 2;
+      M = Math.cos(N), S = Math.sin(N), p = 1;
+    }
+    const $ = s(d), D = $.distance * l, x = p - D, V = Math.abs(x), F = x >= 0 ? 1 : -1, L = o * c * $.strength * F * Math.pow(V, a) / p, y = L * M, I = L * S, E = r.get(d.sourceId) ?? 1, O = r.get(d.targetId) ?? 1, X = E / (E + O);
+    u.pinned || (u.vx += y * (1 - X), u.vy += I * (1 - X)), v.pinned || (v.vx -= y * X, v.vy -= I * X);
+  }
+}
+const Bn = 60, or = 540;
+function bc(e, t, n, s, o) {
+  if (t.radial) {
+    xc(e, t, n, s, o);
+    return;
+  }
+  t.gravityX > 0 && wo(e, "x", n, t.gravityX, t.gravityBandExp, s), t.gravityY > 0 && wo(e, "y", n, t.gravityY, t.gravityBandExp, s);
+}
+function wo(e, t, n, s, o, i) {
+  const r = t === "x" ? "vx" : "vy";
+  for (const c of e) {
+    if (c.pinned) continue;
+    const { lo: a, hi: l } = n.rest(t, c), d = c[t];
+    let u = null;
+    d < a ? u = a : d > l && (u = l), u !== null && (c[r] -= rr(d - u, o, i * s));
+  }
+}
+function rr(e, t, n) {
+  return Math.sign(e) * Math.min(Math.pow(Math.abs(e), t) * n, Math.abs(e));
+}
+function xc(e, t, n, s, o) {
+  const i = t.gravityY;
+  for (const r of e) {
+    if (r.pinned) continue;
+    const c = n.ringOf(r), a = Math.hypot(r.x, r.y);
+    if (a < 1e-6) {
+      c > 0 && (r.vx += o() - 0.5, r.vy += o() - 0.5);
+      continue;
+    }
+    const l = rr(a - c, t.gravityBandExp, s * i);
+    r.vx -= r.x / a * l, r.vy -= r.y / a * l;
+  }
+}
+const wc = -350;
+function Mc(e, t, n, s) {
+  const o = t.gravityTopological;
+  if (o <= 0 || !s) return;
+  const i = t.gravityTopologicalExp, r = t.radial;
+  for (const c of e) {
+    if (c.pinned) continue;
+    const a = s.get(c.id) ?? 0;
+    if (a <= 0) continue;
+    const l = Math.pow(a, i);
+    r ? (c.vx -= c.x * n * o * l, c.vy -= c.y * n * o * l) : c.vy -= (c.y - wc) * n * o * l;
+  }
+}
+function Sc(e, t, n) {
+  const s = t.gravityCenter;
+  if (!(s <= 0))
+    for (const o of e)
+      o.pinned || (o.vx -= o.x * n * s, o.vy -= o.y * n * s);
+}
+function kc(e, t, n, s) {
+  return {
+    push: new Set(Kt(e, n.push)),
+    bandX: ft(n.bandX) ? /* @__PURE__ */ new Set() : new Set(Kt(e, n.bandX)),
+    bandY: ft(n.bandY) ? /* @__PURE__ */ new Set() : new Set(Kt(e, n.bandY)),
+    springs: Hs(n.spring, t, s)
+  };
+}
+function Nc(e, t, n) {
+  const s = new Map(e.overrides);
+  return s.set(t, n), { ...e, overrides: s };
+}
+function ps(e) {
+  if (Zt(e)) throw new Error(`expected a mapped axis, got scalar ${JSON.stringify(e.scalar)}`);
+  return e;
+}
+function Sn(e) {
+  return { mapping: e, push: /* @__PURE__ */ new Map(), spring: /* @__PURE__ */ new Map() };
+}
+function Ec(e, t, n) {
+  const s = new Map(e.push);
+  return s.set(t, n), { ...e, push: s };
+}
+function Ic(e, t, n) {
+  const s = new Map(e.spring);
+  return s.set(t, n), { ...e, spring: s };
+}
+function Qt(e) {
+  return Vn({
+    id: e.styleAxis(),
+    label: e.styleLabel(),
+    labelFor: (t) => e.styleOf(t).label,
+    abbreviationFor: (t) => e.abbreviationFor(t)
+  }, e.styleValues);
+}
+function Hn(e) {
+  return { mapping: Qt(e), overrides: /* @__PURE__ */ new Map() };
+}
+const $c = 0.35, Lt = 24;
+function zs(e) {
+  return e.pushTokens <= Lt && e.pullTokens <= Lt;
+}
+function Cc(e, t) {
+  const n = [Qt(e)];
+  for (const i of Ac(e, t)) {
+    const r = sn(t.nodes, i);
+    r.length > 0 && n.push(Vn(Vs(e, i), r));
+  }
+  const s = Pt(t.nodes), o = (i) => s.get(i);
+  return n.map((i) => ({
+    mapping: i,
+    pushTokens: i.buckets.length,
+    pullTokens: Hs(_s(Sn(i), e), t.edges, o).size
+  }));
+}
+function Ac(e, t) {
+  const n = e.styleAxis(), s = [], o = /* @__PURE__ */ new Set([n]);
+  for (const i of e.filterAxes)
+    o.has(i.id) || (o.add(i.id), s.push(i.id));
+  for (const i of t.nodes)
+    for (const r of Object.keys(i.values))
+      o.has(r) || (o.add(r), s.push(r));
+  return s;
+}
+function Vs(e, t) {
+  return e.axisFor(t) ?? {
+    id: t,
+    label: t,
+    labelFor: (n) => n,
+    abbreviationFor: (n) => n.slice(0, 2)
+  };
+}
+function Oc(e, t) {
+  return [
+    ...e.map((n) => ({ kind: "mapping", option: n })),
+    ...t.scalars.map((n) => ({ kind: "scalar", scalar: n }))
+  ];
+}
+function Yt(e) {
+  return "kind" in e ? e.kind === "scalar" ? `scalar:${e.scalar.id}` : `mapping:${e.option.mapping.axis}` : Zt(e) ? `scalar:${e.scalar}` : `mapping:${e.mapping.axis}`;
+}
+function Rc(e, t) {
+  const n = (s) => s.buckets.map((o) => `${o.id}=${[...o.values].sort().join(",")}`).sort().join(";");
+  return e.axis === t.axis && n(e) === n(t);
+}
+function Tc(e, t, n) {
+  const s = (p) => Zt(p) && !t.scalars.some(($) => $.id === p.scalar) ? Hn(t) : p;
+  if (n.nodes.length === 0) {
+    const p = s(e.bandX), $ = s(e.bandY);
+    return p === e.bandX && $ === e.bandY ? e : { ...e, bandX: p, bandY: $ };
+  }
+  const o = t.styleAxis(), i = Pt(n.nodes), r = (p) => i.get(p), c = (p) => {
+    if (p.axis === o) return Qt(t);
+    const $ = sn(n.nodes, p.axis);
+    return $.length === 0 ? void 0 : Vn(Vs(t, p.axis), $);
+  }, a = (p, $, D) => {
+    const x = c(p.mapping);
+    return x === void 0 || x.axis !== o && !D(x) ? (Fc(p.mapping.axis, x === void 0 ? "no node carries it any more" : `it has ${x.buckets.length} buckets, past the ceiling of ${Lt}`), $(Qt(t))) : Rc(x, p.mapping) ? p : { ...p, mapping: x };
+  }, l = (p) => p.buckets.length <= Lt, d = (p) => zs({
+    pushTokens: p.buckets.length,
+    pullTokens: Hs(_s(Sn(p), t), n.edges, r).size
+  }), u = (p) => Zt(p) ? t.scalars.some(($) => $.id === p.scalar) ? p : Hn(t) : a(p, ($) => ({ mapping: $, overrides: /* @__PURE__ */ new Map() }), l), v = a(e.pair, Sn, d), M = u(e.bandX), S = u(e.bandY);
+  return v === e.pair && M === e.bandX && S === e.bandY ? e : { ...e, pair: v, bandX: M, bandY: S };
+}
+const Mo = /* @__PURE__ */ new Set();
+function Fc(e, t) {
+  const n = `${e}\0${t}`;
+  Mo.has(n) || (Mo.add(n), console.warn(`[graph] the ${JSON.stringify(e)} axis cannot be tuned on: ${t}; the forces returned to the style axis with nothing overridden.`));
+}
+function ir(e) {
+  return {
+    // Both default to the axis the taxonomy resolves style on, so the layout
+    // keys on the same thing it is coloured by.
+    pair: Sn(Qt(e)),
+    bandX: Hn(e),
+    bandY: Hn(e),
+    // Gravity. The Y bands carry the vertical structure of the layout — strong
+    // (gravityY = 0.145) and overlapping at the edges so adjacent tiers can
+    // soften their boundary instead of forming a hard stripe. The X bands bound
+    // the horizontal spread, gently (gravityX = 0.05): wide fan-outs may spread.
+    gravityX: 0.05,
+    gravityY: 0.145,
+    gravityBandExp: 1,
+    radial: !1,
+    // Off by default — the experiment lives behind a slider. When non-zero,
+    // every node with a positive downstream score gets an additional pull
+    // toward the focal point, layered additively on top of the bands.
+    gravityTopological: 0,
+    gravityTopologicalExp: 3,
+    gravityCenter: 0.05,
+    topologicalEnabled: !1,
+    // Dynamics. alphaMin is well below the d3 default (0.001) so the
+    // simulation continues into its slow-cooling tail — layouts read as
+    // "settled" rather than freezing while springs are still measurably
+    // active. friction and cooling are stock.
+    alphaDecay: 5e-3,
+    alphaMin: 1e-4,
+    velocityDecay: 0.4,
+    pushMultiplier: 0.4,
+    pullMultiplier: 0.6,
+    distanceMultiplier: 0.1,
+    coreRadiusMultiplier: 1,
+    chargeExponent: 0.7,
+    // acts on (dist² + softening); = old 1.4 with the /2 folded in
+    linkExponent: 1
+  };
+}
+const ms = 50, Ot = 1e6, Lc = 200;
+function cr(e, t) {
+  return e.filter((n) => t.has(n.sourceId) && t.has(n.targetId));
+}
+class Pc {
+  // `taxonomy` is REQUIRED, deliberately: a default here would let one
+  // construction site resolve through a taxonomy every component ignores,
+  // a split no gate can see because both halves are individually correct.
+  constructor(t, n, s, o, i) {
+    Ze(this, "nodes");
+    Ze(this, "edges");
+    Ze(this, "params");
+    Ze(this, "alpha");
+    // Per-burst cooling rate set by `reheat()` so the settle window stays fixed
+    // (~REHEAT_TICKS) no matter the kick size. Null means "cool at the normal
+    // alphaDecay" — used during steady-state and live tuning via `nudge()`.
+    Ze(this, "reheatDecay", null);
+    Ze(this, "nodeMap");
+    // Source of randomness for the degenerate-frame breakers and the position
+    // jitter. Defaults to the platform generator, so app behaviour is unchanged.
+    Ze(this, "rng");
+    // The taxonomy the link force resolves spring categories through. Held rather
+    // than imported so the engine is not bound to one set of edge categories.
+    Ze(this, "taxonomy");
+    // The per-bucket tables, resolved once from (params, taxonomy) and read by the
+    // kernels per pair / per node. Recomputed only when either input changes —
+    // never per tick, and never inside a loop.
+    Ze(this, "resolved");
+    // The frame the band forces act in — median centres and ring radii over the
+    // WHOLE node set — shared by seeding, the kernels and (through the view) the
+    // overlay, so they agree by construction. Recomputed with the tables.
+    Ze(this, "frame");
+    // Each edge's spring category, classified once per (edges, resolved) rather
+    // than per tick: an edge's category depends on the edge, its endpoints'
+    // buckets and the pair mapping, none of which change between ticks. Built on
+    // first use and dropped whenever the tables are re-resolved.
+    Ze(this, "springByEdge", null);
+    // Loud on a miss: every edge the simulation owns is classified above, so an
+    // absent entry means the cache and the edge list have come apart.
+    Ze(this, "edgeCategory", (t) => {
+      const s = (this.springByEdge ?? (this.springByEdge = this.classifyEdges())).get(t.id);
+      if (s === void 0) throw new Error(`edge ${JSON.stringify(t.id)} has no spring classification; the cache and the edge list have come apart`);
+      return s;
+    });
+    this.params = { ...ir(o), ...n }, this.alpha = 1, this.rng = s, this.taxonomy = o, this.resolved = $s(this.params, o), this.nodes = [], this.nodeMap = /* @__PURE__ */ new Map();
+    const r = t.nodes;
+    this.frame = Cs(jo(t), this.resolved);
+    for (const c of r) {
+      const a = i == null ? void 0 : i.get(c.id), [l, d] = a ? [a.x, a.y] : this.seedPosition(c, s), u = { ...c, x: l, y: d, vx: 0, vy: 0, pinned: !1 };
+      this.nodes.push(u), this.nodeMap.set(u.id, u);
+    }
+    for (const c of this.nodes) {
+      if (!c.parentId || i != null && i.has(c.id)) continue;
+      const a = this.nodeMap.get(c.parentId);
+      if (a)
+        if (this.params.radial) {
+          const l = Math.hypot(c.x, c.y), d = Math.atan2(a.y, a.x) + (s() - 0.5) * 0.3;
+          c.x = l * Math.cos(d), c.y = l * Math.sin(d);
+        } else {
+          const l = this.axisBand(c, "x");
+          c.x = Math.min(Math.max(a.x + (s() - 0.5) * 20, l.lo), l.hi);
+        }
+    }
+    this.edges = t.edges;
+  }
+  getNode(t) {
+    return this.nodeMap.get(t);
+  }
+  // A node's rest interval on one axis in the frame — a re-centred band, a
+  // scalar's point, or the centre itself for a node with no value there.
+  axisBand(t, n) {
+    return this.frame.rest(n, t);
+  }
+  seedPosition(t, n) {
+    if (this.params.radial) {
+      const c = this.frame.ringOf(t), a = n() * Math.PI * 2;
+      return [c * Math.cos(a), c * Math.sin(a)];
+    }
+    const s = this.axisBand(t, "x"), o = this.axisBand(t, "y"), i = Math.max(40, (s.hi - s.lo) * 0.7), r = Math.max(20, (o.hi - o.lo) / 2);
+    return [
+      (s.lo + s.hi) / 2 + (n() - 0.5) * i,
+      (o.lo + o.hi) / 2 + (o.hi - o.lo) * $c + (n() - 0.5) * r
+    ];
+  }
+  tick(t, n) {
+    if (this.alpha < this.params.alphaMin) return;
+    const s = t ? this.nodes.filter((d) => t.has(d.id)) : this.nodes, o = t ? cr(this.edges, t) : this.edges;
+    vc(s, this.params, this.resolved, this.alpha, this.rng), yc(o, this.nodeMap, this.params, this.edgeCategory, this.alpha, this.rng);
+    const i = nr(this.params), r = fc(this.params);
+    i && bc(s, this.params, this.frame, this.alpha, this.rng), r && Mc(s, this.params, this.alpha, n), !i && !r && Sc(s, this.params, this.alpha);
+    const c = this.params.velocityDecay, a = ms * ms;
+    for (const d of s) {
+      if (d.pinned) continue;
+      d.vx *= c, d.vy *= c, Number.isFinite(d.vx) || (d.vx = 0), Number.isFinite(d.vy) || (d.vy = 0);
+      const u = d.vx * d.vx + d.vy * d.vy;
+      if (u > a) {
+        const v = ms / Math.sqrt(u);
+        d.vx *= v, d.vy *= v;
+      }
+      d.x += d.vx, d.y += d.vy, Number.isFinite(d.x) || (d.x = 0), Number.isFinite(d.y) || (d.y = 0), d.x < -Ot ? d.x = -Ot : d.x > Ot && (d.x = Ot), d.y < -Ot ? d.y = -Ot : d.y > Ot && (d.y = Ot);
+    }
+    const l = this.reheatDecay ?? this.params.alphaDecay;
+    this.alpha = Math.max(this.alpha - l, 0), this.alpha <= this.params.alphaMin && (this.reheatDecay = null);
+  }
+  // Strong, bounded-duration kick. A bigger `alpha` rearranges the layout
+  // further but settles in the same ~REHEAT_TICKS window (decay scales with the
+  // kick) rather than lingering proportionally longer.
+  reheat(t = 0.5) {
+    this.alpha = t, this.reheatDecay = t / Lc;
+  }
+  // Raise alpha to at least `target` without ever cooling a hotter sim.
+  // This is the physics primitive behind the control panel's "keep the
+  // layout warm while tuning" hook: a parameter edit re-energises the
+  // simulation just enough to show its effect, but a still-hot sim is
+  // left alone so dragging a slider during settling doesn't dampen it.
+  nudge(t = 0.3) {
+    this.alpha < t && (this.alpha = t), this.reheatDecay = null;
+  }
+  isStable() {
+    return this.alpha < this.params.alphaMin;
+  }
+  pinNode(t, n, s) {
+    const o = this.nodeMap.get(t);
+    o && (o.pinned = !0, o.x = n, o.y = s, o.vx = 0, o.vy = 0);
+  }
+  unpinNode(t) {
+    const n = this.nodeMap.get(t);
+    n && (n.pinned = !1);
+  }
+  setParams(t) {
+    Object.assign(this.params, t), this.resolved = $s(this.params, this.taxonomy), this.frame = Cs(this, this.resolved), this.springByEdge = null;
+  }
+  classifyEdges() {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of this.edges) {
+      const s = this.nodeMap.get(n.sourceId), o = this.nodeMap.get(n.targetId);
+      s && o && t.set(n.id, Bs(this.resolved.spring, n, s, o));
+    }
+    return t;
+  }
+  // Seed a node at a given position (used when new nodes appear during a
+  // level-toggle transition): the point, snapped into the frame the forces act
+  // in — both rest bands in cartesian, the bucket's ring in radial — so the
+  // structure is honoured immediately.
+  seedAt(t, n, s) {
+    const o = this.nodeMap.get(t);
+    if (!o) return;
+    let i, r;
+    if (this.params.radial) {
+      const c = this.frame.ringOf(o), a = Math.atan2(s, n);
+      i = c * Math.cos(a), r = c * Math.sin(a);
+    } else {
+      const c = this.axisBand(o, "x"), a = this.axisBand(o, "y");
+      i = Math.min(Math.max(n, c.lo), c.hi), r = Math.min(Math.max(s, a.lo), a.hi);
+    }
+    o.x = i + (this.rng() - 0.5) * 10, o.y = r + (this.rng() - 0.5) * 10, o.vx = 0, o.vy = 0;
+  }
+}
+const Dc = {
+  baseMul: 0.6,
+  minZoomMul: 0.4,
+  maxZoomMul: 1.65
+};
+function vs(e, t) {
+  return t.baseMul * Math.max(t.minZoomMul, Math.min(t.maxZoomMul, e));
+}
+function zn(e, t) {
+  return { forces: e, nodeScale: t };
+}
+function ar(e) {
+  return zn(ir(e), Dc);
+}
+const lr = [
+  "pushMultiplier",
+  "coreRadiusMultiplier",
+  "chargeExponent",
+  "pullMultiplier",
+  "distanceMultiplier",
+  "linkExponent",
+  "gravityX",
+  "gravityY",
+  "gravityBandExp",
+  "gravityTopological",
+  "gravityTopologicalExp",
+  "gravityCenter",
+  "alphaDecay",
+  "alphaMin",
+  "velocityDecay"
+], dr = ["radial", "topologicalEnabled"], _c = ["baseMul", "minZoomMul", "maxZoomMul"];
+function ur(e) {
+  const t = (s) => Zt(s) ? { scalar: s.scalar, ...s.span ? { span: { ...s.span } } : {} } : { axis: s.mapping.axis, ...s.overrides.size > 0 ? { overrides: Object.fromEntries(s.overrides) } : {} }, n = {
+    pair: {
+      axis: e.pair.mapping.axis,
+      ...e.pair.push.size > 0 ? { push: Object.fromEntries(e.pair.push) } : {},
+      ...e.pair.spring.size > 0 ? { spring: Object.fromEntries(e.pair.spring) } : {}
+    },
+    bandX: t(e.bandX),
+    bandY: t(e.bandY)
+  };
+  for (const s of lr) n[s] = e[s];
+  for (const s of dr) n[s] = e[s];
+  return n;
+}
+function Bc(e, t, n) {
+  if (!je(e)) return;
+  const s = { ...t };
+  for (const o of lr) {
+    const i = e[o];
+    if (i !== void 0) {
+      if (!yt(i)) return;
+      s[o] = i;
+    }
+  }
+  for (const o of dr) {
+    const i = e[o];
+    if (i !== void 0) {
+      if (typeof i != "boolean") return;
+      s[o] = i;
+    }
+  }
+  if (e.pair !== void 0) {
+    const o = zc(e.pair, n);
+    if (!o) return;
+    s.pair = o;
+  }
+  for (const o of ["bandX", "bandY"]) {
+    if (e[o] === void 0) continue;
+    const i = Vc(e[o], n);
+    if (!i) return;
+    s[o] = i;
+  }
+  return s;
+}
+function Hc(e, t) {
+  if (!je(e)) return;
+  const n = { ...t };
+  for (const s of _c) {
+    const o = e[s];
+    if (o !== void 0) {
+      if (!yt(o)) return;
+      n[s] = o;
+    }
+  }
+  return n;
+}
+function fr(e, t) {
+  return t === e.styleAxis() ? Qt(e) : Vn(Vs(e, t), []);
+}
+function zc(e, t) {
+  if (!je(e) || typeof e.axis != "string") return;
+  const n = /* @__PURE__ */ new Map();
+  if (e.push !== void 0) {
+    if (!je(e.push)) return;
+    for (const [o, i] of Object.entries(e.push)) {
+      if (!je(i) || !yt(i.charge) || !yt(i.coreRadius)) return;
+      n.set(o, { charge: i.charge, coreRadius: i.coreRadius });
+    }
+  }
+  const s = /* @__PURE__ */ new Map();
+  if (e.spring !== void 0) {
+    if (!je(e.spring)) return;
+    for (const [o, i] of Object.entries(e.spring)) {
+      if (!je(i) || !yt(i.strength) || !yt(i.distance)) return;
+      s.set(o, { strength: i.strength, distance: i.distance });
+    }
+  }
+  return { mapping: fr(t, e.axis), push: n, spring: s };
+}
+function Vc(e, t) {
+  if (!je(e)) return;
+  if (typeof e.scalar == "string")
+    return e.span === void 0 ? { scalar: e.scalar } : !je(e.span) || !yt(e.span.zero) || !yt(e.span.one) ? void 0 : { scalar: e.scalar, span: { zero: e.span.zero, one: e.span.one } };
+  if (typeof e.axis != "string") return;
+  const n = /* @__PURE__ */ new Map();
+  if (e.overrides !== void 0) {
+    if (!je(e.overrides)) return;
+    for (const [s, o] of Object.entries(e.overrides)) {
+      if (!je(o) || !yt(o.min) || !yt(o.max)) return;
+      n.set(s, { min: o.min, max: o.max });
+    }
+  }
+  return { mapping: fr(t, e.axis), overrides: n };
+}
+function Gc(e, t) {
+  if (e === t) return !0;
+  const n = (s) => {
+    const o = s;
+    return JSON.stringify([ur(o.forces), o.nodeScale]);
+  };
+  return n(e) === n(t);
+}
+const Xc = { x: 0, y: 0, scale: 1 }, Yc = 0.1, Jc = 40;
+function Ye(e, t, n) {
+  return [t * e.scale + e.x, n * e.scale + e.y];
+}
+function ys(e, t, n) {
+  return [(t - e.x) / e.scale, (n - e.y) / e.scale];
+}
+function As(e, t, n, s) {
+  const o = Math.max(Yc, Math.min(Jc, e.scale * s)), i = (t - e.x) / e.scale, r = (n - e.y) / e.scale;
+  return {
+    scale: o,
+    x: t - i * o,
+    y: n - r * o
+  };
+}
+function jc(e, t, n) {
+  if (!(t != null && t.width) || !t.height || !n.width || !n.height) return e;
+  const s = n.width - t.width, o = n.height - t.height;
+  return s || o ? { ...e, x: e.x + s / 2, y: e.y + o / 2 } : e;
+}
+function hr(e, t, n, s = 60) {
+  if (e.length === 0) return { x: t / 2, y: n / 2, scale: 1 };
+  let o = 1 / 0, i = -1 / 0, r = 1 / 0, c = -1 / 0;
+  for (const p of e)
+    p.x < o && (o = p.x), p.x > i && (i = p.x), p.y < r && (r = p.y), p.y > c && (c = p.y);
+  const a = i - o || 1, l = c - r || 1, d = t - s * 2, u = n - s * 2, v = Math.min(d / a, u / l, 2), M = (o + i) / 2, S = (r + c) / 2;
+  return {
+    scale: v,
+    x: t / 2 - M * v,
+    y: n / 2 - S * v
+  };
+}
+function qc(e, t, n) {
+  const s = (o) => {
+    o.preventDefault();
+    const i = e.getBoundingClientRect();
+    n(As(t(), o.clientX - i.left, o.clientY - i.top, o.deltaY < 0 ? 1.15 : 0.85));
+  };
+  return e.addEventListener("wheel", s, { passive: !1 }), () => e.removeEventListener("wheel", s);
+}
+const Uc = "#4A90D9", Kc = "#FFFFFF", Wc = 0.2, Zc = 0.5, Qc = 16, ea = 0.42, ta = 0.16, na = 9, sa = 0.6;
+function So(e) {
+  return 1 + Math.max(0, e - 1) * sa;
+}
+const oa = [6, 4], ra = 6, ia = 0.55, Gs = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif', ca = 11, aa = 0.78, la = 15, da = 12;
+function ua(e) {
+  return e.length > la ? e.slice(0, da) + "…" : e;
+}
+function fa(e) {
+  return `600 ${e.toFixed(1)}px ${Gs}`;
+}
+const gr = 9, ha = 4, pr = 2, ga = 3, mr = 4, pa = "#7C3AED", ma = "#FFFFFF";
+function va(e) {
+  return `600 ${e.toFixed(1)}px ${Gs}`;
+}
+function ya(e, t, n, s, o, i) {
+  const r = Math.min(i, s / 2, o / 2);
+  e.beginPath(), e.moveTo(t + r, n), e.arcTo(t + s, n, t + s, n + o, r), e.arcTo(t + s, n + o, t, n + o, r), e.arcTo(t, n + o, t, n, r), e.arcTo(t, n, t + s, n, r), e.closePath();
+}
+function ba(e, t) {
+  if (!e.badges || e.badges.length === 0) return 0;
+  const n = gr * t + pr * 2 * t;
+  return mr * t + n;
+}
+function zt(e, t, n) {
+  const s = e ?? (typeof document < "u" ? document.documentElement : null);
+  return s && getComputedStyle(s).getPropertyValue(t).trim() || n;
+}
+const Fn = 8, Pe = 100, bs = 0.25, xs = 0.1;
+function ko(e, t, n, s, o, i) {
+  if (!t) return [n, s, o, i];
+  const r = e.sourceId < e.targetId, c = r ? o - n : n - o, a = r ? i - s : s - i, l = Math.hypot(c, a) || 1, d = -a / l * t, u = c / l * t;
+  return [n + d, s + u, o + d, i + u];
+}
+function xa({
+  nodes: e,
+  edges: t,
+  viewport: n,
+  onViewportChange: s,
+  onNodeDragStart: o,
+  onNodeDragMove: i,
+  onNodeDragEnd: r,
+  onDoubleClickNode: c,
+  onFitView: a,
+  onHoverNode: l,
+  onSelectNode: d,
+  highlightedNodes: u,
+  highlightedEdges: v,
+  hoveredNodeId: M,
+  selectedNodeId: S,
+  focusedNodeId: p,
+  searchMatchIds: $,
+  running: D,
+  forceParams: x,
+  resolved: V,
+  overlay: F,
+  theme: L,
+  edgeStrokes: y,
+  edgeOffsets: I,
+  activeSection: E,
+  activePushBucket: O,
+  activeGravityBucket: X,
+  activePullEdge: N,
+  nodeScale: k,
+  groupGlows: w,
+  markedEdges: R
+}) {
+  const z = g.useRef(null), pe = g.useRef(null), [ke, St] = g.useState({ w: 0, h: 0 }), Ne = g.useRef(null), ct = g.useMemo(() => {
+    const B = /* @__PURE__ */ new Map();
+    for (const f of e) B.set(f.id, f);
+    return B;
+  }, [e]), at = g.useMemo(() => {
+    const B = /* @__PURE__ */ new Map();
+    for (const q of e) B.set(Vt(q), (B.get(Vt(q)) ?? 0) + 1);
+    const f = /* @__PURE__ */ new Set();
+    for (const q of e)
+      (B.get(Vt(q)) ?? 0) > 1 && f.add(q.id);
+    return f;
+  }, [e]), lt = g.useMemo(() => {
+    const B = M ?? S;
+    if (!B) return null;
+    const f = ct.get(B);
+    return !f || !at.has(B) ? null : Vt(f);
+  }, [M, S, ct, at]), Ie = Bt(), dt = g.useRef({
+    taxonomy: Ie,
+    nodes: e,
+    edges: t,
+    nodeMap: ct,
+    viewport: n,
+    groupGlows: w,
+    markedEdges: R,
+    highlightedNodes: u,
+    highlightedEdges: v,
+    hoveredNodeId: M,
+    selectedNodeId: S,
+    focusedNodeId: p,
+    searchMatchIds: $,
+    forceParams: x,
+    resolved: V,
+    overlay: F,
+    theme: L,
+    edgeStrokes: y,
+    edgeOffsets: I,
+    activeSection: E,
+    activePushBucket: O,
+    activeGravityBucket: X,
+    activePullEdge: N,
+    nodeScale: k,
+    running: D,
+    dupNodeIds: at,
+    activeDupDefKey: lt
+  });
+  dt.current = {
+    taxonomy: Ie,
+    nodes: e,
+    edges: t,
+    nodeMap: ct,
+    viewport: n,
+    groupGlows: w,
+    markedEdges: R,
+    highlightedNodes: u,
+    highlightedEdges: v,
+    hoveredNodeId: M,
+    selectedNodeId: S,
+    focusedNodeId: p,
+    searchMatchIds: $,
+    forceParams: x,
+    resolved: V,
+    overlay: F,
+    theme: L,
+    edgeStrokes: y,
+    edgeOffsets: I,
+    activeSection: E,
+    activePushBucket: O,
+    activeGravityBucket: X,
+    activePullEdge: N,
+    nodeScale: k,
+    running: D,
+    dupNodeIds: at,
+    activeDupDefKey: lt
+  }, g.useEffect(() => {
+    const B = pe.current;
+    if (!B) return;
+    const f = new ResizeObserver((q) => {
+      const { width: te, height: le } = q[0].contentRect;
+      St({ w: Math.floor(te), h: Math.floor(le) });
+    });
+    return f.observe(B), () => f.disconnect();
+  }, []);
+  const De = g.useCallback((B, f) => {
+    const [q, te] = ys(n, B, f), le = vs(n.scale, k);
+    for (let Ee = e.length - 1; Ee >= 0; Ee--) {
+      const Me = e[Ee], Oe = (Ie.nodeStyleOf(Me).size.r * le + ba(Me, le)) / n.scale + 4;
+      if ((q - Me.x) ** 2 + (te - Me.y) ** 2 <= Oe * Oe) return Me;
+    }
+    return null;
+  }, [e, n, k, Ie]), ht = Te(n), b = Te(s);
+  g.useEffect(() => {
+    const B = z.current;
+    if (B)
+      return qc(B, () => ht.current, (f) => b.current(f));
+  }, []);
+  const T = g.useCallback((B) => {
+    var Ee;
+    const f = B.currentTarget.getBoundingClientRect(), q = B.clientX - f.left, te = B.clientY - f.top, le = De(q, te);
+    if (le) {
+      Ne.current = { type: "node", sx: q, sy: te, moved: !1 };
+      const [Me, A] = ys(n, q, te);
+      o(le.id, Me, A);
+    } else
+      Ne.current = { type: "pan", startVp: { ...n }, sx: q, sy: te, moved: !1 };
+    (Ee = z.current) == null || Ee.setPointerCapture(B.pointerId);
+  }, [n, De, o]), U = g.useCallback((B) => {
+    const f = B.currentTarget.getBoundingClientRect(), q = B.clientX - f.left, te = B.clientY - f.top;
+    if (!Ne.current) {
+      const le = De(q, te);
+      l((le == null ? void 0 : le.id) ?? null);
+      return;
+    }
+    if (Ne.current.moved = !0, Ne.current.type === "pan" && Ne.current.startVp) {
+      const le = q - Ne.current.sx, Ee = te - Ne.current.sy;
+      s({
+        ...Ne.current.startVp,
+        x: Ne.current.startVp.x + le,
+        y: Ne.current.startVp.y + Ee
+      });
+    } else if (Ne.current.type === "node") {
+      const [le, Ee] = ys(n, q, te);
+      i(le, Ee);
+    }
+  }, [n, De, s, i, l]), se = g.useCallback((B) => {
+    var q;
+    const f = Ne.current;
+    if ((f == null ? void 0 : f.type) === "node") {
+      if (r(), !f.moved) {
+        const te = B.currentTarget.getBoundingClientRect(), le = B.clientX - te.left, Ee = B.clientY - te.top, Me = De(le, Ee);
+        Me && d(Me.id);
+      }
+    } else (f == null ? void 0 : f.type) === "pan" && !f.moved && d(null);
+    Ne.current = null, (q = z.current) == null || q.releasePointerCapture(B.pointerId);
+  }, [r, d, De]), G = g.useCallback((B) => {
+    const f = B.currentTarget.getBoundingClientRect(), q = B.clientX - f.left, te = B.clientY - f.top, le = De(q, te);
+    le ? c(le.id) : a();
+  }, [De, a, c]), oe = g.useRef(!0);
+  return g.useEffect(() => {
+    oe.current = !0;
+  }), g.useEffect(() => {
+    const B = z.current;
+    if (!B || ke.w === 0) return;
+    const f = B.getContext("2d");
+    if (!f) return;
+    const q = window.devicePixelRatio || 1;
+    B.width = ke.w * q, B.height = ke.h * q;
+    let te = 0, le = !0;
+    const Ee = () => {
+      var gt, tt;
+      const A = dt.current, { w: Oe, h: xe } = ke, xt = A.highlightedNodes !== null && A.highlightedNodes.size > 0, Y = A.groupGlows.length > 0 ? Zc : Wc, re = zt(B, "--gv-color-graph-label", "#0f172a"), Qe = re.startsWith("#") && re.length === 7 ? re + "33" : "rgba(100,116,139,0.2)", Z = A.viewport, _e = vs(Z.scale, A.nodeScale);
+      if (f.setTransform(q, 0, 0, q, 0, 0), f.clearRect(0, 0, Oe, xe), A.groupGlows.length > 0) {
+        const _ = /* @__PURE__ */ new Map();
+        for (const K of A.groupGlows)
+          for (const H of K.nodeIds) _.set(H, { color: K.color, strength: K.strength });
+        f.save(), f.lineCap = "round";
+        for (const K of A.edges) {
+          const H = _.get(K.sourceId), ne = _.get(K.targetId);
+          if (!H || !ne || H.color !== ne.color) continue;
+          const J = A.nodeMap.get(K.sourceId), Q = A.nodeMap.get(K.targetId);
+          if (!J || !Q) continue;
+          const [ie, ee] = Ye(Z, J.x, J.y), [W, ce] = Ye(Z, Q.x, Q.y);
+          Math.max(ie, W) < -Pe || Math.min(ie, W) > Oe + Pe || Math.max(ee, ce) < -Pe || Math.min(ee, ce) > xe + Pe || (f.globalAlpha = Math.min(0.5, ta * H.strength), f.strokeStyle = H.color, f.lineWidth = na * So(H.strength), f.beginPath(), f.moveTo(ie, ee), f.lineTo(W, ce), f.stroke());
+        }
+        f.globalAlpha = 1;
+        for (const [K, H] of _) {
+          const ne = A.nodeMap.get(K);
+          if (!ne) continue;
+          const [J, Q] = Ye(Z, ne.x, ne.y), ie = A.taxonomy.nodeStyleOf(ne).size.r * _e + Qc * So(H.strength);
+          if (J + ie < 0 || J - ie > Oe || Q + ie < 0 || Q - ie > xe) continue;
+          const ee = Math.min(0.92, ea * H.strength), W = f.createRadialGradient(J, Q, 0, J, Q, ie);
+          W.addColorStop(0, fs(H.color, ee)), W.addColorStop(0.6, fs(H.color, ee * 0.5)), W.addColorStop(1, fs(H.color, 0)), f.fillStyle = W, f.beginPath(), f.arc(J, Q, ie, 0, Math.PI * 2), f.fill();
+        }
+        f.restore(), f.globalAlpha = 1;
+      }
+      for (const _ of A.edges) {
+        const K = A.nodeMap.get(_.sourceId), H = A.nodeMap.get(_.targetId);
+        if (!K || !H) continue;
+        const [ne, J] = Ye(Z, K.x, K.y), [Q, ie] = Ye(Z, H.x, H.y), [ee, W, ce, $e] = ko(_, A.edgeOffsets.get(_.id) ?? 0, ne, J, Q, ie);
+        if (Math.max(ee, ce) < -Pe || Math.min(ee, ce) > Oe + Pe || Math.max(W, $e) < -Pe || Math.min(W, $e) > xe + Pe) continue;
+        const Re = ((gt = A.highlightedEdges) == null ? void 0 : gt.has(_.id)) ?? !1, de = A.edgeStrokes.get(_) ?? wn, he = de.alpha, ge = A.searchMatchIds !== null && (!A.searchMatchIds.has(_.sourceId) || !A.searchMatchIds.has(_.targetId)), ue = xt ? !Re : ge, we = xt && Re ? 1 : ue ? Y : he;
+        if (A.markedEdges.has(_.id) && (f.globalAlpha = ue ? Y : ia, f.beginPath(), f.setLineDash(oa), f.strokeStyle = re, f.lineWidth = ra, f.moveTo(ee, W), f.lineTo(ce, $e), f.stroke()), f.globalAlpha = we, f.beginPath(), f.setLineDash([...de.dash]), f.strokeStyle = de.color[A.theme], f.lineWidth = de.width, f.moveTo(ee, W), f.lineTo(ce, $e), f.stroke(), f.setLineDash([]), !it(_)) {
+          const be = Math.atan2($e - W, ce - ee), Fe = A.taxonomy.nodeStyleOf(H).size.r * vs(Z.scale, A.nodeScale) + 2, He = ce - Math.cos(be) * Fe, ae = $e - Math.sin(be) * Fe;
+          f.beginPath(), f.moveTo(He, ae), f.lineTo(
+            He - Fn * Math.cos(be - Math.PI / 6),
+            ae - Fn * Math.sin(be - Math.PI / 6)
+          ), f.lineTo(
+            He - Fn * Math.cos(be + Math.PI / 6),
+            ae - Fn * Math.sin(be + Math.PI / 6)
+          ), f.closePath(), f.fillStyle = de.color[A.theme], f.fill();
+        }
+        f.globalAlpha = 1;
+      }
+      const Be = A.activeSection === "push", rn = A.activeSection === "pull", kt = A.activeSection === "gravity", et = [0.2, 0.5, 1.5];
+      if (Be) {
+        const _ = A.forceParams.chargeExponent, K = A.forceParams.pushMultiplier, H = A.forceParams.coreRadiusMultiplier, ne = A.activePushBucket;
+        for (const J of A.nodes) {
+          const [Q, ie] = Ye(Z, J.x, J.y), ee = 2e3;
+          if (Q + ee < 0 || Q - ee > Oe || ie + ee < 0 || ie - ee > xe) continue;
+          const W = ne === null || Dt(A.resolved.push, J) === ne, ce = W ? 0.28 : 0.05, $e = W ? 0.06 : 0.015, Re = A.taxonomy.nodeStyleOf(J).color[A.theme].fill;
+          f.strokeStyle = Re;
+          const de = Math.abs(Qo(A.resolved.push, J)) * K;
+          if (de <= 0) continue;
+          const he = H * er(A.resolved.push, J), ge = he * he, ue = [];
+          for (let we = 0; we < et.length; we++) {
+            const be = et[we], fe = de / be, Fe = Math.pow(fe, 1 / Math.max(_, 0.01)) - ge;
+            if (Fe <= 0) continue;
+            const ae = Math.sqrt(Fe) * Z.scale;
+            ae < 2 || ae > 2e3 || ue.push(ae);
+          }
+          if (ue.length !== 0) {
+            f.strokeStyle = Re;
+            for (let we = 0; we < ue.length; we++) {
+              const be = ue[we], fe = ue.length - 1 - we;
+              f.beginPath(), f.arc(Q, ie, be, 0, Math.PI * 2), f.globalAlpha = ce + fe * $e, f.lineWidth = W ? 1.5 : 1, f.stroke();
+            }
+          }
+        }
+        f.globalAlpha = 1;
+      }
+      const Ve = A.activePullEdge;
+      if (rn || Ve) {
+        const _ = A.forceParams.distanceMultiplier, K = zt(B, "--gv-tension-stretch", "#d97706"), H = zt(B, "--gv-tension-compress", "#7CB9E8"), ne = zt(B, "--gv-tension-rest", "#7EC8B8");
+        for (const J of A.edges) {
+          const Q = A.nodeMap.get(J.sourceId), ie = A.nodeMap.get(J.targetId);
+          if (!Q || !ie) continue;
+          const ee = Bs(A.resolved.spring, J, Q, ie);
+          if (Ve && ee.key !== Ve) continue;
+          const [W, ce] = Ye(Z, Q.x, Q.y), [$e, Re] = Ye(Z, ie.x, ie.y), [de, he, ge, ue] = ko(J, A.edgeOffsets.get(J.id) ?? 0, W, ce, $e, Re);
+          if (Math.max(de, ge) < -Pe || Math.min(de, ge) > Oe + Pe || Math.max(he, ue) < -Pe || Math.min(he, ue) > xe + Pe) continue;
+          const we = ee.distance * _, be = ie.x - Q.x, fe = ie.y - Q.y, He = Math.sqrt(be * be + fe * fe) / Math.max(we, 0.1);
+          let ae;
+          if (He > 1.15 ? ae = K : He < 0.85 ? ae = H : ae = ne, Ve) {
+            const Ge = A.edgeStrokes.get(J) ?? wn;
+            f.beginPath(), f.moveTo(de, he), f.lineTo(ge, ue), f.strokeStyle = ae, f.globalAlpha = 0.9, f.lineWidth = Ge.width + 5, f.setLineDash([]), f.stroke(), f.beginPath(), f.moveTo(de, he), f.lineTo(ge, ue), f.strokeStyle = Ge.color[A.theme], f.globalAlpha = 1, f.lineWidth = Ge.width, f.setLineDash([...Ge.dash]), f.stroke(), f.setLineDash([]);
+            continue;
+          }
+          f.beginPath(), f.moveTo(de, he), f.lineTo(ge, ue), f.strokeStyle = ae, f.globalAlpha = 0.5, f.lineWidth = 3, f.setLineDash([]), f.stroke();
+          const Ce = Math.atan2(fe, be), Ke = -Math.sin(Ce), Xt = Math.cos(Ce), We = 5, pt = we * Z.scale;
+          if (pt > 10 && pt < Math.sqrt((ge - de) ** 2 + (ue - he) ** 2) * 2) {
+            const Ge = de + Math.cos(Ce) * pt, kn = he + Math.sin(Ce) * pt;
+            f.beginPath(), f.moveTo(Ge - Ke * We, kn - Xt * We), f.lineTo(Ge + Ke * We, kn + Xt * We), f.strokeStyle = ne, f.globalAlpha = 0.7, f.lineWidth = 1.5, f.stroke();
+            const Xe = ge - Math.cos(Ce) * pt, Nn = ue - Math.sin(Ce) * pt;
+            f.beginPath(), f.moveTo(Xe - Ke * We, Nn - Xt * We), f.lineTo(Xe + Ke * We, Nn + Xt * We), f.stroke();
+          }
+        }
+        f.globalAlpha = 1, f.setLineDash([]);
+      }
+      if (kt && A.overlay.acting) {
+        const _ = A.activeGravityBucket, K = (J) => (J !== void 0 ? A.overlay.colors.get(J) : void 0) ?? zt(B, "--gv-color-text-muted", "#94A3B8"), H = (J) => _ !== null && _.axis === J && (J === "y" && A.overlay.rings.length > 0 ? A.overlay.rings.some((Q) => Q.buckets.includes(_.bucket)) : (J === "x" ? A.overlay.x : A.overlay.y).some((Q) => Q.buckets.includes(_.bucket)));
+        if (A.overlay.rings.length > 0) {
+          const [J, Q] = Ye(Z, 0, 0), ie = H("y");
+          for (const ee of A.overlay.rings) {
+            const W = ie && _ !== null && ee.buckets.includes(_.bucket), ce = ie && !W;
+            f.strokeStyle = K(ee.buckets[0]), f.globalAlpha = W ? 0.6 : ce ? 0.1 : 0.28, f.lineWidth = W ? 1.5 : 1, f.setLineDash([]), f.beginPath(), f.arc(J, Q, ee.radius * Z.scale, 0, Math.PI * 2), f.stroke();
+          }
+        }
+        const ne = (J) => {
+          const Q = J === "x" ? A.overlay.x : A.overlay.y, ie = H(J), ee = (W) => J === "y" ? Ye(Z, 0, W)[1] : Ye(Z, W, 0)[0];
+          for (const { lo: W, hi: ce, buckets: $e, gradient: Re } of Q) {
+            const de = ee(W), he = ee(ce);
+            if (he < 0 || de > (J === "y" ? xe : Oe)) continue;
+            const ge = ie && _ !== null && $e.includes(_.bucket), ue = ie && !ge, we = K($e[0]);
+            if (Re) {
+              const be = ee(Re.zero), fe = ee(Re.one), Fe = J === "y" ? f.createLinearGradient(0, be, 0, fe) : f.createLinearGradient(be, 0, fe, 0);
+              Fe.addColorStop(0, zt(B, "--gv-color-text-muted", "#94A3B8")), Fe.addColorStop(1, zt(B, "--gv-color-text", "#1E293B")), f.fillStyle = Fe, f.globalAlpha = 0.12;
+            } else
+              f.fillStyle = we, f.globalAlpha = ge ? 0.2 : ue ? 0.04 : 0.1;
+            J === "y" ? f.fillRect(0, de, Oe, he - de) : f.fillRect(de, 0, he - de, xe), f.strokeStyle = we, f.globalAlpha = ge ? 0.55 : ue ? 0.08 : 0.22, f.lineWidth = ge ? 1.5 : 1, f.setLineDash([]), f.beginPath(), J === "y" ? (f.moveTo(0, de), f.lineTo(Oe, de), f.moveTo(0, he), f.lineTo(Oe, he)) : (f.moveTo(de, 0), f.lineTo(de, xe), f.moveTo(he, 0), f.lineTo(he, xe)), f.stroke();
+          }
+        };
+        ne("y"), ne("x"), f.globalAlpha = 1;
+      }
+      f.textAlign = "center", f.textBaseline = "middle";
+      const ye = [], Ue = A.nodes.map((_) => {
+        const [K, H] = Ye(Z, _.x, _.y);
+        return { x: K, y: H, r: A.taxonomy.nodeStyleOf(_).size.r * _e };
+      });
+      for (const _ of A.nodes) {
+        const [K, H] = Ye(Z, _.x, _.y), ne = A.taxonomy.nodeStyleOf(_), J = ne.size.r * _e, Q = J;
+        if (K + Q < -Pe || K - Q > Oe + Pe || H + Q < -Pe || H - Q > xe + Pe) continue;
+        const ie = ((tt = A.highlightedNodes) == null ? void 0 : tt.has(_.id)) ?? !1, ee = A.searchMatchIds !== null && !A.searchMatchIds.has(_.id), W = xt && !ie || ee;
+        f.globalAlpha = W ? Y : 1;
+        const { fill: ce, border: $e } = ne.color[A.theme], Re = ne.icon;
+        f.beginPath(), f.arc(K, H, J, 0, Math.PI * 2), f.fillStyle = ce, f.fill(), f.lineWidth = Math.max(1, Math.min(2, Z.scale * 1.25)), f.strokeStyle = $e, f.stroke(), Z.scale >= bs && Re && (f.save(), f.font = `${ne.size.iconSize * _e}px ${Gs}`, f.fillStyle = "#FFFFFF", f.globalAlpha = (W ? Y : 1) * 0.92, f.fillText(Re, K, H + 0.5), f.restore()), _.ring === "dashed" && Z.scale >= xs && (f.save(), f.setLineDash([3, 3]), f.strokeStyle = ce, f.lineWidth = 1.5, f.beginPath(), f.arc(K, H, J + 4, 0, Math.PI * 2), f.stroke(), f.restore());
+        const de = A.activeDupDefKey !== null && Vt(_) === A.activeDupDefKey && Z.scale >= xs;
+        if (de && (f.save(), f.strokeStyle = ce, f.lineWidth = 2, f.setLineDash([]), f.globalAlpha = 0.55, f.beginPath(), f.arc(K, H, J + 5, 0, Math.PI * 2), f.stroke(), f.restore()), _.id === A.selectedNodeId) {
+          const ge = de ? J + 10 : J + 5;
+          f.save(), f.strokeStyle = Kc, f.lineWidth = 2.5, f.setLineDash([]), f.beginPath(), f.arc(K, H, ge, 0, Math.PI * 2), f.stroke(), f.restore();
+        }
+        if (_.id === A.focusedNodeId && Z.scale >= xs && (f.save(), f.strokeStyle = Uc, f.lineWidth = 2, f.setLineDash([2, 2]), f.beginPath(), f.arc(K, H, J + 9, 0, Math.PI * 2), f.stroke(), f.restore()), f.globalAlpha = 1, _.badges && _.badges.length > 0 && Z.scale >= bs) {
+          const ge = gr * _e, ue = ge + pr * 2 * _e, we = ha * _e, be = ga * _e;
+          f.save(), f.font = va(ge), f.textAlign = "center", f.textBaseline = "middle";
+          const fe = _.badges.map((Ce) => {
+            const Ke = Ce;
+            return { text: Ke, w: f.measureText(Ke).width + we * 2 };
+          }), Fe = fe.reduce((Ce, Ke) => Ce + Ke.w, 0) + be * (fe.length - 1), He = H - J - mr * _e - ue;
+          let ae = K - Fe / 2;
+          f.globalAlpha = W ? Y : 1;
+          for (const Ce of fe)
+            ya(f, ae, He, Ce.w, ue, ue / 2), f.fillStyle = pa, f.fill(), f.fillStyle = ma, f.fillText(Ce.text, ae + Ce.w / 2, He + ue / 2 + 0.5), ae += Ce.w + be;
+          f.restore(), f.globalAlpha = 1;
+        }
+        const he = _.id === A.hoveredNodeId || _.id === A.selectedNodeId;
+        if (Z.scale >= bs || he) {
+          const ge = ca * (he ? Math.max(_e, 1) : _e), ue = H + J + 4 + ge * 0.7;
+          f.font = fa(ge);
+          const we = ua(_.name), be = f.measureText(we).width, fe = { x: K - be / 2 - 2, y: ue - ge / 2 - 1, w: be + 4, h: ge + 2 }, Fe = ye.some((ae) => fe.x < ae.x + ae.w && fe.x + fe.w > ae.x && fe.y < ae.y + ae.h && fe.y + fe.h > ae.y), He = !Fe && Ue.some((ae) => {
+            const Ce = Math.max(fe.x, Math.min(ae.x, fe.x + fe.w)), Ke = Math.max(fe.y, Math.min(ae.y, fe.y + fe.h));
+            return (ae.x - Ce) ** 2 + (ae.y - Ke) ** 2 < ae.r * ae.r;
+          });
+          (he || !Fe && !He) && (ye.push(fe), f.globalAlpha = W ? 1 : aa, f.fillStyle = W ? Qe : re, f.fillText(we, K, ue), f.globalAlpha = 1);
+        }
+      }
+    }, Me = () => {
+      if (!le) return;
+      (dt.current.running || oe.current) && (oe.current = !1, Ee()), te = requestAnimationFrame(Me);
+    };
+    return te = requestAnimationFrame(Me), () => {
+      le = !1, cancelAnimationFrame(te);
+    };
+  }, [ke]), /* @__PURE__ */ h("div", { ref: pe, className: "gv-graph-canvas-container", children: /* @__PURE__ */ h(
+    "canvas",
+    {
+      ref: z,
+      style: { width: ke.w, height: ke.h },
+      onPointerDown: T,
+      onPointerMove: U,
+      onPointerUp: se,
+      onDoubleClick: G
+    }
+  ) });
+}
+class No extends g.Component {
+  constructor(t) {
+    super(t), this.state = { error: null };
+  }
+  static getDerivedStateFromError(t) {
+    return { error: t };
+  }
+  componentDidCatch(t, n) {
+    console.error(`${this.props.what ?? "graph canvas"} render/draw error:`, t, n.componentStack);
+  }
+  render() {
+    return this.state.error ? /* @__PURE__ */ C("div", { className: "gv-graph-canvas-error", role: "alert", children: [
+      /* @__PURE__ */ C("p", { children: [
+        "The ",
+        this.props.what ?? "graph canvas",
+        " failed to render."
+      ] }),
+      /* @__PURE__ */ h("p", { className: "gv-graph-canvas-error-detail", children: this.state.error.message })
+    ] }) : this.props.children;
+  }
+}
+const wa = "var(--gv-color-text-muted)";
+function en(e, t, n) {
+  return t.axis === e.styleAxis() && Fs(t) ? `var(${e.colorVar(n)})` : wa;
+}
+function Xs({
+  yLabel: e,
+  ySlider: t,
+  bottom: n,
+  children: s
+}) {
+  return /* @__PURE__ */ C("div", { className: "gv-ctl-plot", children: [
+    e !== void 0 && /* @__PURE__ */ h("div", { className: "gv-ctl-plot-ylabel", children: e }),
+    t !== void 0 && /* @__PURE__ */ h("div", { className: "gv-ctl-plot-yslider", children: t }),
+    /* @__PURE__ */ h("div", { className: "gv-ctl-plot-main", children: s }),
+    n !== void 0 && /* @__PURE__ */ h("div", { className: "gv-ctl-plot-bottom", children: n })
+  ] });
+}
+const vr = g.createContext({ popped: null, setPopped: () => {
+} });
+function Ma({ children: e }) {
+  const [t, n] = g.useState(null), s = g.useMemo(() => ({ popped: t, setPopped: n }), [t]);
+  return /* @__PURE__ */ h(vr.Provider, { value: s, children: e });
+}
+function yr() {
+  return g.useContext(vr);
+}
+function rt({ id: e, children: t }) {
+  const { popped: n, setPopped: s } = yr();
+  return /* @__PURE__ */ h(
+    "span",
+    {
+      className: `gv-ctl-formula-value${n === e ? " active" : ""}`,
+      onMouseEnter: () => s(e),
+      onMouseLeave: () => s(null),
+      children: t
+    }
+  );
+}
+function _t({
+  value: e,
+  min: t,
+  max: n,
+  step: s,
+  onChange: o,
+  orientation: i = "horizontal",
+  title: r,
+  ariaLabel: c,
+  className: a,
+  popId: l
+}) {
+  const { popped: d } = yr(), v = `gv-ctl-slider gv-ctl-slider-${i === "vertical" ? "v" : "h"}` + (l !== void 0 && d === l ? " gv-ctl-slider-popped" : "") + (a ? " " + a : "");
+  return /* @__PURE__ */ h(
+    "input",
+    {
+      type: "range",
+      className: v,
+      min: t,
+      max: n,
+      step: s,
+      value: e,
+      onChange: (M) => o(Number(M.target.value)),
+      title: r,
+      "aria-label": c,
+      "data-pop-id": l
+    }
+  );
+}
+const Os = (e, t, n) => Math.max(t, Math.min(n, e)), Eo = (e, t) => Math.round(e / t) * t, jt = 300, Rt = 200, qt = 12, Io = jt - 2 * qt, $o = Rt - 2 * qt, Je = 7;
+function br({
+  tokens: e,
+  xAxis: t,
+  yAxis: n,
+  onDrag: s,
+  hoveredId: o,
+  onHover: i,
+  xSlider: r,
+  ySlider: c,
+  ariaLabel: a
+}) {
+  const l = g.useRef(null), d = g.useRef(null), u = (y) => qt + (y - t.min) / (t.max - t.min) * Io, v = (y) => Rt - qt - (y - n.min) / (n.max - n.min) * $o, M = (y) => t.min + (y - qt) / Io * (t.max - t.min), S = (y) => n.min + (Rt - qt - y) / $o * (n.max - n.min), p = (y) => {
+    const I = l.current;
+    if (!I) return { x: 0, y: 0 };
+    const E = I.createSVGPoint();
+    E.x = y.clientX, E.y = y.clientY;
+    const O = I.getScreenCTM();
+    if (!O) return { x: 0, y: 0 };
+    const X = E.matrixTransform(O.inverse());
+    return { x: X.x, y: X.y };
+  }, $ = (y, I) => {
+    y.preventDefault(), y.currentTarget.setPointerCapture(y.pointerId), d.current = I;
+  }, D = (y) => {
+    const I = d.current;
+    if (!I) return;
+    const { x: E, y: O } = p(y), X = Os(Eo(M(E), t.step), t.min, t.max), N = Os(Eo(S(O), n.step), n.min, n.max);
+    s(I, X, N);
+  }, x = (y) => {
+    var I, E;
+    d.current = null, (E = (I = y.currentTarget).releasePointerCapture) == null || E.call(I, y.pointerId);
+  }, V = [0, jt / 2, jt], F = [0, Rt / 2, Rt], L = Sa(e.map((y) => ({ cx: u(y.x), cy: v(y.y) })));
+  return /* @__PURE__ */ h(
+    Xs,
+    {
+      yLabel: n.label,
+      ySlider: /* @__PURE__ */ h(
+        _t,
+        {
+          orientation: "vertical",
+          min: c.min,
+          max: c.max,
+          step: c.step,
+          value: c.value,
+          onChange: c.onChange,
+          title: c.title,
+          ariaLabel: c.ariaLabel,
+          popId: c.popId
+        }
+      ),
+      bottom: /* @__PURE__ */ C(yn, { children: [
+        /* @__PURE__ */ h(
+          _t,
+          {
+            min: r.min,
+            max: r.max,
+            step: r.step,
+            value: r.value,
+            onChange: r.onChange,
+            title: r.title,
+            ariaLabel: r.ariaLabel,
+            popId: r.popId
+          }
+        ),
+        /* @__PURE__ */ h("div", { className: "gv-ctl-plot-xlabel", children: t.label })
+      ] }),
+      children: /* @__PURE__ */ C(
+        "svg",
+        {
+          ref: l,
+          className: "gv-spring-map-svg",
+          viewBox: `0 0 ${jt} ${Rt}`,
+          role: "group",
+          "aria-label": a,
+          children: [
+            /* @__PURE__ */ h("rect", { x: 0, y: 0, width: jt, height: Rt, className: "gv-spring-plot-bg" }),
+            V.map((y) => /* @__PURE__ */ h("line", { x1: y, y1: 0, x2: y, y2: Rt, className: "gv-spring-grid" }, `gx${y}`)),
+            F.map((y) => /* @__PURE__ */ h("line", { x1: 0, y1: y, x2: jt, y2: y, className: "gv-spring-grid" }, `gy${y}`)),
+            e.map((y, I) => {
+              const { cx: E, cy: O } = L[I], X = o !== null && o !== y.id, N = o === y.id;
+              return /* @__PURE__ */ C(
+                "g",
+                {
+                  transform: `translate(${E} ${O})`,
+                  className: `gv-spring-token${X ? " dim" : ""}${N ? " active" : ""}`,
+                  onPointerDown: (k) => $(k, y.id),
+                  onPointerMove: D,
+                  onPointerUp: x,
+                  onPointerEnter: () => i(y.id),
+                  onPointerLeave: () => {
+                    d.current || i(null);
+                  },
+                  children: [
+                    y.tooltip && /* @__PURE__ */ h("title", { children: y.tooltip }),
+                    y.colorB === void 0 ? /* @__PURE__ */ h("circle", { r: Je, fill: y.colorA }) : /* @__PURE__ */ C(yn, { children: [
+                      /* @__PURE__ */ h("path", { d: `M0,${-Je} A${Je},${Je} 0 0 0 0,${Je} Z`, fill: y.colorA }),
+                      /* @__PURE__ */ h("path", { d: `M0,${-Je} A${Je},${Je} 0 0 1 0,${Je} Z`, fill: y.colorB })
+                    ] }),
+                    /* @__PURE__ */ h(
+                      "circle",
+                      {
+                        r: Je,
+                        fill: "none",
+                        className: "gv-spring-token-outline",
+                        strokeDasharray: y.outline === "dashed" ? "2 2" : void 0
+                      }
+                    ),
+                    /* @__PURE__ */ h("text", { y: Je + 11, textAnchor: "middle", className: "gv-spring-token-label", children: y.label })
+                  ]
+                },
+                y.id
+              );
+            })
+          ]
+        }
+      )
+    }
+  );
+}
+function Sa(e) {
+  const t = [];
+  e.forEach((s, o) => {
+    const i = t.find((r) => Math.hypot(r.cx - s.cx, r.cy - s.cy) < Je);
+    i ? i.members.push(o) : t.push({ cx: s.cx, cy: s.cy, members: [o] });
+  });
+  const n = e.map((s) => ({ cx: s.cx, cy: s.cy }));
+  for (const s of t) {
+    if (s.members.length === 1) continue;
+    const o = Math.max(Je * 1.6, s.members.length * Je / Math.PI);
+    s.members.forEach((i, r) => {
+      const c = -Math.PI / 2 + 2 * Math.PI * r / s.members.length;
+      n[i] = { cx: s.cx + o * Math.cos(c), cy: s.cy + o * Math.sin(c) };
+    });
+  }
+  return n;
+}
+const Tt = 300, ot = 130, tn = 56;
+function ka(e) {
+  var s;
+  const t = e.trim().split(/\s+/), n = (s = t[t.length - 1]) == null ? void 0 : s.split(",");
+  return !n || n.length < 2 ? null : { x: Number(n[0]), y: Number(n[1]) };
+}
+function Na(e, t) {
+  if (!(e > 0)) return 1;
+  const n = e / t, s = Math.pow(10, Math.floor(Math.log10(n))), o = n / s;
+  return (o < 1.5 ? 1 : o < 3 ? 2 : o < 7 ? 5 : 10) * s;
+}
+function Ys({
+  curves: e,
+  baselineY: t,
+  hoveredId: n,
+  onHover: s,
+  xLabel: o,
+  yLabel: i,
+  exp: r,
+  ariaLabel: c,
+  xMax: a
+}) {
+  const l = [];
+  if (a !== void 0 && a > 0) {
+    const d = Na(a, 6);
+    for (let u = d; u < a * 0.999; u += d) l.push(u / a * Tt);
+  }
+  return /* @__PURE__ */ C("div", { className: "gv-spring-curves", children: [
+    /* @__PURE__ */ h("div", { className: "gv-spring-axis-label gv-spring-curves-axis-y", children: i }),
+    /* @__PURE__ */ C(
+      "svg",
+      {
+        className: "gv-spring-curves-svg",
+        viewBox: `0 0 ${Tt} ${ot}`,
+        role: "img",
+        "aria-label": c,
+        children: [
+          /* @__PURE__ */ h("rect", { x: 0, y: 0, width: Tt, height: ot, className: "gv-spring-curve-frame" }),
+          l.map((d, u) => /* @__PURE__ */ h("line", { x1: d.toFixed(1), y1: 0, x2: d.toFixed(1), y2: ot, className: "gv-ctl-grid-line" }, `g${u}`)),
+          t !== void 0 && /* @__PURE__ */ h("line", { x1: 0, y1: t, x2: Tt, y2: t, className: "gv-spring-curve-baseline" }),
+          e.filter((d) => d.id === n && d.markerX !== void 0).map((d) => /* @__PURE__ */ h("line", { x1: d.markerX, y1: 0, x2: d.markerX, y2: ot, className: "gv-spring-curve-restmark" }, `m${d.id}`)),
+          e.map((d) => {
+            const u = n !== null && n !== d.id, v = n === d.id;
+            return /* @__PURE__ */ C("g", { className: `gv-spring-curve${u ? " dim" : ""}${v ? " active" : ""}`, children: [
+              /* @__PURE__ */ h(
+                "polyline",
+                {
+                  points: d.points,
+                  className: "gv-spring-curve-hit",
+                  onPointerEnter: () => s(d.id),
+                  onPointerLeave: () => s(null)
+                }
+              ),
+              /* @__PURE__ */ h(
+                "polyline",
+                {
+                  points: d.points,
+                  className: "gv-spring-curve-line",
+                  style: { stroke: d.color }
+                }
+              ),
+              d.label && (() => {
+                const M = ka(d.points);
+                return M ? /* @__PURE__ */ h(
+                  "text",
+                  {
+                    x: Math.min(M.x + 4, Tt - 2),
+                    y: Os(M.y, 9, ot - 2),
+                    className: "gv-spring-curve-label",
+                    style: { fill: d.color },
+                    textAnchor: "end",
+                    children: d.label
+                  }
+                ) : null;
+              })()
+            ] }, d.id);
+          })
+        ]
+      }
+    ),
+    /* @__PURE__ */ h("div", { className: "gv-spring-axis-label gv-spring-curves-axis-x", children: o }),
+    /* @__PURE__ */ C("div", { className: "gv-spring-curves-exp", title: r.title, children: [
+      /* @__PURE__ */ h("span", { className: "gv-spring-exp-label", children: r.label ?? "exp" }),
+      /* @__PURE__ */ h(
+        _t,
+        {
+          min: r.min,
+          max: r.max,
+          step: r.step,
+          value: r.value,
+          onChange: r.onChange,
+          popId: r.popId
+        }
+      )
+    ] })
+  ] });
+}
+const Ea = 0, Ia = 1e3, $a = 10, Ca = 0, Aa = 100, Oa = 1, Ra = (e, t, n) => Math.max(t, Math.min(n, e));
+function Ta({ params: e, resolved: t, present: n, onParamChange: s, hoveredBucket: o, onHoverBucket: i }) {
+  const r = Bt(), { push: c } = t, l = c.mapping.buckets.filter((u) => n.has(u.id)).map((u) => ({
+    id: u.id,
+    x: gn(c, u.id).coreRadius,
+    y: Math.abs(gn(c, u.id).charge),
+    colorA: en(r, c.mapping, u.id),
+    outline: "solid",
+    label: u.abbreviation,
+    tooltip: `${u.label} repulsion charge & core radius`
+  }));
+  return /* @__PURE__ */ h(
+    br,
+    {
+      tokens: l,
+      xAxis: { min: Ca, max: Aa, step: Oa, label: "core radius" },
+      yAxis: { min: Ea, max: Ia, step: $a, label: "charge" },
+      onDrag: (u, v, M) => {
+        const S = u;
+        s({
+          // One override per bucket, carrying both numbers the token encodes;
+          // charge is stored negative (repulsion).
+          pair: Ec(e.pair, S, { charge: -M, coreRadius: v })
+        });
+      },
+      hoveredId: o,
+      onHover: i,
+      ariaLabel: "Charge map: core radius versus charge magnitude",
+      xSlider: {
+        value: e.coreRadiusMultiplier,
+        min: 0.1,
+        max: 3,
+        step: 0.05,
+        onChange: (u) => s({ coreRadiusMultiplier: u }),
+        title: "Scale every type’s core radius",
+        ariaLabel: "Scale all core radius",
+        popId: "coreRadiusMultiplier"
+      },
+      ySlider: {
+        value: e.pushMultiplier,
+        min: 0,
+        max: 3,
+        step: 0.1,
+        onChange: (u) => s({ pushMultiplier: u }),
+        title: "Scale every type’s charge",
+        ariaLabel: "Scale all charge",
+        popId: "pushMultiplier"
+      }
+    }
+  );
+}
+function Fa({ params: e, resolved: t, present: n, onParamChange: s, hoveredBucket: o, onHoverBucket: i }) {
+  const r = Bt(), { push: c } = t, a = c.mapping.buckets.filter((S) => n.has(S.id)), l = e.pushMultiplier, d = e.coreRadiusMultiplier, u = e.chargeExponent, { curves: v, dMax: M } = g.useMemo(() => {
+    const S = a.map((E) => d * gn(c, E.id).coreRadius), p = Math.max(0, ...S), $ = Math.max(150, p * 4);
+    let D = 0;
+    const x = a.map(({ id: E }) => {
+      const O = Math.abs(gn(c, E).charge) * l, X = d * gn(c, E).coreRadius, N = X * X, k = [];
+      for (let w = 0; w <= tn; w++) {
+        const R = w / tn * $, z = O / Math.pow(R * R + N, Math.max(u, 0.01));
+        z > D && (D = z), k.push({ d: R, v: z });
+      }
+      return { type: E, rEff: X, pts: k };
+    }), V = D > 0 ? D : 1, F = ot * 0.95, L = (E) => E / $ * Tt, y = (E) => Ra(ot - E / V * F, 0, ot);
+    return { curves: x.map(({ type: E, rEff: O, pts: X }) => ({
+      id: E,
+      color: en(r, c.mapping, E),
+      markerX: L(O),
+      points: X.map((N) => `${L(N.d).toFixed(1)},${y(N.v).toFixed(1)}`).join(" ")
+    })), dMax: $ };
+  }, [e, l, c, d, u, r, n]);
+  return /* @__PURE__ */ h(
+    Ys,
+    {
+      curves: v,
+      xMax: M,
+      hoveredId: o,
+      onHover: i,
+      xLabel: "distance",
+      yLabel: "force",
+      ariaLabel: "Charge falloff curves",
+      exp: {
+        value: u,
+        min: 0.5,
+        max: 1,
+        step: 0.05,
+        onChange: (S) => s({ chargeExponent: S }),
+        title: "Power of (d² + r²) in the charge falloff. 1 = inverse-square; higher = sharper drop-off.",
+        popId: "chargeExponent"
+      }
+    }
+  );
+}
+const La = 0, Pa = 2, Da = 0.05, _a = 0, Ba = 1e3, Ha = 10, za = (e, t, n) => Math.max(t, Math.min(n, e));
+function xr(e, t) {
+  const n = [];
+  for (const s of t) {
+    const o = e.describe(s);
+    o && n.push(o);
+  }
+  return n;
+}
+function Va({ params: e, resolved: t, present: n, onParamChange: s, hoveredEdge: o, onHoverEdge: i }) {
+  const r = Bt(), { spring: c } = t, l = xr(c, n).map((u) => {
+    const v = c.physicsFor(u.id);
+    return {
+      id: u.id,
+      x: v.distance,
+      y: v.strength,
+      colorA: en(r, c.mapping, u.sourceValue),
+      colorB: en(r, c.mapping, u.targetValue),
+      outline: u.relation === "containment" ? "dashed" : "solid",
+      label: u.label,
+      tooltip: u.tooltip
+    };
+  });
+  return /* @__PURE__ */ h(
+    br,
+    {
+      tokens: l,
+      xAxis: { min: _a, max: Ba, step: Ha, label: "length" },
+      yAxis: { min: La, max: Pa, step: Da, label: "stiffness" },
+      onDrag: (u, v, M) => {
+        s({ pair: Ic(e.pair, u, { strength: M, distance: v }) });
+      },
+      hoveredId: o,
+      onHover: i,
+      ariaLabel: "Spring map: rest length versus stiffness",
+      xSlider: {
+        value: e.distanceMultiplier,
+        min: 0.05,
+        max: 3,
+        step: 0.05,
+        onChange: (u) => s({ distanceMultiplier: u }),
+        title: "Scale every spring’s rest length",
+        ariaLabel: "Scale all length",
+        popId: "distanceMultiplier"
+      },
+      ySlider: {
+        value: e.pullMultiplier,
+        min: 0,
+        max: 3,
+        step: 0.1,
+        onChange: (u) => s({ pullMultiplier: u }),
+        title: "Scale every spring’s stiffness",
+        ariaLabel: "Scale all stiffness",
+        popId: "pullMultiplier"
+      }
+    }
+  );
+}
+const ws = ot * 0.78;
+function Ga(e, t, n, s) {
+  const o = e - n;
+  return t * Math.sign(o) * Math.pow(Math.abs(o), s);
+}
+function Xa({ params: e, resolved: t, present: n, onParamChange: s, hoveredEdge: o, onHoverEdge: i }) {
+  const r = Bt(), { spring: c } = t, a = g.useMemo(() => xr(c, n), [c, n]), l = e.pullMultiplier, d = e.distanceMultiplier, u = e.linkExponent, { curves: v, dMax: M } = g.useMemo(() => {
+    const S = a.map((I) => c.physicsFor(I.id).distance * d), p = Math.max(60, Math.max(...S) * 2.2);
+    let $ = 0;
+    const D = a.map((I) => {
+      const E = c.physicsFor(I.id), O = E.strength * l, X = E.distance * d, N = [];
+      for (let k = 0; k <= tn; k++) {
+        const w = k / tn * p, R = Ga(w, O, X, u);
+        Math.abs(R) > $ && ($ = Math.abs(R)), N.push({ d: w, v: R });
+      }
+      return { edge: I, restEff: X, pts: N };
+    }), x = $ > 0 ? $ : 1, V = ws, F = (I) => I / p * Tt, L = (I) => za(ws - I / x * V, 0, ot);
+    return { curves: D.map(({ edge: I, restEff: E, pts: O }) => ({
+      id: I.id,
+      color: en(r, c.mapping, I.sourceValue),
+      markerX: F(E),
+      points: O.map((X) => `${F(X.d).toFixed(1)},${L(X.v).toFixed(1)}`).join(" ")
+    })), dMax: p };
+  }, [c, a, l, d, u, r]);
+  return /* @__PURE__ */ h(
+    Ys,
+    {
+      curves: v,
+      xMax: M,
+      baselineY: ws,
+      hoveredId: o,
+      onHover: i,
+      xLabel: "distance",
+      yLabel: "force",
+      ariaLabel: "Spring force response curves",
+      exp: {
+        value: u,
+        min: 0.5,
+        max: 3,
+        step: 0.1,
+        onChange: (S) => s({ linkExponent: S }),
+        title: "Power of displacement in the spring force. 1 = linear (Hooke); higher = softer near rest, stiffer far out.",
+        popId: "linkExponent"
+      }
+    }
+  );
+}
+function Js({ children: e }) {
+  return e === "" || e === null || e === void 0 ? null : typeof e == "string" ? /* @__PURE__ */ h("pre", { className: "gv-graph-control-equation-formula", children: e }) : /* @__PURE__ */ h("div", { className: "gv-graph-control-equation-formula", children: e });
+}
+function pn({ subtitle: e, equation: t, onHover: n, children: s }) {
+  return /* @__PURE__ */ C(
+    "div",
+    {
+      className: "gv-graph-control-equation-section",
+      onMouseEnter: () => n(!0),
+      onMouseLeave: () => n(!1),
+      children: [
+        e && /* @__PURE__ */ h("div", { className: "gv-graph-control-equation-header", children: /* @__PURE__ */ C("span", { className: "gv-graph-control-equation-subtitle", children: [
+          "(",
+          e,
+          ")"
+        ] }) }),
+        /* @__PURE__ */ h(Js, { children: t }),
+        /* @__PURE__ */ h("div", { className: "gv-graph-control-equation-body", children: s })
+      ]
+    }
+  );
+}
+function wr({ label: e, children: t }) {
+  return /* @__PURE__ */ h("div", { className: "gv-force-subtabs", role: "tablist", "aria-label": e, children: t });
+}
+function mn({ label: e, active: t, onSelect: n, leading: s }) {
+  return /* @__PURE__ */ C(
+    "div",
+    {
+      role: "tab",
+      "aria-selected": t,
+      tabIndex: 0,
+      className: `gv-force-subtab${t ? " active" : ""}`,
+      onClick: n,
+      onKeyDown: (o) => {
+        (o.key === "Enter" || o.key === " ") && (o.preventDefault(), n());
+      },
+      children: [
+        s,
+        /* @__PURE__ */ h("span", { className: "gv-force-subtab-label", children: e })
+      ]
+    }
+  );
+}
+function Mr({ children: e }) {
+  return /* @__PURE__ */ h("div", { className: "gv-force-bodies", children: e });
+}
+function vn({ active: e, children: t }) {
+  return /* @__PURE__ */ h("div", { className: `gv-force-body${e ? " active" : ""}`, "aria-hidden": !e, children: t });
+}
+const Ya = /* @__PURE__ */ C("span", { className: "gv-eq-line", children: [
+  "F =",
+  /* @__PURE__ */ C("span", { className: "gv-eq-frac", children: [
+    /* @__PURE__ */ h("span", { className: "gv-eq-num", children: /* @__PURE__ */ h(rt, { id: "pushMultiplier", children: "charge" }) }),
+    /* @__PURE__ */ C("span", { className: "gv-eq-den", children: [
+      "(d² + ",
+      /* @__PURE__ */ h(rt, { id: "coreRadiusMultiplier", children: "r" }),
+      "²)",
+      /* @__PURE__ */ h("sup", { children: /* @__PURE__ */ h(rt, { id: "chargeExponent", children: "exp" }) })
+    ] })
+  ] })
+] }), Ja = /* @__PURE__ */ C("span", { className: "gv-eq-line", children: [
+  "F = ",
+  /* @__PURE__ */ h(rt, { id: "pullMultiplier", children: "stiffness" }),
+  " ×",
+  /* @__PURE__ */ C("span", { className: "gv-eq-frac", children: [
+    /* @__PURE__ */ C("span", { className: "gv-eq-num", children: [
+      "(d − ",
+      /* @__PURE__ */ h(rt, { id: "distanceMultiplier", children: "length" }),
+      ")",
+      /* @__PURE__ */ h("sup", { children: /* @__PURE__ */ h(rt, { id: "linkExponent", children: "exp" }) })
+    ] }),
+    /* @__PURE__ */ h("span", { className: "gv-eq-den", children: "d" })
+  ] })
+] });
+function ja(e) {
+  return zs(e) ? `${e.mapping.label} (${e.pushTokens} · ${e.pullTokens})` : `${e.mapping.label} — ${Math.max(e.pushTokens, e.pullTokens)} tokens (max ${Lt})`;
+}
+function qa({
+  params: e,
+  resolved: t,
+  axes: n,
+  present: s,
+  onParamChange: o,
+  onAxisChange: i,
+  onActiveSection: r,
+  hoveredPushBucket: c,
+  onHoverPushBucket: a,
+  hoveredEdge: l,
+  onHoverEdge: d
+}) {
+  const [u, v] = g.useState("push"), M = e.pair.mapping.axis;
+  return /* @__PURE__ */ C("div", { className: "gv-pushpull-controls", children: [
+    /* @__PURE__ */ C("div", { className: "gv-axis-row", children: [
+      /* @__PURE__ */ h("label", { className: "gv-axis-label", htmlFor: "pushpull-axis", children: "axis" }),
+      /* @__PURE__ */ h(
+        "select",
+        {
+          id: "pushpull-axis",
+          className: "gv-axis-select",
+          value: M,
+          title: "The axis push and pull key on. Tokens are the visible set's: a push token per bucket some visible node falls in, a pull token per spring category some sprung edge falls in; the counts measure the whole graph",
+          onChange: (S) => {
+            const p = n.find(($) => $.mapping.axis === S.target.value);
+            p && i(p.mapping);
+          },
+          children: n.map((S) => /* @__PURE__ */ h("option", { value: S.mapping.axis, disabled: !zs(S), children: ja(S) }, S.mapping.axis))
+        }
+      )
+    ] }),
+    /* @__PURE__ */ C(wr, { label: "Pair force", children: [
+      /* @__PURE__ */ h(mn, { label: "Push", active: u === "push", onSelect: () => v("push") }),
+      /* @__PURE__ */ h(mn, { label: "Pull", active: u === "pull", onSelect: () => v("pull") })
+    ] }),
+    /* @__PURE__ */ C(Mr, { children: [
+      /* @__PURE__ */ h(vn, { active: u === "push", children: /* @__PURE__ */ C(pn, { subtitle: "", equation: Ya, onHover: (S) => r(S ? "push" : null), children: [
+        /* @__PURE__ */ h(
+          Ta,
+          {
+            params: e,
+            resolved: t,
+            present: s.push,
+            onParamChange: o,
+            hoveredBucket: c,
+            onHoverBucket: a
+          }
+        ),
+        /* @__PURE__ */ h(
+          Fa,
+          {
+            params: e,
+            resolved: t,
+            present: s.push,
+            onParamChange: o,
+            hoveredBucket: c,
+            onHoverBucket: a
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ h(vn, { active: u === "pull", children: /* @__PURE__ */ C(pn, { subtitle: "", equation: Ja, onHover: (S) => r(S ? "pull" : null), children: [
+        /* @__PURE__ */ h(
+          Va,
+          {
+            params: e,
+            resolved: t,
+            present: s.springs,
+            onParamChange: o,
+            hoveredEdge: l,
+            onHoverEdge: d
+          }
+        ),
+        /* @__PURE__ */ h(
+          Xa,
+          {
+            params: e,
+            resolved: t,
+            present: s.springs,
+            onParamChange: o,
+            hoveredEdge: l,
+            onHoverEdge: d
+          }
+        )
+      ] }) })
+    ] })
+  ] });
+}
+const Ua = (e) => e === "x" ? "bandX" : "bandY", Sr = (e) => e === "x" ? "gravityX" : "gravityY", Ms = (e, t) => e === "x" ? { bandX: t } : { bandY: t }, Co = (e, t) => e === "x" ? { gravityX: t } : { gravityY: t }, js = 300, qs = 210, Jn = { top: 16, right: 8, bottom: 2, left: 8 }, ut = Jn.left, Wt = js - Jn.right, qe = Jn.top, bt = qs - Jn.bottom, nn = -600, jn = 600, Pn = 10, Rs = 5, Ut = (e, t) => {
+  const n = (t - nn) / (jn - nn);
+  return e === "y" ? qe + n * (bt - qe) : bt - n * (bt - qe);
+}, kr = (e, t) => {
+  const n = e === "y" ? (t - qe) / (bt - qe) : (bt - t) / (bt - qe);
+  return nn + n * (jn - nn);
+}, Nr = (e, t, n) => Math.max(t, Math.min(n, e)), Er = (e, t) => Math.round(e / t) * t;
+function Ao({ axis: e, params: t, resolved: n, axes: s, present: o, onParamChange: i, onRelayout: r, hovered: c, onHover: a }) {
+  const l = Bt(), d = Ua(e), u = t[d], v = e === "x" ? n.bandX : n.bandY, M = t[Sr(e)], S = e.toUpperCase(), p = e === "x" && t.radial, $ = Yt(u), D = (x) => {
+    if (x === $) return;
+    const V = s.find((F) => Yt(F) === x);
+    V && r(Ms(e, V.kind === "scalar" ? { scalar: V.scalar.id } : { mapping: V.option.mapping, overrides: /* @__PURE__ */ new Map() }));
+  };
+  return /* @__PURE__ */ C("div", { className: `gv-gravity-section-tools${M > 0 && !p ? "" : " inactive"}`, children: [
+    /* @__PURE__ */ h(Js, { children: ft(v) ? /* @__PURE__ */ C(yn, { children: [
+      "F = ",
+      /* @__PURE__ */ h(rt, { id: `bandStrength${S}`, children: "strength" }),
+      " × d",
+      /* @__PURE__ */ h("sup", { children: /* @__PURE__ */ h(rt, { id: "bandExp", children: "exp" }) }),
+      ", d = |p − p",
+      /* @__PURE__ */ h("sub", { children: "0" }),
+      " − s·(p",
+      /* @__PURE__ */ h("sub", { children: "1" }),
+      " − p",
+      /* @__PURE__ */ h("sub", { children: "0" }),
+      ")|"
+    ] }) : /* @__PURE__ */ C(yn, { children: [
+      "F = ",
+      /* @__PURE__ */ h(rt, { id: `bandStrength${S}`, children: "strength" }),
+      " × d",
+      /* @__PURE__ */ h("sup", { children: /* @__PURE__ */ h(rt, { id: "bandExp", children: "exp" }) })
+    ] }) }),
+    /* @__PURE__ */ C("div", { className: "gv-axis-row", children: [
+      /* @__PURE__ */ h("label", { className: "gv-axis-label", htmlFor: `gravity-axis-${e}`, children: "axis" }),
+      /* @__PURE__ */ h(
+        "select",
+        {
+          id: `gravity-axis-${e}`,
+          className: "gv-axis-select",
+          value: $,
+          title: `What the ${S} axis keys on: one column per bucket of a mapping, or a computed scalar as a gradient`,
+          onChange: (x) => D(x.target.value),
+          children: s.map((x) => x.kind === "scalar" ? /* @__PURE__ */ C("option", { value: Yt(x), title: x.scalar.tooltip, children: [
+            x.scalar.label,
+            " — computed"
+          ] }, Yt(x)) : /* @__PURE__ */ h("option", { value: Yt(x), disabled: x.option.pushTokens > Lt, children: x.option.pushTokens > Lt ? `${x.option.mapping.label} — ${x.option.pushTokens} columns (max ${Lt})` : `${x.option.mapping.label} (${x.option.pushTokens})` }, Yt(x)))
+        }
+      ),
+      p && /* @__PURE__ */ h("span", { className: "gv-axis-note", children: "ignored in radial" })
+    ] }),
+    ft(v) ? /* @__PURE__ */ h(
+      Ka,
+      {
+        axis: e,
+        radial: t.radial,
+        label: v.scalar.label,
+        tooltip: v.scalar.tooltip,
+        span: v.span,
+        strength: M,
+        onStrength: (x) => i(Co(e, x)),
+        onSpan: (x) => i(Ms(e, { scalar: v.scalar.id, span: x }))
+      }
+    ) : /* @__PURE__ */ h(
+      Wa,
+      {
+        axis: e,
+        radial: t.radial,
+        tuning: ps(u),
+        table: v,
+        present: o,
+        strength: M,
+        onStrength: (x) => i(Co(e, x)),
+        onBand: (x, V) => i(Ms(e, Nc(ps(u), x, V))),
+        hovered: c,
+        onHover: a,
+        color: (x) => en(l, ps(u).mapping, x)
+      }
+    ),
+    /* @__PURE__ */ h(Za, { axis: e, params: t, onParamChange: i })
+  ] });
+}
+function Ka({ axis: e, radial: t, label: n, tooltip: s, span: o, strength: i, onStrength: r, onSpan: c }) {
+  const a = g.useRef(null), l = g.useRef(null), d = e.toUpperCase(), u = (ut + Wt) / 2, v = (F) => {
+    const L = a.current;
+    if (!L) return 0;
+    const y = L.createSVGPoint();
+    y.x = F.clientX, y.y = F.clientY;
+    const I = L.getScreenCTM();
+    return I ? y.matrixTransform(I.inverse()).y : 0;
+  }, M = (F, L) => {
+    F.preventDefault(), F.currentTarget.setPointerCapture(F.pointerId), l.current = L;
+  }, S = (F) => {
+    const L = l.current;
+    L && c({ ...o, [L]: Nr(Er(kr(e, v(F)), Pn), nn, jn) });
+  }, p = (F) => {
+    var L, y;
+    l.current = null, (y = (L = F.currentTarget).releasePointerCapture) == null || y.call(L, F.pointerId);
+  }, $ = Ut(e, o.zero), D = Ut(e, o.one), x = g.useId(), V = (F, L) => /* @__PURE__ */ C("g", { children: [
+    /* @__PURE__ */ h("text", { x: ut + 10, y: L + 4, textAnchor: "middle", className: "gv-gravity-band-label", children: F === "zero" ? "0" : "1" }),
+    /* @__PURE__ */ h(
+      "circle",
+      {
+        cx: u,
+        cy: L,
+        r: Rs,
+        className: "gv-gravity-band-dot gv-gravity-scalar-dot",
+        onPointerDown: (y) => M(y, F),
+        onPointerMove: S,
+        onPointerUp: p,
+        children: /* @__PURE__ */ h("title", { children: `where a score of ${F === "zero" ? 0 : 1} rests on ${d}: ${o[F]}` })
+      }
+    )
+  ] }, F);
+  return /* @__PURE__ */ h(
+    Xs,
+    {
+      yLabel: `${d} strength`,
+      ySlider: /* @__PURE__ */ h(
+        _t,
+        {
+          orientation: "vertical",
+          min: 0,
+          max: 0.25,
+          step: 5e-3,
+          value: i,
+          onChange: r,
+          title: `${d} pull strength (scale all); 0 switches the axis off`,
+          ariaLabel: `${d} strength`,
+          popId: `bandStrength${d}`
+        }
+      ),
+      bottom: /* @__PURE__ */ h("div", { className: "gv-ctl-plot-xlabel", children: t && e === "y" ? "ring: the span’s low end innermost" : `${d} position: ${n}, 0 → 1` }),
+      children: /* @__PURE__ */ C(
+        "svg",
+        {
+          ref: a,
+          className: "gv-gravity-band-svg",
+          viewBox: `0 0 ${js} ${qs}`,
+          role: "group",
+          "aria-label": `${d} axis: ${n}, a computed scalar; drag the 0 and 1 ends`,
+          children: [
+            /* @__PURE__ */ h("defs", { children: /* @__PURE__ */ C("linearGradient", { id: x, x1: "0", y1: $, x2: "0", y2: D, gradientUnits: "userSpaceOnUse", children: [
+              /* @__PURE__ */ h("stop", { offset: "0", stopColor: "var(--gv-color-text-muted)", stopOpacity: "0.15" }),
+              /* @__PURE__ */ h("stop", { offset: "1", stopColor: "var(--gv-color-text)", stopOpacity: "0.55" })
+            ] }) }),
+            /* @__PURE__ */ h("rect", { x: ut, y: qe, width: Wt - ut, height: bt - qe, className: "gv-gravity-band-bg" }),
+            /* @__PURE__ */ h("title", { children: s }),
+            /* @__PURE__ */ h("rect", { x: ut + 24, y: Math.min($, D), width: Wt - ut - 48, height: Math.abs(D - $), fill: `url(#${x})`, className: "gv-gravity-scalar-gradient" }),
+            /* @__PURE__ */ h("text", { x: u, y: qe - 6, textAnchor: "middle", className: "gv-gravity-band-label", children: n }),
+            /* @__PURE__ */ h("line", { x1: u, y1: qe, x2: u, y2: bt, className: "gv-gravity-band-track" }),
+            V("zero", $),
+            V("one", D)
+          ]
+        }
+      )
+    }
+  );
+}
+function Wa({ axis: e, radial: t, tuning: n, table: s, present: o, strength: i, onStrength: r, onBand: c, hovered: a, onHover: l, color: d }) {
+  const u = g.useRef(null), v = g.useRef(null), M = n.mapping.buckets.filter((y) => o.has(y.id)), S = (y) => ut + (y + 0.5) / Math.max(1, M.length) * (Wt - ut), p = e.toUpperCase(), $ = (y) => {
+    const I = u.current;
+    if (!I) return 0;
+    const E = I.createSVGPoint();
+    E.x = y.clientX, E.y = y.clientY;
+    const O = I.getScreenCTM();
+    return O ? E.matrixTransform(O.inverse()).y : 0;
+  }, D = (y, I, E) => {
+    y.preventDefault(), y.currentTarget.setPointerCapture(y.pointerId), v.current = { bucket: I, edge: E };
+  }, x = (y) => {
+    const I = v.current;
+    if (!I) return;
+    const E = gs(s, I.bucket), O = Nr(Er(kr(e, $(y)), Pn), nn, jn);
+    c(I.bucket, I.edge === "min" ? { min: Math.min(O, E.max - Pn), max: E.max } : { min: E.min, max: Math.max(O, E.min + Pn) });
+  }, V = (y) => {
+    var I, E;
+    v.current = null, (E = (I = y.currentTarget).releasePointerCapture) == null || E.call(I, y.pointerId);
+  }, F = (y) => a !== null && a.axis === e && a.bucket === y, L = a !== null && a.axis === e;
+  return /* @__PURE__ */ h(
+    Xs,
+    {
+      yLabel: `${p} strength`,
+      ySlider: /* @__PURE__ */ h(
+        _t,
+        {
+          orientation: "vertical",
+          min: 0,
+          max: 0.25,
+          step: 5e-3,
+          value: i,
+          onChange: r,
+          title: `${p} band-pull strength (scale all); 0 switches the axis off`,
+          ariaLabel: `${p} band strength`,
+          popId: `bandStrength${p}`
+        }
+      ),
+      bottom: (
+        // In radial, Y reads each bucket's band CENTRE as its ring (width is
+        // ignored, equal centres share a ring); the label says so in the same
+        // slot, so the body does not change height when the mode flips.
+        /* @__PURE__ */ h("div", { className: "gv-ctl-plot-xlabel", children: t && e === "y" ? "ring: the band centre, innermost first" : `${p} position` })
+      ),
+      children: /* @__PURE__ */ C(
+        "svg",
+        {
+          ref: u,
+          className: "gv-gravity-band-svg",
+          viewBox: `0 0 ${js} ${qs}`,
+          role: "group",
+          "aria-label": `${p} axis: one column per bucket, its rest band as two handles`,
+          children: [
+            /* @__PURE__ */ h("rect", { x: ut, y: qe, width: Wt - ut, height: bt - qe, className: "gv-gravity-band-bg" }),
+            /* @__PURE__ */ h("g", { className: "gv-gravity-band-stripes", children: M.map((y, I) => {
+              const E = gs(s, y.id), O = Ut(e, E.min), X = Ut(e, E.max), N = (Wt - ut) / M.length / 2;
+              return /* @__PURE__ */ h(
+                "rect",
+                {
+                  x: S(I) - N,
+                  y: O,
+                  width: N * 2,
+                  height: Math.max(0, X - O),
+                  fill: d(y.id),
+                  className: `gv-gravity-band-stripe${L && !F(y.id) ? " dim" : ""}${F(y.id) ? " active" : ""}`
+                },
+                y.id
+              );
+            }) }),
+            M.map((y, I) => {
+              const E = S(I), O = gs(s, y.id), X = Ut(e, O.min), N = Ut(e, O.max), k = d(y.id);
+              return /* @__PURE__ */ C(
+                "g",
+                {
+                  className: `gv-gravity-band-col${L && !F(y.id) ? " dim" : ""}${F(y.id) ? " active" : ""}`,
+                  onPointerEnter: () => l({ axis: e, bucket: y.id }),
+                  onPointerLeave: () => {
+                    v.current || l(null);
+                  },
+                  children: [
+                    /* @__PURE__ */ h("title", { children: y.label }),
+                    /* @__PURE__ */ h("text", { x: E, y: qe - 6, textAnchor: "middle", className: "gv-gravity-band-label", style: { fill: k }, children: y.abbreviation }),
+                    /* @__PURE__ */ h("line", { x1: E, y1: qe, x2: E, y2: bt, className: "gv-gravity-band-track" }),
+                    /* @__PURE__ */ h("line", { x1: E, y1: X, x2: E, y2: N, stroke: k, className: "gv-gravity-band-stem" }),
+                    /* @__PURE__ */ h(
+                      "circle",
+                      {
+                        cx: E,
+                        cy: X,
+                        r: Rs,
+                        fill: k,
+                        className: "gv-gravity-band-dot",
+                        onPointerDown: (w) => D(w, y.id, "min"),
+                        onPointerMove: x,
+                        onPointerUp: V
+                      }
+                    ),
+                    /* @__PURE__ */ h(
+                      "circle",
+                      {
+                        cx: E,
+                        cy: N,
+                        r: Rs,
+                        fill: k,
+                        className: "gv-gravity-band-dot",
+                        onPointerDown: (w) => D(w, y.id, "max"),
+                        onPointerMove: x,
+                        onPointerUp: V
+                      }
+                    )
+                  ]
+                },
+                y.id
+              );
+            })
+          ]
+        }
+      )
+    }
+  );
+}
+const Oo = 4;
+function Za({ axis: e, params: t, onParamChange: n }) {
+  const s = t.gravityBandExp, o = t[Sr(e)], i = Math.max(t.gravityX, t.gravityY, 1e-6), r = Array.from({ length: tn + 1 }, (a, l) => {
+    const d = l / tn, u = o / i * Math.pow(d, s), v = d * Tt, M = ot - Oo - u * (ot - 2 * Oo);
+    return `${v.toFixed(1)},${M.toFixed(1)}`;
+  }).join(" "), c = [{ id: e, points: r, color: "var(--gv-color-text)", label: e.toUpperCase() }];
+  return /* @__PURE__ */ h(
+    Ys,
+    {
+      curves: c,
+      xMax: 1,
+      hoveredId: null,
+      onHover: () => {
+      },
+      xLabel: "distance",
+      yLabel: "force",
+      ariaLabel: `${e.toUpperCase()} band force-response curve`,
+      exp: {
+        value: s,
+        min: 0.5,
+        max: 3,
+        step: 0.1,
+        onChange: (a) => n({ gravityBandExp: a }),
+        title: "Band falloff exponent, shared by both axes. 1 = linear (Hooke); higher = softer just outside the band, stiffer far out.",
+        popId: "bandExp"
+      }
+    }
+  );
+}
+function Qa({ params: e, resolved: t, axes: n, onParamChange: s, onRelayout: o, hovered: i, onHover: r, present: c }) {
+  const [a, l] = g.useState("y");
+  return /* @__PURE__ */ C("div", { className: "gv-gravity-controls", children: [
+    /* @__PURE__ */ C(wr, { label: "Gravity", children: [
+      /* @__PURE__ */ h(mn, { label: "X Axis", active: a === "x", onSelect: () => l("x") }),
+      /* @__PURE__ */ h(
+        mn,
+        {
+          label: "Y Axis",
+          active: a === "y",
+          onSelect: () => l("y"),
+          leading: /* @__PURE__ */ h(Ro, { label: "Radial layout: Y as distance from the centre", enabled: e.radial, onToggle: (d) => o({ radial: d }) })
+        }
+      ),
+      /* @__PURE__ */ h(
+        mn,
+        {
+          label: "Topological",
+          active: a === "topological",
+          onSelect: () => l("topological"),
+          leading: /* @__PURE__ */ h(Ro, { label: "Topological gravity enabled", enabled: e.topologicalEnabled, onToggle: (d) => o({ topologicalEnabled: d }) })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ C(Mr, { children: [
+      /* @__PURE__ */ h(vn, { active: a === "x", children: /* @__PURE__ */ h(
+        Ao,
+        {
+          axis: "x",
+          params: e,
+          resolved: t,
+          axes: n,
+          present: c.bandX,
+          onParamChange: s,
+          onRelayout: o,
+          hovered: i,
+          onHover: r
+        }
+      ) }),
+      /* @__PURE__ */ h(vn, { active: a === "y", children: /* @__PURE__ */ h(
+        Ao,
+        {
+          axis: "y",
+          params: e,
+          resolved: t,
+          axes: n,
+          present: c.bandY,
+          onParamChange: s,
+          onRelayout: o,
+          hovered: i,
+          onHover: r
+        }
+      ) }),
+      /* @__PURE__ */ h(vn, { active: a === "topological", children: /* @__PURE__ */ C("div", { className: `gv-gravity-section-tools gv-gravity-topo${e.topologicalEnabled ? "" : " inactive"}`, children: [
+        /* @__PURE__ */ h(Js, { children: /* @__PURE__ */ C(yn, { children: [
+          "F = ",
+          /* @__PURE__ */ h(rt, { id: "topoStrength", children: "strength" }),
+          " × depth",
+          /* @__PURE__ */ h("sup", { children: /* @__PURE__ */ h(rt, { id: "topoExp", children: "exp" }) }),
+          " × d"
+        ] }) }),
+        /* @__PURE__ */ h(tl, { exp: e.gravityTopologicalExp }),
+        /* @__PURE__ */ C("div", { className: "gv-gravity-slider-row", children: [
+          /* @__PURE__ */ h("label", { className: "gv-graph-control-slider-label", children: "strength" }),
+          /* @__PURE__ */ h(
+            _t,
+            {
+              min: 0,
+              max: 2,
+              step: 0.02,
+              value: e.gravityTopological,
+              onChange: (d) => s({ gravityTopological: d }),
+              popId: "topoStrength"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ C("div", { className: "gv-gravity-slider-row", children: [
+          /* @__PURE__ */ h("label", { className: "gv-graph-control-slider-label", children: "exp" }),
+          /* @__PURE__ */ h(
+            _t,
+            {
+              min: 1,
+              max: 6,
+              step: 0.1,
+              value: e.gravityTopologicalExp,
+              onChange: (d) => s({ gravityTopologicalExp: d }),
+              popId: "topoExp"
+            }
+          )
+        ] })
+      ] }) })
+    ] })
+  ] });
+}
+function Ro({ label: e, enabled: t, onToggle: n }) {
+  return /* @__PURE__ */ C("label", { className: `gv-switch${t ? " on" : ""}`, onClick: (s) => s.stopPropagation(), title: e, children: [
+    /* @__PURE__ */ h("input", { type: "checkbox", checked: t, onChange: (s) => n(s.target.checked), "aria-label": e }),
+    /* @__PURE__ */ h("span", { className: "gv-switch-track", children: /* @__PURE__ */ h("span", { className: "gv-switch-knob" }) })
+  ] });
+}
+const To = 220, Ss = 96, ks = 8, el = 16;
+function tl({ exp: e }) {
+  const t = el, n = To - ks, s = ks, o = Ss - ks - 12, i = (s + o) / 2, r = 48, c = Array.from({ length: r + 1 }, (a, l) => {
+    const d = l / r, u = Math.pow(d, e);
+    return `${(t + d * (n - t)).toFixed(1)},${(o - u * (o - s)).toFixed(1)}`;
+  }).join(" ");
+  return /* @__PURE__ */ C("svg", { className: "gv-gravity-topo-curve", viewBox: `0 0 ${To} ${Ss}`, role: "img", "aria-label": "Depth-to-pull contrast curve", children: [
+    /* @__PURE__ */ h("rect", { x: t, y: s, width: n - t, height: o - s, className: "gv-spring-curve-frame" }),
+    /* @__PURE__ */ h("polyline", { points: c, className: "gv-gravity-topo-curve-line" }),
+    /* @__PURE__ */ h("text", { x: (t + n) / 2, y: Ss - 1, textAnchor: "middle", className: "gv-gravity-topo-curve-axis", children: "depth" }),
+    /* @__PURE__ */ h("text", { x: 5, y: i, textAnchor: "middle", className: "gv-gravity-topo-curve-axis", transform: `rotate(-90 5 ${i})`, children: "pull" })
+  ] });
+}
+const nl = [
+  { id: "forces", label: "Push/Pull" },
+  { id: "gravity", label: "Gravity" },
+  { id: "misc", label: "Misc" }
+], sl = [
+  {
+    key: "velocityDecay",
+    label: "friction",
+    min: 0.05,
+    max: 0.95,
+    step: 0.05,
+    tooltip: "Damping factor per tick. Higher = more friction"
+  },
+  {
+    key: "alphaDecay",
+    label: "cooling",
+    min: 5e-4,
+    max: 0.02,
+    step: 5e-4,
+    tooltip: "Energy lost per tick. Higher = settles faster"
+  },
+  {
+    key: "alphaMin",
+    label: "threshold",
+    min: 0,
+    max: 5e-3,
+    step: 1e-4,
+    tooltip: "Energy level below which simulation pauses"
+  }
+], ol = [
+  {
+    key: "baseMul",
+    label: "size",
+    min: 0.3,
+    max: 2,
+    step: 0.05,
+    tooltip: "Overall node + label size. 1 = default."
+  },
+  {
+    key: "maxZoomMul",
+    label: "grow cap",
+    min: 0.5,
+    max: 3,
+    step: 0.05,
+    tooltip: "Zoom past which nodes stop growing. Lower = nodes start shrinking sooner as you zoom out."
+  },
+  {
+    key: "minZoomMul",
+    label: "shrink floor",
+    min: 0.1,
+    max: 1,
+    step: 0.05,
+    tooltip: "Smallest nodes may get when zoomed all the way out."
+  }
+];
+function rl({
+  params: e,
+  resolved: t,
+  onParamChange: n,
+  onAdjust: s,
+  onRelayout: o,
+  axes: i,
+  layoutAxes: r,
+  present: c,
+  onAxisChange: a,
+  onActiveSection: l,
+  onActivePushBucket: d,
+  onActiveGravityBucket: u,
+  onActivePullEdge: v,
+  nodeScale: M,
+  onNodeScaleChange: S
+}) {
+  const [p, $] = g.useState(!1), [D, x] = g.useState("forces"), [V, F] = g.useState(null), L = g.useCallback((w) => {
+    F(w), v(w);
+  }, [v]), [y, I] = g.useState(null), E = g.useCallback((w) => {
+    I(w), d(w);
+  }, [d]), [O, X] = g.useState(null), N = g.useCallback((w) => {
+    X(w), u(w);
+  }, [u]), k = g.useCallback((w) => {
+    n(w), s();
+  }, [n, s]);
+  return /* @__PURE__ */ C("div", { className: `gv-graph-control-panel ${p ? "open" : ""}`, children: [
+    /* @__PURE__ */ h(
+      "button",
+      {
+        className: "gv-graph-control-panel-toggle",
+        onClick: () => $(!p),
+        title: "Toggle control panel",
+        children: p ? "▼ Controls" : "▶ Controls"
+      }
+    ),
+    p && /* @__PURE__ */ h(Ma, { children: /* @__PURE__ */ C("div", { className: "gv-graph-control-panel-body", children: [
+      /* @__PURE__ */ h("div", { className: "gv-graph-control-tabs", role: "tablist", children: nl.map((w) => /* @__PURE__ */ h(
+        "button",
+        {
+          role: "tab",
+          "aria-selected": D === w.id,
+          className: `gv-graph-control-tab${D === w.id ? " active" : ""}`,
+          onClick: () => x(w.id),
+          children: w.label
+        },
+        w.id
+      )) }),
+      /* @__PURE__ */ C("div", { className: "gv-graph-control-sections", children: [
+        /* @__PURE__ */ h(Ns, { active: D === "forces", children: /* @__PURE__ */ h(
+          qa,
+          {
+            params: e,
+            resolved: t,
+            axes: i,
+            present: c,
+            onParamChange: k,
+            onAxisChange: a,
+            onActiveSection: l,
+            hoveredPushBucket: y,
+            onHoverPushBucket: E,
+            hoveredEdge: V,
+            onHoverEdge: L
+          }
+        ) }),
+        /* @__PURE__ */ h(Ns, { active: D === "gravity", children: /* @__PURE__ */ h(
+          pn,
+          {
+            subtitle: "",
+            equation: "",
+            onHover: (w) => {
+              l(w ? "gravity" : null), w || u(null);
+            },
+            children: /* @__PURE__ */ h(
+              Qa,
+              {
+                params: e,
+                resolved: t,
+                axes: r,
+                present: c,
+                onParamChange: k,
+                onRelayout: o,
+                hovered: O,
+                onHover: N
+              }
+            )
+          }
+        ) }),
+        /* @__PURE__ */ C(Ns, { active: D === "misc", children: [
+          /* @__PURE__ */ C("div", { className: "gv-graph-control-subsection", children: [
+            /* @__PURE__ */ h("div", { className: "gv-graph-control-subsection-title", children: "Dynamics" }),
+            /* @__PURE__ */ h(pn, { subtitle: "", equation: `v ×= friction
+α −= cooling, stop at threshold`, onHover: (w) => l(w ? "dynamics" : null), children: sl.map((w) => /* @__PURE__ */ h(Fo, { def: w, value: e[w.key], onChange: (R) => k({ [w.key]: R }) }, w.key)) })
+          ] }),
+          /* @__PURE__ */ C("div", { className: "gv-graph-control-subsection", children: [
+            /* @__PURE__ */ h("div", { className: "gv-graph-control-subsection-title", children: "Node scaling" }),
+            /* @__PURE__ */ h(pn, { subtitle: "", equation: "size = base × clamp(zoom, floor, cap)", onHover: () => {
+            }, children: ol.map((w) => /* @__PURE__ */ h(Fo, { def: w, value: M[w.key], onChange: (R) => S({ [w.key]: R }) }, w.key)) })
+          ] })
+        ] })
+      ] })
+    ] }) })
+  ] });
+}
+function Ns({ active: e, children: t }) {
+  return /* @__PURE__ */ h("div", { className: `gv-graph-control-section-slot${e ? " active" : ""}`, "aria-hidden": !e, children: t });
+}
+function Fo({ def: e, value: t, onChange: n, nodeType: s }) {
+  const o = Bt(), i = e.step < 1 ? String(t) : String(Math.round(t)), r = s ? { className: "gv-graph-control-slider gv-graph-control-typed-row", style: { "--gv-type-color": `var(${o.colorVar(s)})` } } : { className: "gv-graph-control-slider", style: void 0 };
+  return /* @__PURE__ */ C("div", { className: r.className, style: r.style, title: e.tooltip, children: [
+    /* @__PURE__ */ h("label", { className: "gv-graph-control-slider-label", children: e.label }),
+    /* @__PURE__ */ h(_t, { min: e.min, max: e.max, step: e.step, value: t, onChange: n }),
+    /* @__PURE__ */ h("span", { className: "gv-graph-control-slider-value", children: i })
+  ] });
+}
+const il = {
+  dark: [
+    "#2DD4BF",
+    // teal
+    "#F59E0B",
+    // amber
+    "#A78BFA",
+    // violet
+    "#F472B6",
+    // rose
+    "#34D399",
+    // green
+    "#60A5FA",
+    // blue
+    "#FB923C",
+    // orange
+    "#A3E635",
+    // lime
+    "#22D3EE",
+    // cyan
+    "#E879F9"
+    // fuchsia
+  ],
+  light: [
+    "#0F766E",
+    // teal
+    "#B45309",
+    // amber
+    "#6D28D9",
+    // violet
+    "#BE185D",
+    // rose
+    "#047857",
+    // green
+    "#1D4ED8",
+    // blue
+    "#C2410C",
+    // orange
+    "#4D7C0F",
+    // lime
+    "#0E7490",
+    // cyan
+    "#A21CAF"
+    // fuchsia
+  ]
+}, cl = 2.2, al = 2.2;
+function ll(e, t, n = "dark", s = null) {
+  const o = il[n], i = [];
+  return e.forEach((r, c) => {
+    const a = /* @__PURE__ */ new Set();
+    for (const l of r.nodeIds) t.has(l) && a.add(l);
+    a.size !== 0 && i.push({ id: r.id, strength: r.emphasized || r.id === s ? cl : 1, nodeIds: a, color: r.color ?? o[c % o.length] });
+  }), i;
+}
+function dl(e, t) {
+  const n = t.filter((i) => !!i);
+  if (n.length === 0) return e;
+  let s = !1;
+  const o = e.map((i) => n.some((r) => i.nodeIds.has(r)) ? (s = !0, { ...i, strength: Math.max(i.strength, al) }) : i);
+  return s ? o : e;
+}
+function ul() {
+  const [e, t] = g.useState(Xc), n = g.useRef(null), s = g.useRef(!1), o = g.useRef(null), i = g.useRef(null), r = g.useCallback(() => {
+    const a = n.current;
+    if (!a) return null;
+    const { width: l, height: d } = a.getBoundingClientRect();
+    return i.current = { width: l, height: d }, { width: l, height: d };
+  }, []);
+  g.useEffect(() => {
+    const a = n.current;
+    if (!a || typeof ResizeObserver > "u") return;
+    const l = new ResizeObserver(() => {
+      const d = i.current, u = r();
+      u && t((v) => jc(v, d, u));
+    });
+    return l.observe(a), () => l.disconnect();
+  }, [r]);
+  const c = g.useCallback((a, l) => {
+    const d = r();
+    d && t(hr(a, d.width, d.height, l));
+  }, [r]);
+  return { viewport: e, setViewport: t, containerRef: n, initialFitDone: s, pendingCenterRef: o, measure: r, fit: c };
+}
+function fl(e, t, n, s) {
+  const o = /* @__PURE__ */ new Set([e]), i = [e];
+  for (; i.length > 0; ) {
+    const r = i.shift();
+    for (const c of t) {
+      if (it(c)) continue;
+      let a;
+      s === "downstream" && c.sourceId === r ? a = c.targetId : s === "upstream" && c.targetId === r && (a = c.sourceId), a && n.has(a) && !o.has(a) && (o.add(a), i.push(a));
+    }
+  }
+  return o;
+}
+function hl(e, t) {
+  const n = /* @__PURE__ */ new Set();
+  for (const s of t)
+    it(s) || e.has(s.sourceId) && e.has(s.targetId) && n.add(s.id);
+  return n;
+}
+function gl(e, t, n, s) {
+  const o = fl(t.id, [...s.visibleEdges], new Set(s.visibleIds), n), i = e.highlight(t, { nodes: o }, s, n), r = new Set(i.nodes), c = i.edges ? new Set(i.edges) : hl(r, [...s.visibleEdges]);
+  return { nodes: r, edges: c };
+}
+function pl(e, t, n, s, o, i, r, c) {
+  const [a, l] = g.useState(null), [d, u] = g.useState(-1), [v, M] = g.useState(!1), [S, p] = g.useState(null), [$, D] = g.useState(null), [x, V] = g.useState(null), [F, L] = g.useState(null);
+  g.useEffect(() => {
+    l(null), u(-1);
+  }, [o]), g.useEffect(() => {
+    const O = (N) => {
+      N.key === "Shift" && M(!0);
+    }, X = (N) => {
+      N.key === "Shift" && M(!1);
+    };
+    return window.addEventListener("keydown", O), window.addEventListener("keyup", X), () => {
+      window.removeEventListener("keydown", O), window.removeEventListener("keyup", X);
+    };
+  }, []);
+  const y = d >= 0 && d < e.length ? e[d].id : null, { highlightedNodes: I, highlightedEdges: E } = g.useMemo(() => {
+    const O = a ?? r;
+    if (!O || !n.has(O))
+      return { highlightedNodes: null, highlightedEdges: null };
+    const X = v ? "upstream" : "downstream", N = s(O);
+    if (!N) return { highlightedNodes: null, highlightedEdges: null };
+    const k = (z) => c.get(z), { nodes: w, edges: R } = gl(i, k(O) ?? N, X, {
+      visibleNodes: e.map((z) => k(z.id) ?? z),
+      visibleEdges: t,
+      visibleIds: n,
+      getNode: (z) => k(z) ?? s(z)
+    });
+    return { highlightedNodes: w, highlightedEdges: R };
+  }, [a, r, v, t, n, e, s, i, c]);
+  return {
+    hoveredNodeId: a,
+    setHoveredNodeId: l,
+    focusedIndex: d,
+    setFocusedIndex: u,
+    shiftHeld: v,
+    focusedNodeId: y,
+    highlightedNodes: I,
+    highlightedEdges: E,
+    activeSection: S,
+    setActiveSection: p,
+    activePushBucket: $,
+    setActivePushBucket: D,
+    activeGravityBucket: x,
+    setActiveGravityBucket: V,
+    activePullEdge: F,
+    setActivePullEdge: L
+  };
+}
+const ml = Math.random;
+function vl(e, t, n, s, o, i) {
+  const r = g.useRef(null), c = g.useRef(null), a = g.useRef(!1), l = g.useRef([]), d = g.useRef(!1), u = g.useRef(null), v = g.useRef(null), [M, S] = g.useState(!0), p = g.useMemo(() => Tc(o, t, e), [o, t, e]);
+  g.useEffect(() => {
+    p !== o && i((N) => N === o ? p : N);
+  }, [p, o]);
+  const [$, D] = g.useState(0), x = g.useRef(s);
+  x.current = s, g.useEffect(() => {
+    var w;
+    const N = r.current;
+    if (N && c.current && c.current !== e && !a.current && Ji(c.current, e) && (a.current = !0, console.warn("[graph] the graph's identity changed but nothing in it did; the view rebuilt its simulation for nothing. Keep one graph object until its nodes or edges change.")), c.current = e, u.current !== null && u.current !== t && !d.current) {
+      const R = typeof performance < "u" ? performance.now() : 0, z = l.current.filter((pe) => R - pe < 2e3);
+      z.push(R), l.current = z, z.length >= 3 && (d.current = !0, console.warn("[graph] the taxonomy's identity changed three times in two seconds; the view rebuilds its simulation for each. Build the taxonomy once, outside render."));
+    }
+    u.current = t;
+    const k = new Map(n ?? []);
+    if (N) for (const R of N.nodes) k.set(R.id, { x: R.x, y: R.y });
+    r.current = new Pc(e, p, ml, t, k.size > 0 ? k : void 0), (w = x.current) == null || w.call(x, N !== null), S(!0), D((R) => R + 1);
+  }, [e, t]), g.useEffect(() => {
+    const N = r.current;
+    N && N.params !== p && N.setParams(p);
+  }, [p]);
+  const V = g.useCallback((N) => {
+    var k;
+    return (k = r.current) == null ? void 0 : k.getNode(N);
+  }, []), F = g.useCallback((N) => {
+    i((k) => ({ ...k, ...N }));
+  }, [i]), L = g.useCallback(() => {
+    var N;
+    (N = r.current) == null || N.nudge(0.3), S(!0);
+  }, []), y = g.useCallback((N) => {
+    var k;
+    i((w) => ({ ...w, ...N })), (k = r.current) == null || k.reheat(0.6), S(!0);
+  }, [i]), I = g.useCallback((N, k, w) => {
+    var R, z;
+    v.current = N, (R = r.current) == null || R.pinNode(N, k, w), (z = r.current) == null || z.reheat(0.3), S(!0);
+  }, []), E = g.useCallback((N, k) => {
+    var w;
+    v.current && ((w = r.current) == null || w.pinNode(v.current, N, k));
+  }, []), O = g.useCallback(() => {
+    var N;
+    v.current && ((N = r.current) == null || N.unpinNode(v.current), v.current = null);
+  }, []), X = g.useCallback(() => {
+    var N;
+    M ? S(!1) : ((N = r.current) == null || N.reheat(0.5), S(!0));
+  }, [M]);
+  return {
+    simRef: r,
+    simVersion: $,
+    running: M,
+    setRunning: S,
+    forceParams: p,
+    getNode: V,
+    onParamChange: F,
+    onForceAdjust: L,
+    onRelayout: y,
+    onNodeDragStart: I,
+    onNodeDragMove: E,
+    onNodeDragEnd: O,
+    onToggleRunning: X
+  };
+}
+const yl = {
+  visibleNodes: [],
+  visibleEdges: [],
+  visibleIds: /* @__PURE__ */ new Set(),
+  edgeTypes: /* @__PURE__ */ new Map(),
+  origins: /* @__PURE__ */ new Map(),
+  nodeSummaries: /* @__PURE__ */ new Map(),
+  downstreamScores: /* @__PURE__ */ new Map()
+};
+function Ir(e, t, n) {
+  const s = n(e);
+  if (!s) return null;
+  let o = s.parentId;
+  for (; o; ) {
+    if (t.has(o)) return o;
+    const i = n(o);
+    o = i == null ? void 0 : i.parentId;
+  }
+  return null;
+}
+function Ts(e, t, n, s, o, i, r, c = /* @__PURE__ */ new Set()) {
+  if (t) return [e];
+  if (c.has(e)) return [];
+  c.add(e);
+  const a = i(e);
+  if (a && r.nodeStyleOf(a).whenHidden === "splice") {
+    const d = [];
+    for (const u of s.edges) {
+      if (it(u)) continue;
+      const v = n === "tgt" ? u.sourceId === e ? u.targetId : null : u.targetId === e ? u.sourceId : null;
+      if (v)
+        for (const M of Ts(v, o.has(v), n, s, o, i, r, c))
+          d.push(M);
+    }
+    if (d.length > 0) return d;
+  }
+  const l = Ir(e, o, i);
+  return l ? [l] : [];
+}
+function bl(e, t, n, s) {
+  const { summaryKind: o } = s.nodeStyleOf(e);
+  if (o === "none") return "";
+  if (o === "children") {
+    const a = /* @__PURE__ */ new Map();
+    for (const l of t) {
+      if (!it(l) || l.targetId !== e.id) continue;
+      const d = n.get(l.sourceId);
+      if (!d) continue;
+      const u = s.styleValueOf(d);
+      u !== void 0 && a.set(u, (a.get(u) ?? 0) + 1);
+    }
+    return s.styleValues.filter((l) => a.has(l)).map((l) => `${a.get(l)} ${s.abbreviationFor(l)}`).join(" · ");
+  }
+  let i = 0, r = 0;
+  for (const a of t)
+    it(a) || (a.sourceId === e.id && i++, a.targetId === e.id && r++);
+  const c = [];
+  return i > 0 && c.push(`→${i}`), r > 0 && c.push(`←${r}`), c.join(" ");
+}
+function Dn(e, t, n, s = n.filterAxes) {
+  return Xn(t, s, (o) => n.valueOn(e, o));
+}
+function xl(e, t) {
+  var o;
+  const n = new Map(t.edgeTypes.map((i) => [i.id, i])), s = /* @__PURE__ */ new Map();
+  for (const i of e.edges) {
+    const r = e.getNode(i.sourceId), c = e.getNode(i.targetId);
+    let a;
+    try {
+      a = t.edgeTypeOf(i, r && t.styleValueOf(r), c && t.styleValueOf(c));
+    } catch {
+      a = void 0;
+    }
+    s.set(i.id, a !== void 0 && ((o = n.get(a)) == null ? void 0 : o.relation) === xn(i) ? a : void 0);
+  }
+  return s;
+}
+function wl(e, t, n, s = n.filterAxes) {
+  const o = /* @__PURE__ */ new Set(), i = [];
+  for (const x of e.nodes)
+    Dn(x, t, n, s) && (o.add(x.id), i.push(x));
+  const r = xl(e, n), c = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), l = (x) => e.getNode(x), d = [], u = /* @__PURE__ */ new Set(), v = [];
+  for (const x of e.edges) {
+    const V = o.has(x.sourceId), F = o.has(x.targetId);
+    if (it(x)) {
+      if (!V) continue;
+      if (F)
+        d.push(x), c.set(x.id, r.get(x.id)), a.set(x.id, x.id);
+      else {
+        const L = Ir(x.targetId, o, l);
+        if (L) {
+          const y = `grad:${x.id}`;
+          d.push({ ...x, targetId: L, id: y }), c.set(y, r.get(x.id)), a.set(y, x.id);
+        }
+      }
+    } else V && F ? (d.push(x), c.set(x.id, r.get(x.id)), a.set(x.id, x.id), u.add(`${x.sourceId}→${x.targetId}`)) : v.push(x);
+  }
+  const M = /* @__PURE__ */ new Map();
+  for (const x of v) {
+    const V = Ts(x.sourceId, o.has(x.sourceId), "src", e, o, l, n), F = Ts(x.targetId, o.has(x.targetId), "tgt", e, o, l, n);
+    for (const L of V)
+      for (const y of F) {
+        if (L === y) continue;
+        const I = `${L}→${y}`;
+        if (u.has(I)) continue;
+        const E = M.get(I);
+        E && n.collapse(E.origin, x) === E.origin || M.set(I, { origin: x, edge: { ...x, sourceId: L, targetId: y, id: `grad:${I}` } });
+      }
+  }
+  const S = [...d];
+  for (const { origin: x, edge: V } of M.values())
+    S.push(V), c.set(V.id, r.get(x.id)), a.set(V.id, x.id);
+  const p = /* @__PURE__ */ new Map();
+  for (const x of i) p.set(x.id, x);
+  const $ = /* @__PURE__ */ new Map();
+  for (const x of i) {
+    const V = bl(x, S, p, n);
+    V && $.set(x.id, V);
+  }
+  const D = Uo({ nodes: i, edges: S, getNode: (x) => p.get(x) });
+  return { visibleNodes: i, visibleEdges: S, visibleIds: o, edgeTypes: c, origins: a, nodeSummaries: $, downstreamScores: D };
+}
+function Ml(e, t, n, s, o) {
+  return g.useMemo(() => {
+    const i = e.current;
+    return i ? wl(i, n, o, s) : yl;
+  }, [n, s, t, o]);
+}
+function Sl({
+  simRef: e,
+  running: t,
+  setRunning: n,
+  visibleIds: s,
+  visibleNodes: o,
+  downstreamScores: i,
+  filter: r,
+  axes: c,
+  hoveredNodeId: a,
+  selectedNodeId: l,
+  measure: d,
+  initialFitDone: u,
+  pendingCenterRef: v,
+  setViewport: M,
+  setSelectedNodeId: S,
+  taxonomy: p
+}) {
+  const [$, D] = g.useState(0), x = g.useRef({ frames: 0, lastStamp: 0 });
+  g.useEffect(() => {
+    if (!t) return;
+    let L = 0;
+    x.current = { frames: 0, lastStamp: 0 };
+    const y = () => {
+      const I = e.current;
+      if (!I) return;
+      if (I.tick(s, i), !u.current && I.alpha < 0.3) {
+        const N = d();
+        N && N.width > 0 && N.height > 0 && (M(hr(o, N.width, N.height)), u.current = !0);
+      }
+      if (u.current && v.current) {
+        const N = I.getNode(v.current.nodeId);
+        if (N) {
+          const k = d();
+          if (k) {
+            const { width: w, height: R } = k;
+            M((z) => ({
+              scale: Math.max(z.scale, 1.2),
+              x: w / 2 - N.x * Math.max(z.scale, 1.2),
+              y: R / 2 - N.y * Math.max(z.scale, 1.2)
+            })), S(N.id);
+          }
+        }
+        v.current = null;
+      }
+      const E = performance.now(), O = x.current;
+      O.frames++, O.lastStamp === 0 && (O.lastStamp = E);
+      const X = E - O.lastStamp;
+      if (X >= 500) {
+        const N = Math.round(O.frames * 1e3 / X);
+        D((k) => k === N ? k : N), O.frames = 0, O.lastStamp = E;
+      }
+      if (I.isStable()) {
+        n(!1);
+        return;
+      }
+      L = requestAnimationFrame(y);
+    };
+    return L = requestAnimationFrame(y), () => {
+      L && cancelAnimationFrame(L);
+    };
+  }, [t, s, o, l]);
+  const [, V] = g.useState(0);
+  g.useEffect(() => {
+    if (!t || !a) return;
+    const L = window.setInterval(() => V((y) => y + 1), 100);
+    return () => window.clearInterval(L);
+  }, [t, a]);
+  const F = g.useRef(r);
+  return g.useEffect(() => {
+    const L = F.current;
+    if (L === r) return;
+    const y = e.current;
+    if (!y) {
+      F.current = r;
+      return;
+    }
+    const { alpha: I, seedRevealed: E, refit: O, resume: X } = bi(
+      c.filter(
+        (N) => !Gn(ze(L, N.id), ze(r, N.id))
+      )
+    );
+    if (I > 0) {
+      if (E)
+        for (const N of y.nodes) {
+          if (!Dn(N, r, p, c) || Dn(N, L, p, c)) continue;
+          let k = N.parentId;
+          for (; k; ) {
+            const w = y.getNode(k);
+            if (!w) break;
+            if (Dn(w, r, p, c)) {
+              y.seedAt(N.id, w.x, w.y);
+              break;
+            }
+            k = w.parentId;
+          }
+        }
+      y.reheat(I), X && n(!0), O && (u.current = !1);
+    }
+    F.current = r;
+  }, [r]), { fps: $ };
+}
+function Lo(e, t) {
+  return e === t || e !== null && t !== null && e.id === t.id && e.key === t.key;
+}
+const kl = /* @__PURE__ */ new Set(["containment", "dependency"]);
+function Nl(e, t) {
+  const n = [], s = new Map(t.edgeTypes.map((l) => [l.id, l])), o = new Set(t.styleValues), i = Pt(e.nodes), r = /* @__PURE__ */ new Set();
+  for (const l of e.nodes) {
+    if (r.has(l.id)) {
+      n.push({ severity: "error", code: "node-id-duplicate", nodeId: l.id, message: `node id ${JSON.stringify(l.id)} is used more than once; the view draws the first` });
+      continue;
+    }
+    r.add(l.id), l.parentId !== void 0 && !i.has(l.parentId) && n.push({ severity: "error", code: "parent-missing", nodeId: l.id, message: `node ${JSON.stringify(l.id)} names parent ${JSON.stringify(l.parentId)}, which is not in the graph` });
+    const d = t.styleValueOf(l);
+    d !== void 0 && !o.has(d) && n.push({ severity: "warning", code: "node-value-undeclared", nodeId: l.id, message: `node ${JSON.stringify(l.id)} sits at ${JSON.stringify(d)} on the style axis, which the taxonomy does not declare; it draws in the fallback style` });
+  }
+  const c = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map();
+  for (const l of e.edges) {
+    if (c.has(l.id)) {
+      n.push({ severity: "error", code: "edge-id-duplicate", edgeId: l.id, message: `edge id ${JSON.stringify(l.id)} is used more than once` });
+      continue;
+    }
+    c.add(l.id);
+    const d = i.get(l.sourceId), u = i.get(l.targetId);
+    if (!d || !u) {
+      const p = [!d && l.sourceId, !u && l.targetId].filter(($) => typeof $ == "string");
+      n.push({ severity: "error", code: "edge-endpoint-missing", edgeId: l.id, message: `edge ${JSON.stringify(l.id)} names ${p.map(($) => JSON.stringify($)).join(" and ")}, not in the graph` });
+      continue;
+    }
+    if (l.relation !== void 0 && !kl.has(l.relation)) {
+      n.push({ severity: "error", code: "edge-relation-unknown", edgeId: l.id, message: `edge ${JSON.stringify(l.id)} has relation ${JSON.stringify(l.relation)}; the engine knows "containment" and "dependency"` });
+      continue;
+    }
+    const v = xn(l);
+    if (v === "containment") {
+      const p = a.get(l.sourceId) ?? /* @__PURE__ */ new Set();
+      p.add(l.targetId), a.set(l.sourceId, p);
+    }
+    let M;
+    try {
+      M = t.edgeTypeOf(l, t.styleValueOf(d), t.styleValueOf(u));
+    } catch (p) {
+      n.push({ severity: "error", code: "edge-type-rule-threw", edgeId: l.id, message: `the taxonomy's classifyEdge rule threw on edge ${JSON.stringify(l.id)}: ${p instanceof Error ? p.message : String(p)}` });
+      continue;
+    }
+    const S = M === void 0 ? void 0 : s.get(M);
+    if (!S) {
+      const p = M === void 0 ? "no declared type fits its endpoints and values" : `classifyEdge answered ${JSON.stringify(M)}, which edgeTypes does not declare`;
+      n.push({ severity: "warning", code: "edge-type-unclassified", edgeId: l.id, message: `edge ${JSON.stringify(l.id)} has no type: ${p}; it draws in its relation's default stroke and pulls nothing while push and pull key on the style axis` });
+      continue;
+    }
+    S.relation !== v && n.push({ severity: "error", code: "edge-type-relation-mismatch", edgeId: l.id, message: `edge ${JSON.stringify(l.id)} is a ${v} edge but resolves to type ${JSON.stringify(M)}, declared as ${S.relation}` });
+  }
+  for (const l of i.values()) {
+    const d = a.get(l.id);
+    l.parentId !== void 0 && d !== void 0 && !d.has(l.parentId) && n.push({ severity: "warning", code: "containment-parent-mismatch", nodeId: l.id, message: `node ${JSON.stringify(l.id)} has containment edges to ${[...d].map((u) => JSON.stringify(u)).join(" and ")} but its parentId is ${JSON.stringify(l.parentId)}` });
+  }
+  return n;
+}
+function El(e, t) {
+  const n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
+  for (const l of t)
+    l.severity === "error" && (l.edgeId !== void 0 && n.add(l.edgeId), l.code === "parent-missing" && l.nodeId !== void 0 && s.add(l.nodeId), l.code === "node-id-duplicate" && l.nodeId !== void 0 && o.add(l.nodeId));
+  if (n.size === 0 && s.size === 0 && o.size === 0) return e;
+  const i = /* @__PURE__ */ new Set(), r = [];
+  for (const l of e.nodes)
+    o.has(l.id) && i.has(l.id) || (i.add(l.id), r.push(s.has(l.id) ? { ...l, parentId: void 0 } : l));
+  const c = /* @__PURE__ */ new Set(), a = [];
+  for (const l of e.edges)
+    n.has(l.id) && c.has(l.id) || n.has(l.id) && !t.some((d) => d.edgeId === l.id && d.code === "edge-id-duplicate") || (c.add(l.id), a.push(l));
+  return { nodes: r, edges: a };
+}
+function Il(e, t, n) {
+  const s = new Set(t.edges), o = Pt(e.nodes), i = [];
+  for (const a of e.edges) {
+    if (s.has(a) || xn(a) !== "containment") continue;
+    const l = o.get(a.sourceId), d = o.get(a.targetId);
+    let u;
+    try {
+      u = n.edgeTypeOf(a, l && n.styleValueOf(l), d && n.styleValueOf(d));
+    } catch {
+      u = void 0;
+    }
+    const v = u === void 0 ? void 0 : n.edgeTypes.find((M) => M.id === u);
+    (v === void 0 || v.relation !== "containment") && i.push(a.id);
+  }
+  if (i.length === 0) return [];
+  const r = i.slice(0, 3).map((a) => JSON.stringify(a)).join(", "), c = i.length === 1;
+  return [{
+    severity: "warning",
+    code: "containment-untyped",
+    edgeId: i[0],
+    message: `${i.length} derived containment edge${c ? "" : "s"} (${r}${i.length > 3 ? ", …" : ""}) ${c ? "has" : "have"} no type: no declared containment type runs between the child's value and the parent's; ${c ? "it draws" : "they draw"} in the containment stroke and pull${c ? "s" : ""} nothing while push and pull key on the style axis`
+  }];
+}
+const Po = /* @__PURE__ */ new Set(), Yl = g.forwardRef(function({
+  graph: t,
+  taxonomy: n,
+  keyboard: s = "pane",
+  defaultPositions: o,
+  counts: i,
+  findings: r,
+  groups: c,
+  groupsControl: a,
+  markedEdges: l,
+  nodeAction: d,
+  chrome: u,
+  searchTitle: v = "Search nodes (/)",
+  searchPlaceholder: M = "Search nodes...",
+  selectedId: S,
+  defaultSelectedId: p = null,
+  focus: $,
+  onFocusResult: D,
+  className: x,
+  style: V,
+  filter: F,
+  onFilterChange: L,
+  defaultFilter: y,
+  locks: I,
+  onLocksChange: E,
+  defaultLocks: O,
+  overriddenLocks: X,
+  axes: N,
+  onAxesChange: k,
+  defaultAxes: w,
+  search: R,
+  onSearchChange: z,
+  defaultSearch: pe,
+  theme: ke,
+  onThemeChange: St,
+  defaultTheme: Ne,
+  systemTheme: ct,
+  layout: at,
+  onLayoutChange: lt,
+  defaultLayout: Ie,
+  onSelectionChange: dt,
+  onNodeActivate: De,
+  onHover: ht,
+  onThemeResolved: b,
+  onDiagnostics: T
+}, U) {
+  const se = g.useContext(_n), G = n ?? se;
+  if (!G)
+    throw new Error("GraphView has no taxonomy: pass `taxonomy`, or mount it inside <TaxonomyContext.Provider value={…}>.");
+  const oe = g.useMemo(() => Pt(t.nodes), [t]), [B, f] = Mt(F, void 0, () => y ?? Ps(G, t), "filter"), q = Ft(B, bn), te = Te(q), le = Te(L), Ee = F === void 0 || L !== void 0, Me = g.useCallback((m, P) => {
+    var j;
+    te.current = m, f(m), (j = le.current) == null || j.call(le, m, P);
+  }, [te, f, le]), A = g.useRef(/* @__PURE__ */ new Set()), Oe = g.useCallback((m, P) => {
+    for (const j of P) A.current.add(j);
+    Me(m, P);
+  }, [Me]), xe = g.useRef(y !== void 0), xt = g.useRef(t);
+  g.useEffect(() => {
+    if (xt.current === t || (xt.current = t, F !== void 0 || xe.current)) return;
+    const m = Yo(q, G, t, A.current);
+    m !== q && Me(m, []);
+  }, [t]);
+  const [Y, re] = Mt(I, E, () => O ?? /* @__PURE__ */ new Map(), "locks"), Qe = Ft(Y, Go), [Z, _e] = Mt(N, k, () => w ?? G.filterAxes.map((m) => m.id), "axes"), Be = Ft(Z, Xo), rn = N === void 0 || k !== void 0, [kt, et] = Mt(R, z, () => pe ?? { query: "", active: !1 }, "search"), [Ve, ye] = Mt(ke, St, () => Ne ?? "system", "theme"), Ue = kt.query, gt = kt.active, tt = g.useMemo(
+    () => Be.flatMap((m) => {
+      const P = G.axisFor(m);
+      return P ? [P] : [];
+    }),
+    [Be, G]
+  ), _ = {
+    search: (u == null ? void 0 : u.search) ?? !0,
+    locks: (u == null ? void 0 : u.locks) ?? (I !== void 0 && E !== void 0),
+    transport: (u == null ? void 0 : u.transport) ?? !0,
+    diagnostics: (u == null ? void 0 : u.diagnostics) ?? !0,
+    shortcuts: (u == null ? void 0 : u.shortcuts) ?? !0,
+    directionLine: (u == null ? void 0 : u.directionLine) ?? !0,
+    activateZoom: (u == null ? void 0 : u.activateZoom) ?? !0,
+    controls: (u == null ? void 0 : u.controls) ?? !0,
+    themeToggle: (u == null ? void 0 : u.themeToggle) ?? !0
+  }, { diagnostics: K, graph: H } = g.useMemo(() => {
+    const m = Nl(t, G), P = Xi(El(t, m));
+    return { diagnostics: [...m, ...Il(P, t, G)], graph: P };
+  }, [t, G]), ne = g.useMemo(() => Pt(H.nodes), [H]), J = g.useMemo(() => _o(H.nodes, Be), [H, Be]), Q = i ?? J, ie = g.useMemo(() => Gi(H), [H]), { viewport: ee, setViewport: W, containerRef: ce, initialFitDone: $e, pendingCenterRef: Re, measure: de, fit: he } = ul(), ge = g.useRef(null), [ue, we] = g.useState(!1), be = g.useRef(null), [fe, Fe] = g.useState(0);
+  Es(() => {
+    const m = be.current;
+    if (!m || typeof ResizeObserver > "u") return;
+    const P = () => Fe(m.getBoundingClientRect().height);
+    P();
+    const j = new ResizeObserver(P);
+    return j.observe(m), () => j.disconnect();
+  }, []);
+  const He = g.useRef(!1);
+  Es(() => {
+    const m = ce.current;
+    if (!m || typeof ResizeObserver > "u") return;
+    const P = () => {
+      if (He.current || m.offsetParent === null) return;
+      const { width: me, height: ve } = m.getBoundingClientRect();
+      me > 0 && ve === 0 && (He.current = !0, console.warn("[force-graph] the pane measured 0 px tall: give its parent a height — the pane fills a flex column, or a block with a height."));
+    };
+    P();
+    const j = new ResizeObserver(P);
+    return j.observe(m), () => j.disconnect();
+  }, []);
+  const ae = Jo(q), Ce = g.useMemo(
+    () => new Map(G.filterAxes.map((m) => [m.id, sn(H.nodes, m.id)])),
+    [H, G]
+  ), Ke = g.useCallback((m) => {
+    m || ($e.current = !1);
+  }, [$e]), [Xt, We] = Mt(at, lt, () => Ie ?? ar(G), "layout"), pt = Ft(Xt, Gc), Ge = Te(pt), kn = g.useCallback((m) => {
+    const P = Ge.current, j = m(P.forces);
+    if (j === P.forces) return;
+    const me = zn(j, P.nodeScale);
+    Ge.current = me, We(me);
+  }, [Ge, We]), {
+    simRef: Xe,
+    simVersion: Nn,
+    running: Nt,
+    setRunning: cn,
+    forceParams: Et,
+    getNode: qn,
+    onParamChange: Cr,
+    onForceAdjust: Ar,
+    onRelayout: Un,
+    onNodeDragStart: Or,
+    onNodeDragMove: Rr,
+    onNodeDragEnd: Tr,
+    onToggleRunning: Kn
+  } = vl(H, G, o, Ke, pt.forces, kn), It = g.useMemo(() => $s(Et, G), [Et, G]), Wn = g.useMemo(() => Cc(G, H), [G, H]), Fr = g.useMemo(() => Oc(Wn, G), [Wn, G]), Us = g.useMemo(() => Cs(jo(H), It), [H, It]), nt = Ho(ce, Ve, ct), Lr = g.useMemo(() => zo(G, nt), [G, nt]), Pr = g.useMemo(() => hc(
+    H.nodes,
+    Et,
+    It,
+    Us,
+    (m, P) => m.mapping.axis === G.styleAxis() && Fs(m.mapping) ? G.styleOf(P).color[nt].fill : void 0
+  ), [H, Et, It, Us, G, nt]), Dr = g.useCallback((m) => {
+    m.axis !== Et.pair.mapping.axis && Un({ pair: Sn(m) });
+  }, [Et.pair.mapping.axis, Un]), Ks = pt.nodeScale, _r = g.useCallback((m) => {
+    const P = Ge.current, j = zn(P.forces, { ...P.nodeScale, ...m });
+    Ge.current = j, We(j);
+  }, [Ge, We]), [Zn, Qn] = g.useState(Po);
+  g.useEffect(() => {
+    if (Zn.size === 0) return;
+    const m = setTimeout(() => Qn(Po), 600);
+    return () => clearTimeout(m);
+  }, [Zn]), g.useEffect(() => {
+    X && X.size > 0 && Qn((m) => /* @__PURE__ */ new Set([...m, ...X]));
+  }, [X]);
+  const { visibleNodes: st, visibleEdges: mt, visibleIds: wt, edgeTypes: Ws, origins: Zs, nodeSummaries: Br, downstreamScores: Hr } = Ml(Xe, Nn, q, tt, G), zr = g.useMemo(() => {
+    const m = /* @__PURE__ */ new Set();
+    if (l)
+      for (const P of mt) l.has(Zs.get(P.id)) && m.add(P.id);
+    return m;
+  }, [l, mt, Zs]), Vr = g.useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const P of mt) {
+      const j = Ws.get(P.id);
+      m.set(P, j !== void 0 ? G.edgeStrokeFor(j) : it(P) ? Ko : wn);
+    }
+    return m;
+  }, [mt, Ws, G]), Gr = g.useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const j of mt) {
+      if (it(j)) continue;
+      const me = j.sourceId < j.targetId ? `${j.sourceId}|${j.targetId}` : `${j.targetId}|${j.sourceId}`, ve = m.get(me);
+      ve ? ve.push(j.id) : m.set(me, [j.id]);
+    }
+    const P = /* @__PURE__ */ new Map();
+    for (const j of m.values())
+      j.length < 2 || j.forEach((me, ve) => P.set(me, (ve - (j.length - 1) / 2) * 7));
+    return P;
+  }, [mt]), Qs = g.useMemo(() => cr(H.edges, wt), [H, wt]), Xr = g.useMemo(
+    () => kc(st, Qs, It, qn),
+    [st, Qs, It, G, qn]
+  ), an = S !== void 0;
+  Bo("selectedId", an);
+  const [es, eo] = g.useState(p), $t = an ? S : es, to = Te($t), Ht = Te(dt), ts = Te(oe), Ct = g.useCallback((m) => {
+    var P;
+    m !== null && !ts.current.has(m) || (an || eo(m), m !== to.current && ((P = Ht.current) == null || P.call(Ht, m === null ? null : ts.current.get(m) ?? null)));
+  }, [an, ts, to, Ht]);
+  g.useEffect(() => {
+    var m;
+    an || es === null || oe.has(es) || (eo(null), (m = Ht.current) == null || m.call(Ht, null));
+  }, [oe]);
+  const {
+    hoveredNodeId: At,
+    setHoveredNodeId: ns,
+    setFocusedIndex: no,
+    shiftHeld: Yr,
+    focusedNodeId: En,
+    highlightedNodes: Jr,
+    highlightedEdges: jr,
+    activeSection: qr,
+    setActiveSection: Ur,
+    activePushBucket: Kr,
+    setActivePushBucket: Wr,
+    activeGravityBucket: Zr,
+    setActiveGravityBucket: Qr,
+    activePullEdge: ei,
+    setActivePullEdge: ti
+  } = pl(st, mt, wt, qn, H, G, $t, oe), [so, ni] = g.useState(null), si = g.useMemo(() => ({ emphasize: ni }), []), ss = g.useMemo(() => ll(c ?? [], wt, nt, so), [c, wt, nt, so]), oi = g.useMemo(
+    () => dl(ss, [At, $t]),
+    [ss, At, $t]
+  ), { visibleMatchIds: In, hiddenMatchCount: $n, hiddenMatches: ri } = g.useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    if (!Ue) return { visibleMatchIds: null, hiddenMatchCount: 0, hiddenMatches: m };
+    const P = Ue.toLowerCase(), j = Xe.current;
+    if (!j) return { visibleMatchIds: /* @__PURE__ */ new Set(), hiddenMatchCount: 0, hiddenMatches: m };
+    const me = Fi({ nodes: j.nodes, filter: q, taxonomy: G, axes: Be, visibleIds: wt, matches: (ve) => G.searchText(oe.get(ve.id) ?? ve).toLowerCase().includes(P) });
+    return { visibleMatchIds: me.visible, hiddenMatchCount: me.hiddenCount, hiddenMatches: me.hiddenByAxis };
+  }, [Ue, wt, q, Be, G, oe]), { fps: ii } = Sl({
+    simRef: Xe,
+    running: Nt,
+    setRunning: cn,
+    visibleIds: wt,
+    visibleNodes: st,
+    downstreamScores: Hr,
+    filter: q,
+    axes: tt,
+    hoveredNodeId: At,
+    selectedNodeId: $t,
+    measure: de,
+    initialFitDone: $e,
+    pendingCenterRef: Re,
+    setViewport: W,
+    setSelectedNodeId: Ct,
+    taxonomy: G
+  }), os = Te(ht), rs = Te(De), is = Te(b), cs = Te(T), oo = g.useRef(!1);
+  g.useEffect(() => {
+    var m;
+    oo.current && ((m = os.current) == null || m.call(os, At === null ? null : oe.get(At) ?? null));
+  }, [At]), g.useEffect(() => {
+    oo.current = !0;
+  }, []), g.useEffect(() => {
+    var m;
+    (m = is.current) == null || m.call(is, nt);
+  }, [nt]), g.useEffect(() => {
+    var m;
+    (m = cs.current) == null || m.call(cs, K);
+  }, [K]);
+  const ci = g.useCallback((m) => {
+    var Ae;
+    const P = Xe.current;
+    if (!P || !P.getNode(m)) return;
+    const me = oe.get(m);
+    me && ((Ae = rs.current) == null || Ae.call(rs, me));
+    const ve = /* @__PURE__ */ new Set([m]);
+    for (const Le of P.edges)
+      Le.sourceId === m && ve.add(Le.targetId), Le.targetId === m && ve.add(Le.sourceId);
+    if (!_.activateZoom) return;
+    const Se = P.nodes.filter((Le) => ve.has(Le.id));
+    he(Se, 80);
+  }, [he, oe, _.activateZoom]), Cn = g.useCallback(() => {
+    he(st);
+  }, [he, st]), ai = () => {
+    gt ? et({ query: "", active: !1 }) : (et({ query: Ue, active: !0 }), setTimeout(() => {
+      var m;
+      return (m = ge.current) == null ? void 0 : m.focus();
+    }, 50));
+  }, ln = g.useRef(null), as = g.useCallback(() => {
+    ln.current !== null && (clearTimeout(ln.current), ln.current = null);
+  }, []), ro = g.useCallback((m) => {
+    as(), m !== null ? ns(m) : ln.current = window.setTimeout(() => {
+      ns(null), ln.current = null;
+    }, 150);
+  }, [as, ns]), li = (m) => {
+    Ct(m);
+    const P = Xe.current, j = P == null ? void 0 : P.getNode(m), me = j && de();
+    if (!j || !me) return;
+    const { width: ve, height: Se } = me;
+    W({
+      scale: ee.scale,
+      x: ve / 2 - j.x * ee.scale,
+      y: Se / 2 - j.y * ee.scale
+    });
+  }, io = Te(st), ls = g.useCallback((m) => {
+    var Ae;
+    const P = ne.get(m);
+    if (!P) return !1;
+    const j = te.current, me = qo({ destination: j, source: j, locks: Qe, transition: { kind: "focus", target: { values: P.values } }, taxonomy: G, axes: Be, graph: H }), ve = Ee ? me.filter : j;
+    return ve !== j && (Me(ve, []), me.overriddenLocks.size > 0 && Qn(me.overriddenLocks)), Xn(ve, tt, (Le) => G.valueOn(P, Le)) ? (Re.current = { nodeId: m }, Nt || ((Ae = Xe.current) == null || Ae.reheat(0.1), cn(!0)), !0) : !1;
+  }, [ne, H, te, Ee, Me, Qe, Be, tt, Nt, cn, Xe, Re, G]), An = g.useRef(null), On = g.useRef(null), ds = Te(D);
+  g.useEffect(() => {
+    if (!$) {
+      An.current = null, On.current = null;
+      return;
+    }
+    Lo(An.current, $) || (An.current = $, On.current = $);
+  }, [$]);
+  const [dn, co] = g.useState(null);
+  g.useEffect(() => {
+    const m = On.current;
+    !m || !ne.has(m.id) || (On.current = null, co(m));
+  }, [$, ne]), g.useEffect(() => {
+    var m;
+    dn && (co(null), Lo(An.current, dn) && ((m = ds.current) == null || m.call(ds, dn, ls(dn.id))));
+  }, [dn]), g.useImperativeHandle(U, () => ({
+    focusNode: ls,
+    select: Ct,
+    fit: () => he(io.current),
+    getPositions: () => {
+      var m;
+      return new Map((((m = Xe.current) == null ? void 0 : m.nodes) ?? []).map((P) => [P.id, { x: P.x, y: P.y }]));
+    },
+    setPositions: (m) => {
+      const P = Xe.current;
+      if (P) {
+        for (const [j, me] of m) {
+          const ve = P.getNode(j);
+          !ve || ve.pinned || (ve.x = me.x, ve.y = me.y, ve.vx = 0, ve.vy = 0);
+        }
+        P.reheat(0.1), cn(!0);
+      }
+    }
+  }), [ls, he, cn, Ct, Xe, io]);
+  const un = g.useCallback((m) => {
+    var me, ve;
+    if (m.metaKey || m.ctrlKey || m.altKey) return;
+    const P = m.target instanceof Element ? m.target : null;
+    if (!(P instanceof HTMLInputElement || P instanceof HTMLTextAreaElement || P !== null && P !== ce.current && P.closest('button, select, a, [contenteditable], [role="tab"]') !== null && m.key !== "Escape"))
+      switch (m.key) {
+        case "Tab": {
+          if (P !== ce.current) return;
+          m.preventDefault();
+          const Se = st.length;
+          if (Se === 0) return;
+          m.shiftKey ? no((Ae) => Ae > 0 ? Ae - 1 : Se - 1) : no((Ae) => Ae < Se - 1 ? Ae + 1 : 0);
+          break;
+        }
+        case "Enter": {
+          m.preventDefault(), En && Ct(En);
+          break;
+        }
+        case "Escape": {
+          if (ue) {
+            m.preventDefault(), we(!1);
+            break;
+          }
+          if (gt) {
+            m.preventDefault(), ai();
+            break;
+          }
+          if ($t) {
+            m.preventDefault(), Ct(null);
+            break;
+          }
+          s === "pane" && ((me = ce.current) == null || me.blur());
+          break;
+        }
+        case "ArrowLeft":
+        case "ArrowRight":
+        case "ArrowUp":
+        case "ArrowDown": {
+          m.preventDefault();
+          const Se = 30, Ae = m.key === "ArrowLeft" ? Se : m.key === "ArrowRight" ? -Se : 0, Le = m.key === "ArrowUp" ? Se : m.key === "ArrowDown" ? -Se : 0;
+          W((us) => ({ ...us, x: us.x + Ae, y: us.y + Le }));
+          break;
+        }
+        case "+":
+        case "=": {
+          m.preventDefault(), W((Se) => {
+            var Ae, Le;
+            return As(Se, (((Ae = ce.current) == null ? void 0 : Ae.clientWidth) ?? 400) / 2, (((Le = ce.current) == null ? void 0 : Le.clientHeight) ?? 400) / 2, 1.15);
+          });
+          break;
+        }
+        case "-":
+        case "_": {
+          m.preventDefault(), W((Se) => {
+            var Ae, Le;
+            return As(Se, (((Ae = ce.current) == null ? void 0 : Ae.clientWidth) ?? 400) / 2, (((Le = ce.current) == null ? void 0 : Le.clientHeight) ?? 400) / 2, 0.85);
+          });
+          break;
+        }
+        case "f":
+        case "F": {
+          m.preventDefault(), Cn();
+          break;
+        }
+        case "/": {
+          if (!_.search) break;
+          m.preventDefault(), gt ? (ve = ge.current) == null || ve.focus() : (et({ query: Ue, active: !0 }), setTimeout(() => {
+            var Se;
+            return (Se = ge.current) == null ? void 0 : Se.focus();
+          }, 50));
+          break;
+        }
+        case " ": {
+          m.preventDefault(), Kn();
+          break;
+        }
+        case "?": {
+          if (!_.shortcuts) break;
+          m.preventDefault(), we((Se) => !Se);
+          break;
+        }
+      }
+  }, [s, st, En, $t, Ct, gt, Ue, et, ue, _.search, _.shortcuts, Cn, Kn]);
+  g.useEffect(() => {
+    if (s === "global")
+      return window.addEventListener("keydown", un), () => window.removeEventListener("keydown", un);
+  }, [s, un]);
+  const di = g.useCallback((m) => un(m.nativeEvent), [un]), ui = g.useCallback((m) => {
+    const P = oe.get(m.id) ?? m, j = typeof d == "function" ? d(P) : d ?? null;
+    return j && { label: j.label, onSelect: () => j.onSelect(P) };
+  }, [d, oe]), fi = g.useCallback((m) => oe.get(m), [oe]), ao = st.length, lo = mt.length, hi = $n > 0 ? /* @__PURE__ */ C("span", { className: "gv-header-search-badge", title: `${$n} match${$n !== 1 ? "es" : ""} hidden by filters`, children: [
+    "+",
+    $n
+  ] }) : null;
+  return /* @__PURE__ */ h(_n.Provider, { value: G, children: /* @__PURE__ */ h(No, { what: "graph view", children: /* @__PURE__ */ C(
+    "div",
+    {
+      className: `gv-graph-view${x ? ` ${x}` : ""}`,
+      ref: ce,
+      "data-theme": nt,
+      tabIndex: s === "pane" ? 0 : void 0,
+      onKeyDown: s === "pane" ? di : void 0,
+      style: { ...Lr, ...fe ? { "--gv-toolbar-height": `${fe}px` } : {}, ...V },
+      children: [
+        /* @__PURE__ */ C("div", { className: "gv-graph-canvas-area", children: [
+          /* @__PURE__ */ h(No, { children: /* @__PURE__ */ h(
+            xa,
+            {
+              nodes: st,
+              edges: mt,
+              viewport: ee,
+              onViewportChange: W,
+              onNodeDragStart: Or,
+              onNodeDragMove: Rr,
+              onNodeDragEnd: Tr,
+              onDoubleClickNode: ci,
+              onFitView: Cn,
+              onHoverNode: ro,
+              onSelectNode: Ct,
+              highlightedNodes: Jr,
+              highlightedEdges: jr,
+              hoveredNodeId: At,
+              selectedNodeId: $t,
+              focusedNodeId: En,
+              searchMatchIds: In,
+              running: Nt,
+              forceParams: Et,
+              resolved: It,
+              overlay: Pr,
+              theme: nt,
+              edgeStrokes: Vr,
+              edgeOffsets: Gr,
+              activeSection: qr,
+              activePushBucket: Kr,
+              activeGravityBucket: Zr,
+              activePullEdge: ei,
+              nodeScale: Ks,
+              groupGlows: oi,
+              markedEdges: zr
+            }
+          ) }),
+          /* @__PURE__ */ h(
+            Cl,
+            {
+              hoveredNodeId: At,
+              simRef: Xe,
+              visibleEdges: mt,
+              visibleIds: wt,
+              viewport: ee,
+              shiftHeld: Yr,
+              directionLine: _.directionLine,
+              copies: ie,
+              nodeSummaries: Br,
+              nodeAction: ui,
+              hostNodeOf: fi,
+              onMouseEnter: as,
+              onMouseLeave: () => ro(null)
+            }
+          )
+        ] }),
+        /* @__PURE__ */ C("div", { className: "gv-graph-overlay", ref: be, children: [
+          /* @__PURE__ */ h("div", { className: "gv-graph-toolbar", children: /* @__PURE__ */ h(
+            Vi,
+            {
+              chrome: { search: _.search, locks: _.locks },
+              theme: nt,
+              counts: Q,
+              values: Ce,
+              filter: q,
+              onFilterChange: Oe,
+              locks: Qe,
+              onLocksChange: re,
+              axes: Be,
+              onAxesChange: rn ? _e : void 0,
+              overriddenLocks: Zn,
+              recentlyChanged: ae,
+              search: kt,
+              onSearchChange: et,
+              searchInputRef: ge,
+              searchTitle: v,
+              searchPlaceholder: M,
+              searchExtra: hi,
+              hiddenMatches: ri,
+              findings: r
+            }
+          ) }),
+          _.diagnostics && K.length > 0 && /* @__PURE__ */ h($l, { diagnostics: K }),
+          In && In.size > 0 && gt && /* @__PURE__ */ h("div", { className: "gv-graph-search-results", children: st.filter((m) => In.has(m.id)).map((m) => /* @__PURE__ */ C(
+            "button",
+            {
+              className: "gv-graph-search-result",
+              onClick: () => li(m.id),
+              children: [
+                /* @__PURE__ */ h("span", { className: "gv-graph-search-result-type", children: G.nodeStyleOf(m).label }),
+                /* @__PURE__ */ h("span", { className: "gv-graph-search-result-name", children: m.name })
+              ]
+            },
+            m.id
+          )) })
+        ] }),
+        _.transport && /* @__PURE__ */ h("div", { className: `gv-graph-bottom-left${ue ? " shifted" : ""}`, children: /* @__PURE__ */ C("span", { className: "gv-graph-count", children: [
+          ao,
+          " node",
+          ao !== 1 ? "s" : "",
+          ", ",
+          lo,
+          " edge",
+          lo !== 1 ? "s" : ""
+        ] }) }),
+        _.transport && /* @__PURE__ */ C("div", { className: "gv-graph-bottom-center", children: [
+          /* @__PURE__ */ h("button", { className: "gv-graph-toolbar-btn", onClick: Cn, title: "Fit to view (F)", children: "Fit" }),
+          _.themeToggle && /* @__PURE__ */ h(
+            "button",
+            {
+              className: `gv-graph-toolbar-btn${Ve === "system" ? "" : " active"}`,
+              onClick: () => ye(Ln[(Ln.indexOf(Ve) + 1) % Ln.length]),
+              title: `Colour scheme: ${Ve}${Ve === "system" ? ` (${nt})` : ""} — click to change`,
+              "aria-label": "Colour scheme",
+              children: Ve === "system" ? "Auto" : Ve === "light" ? "Light" : "Dark"
+            }
+          ),
+          /* @__PURE__ */ h(
+            "button",
+            {
+              className: `gv-graph-toolbar-btn ${Nt ? "active" : ""}`,
+              onClick: Kn,
+              title: Nt ? "Pause simulation (Space)" : "Resume simulation (Space)",
+              children: Nt ? "Pause" : "Play"
+            }
+          ),
+          /* @__PURE__ */ C("span", { className: `gv-graph-count-fps${Nt ? "" : " hidden"}`, title: "Simulation frames per second", children: [
+            ii,
+            " fps"
+          ] })
+        ] }),
+        _.controls && /* @__PURE__ */ h(
+          rl,
+          {
+            params: Et,
+            resolved: It,
+            onParamChange: Cr,
+            onAdjust: Ar,
+            onRelayout: Un,
+            axes: Wn,
+            layoutAxes: Fr,
+            present: Xr,
+            onAxisChange: Dr,
+            onActiveSection: Ur,
+            onActivePushBucket: Wr,
+            onActiveGravityBucket: Qr,
+            onActivePullEdge: ti,
+            nodeScale: Ks,
+            onNodeScaleChange: _r
+          }
+        ),
+        a == null ? void 0 : a(ss, si),
+        _.shortcuts && ue && /* @__PURE__ */ C("div", { className: "gv-graph-shortcuts-panel", children: [
+          /* @__PURE__ */ C("div", { className: "gv-graph-shortcuts-title", children: [
+            "Keyboard Shortcuts",
+            /* @__PURE__ */ h("button", { className: "gv-graph-shortcuts-close", onClick: () => we(!1), children: "×" })
+          ] }),
+          /* @__PURE__ */ C("div", { className: "gv-graph-shortcuts-list", children: [
+            /* @__PURE__ */ h(vt, { keys: "Tab / Shift+Tab", desc: "Cycle focus" }),
+            /* @__PURE__ */ h(vt, { keys: "Enter", desc: "Select focused node" }),
+            /* @__PURE__ */ h(vt, { keys: "Escape", desc: "Deselect / close" }),
+            /* @__PURE__ */ h(vt, { keys: "Arrow keys", desc: "Pan viewport" }),
+            /* @__PURE__ */ h(vt, { keys: "+ / -", desc: "Zoom in / out" }),
+            /* @__PURE__ */ h(vt, { keys: "F", desc: "Fit to view" }),
+            _.search && /* @__PURE__ */ h(vt, { keys: "/", desc: "Open search" }),
+            /* @__PURE__ */ h(vt, { keys: "Space", desc: "Toggle simulation" }),
+            /* @__PURE__ */ h(vt, { keys: "Shift + hover", desc: "Upstream deps" }),
+            /* @__PURE__ */ h(vt, { keys: "?", desc: "This panel" })
+          ] })
+        ] })
+      ]
+    }
+  ) }) });
+});
+function $l({ diagnostics: e }) {
+  const t = e.filter((o) => o.severity === "error").length, n = e.length - t, s = [];
+  return t > 0 && s.push(`${t} graph error${t === 1 ? "" : "s"}`), n > 0 && s.push(`${n} graph warning${n === 1 ? "" : "s"}`), /* @__PURE__ */ C("details", { className: `gv-graph-diagnostics${t > 0 ? " has-errors" : ""}`, role: t > 0 ? "alert" : void 0, children: [
+    /* @__PURE__ */ C("summary", { children: [
+      s.join(", "),
+      t > 0 ? " — what is named is not drawn" : ""
+    ] }),
+    /* @__PURE__ */ h("ul", { children: e.map((o, i) => /* @__PURE__ */ C("li", { className: `gv-graph-diagnostic ${o.severity}`, children: [
+      /* @__PURE__ */ h("code", { children: o.code }),
+      o.message
+    ] }, i)) })
+  ] });
+}
+function Cl({ hoveredNodeId: e, simRef: t, visibleEdges: n, visibleIds: s, viewport: o, shiftHeld: i, directionLine: r, copies: c, nodeSummaries: a, nodeAction: l, hostNodeOf: d, onMouseEnter: u, onMouseLeave: v }) {
+  const M = Bt();
+  if (!e) return null;
+  const S = t.current;
+  if (!S) return null;
+  const p = S.getNode(e);
+  if (!p) return null;
+  const $ = p.parentId === void 0 ? void 0 : d(p.parentId) ?? S.getNode(p.parentId), D = M.contextLine(d(p.id) ?? p, $), x = D == null ? [] : Array.isArray(D) ? [...D] : [D], V = l(p), F = M.nodeStyleOf(p).icon, L = M.nodeStyleOf(p).summaryKind, y = L === "children" && a.get(e) || void 0, I = p.badges && p.badges.length > 0 ? p.badges.join(" ") : void 0;
+  let E = 0, O = 0;
+  for (const pe of n)
+    it(pe) || (pe.sourceId === e && E++, pe.targetId === e && O++);
+  const X = c.get(Vt(p)), N = X ? Array.from(X).filter((pe) => s.has(pe)) : [p.id], k = N.length, w = k > 1 ? N.indexOf(p.id) + 1 : 0, [R, z] = Ye(o, p.x, p.y);
+  return /* @__PURE__ */ C(
+    "div",
+    {
+      className: "gv-graph-hover-tooltip",
+      style: { left: R, top: z },
+      onMouseEnter: u,
+      onMouseLeave: v,
+      children: [
+        /* @__PURE__ */ C("div", { className: "gv-tooltip-identity", children: [
+          F && /* @__PURE__ */ h("span", { className: "gv-tooltip-type-icon", children: F }),
+          /* @__PURE__ */ h("span", { className: "gv-tooltip-name", children: p.name })
+        ] }),
+        x.map((pe, ke) => /* @__PURE__ */ h("div", { className: "gv-tooltip-parent", children: pe }, ke)),
+        y && /* @__PURE__ */ h("div", { className: "gv-tooltip-summary", children: y }),
+        I && /* @__PURE__ */ h("div", { className: "gv-tooltip-summary", children: I }),
+        k > 1 && /* @__PURE__ */ C("div", { className: "gv-tooltip-duplicates", title: "The same entity appears in more than one place. Hovering any copy marks all copies.", children: [
+          "copy ",
+          w,
+          " of ",
+          k
+        ] }),
+        L !== "none" && (E > 0 || O > 0) && /* @__PURE__ */ C("div", { className: "gv-tooltip-connections", children: [
+          E > 0 && /* @__PURE__ */ C("span", { className: "gv-tooltip-conn-out", children: [
+            "→",
+            E
+          ] }),
+          O > 0 && /* @__PURE__ */ C("span", { className: "gv-tooltip-conn-in", children: [
+            "←",
+            O
+          ] })
+        ] }),
+        r && /* @__PURE__ */ h("div", { className: "gv-tooltip-direction", children: i ? "dependents" : "dependencies" }),
+        V && /* @__PURE__ */ h(
+          "button",
+          {
+            className: "gv-tooltip-cross-view",
+            onClick: () => V.onSelect(p),
+            title: V.label,
+            children: V.label
+          }
+        )
+      ]
+    }
+  );
+}
+function vt({ keys: e, desc: t }) {
+  return /* @__PURE__ */ C("div", { className: "gv-graph-shortcut-row", children: [
+    /* @__PURE__ */ h("kbd", { className: "gv-graph-shortcut-key", children: e }),
+    /* @__PURE__ */ h("span", { className: "gv-graph-shortcut-desc", children: t })
+  ] });
+}
+function Jl({ items: e, active: t, enabled: n, onToggle: s, onEmphasize: o, title: i, className: r }) {
+  const c = g.useMemo(() => new Map(t.map((l) => [l.id, l.color])), [t]), a = g.useRef(o);
+  return a.current = o, g.useEffect(() => () => {
+    var l;
+    return (l = a.current) == null ? void 0 : l.call(a, null);
+  }, []), /* @__PURE__ */ C("div", { className: `gv-group-legend${r ? ` ${r}` : ""}`, onMouseLeave: o ? () => o(null) : void 0, children: [
+    i && /* @__PURE__ */ h("div", { className: "gv-group-legend-title", children: i }),
+    e.map((l) => {
+      const d = n === void 0 || n.has(l.id), u = c.get(l.id);
+      return /* @__PURE__ */ C(s ? "label" : "div", { className: `gv-group-legend-row${d ? "" : " off"}`, onMouseEnter: o ? () => o(l.id) : void 0, children: [
+        s && /* @__PURE__ */ h("input", { type: "checkbox", checked: d, onChange: () => s(l.id) }),
+        /* @__PURE__ */ h("span", { className: "gv-group-legend-swatch", style: { background: u ?? "transparent" } }),
+        /* @__PURE__ */ h("span", { className: "gv-group-legend-label", children: l.label }),
+        d && u === void 0 && /* @__PURE__ */ h("span", { className: "gv-group-legend-note", children: "not shown" })
+      ] }, l.id);
+    })
+  ] });
+}
+const $r = /* @__PURE__ */ new Set();
+function Do(e, t, n, s, o, i) {
+  const r = e[n], c = qo({
+    destination: r.filter,
+    source: e[s].filter,
+    locks: r.locks,
+    transition: o,
+    taxonomy: t,
+    axes: r.axes,
+    graph: i
+  }), a = c.overriddenLocks.size > 0 ? c.overriddenLocks : $r, l = a === r.overriddenLocks || a.size === 0 && r.overriddenLocks.size === 0;
+  return c.filter === r.filter && l ? { state: e, result: c } : { state: { ...e, [n]: { ...r, filter: c.filter, overriddenLocks: a } }, result: c };
+}
+function fn(e, t) {
+  const n = /* @__PURE__ */ Object.create(null);
+  for (const s of e) n[s] = t(s);
+  return n;
+}
+function jl({ taxonomy: e, views: t, initial: n, graph: s, start: o, initialSearch: i }) {
+  const r = g.useRef(fn(t, () => /* @__PURE__ */ new Set())), [c, a] = g.useState(() => fn(t, (k) => {
+    const w = n == null ? void 0 : n(k), R = Ps(e, s ?? { nodes: [] });
+    if ((w == null ? void 0 : w.filter) !== void 0) for (const z of Oi(R, w.filter)) r.current[k].add(z);
+    return {
+      filter: (w == null ? void 0 : w.filter) ?? R,
+      locks: (w == null ? void 0 : w.locks) ?? /* @__PURE__ */ new Map(),
+      axes: (w == null ? void 0 : w.axes) ?? e.filterAxes.map((z) => z.id),
+      overriddenLocks: $r
+    };
+  })), [l, d] = g.useState(() => o ?? t[0]), [u, v] = g.useState(() => i ?? { query: "", active: !1 }), [M, S] = g.useState(() => fn(t, () => null)), p = g.useRef(0), $ = Te(c), D = Te(l), x = Te(e), V = Te(s), F = t.join("\0"), L = g.useMemo(() => fn(t, (k) => ({
+    onFilterChange: (w, R = []) => {
+      for (const z of R) r.current[k].add(z);
+      a((z) => z[k].filter === w ? z : { ...z, [k]: { ...z[k], filter: w } });
+    },
+    onLocksChange: (w) => a((R) => R[k].locks === w ? R : { ...R, [k]: { ...R[k], locks: w } }),
+    onAxesChange: (w) => a((R) => R[k].axes === w ? R : { ...R, [k]: { ...R[k], axes: w } }),
+    onSearchChange: v,
+    // The request is spent once the pane reports it, so a pane that mounts
+    // again later does not act on it twice.
+    onFocusResult: (w) => S((R) => R[k] === w ? { ...R, [k]: null } : R)
+  })), [F]), y = g.useMemo(() => fn(t, (k) => ({ ...c[k], ...L[k], search: u, focus: M[k] })), [c, L, u, M]), I = g.useRef(s);
+  g.useEffect(() => {
+    I.current === s || s === void 0 || (I.current = s, a((k) => {
+      let w = !1;
+      const R = { ...k };
+      for (const z of Object.keys(k)) {
+        const pe = Yo(k[z].filter, x.current, s, r.current[z]);
+        pe !== k[z].filter && (w = !0, R[z] = { ...k[z], filter: pe });
+      }
+      return w ? R : k;
+    }));
+  }, [s]);
+  const E = g.useCallback((k, w = { kind: "manual" }) => {
+    const R = D.current, { state: z, result: pe } = Do($.current, x.current, k, R, w, V.current);
+    return $.current = z, a((ke) => Do(ke, x.current, k, R, w, V.current).state), D.current = k, d(k), pe;
+  }, [$, D, x, V]), O = g.useCallback((k, w) => {
+    const R = E(k, { kind: "focus", target: { values: w.values } });
+    return S((z) => ({ ...z, [k]: { id: w.id, key: ++p.current } })), R;
+  }, [E]), X = g.useCallback((k, w) => {
+    a((R) => {
+      const z = w(R[k].filter);
+      return z === R[k].filter ? R : { ...R, [k]: { ...R[k], filter: z } };
+    });
+  }, []), N = g.useCallback((k) => {
+    a((w) => {
+      let R = !1;
+      const z = { ...w };
+      for (const pe of Object.keys(w)) {
+        const ke = k(w[pe].filter, pe);
+        ke !== w[pe].filter && (R = !0, z[pe] = { ...w[pe], filter: ke });
+      }
+      return R ? z : w;
+    });
+  }, []);
+  return g.useMemo(() => ({
+    of: (k) => {
+      const w = c[k] === void 0 ? void 0 : y[k];
+      if (w === void 0) throw new Error(`useLinkedViews: no view ${JSON.stringify(k)}; the views (read once, at mount) are ${Object.keys(c).map((R) => JSON.stringify(R)).join(", ")}`);
+      return w;
+    },
+    active: l,
+    switchTo: E,
+    focus: O,
+    updateFilter: X,
+    updateFilters: N,
+    search: u,
+    state: c
+  }), [y, l, E, O, X, N, u, c]);
+}
+function ql() {
+  const [e, t] = g.useState(null), n = g.useRef(0), s = g.useCallback((o) => t(o === null ? null : { id: o, key: ++n.current }), []);
+  return [e, s];
+}
+const Al = {
+  label: "Unknown",
+  icon: "?",
+  color: { light: { fill: "#CBD5E1", border: "#94A3B8" }, dark: { fill: "#64748B", border: "#94A3B8" } },
+  size: { r: 10 },
+  summaryKind: "none"
+};
+function Ul(e) {
+  var at, lt, Ie, dt, De, ht;
+  const t = [], n = e.styles.map((b) => b.id), s = /* @__PURE__ */ new Set();
+  for (const b of n)
+    s.has(b) && t.push(`style value ${JSON.stringify(b)} is declared twice`), s.add(b);
+  const o = /* @__PURE__ */ new Map();
+  for (const b of n) o.set(Tn(b), (o.get(Tn(b)) ?? 0) + 1);
+  const i = /* @__PURE__ */ new Map();
+  n.forEach((b, T) => {
+    const U = Tn(b);
+    i.set(b, U !== "" && o.get(U) === 1 ? U : `v${T + 1}`);
+  });
+  const r = (b, T) => {
+    Ii(T) || t.push(`${b} is ${JSON.stringify(T)}, not a hex, rgb() or hsl() colour`);
+  }, c = (b, T) => {
+    T && !(T.min <= T.max) && t.push(`${b} runs from ${T.min} to ${T.max}; a band's min must not exceed its max`);
+  }, a = (b, T) => {
+    var U, se, G, oe;
+    for (const B of ["light", "dark"])
+      r(`${b}.color.${B}.fill`, T.color[B].fill), r(`${b}.color.${B}.border`, T.color[B].border);
+    T.whenHidden !== void 0 && T.whenHidden !== "ascend" && T.whenHidden !== "splice" && t.push(`${b}.whenHidden is ${JSON.stringify(T.whenHidden)}, not 'ascend' or 'splice'`), T.summaryKind !== void 0 && T.summaryKind !== "children" && T.summaryKind !== "degree" && T.summaryKind !== "none" && t.push(`${b}.summaryKind is ${JSON.stringify(T.summaryKind)}, not 'children', 'degree' or 'none'`), c(`${b}.physics.band.x`, (se = (U = T.physics) == null ? void 0 : U.band) == null ? void 0 : se.x), c(`${b}.physics.band.y`, (oe = (G = T.physics) == null ? void 0 : G.band) == null ? void 0 : oe.y);
+  };
+  for (const b of e.styles) a(`styles.${b.id}`, b);
+  const l = e.fallbackStyle ?? Al;
+  a("fallbackStyle", l);
+  const d = /* @__PURE__ */ new Set(), u = (b, T, U) => JSON.stringify(T <= U ? [b, T, U] : [b, U, T]), v = /* @__PURE__ */ new Map(), M = e.edgeTypes ?? [];
+  for (const b of M) {
+    d.has(b.id) && t.push(`edge type ${JSON.stringify(b.id)} is declared twice`), d.add(b.id), ((lt = (at = b.style) == null ? void 0 : at.color) == null ? void 0 : lt.light) !== void 0 && r(`edgeTypes.${b.id}.style.color.light`, b.style.color.light), ((dt = (Ie = b.style) == null ? void 0 : Ie.color) == null ? void 0 : dt.dark) !== void 0 && r(`edgeTypes.${b.id}.style.color.dark`, b.style.color.dark);
+    for (const T of ["sourceValue", "targetValue"]) {
+      const U = Mn(b[T]);
+      U.length === 0 && t.push(`edgeTypes.${b.id}.${T} names no value; name at least one`), U.forEach((se, G) => {
+        s.has(se) || t.push(`edgeTypes.${b.id}.${T}${U.length > 1 ? `[${G}]` : ""} is ${JSON.stringify(se)}, which styles does not declare`);
+      });
+    }
+    if (b.relation !== "containment" && b.relation !== "dependency" && t.push(`edgeTypes.${b.id}.relation is ${JSON.stringify(b.relation)}, not 'containment' or 'dependency'`), b.match !== void 0) {
+      Object.keys(b.match).length === 0 && t.push(`edgeTypes.${b.id}.match is empty; leave it out`);
+      for (const [T, U] of Object.entries(b.match))
+        typeof U != "string" && t.push(`edgeTypes.${b.id}.match.${T} is ${JSON.stringify(U)}, not a value`);
+    }
+    for (const [T, U] of hn(b)) {
+      const se = u(b.relation, T, U), G = v.get(se) ?? [];
+      G.includes(b) || G.push(b), v.set(se, G);
+    }
+  }
+  const S = (b, T) => {
+    if (b.match === void 0 || T.match === void 0) return b.match === T.match;
+    const U = Object.keys(b.match);
+    return U.length === Object.keys(T.match).length && U.every((se) => b.match[se] === T.match[se]);
+  };
+  if (!e.classifyEdge) {
+    const b = (U, se) => hn(U).some(([G, oe]) => hn(se).some(([B, f]) => G === B && oe === f)), T = /* @__PURE__ */ new Set();
+    for (const [U, se] of v)
+      for (let G = 0; G < se.length; G++)
+        for (let oe = G + 1; oe < se.length; oe++) {
+          const B = se[G], f = se[oe], q = `${B.id}\0${f.id}`;
+          T.has(q) || !b(B, f) || !S(B, f) || (T.add(q), t.push(`edge types ${JSON.stringify(B.id)} and ${JSON.stringify(f.id)} run between the same values with the same relation (${JSON.parse(U)[0]}) and nothing tells them apart; give one a match on an edge axis, declare them in opposite orientations, or give classifyEdge`));
+        }
+  }
+  const p = e.filterAxes ?? [{ id: e.styleAxis, label: e.styleLabel ?? e.styleAxis, emptyMeans: "none" }], $ = /* @__PURE__ */ new Set();
+  for (const b of p)
+    $.has(b.id) && t.push(`filter axis ${JSON.stringify(b.id)} is declared twice`), $.add(b.id), b.emptyMeans !== "all" && b.emptyMeans !== "none" && t.push(`filterAxes.${b.id}.emptyMeans is ${JSON.stringify(b.emptyMeans)}, not 'all' or 'none'`);
+  const D = [...sc, ...e.scalars ?? []].map(Ki), x = /* @__PURE__ */ new Set();
+  for (const b of D)
+    x.has(b.id) && t.push(`scalar ${JSON.stringify(b.id)} is declared twice (the built-ins are reach, degree and depth)`), x.add(b.id);
+  if (t.length > 0) throw new Error(`taxonomy is incoherent: ${t.join("; ")}`);
+  const V = e.styles.length, F = /* @__PURE__ */ Object.create(null);
+  e.styles.forEach((b, T) => {
+    F[b.id] = vo(b, T, V);
+  });
+  const L = vo({ id: "", ...l }, 0, 1);
+  V > 0 && ((ht = (De = l.physics) == null ? void 0 : De.band) == null ? void 0 : ht.y) === void 0 && (L.physics.band.y = { min: F[n[0]].physics.band.y.min, max: F[n[V - 1]].physics.band.y.max });
+  const y = M.map(ic), I = new Map(y.map((b) => [b.id, b.style])), E = /* @__PURE__ */ new Set(), O = (b) => {
+    const T = I.get(b);
+    return T || (E.has(b) || (E.add(b), console.warn(`[graph] edge type ${JSON.stringify(b)} has no stroke: the taxonomy does not declare it; drawing it neutral`)), wn);
+  }, X = (b, T) => {
+    var U;
+    for (const se of Object.keys(T)) if (((U = b.values) == null ? void 0 : U[se]) !== T[se]) return !1;
+    return !0;
+  }, N = (b, T, U) => {
+    var q;
+    if (T === void 0 || U === void 0) return;
+    const se = v.get(u(b.relation === "containment" ? "containment" : "dependency", T, U));
+    if (se === void 0) return;
+    const G = se.filter((te) => te.match === void 0 || X(b, te.match)), oe = G.filter((te) => te.match !== void 0), B = oe.length > 0 ? oe : G;
+    return (q = B.filter((te) => hn(te).some(([le, Ee]) => le === T && Ee === U))[0] ?? B[0]) == null ? void 0 : q.id;
+  }, k = (b, T, U) => {
+    var G;
+    const se = N(b, T, U);
+    return ((G = e.classifyEdge) == null ? void 0 : G.call(e, b, T, U, se)) ?? se;
+  }, w = /* @__PURE__ */ new Set(), R = (b) => {
+    const T = b !== void 0 && Rn(F, b) ? F[b] : void 0;
+    if (T !== void 0) return T;
+    const U = b ?? "<absent>";
+    return w.has(U) || (w.add(U), console.warn(
+      `[graph] no style declared for value ${JSON.stringify(U)}; using the fallback. The graph will render, but this node is drawn with placeholder styling.`
+    )), L;
+  }, { styleAxis: z } = e, pe = (b) => b.values[z], ke = (b) => Rn(F, b) ? F[b].abbreviation : b.slice(0, 2), St = {
+    axis: z,
+    labelFor: (b) => Rn(F, b) ? F[b].label : b,
+    abbreviationFor: ke,
+    iconFor: (b) => Rn(F, b) ? F[b].icon : ""
+  }, Ne = p.map((b) => mi(b, St)), ct = new Map(Ne.map((b) => [b.id, b]));
+  return {
+    styleAxis: () => z,
+    styleLabel: () => e.styleLabel ?? z,
+    filterAxes: Ne,
+    axisFor: (b) => ct.get(b),
+    valueOn: (b, T) => b.values[T],
+    abbreviationFor: ke,
+    styleValues: n,
+    edgeTypes: y,
+    scalars: D,
+    edgeStrokeFor: O,
+    colorVar: (b) => `--gv-node-${i.get(b) ?? (Tn(b) || "undeclared")}`,
+    styleOf: R,
+    styleValueOf: pe,
+    // Hot path: one property read, one record lookup, one branch. No allocation
+    // — this runs per node per frame in the draw loop.
+    nodeStyleOf: (b) => R(pe(b)),
+    edgeTypeOf: k,
+    collapse: e.collapse ?? ((b) => b),
+    contextLine: e.contextLine ?? ((b, T) => T == null ? void 0 : T.name),
+    searchText: e.searchText ?? ((b) => b.name),
+    highlight: e.highlight ?? ((b, T) => T)
+  };
+}
+function Kl(e) {
+  const { forces: t, nodeScale: n } = e;
+  return { forces: ur(t), nodeScale: { ...n } };
+}
+function Wl(e, t) {
+  if (!je(e)) return;
+  const n = ar(t), s = e.forces === void 0 ? n.forces : Bc(e.forces, n.forces, t);
+  if (!s) return;
+  const o = e.nodeScale === void 0 ? n.nodeScale : Hc(e.nodeScale, n.nodeScale);
+  if (o)
+    return zn(s, o);
+}
+export {
+  Jt as BAND_FRAME,
+  Ko as CONTAINMENT_STROKE,
+  Vi as FilterBar,
+  Yl as GraphView,
+  Jl as GroupLegend,
+  wn as NEUTRAL_STROKE,
+  _n as TaxonomyContext,
+  Gi as copyGroups,
+  _o as countsOn,
+  Ul as createTaxonomy,
+  Dl as filterFromJSON,
+  bn as filterStatesEqual,
+  Pl as filterToJSON,
+  Fi as hiddenMatchesOf,
+  Ps as initialFilter,
+  it as isContainment,
+  Wl as layoutFromJSON,
+  Kl as layoutToJSON,
+  Ls as lockedFor,
+  Bl as locksFromJSON,
+  _l as locksToJSON,
+  Hl as matchesFocus,
+  Pt as nodesById,
+  zl as passesSelection,
+  Xl as payloadNumber,
+  Gl as payloadString,
+  qo as reconcileFilter,
+  Yo as reseedFilter,
+  Ll as schemeStylesheet,
+  zo as schemeVars,
+  ze as selectionFor,
+  Fl as themeChoiceOf,
+  Li as toggleGroup,
+  Vl as toggleValue,
+  ql as useFocusRequest,
+  wi as useHostTheme,
+  jl as useLinkedViews,
+  Bt as useTaxonomy,
+  Nl as validateGraph,
+  sn as valuesOn,
+  Ai as withLock,
+  on as withSelection
+};
+//# sourceMappingURL=index.js.map