hub-ui-x 0.0.1

package/dist/dagre-OKDRZEBW-qXmKnSET.js

@@ -0,0 +1,447 @@
+import { _ as X, an as F, ao as Y, ap as _, aq as H, l as i, c as V, ar as q, as as U, ac as $, ah as z, ad as P, ab as K, at as Q, au as W, av as Z } from "./mermaid-CZvYCPmi.js";
+import { G as B } from "./graph-zFu0gYaZ.js";
+import { l as I } from "./layout-BqSq5ofg.js";
+import { i as x } from "./_baseUniq-CGQBVjq6.js";
+import { c as L } from "./clone-BZBtMp_G.js";
+import { m as A } from "./_basePickBy-C1WsytTM.js";
+function E(e) {
+  var t = {
+    options: {
+      directed: e.isDirected(),
+      multigraph: e.isMultigraph(),
+      compound: e.isCompound()
+    },
+    nodes: ee(e),
+    edges: ne(e)
+  };
+  return x(e.graph()) || (t.value = L(e.graph())), t;
+}
+function ee(e) {
+  return A(e.nodes(), function(t) {
+    var n = e.node(t), o = e.parent(t), c = { v: t };
+    return x(n) || (c.value = n), x(o) || (c.parent = o), c;
+  });
+}
+function ne(e) {
+  return A(e.edges(), function(t) {
+    var n = e.edge(t), o = { v: t.v, w: t.w };
+    return x(t.name) || (o.name = t.name), x(n) || (o.value = n), o;
+  });
+}
+var f = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), J = /* @__PURE__ */ new Map(), te = /* @__PURE__ */ X(() => {
+  b.clear(), J.clear(), f.clear();
+}, "clear"), O = /* @__PURE__ */ X((e, t) => {
+  const n = b.get(t) || [];
+  return i.trace("In isDescendant", t, " ", e, " = ", n.includes(e)), n.includes(e);
+}, "isDescendant"), se = /* @__PURE__ */ X((e, t) => {
+  const n = b.get(t) || [];
+  return i.info("Descendants of ", t, " is ", n), i.info("Edge is ", e), e.v === t || e.w === t ? !1 : n ? n.includes(e.v) || O(e.v, t) || O(e.w, t) || n.includes(e.w) : (i.debug("Tilt, ", t, ",not in descendants"), !1);
+}, "edgeInCluster"), G = /* @__PURE__ */ X((e, t, n, o) => {
+  i.warn(
+    "Copying children of ",
+    e,
+    "root",
+    o,
+    "data",
+    t.node(e),
+    o
+  );
+  const c = t.children(e) || [];
+  e !== o && c.push(e), i.warn("Copying (nodes) clusterId", e, "nodes", c), c.forEach((a) => {
+    if (t.children(a).length > 0)
+      G(a, t, n, o);
+    else {
+      const r = t.node(a);
+      i.info("cp ", a, " to ", o, " with parent ", e), n.setNode(a, r), o !== t.parent(a) && (i.warn("Setting parent", a, t.parent(a)), n.setParent(a, t.parent(a))), e !== o && a !== e ? (i.debug("Setting parent", a, e), n.setParent(a, e)) : (i.info("In copy ", e, "root", o, "data", t.node(e), o), i.debug(
+        "Not Setting parent for node=",
+        a,
+        "cluster!==rootId",
+        e !== o,
+        "node!==clusterId",
+        a !== e
+      ));
+      const u = t.edges(a);
+      i.debug("Copying Edges", u), u.forEach((l) => {
+        i.info("Edge", l);
+        const v = t.edge(l.v, l.w, l.name);
+        i.info("Edge data", v, o);
+        try {
+          se(l, o) ? (i.info("Copying as ", l.v, l.w, v, l.name), n.setEdge(l.v, l.w, v, l.name), i.info("newGraph edges ", n.edges(), n.edge(n.edges()[0]))) : i.info(
+            "Skipping copy of edge ",
+            l.v,
+            "-->",
+            l.w,
+            " rootId: ",
+            o,
+            " clusterId:",
+            e
+          );
+        } catch (C) {
+          i.error(C);
+        }
+      });
+    }
+    i.debug("Removing node", a), t.removeNode(a);
+  });
+}, "copy"), R = /* @__PURE__ */ X((e, t) => {
+  const n = t.children(e);
+  let o = [...n];
+  for (const c of n)
+    J.set(c, e), o = [...o, ...R(c, t)];
+  return o;
+}, "extractDescendants"), ie = /* @__PURE__ */ X((e, t, n) => {
+  const o = e.edges().filter((l) => l.v === t || l.w === t), c = e.edges().filter((l) => l.v === n || l.w === n), a = o.map((l) => ({ v: l.v === t ? n : l.v, w: l.w === t ? t : l.w })), r = c.map((l) => ({ v: l.v, w: l.w }));
+  return a.filter((l) => r.some((v) => l.v === v.v && l.w === v.w));
+}, "findCommonEdges"), D = /* @__PURE__ */ X((e, t, n) => {
+  const o = t.children(e);
+  if (i.trace("Searching children of id ", e, o), o.length < 1)
+    return e;
+  let c;
+  for (const a of o) {
+    const r = D(a, t, n), u = ie(t, n, r);
+    if (r)
+      if (u.length > 0)
+        c = r;
+      else
+        return r;
+  }
+  return c;
+}, "findNonClusterChild"), k = /* @__PURE__ */ X((e) => !f.has(e) || !f.get(e).externalConnections ? e : f.has(e) ? f.get(e).id : e, "getAnchorId"), re = /* @__PURE__ */ X((e, t) => {
+  if (!e || t > 10) {
+    i.debug("Opting out, no graph ");
+    return;
+  } else
+    i.debug("Opting in, graph ");
+  e.nodes().forEach(function(n) {
+    e.children(n).length > 0 && (i.warn(
+      "Cluster identified",
+      n,
+      " Replacement id in edges: ",
+      D(n, e, n)
+    ), b.set(n, R(n, e)), f.set(n, { id: D(n, e, n), clusterData: e.node(n) }));
+  }), e.nodes().forEach(function(n) {
+    const o = e.children(n), c = e.edges();
+    o.length > 0 ? (i.debug("Cluster identified", n, b), c.forEach((a) => {
+      const r = O(a.v, n), u = O(a.w, n);
+      r ^ u && (i.warn("Edge: ", a, " leaves cluster ", n), i.warn("Descendants of XXX ", n, ": ", b.get(n)), f.get(n).externalConnections = !0);
+    })) : i.debug("Not a cluster ", n, b);
+  });
+  for (let n of f.keys()) {
+    const o = f.get(n).id, c = e.parent(o);
+    c !== n && f.has(c) && !f.get(c).externalConnections && (f.get(n).id = c);
+  }
+  e.edges().forEach(function(n) {
+    const o = e.edge(n);
+    i.warn("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(n)), i.warn("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(e.edge(n)));
+    let c = n.v, a = n.w;
+    if (i.warn(
+      "Fix XXX",
+      f,
+      "ids:",
+      n.v,
+      n.w,
+      "Translating: ",
+      f.get(n.v),
+      " --- ",
+      f.get(n.w)
+    ), f.get(n.v) || f.get(n.w)) {
+      if (i.warn("Fixing and trying - removing XXX", n.v, n.w, n.name), c = k(n.v), a = k(n.w), e.removeEdge(n.v, n.w, n.name), c !== n.v) {
+        const r = e.parent(c);
+        f.get(r).externalConnections = !0, o.fromCluster = n.v;
+      }
+      if (a !== n.w) {
+        const r = e.parent(a);
+        f.get(r).externalConnections = !0, o.toCluster = n.w;
+      }
+      i.warn("Fix Replacing with XXX", c, a, n.name), e.setEdge(c, a, o, n.name);
+    }
+  }), i.warn("Adjusted Graph", E(e)), T(e, 0), i.trace(f);
+}, "adjustClustersAndEdges"), T = /* @__PURE__ */ X((e, t) => {
+  var c, a;
+  if (i.warn("extractor - ", t, E(e), e.children("D")), t > 10) {
+    i.error("Bailing out");
+    return;
+  }
+  let n = e.nodes(), o = !1;
+  for (const r of n) {
+    const u = e.children(r);
+    o = o || u.length > 0;
+  }
+  if (!o) {
+    i.debug("Done, no node has children", e.nodes());
+    return;
+  }
+  i.debug("Nodes = ", n, t);
+  for (const r of n)
+    if (i.debug(
+      "Extracting node",
+      r,
+      f,
+      f.has(r) && !f.get(r).externalConnections,
+      !e.parent(r),
+      e.node(r),
+      e.children("D"),
+      " Depth ",
+      t
+    ), !f.has(r))
+      i.debug("Not a cluster", r, t);
+    else if (!f.get(r).externalConnections && e.children(r) && e.children(r).length > 0) {
+      i.warn(
+        "Cluster without external connections, without a parent and with children",
+        r,
+        t
+      );
+      let l = e.graph().rankdir === "TB" ? "LR" : "TB";
+      (a = (c = f.get(r)) == null ? void 0 : c.clusterData) != null && a.dir && (l = f.get(r).clusterData.dir, i.warn("Fixing dir", f.get(r).clusterData.dir, l));
+      const v = new B({
+        multigraph: !0,
+        compound: !0
+      }).setGraph({
+        rankdir: l,
+        nodesep: 50,
+        ranksep: 50,
+        marginx: 8,
+        marginy: 8
+      }).setDefaultEdgeLabel(function() {
+        return {};
+      });
+      i.warn("Old graph before copy", E(e)), G(r, e, v, r), e.setNode(r, {
+        clusterNode: !0,
+        id: r,
+        clusterData: f.get(r).clusterData,
+        label: f.get(r).label,
+        graph: v
+      }), i.warn("New graph after copy node: (", r, ")", E(v)), i.debug("Old graph after copy", E(e));
+    } else
+      i.warn(
+        "Cluster ** ",
+        r,
+        " **not meeting the criteria !externalConnections:",
+        !f.get(r).externalConnections,
+        " no parent: ",
+        !e.parent(r),
+        " children ",
+        e.children(r) && e.children(r).length > 0,
+        e.children("D"),
+        t
+      ), i.debug(f);
+  n = e.nodes(), i.warn("New list of nodes", n);
+  for (const r of n) {
+    const u = e.node(r);
+    i.warn(" Now next level", r, u), u != null && u.clusterNode && T(u.graph, t + 1);
+  }
+}, "extractor"), M = /* @__PURE__ */ X((e, t) => {
+  if (t.length === 0)
+    return [];
+  let n = Object.assign([], t);
+  return t.forEach((o) => {
+    const c = e.children(o), a = M(e, c);
+    n = [...n, ...a];
+  }), n;
+}, "sorter"), oe = /* @__PURE__ */ X((e) => M(e, e.children()), "sortNodesByHierarchy"), j = /* @__PURE__ */ X(async (e, t, n, o, c, a) => {
+  i.warn("Graph in recursive render:XAX", E(t), c);
+  const r = t.graph().rankdir;
+  i.trace("Dir in recursive render - dir:", r);
+  const u = e.insert("g").attr("class", "root");
+  t.nodes() ? i.info("Recursive render XXX", t.nodes()) : i.info("No nodes found for", t), t.edges().length > 0 && i.info("Recursive edges", t.edge(t.edges()[0]));
+  const l = u.insert("g").attr("class", "clusters"), v = u.insert("g").attr("class", "edgePaths"), C = u.insert("g").attr("class", "edgeLabels"), g = u.insert("g").attr("class", "nodes");
+  await Promise.all(
+    t.nodes().map(async function(d) {
+      const s = t.node(d);
+      if (c !== void 0) {
+        const w = JSON.parse(JSON.stringify(c.clusterData));
+        i.trace(
+          `Setting data for parent cluster XXX
+ Node.id = `,
+          d,
+          `
+ data=`,
+          w.height,
+          `
+Parent cluster`,
+          c.height
+        ), t.setNode(c.id, w), t.parent(d) || (i.trace("Setting parent", d, c.id), t.setParent(d, c.id, w));
+      }
+      if (i.info("(Insert) Node XXX" + d + ": " + JSON.stringify(t.node(d))), s != null && s.clusterNode) {
+        i.info("Cluster identified XBX", d, s.width, t.node(d));
+        const { ranksep: w, nodesep: m } = t.graph();
+        s.graph.setGraph({
+          ...s.graph.graph(),
+          ranksep: w + 25,
+          nodesep: m
+        });
+        const N = await j(
+          g,
+          s.graph,
+          n,
+          o,
+          t.node(d),
+          a
+        ), S = N.elem;
+        q(s, S), s.diff = N.diff || 0, i.info(
+          "New compound node after recursive render XAX",
+          d,
+          "width",
+          // node,
+          s.width,
+          "height",
+          s.height
+          // node.x,
+          // node.y
+        ), U(S, s);
+      } else
+        t.children(d).length > 0 ? (i.trace(
+          "Cluster - the non recursive path XBX",
+          d,
+          s.id,
+          s,
+          s.width,
+          "Graph:",
+          t
+        ), i.trace(D(s.id, t)), f.set(s.id, { id: D(s.id, t), node: s })) : (i.trace("Node - the non recursive path XAX", d, g, t.node(d), r), await $(g, t.node(d), { config: a, dir: r }));
+    })
+  ), await (/* @__PURE__ */ X(async () => {
+    const d = t.edges().map(async function(s) {
+      const w = t.edge(s.v, s.w, s.name);
+      i.info("Edge " + s.v + " -> " + s.w + ": " + JSON.stringify(s)), i.info("Edge " + s.v + " -> " + s.w + ": ", s, " ", JSON.stringify(t.edge(s))), i.info(
+        "Fix",
+        f,
+        "ids:",
+        s.v,
+        s.w,
+        "Translating: ",
+        f.get(s.v),
+        f.get(s.w)
+      ), await Z(C, w);
+    });
+    await Promise.all(d);
+  }, "processEdges"))(), i.info("Graph before layout:", JSON.stringify(E(t))), i.info("############################################# XXX"), i.info("###                Layout                 ### XXX"), i.info("############################################# XXX"), I(t), i.info("Graph after layout:", JSON.stringify(E(t)));
+  let p = 0, { subGraphTitleTotalMargin: y } = z(a);
+  return await Promise.all(
+    oe(t).map(async function(d) {
+      var w;
+      const s = t.node(d);
+      if (i.info(
+        "Position XBX => " + d + ": (" + s.x,
+        "," + s.y,
+        ") width: ",
+        s.width,
+        " height: ",
+        s.height
+      ), s != null && s.clusterNode)
+        s.y += y, i.info(
+          "A tainted cluster node XBX1",
+          d,
+          s.id,
+          s.width,
+          s.height,
+          s.x,
+          s.y,
+          t.parent(d)
+        ), f.get(s.id).node = s, P(s);
+      else if (t.children(d).length > 0) {
+        i.info(
+          "A pure cluster node XBX1",
+          d,
+          s.id,
+          s.x,
+          s.y,
+          s.width,
+          s.height,
+          t.parent(d)
+        ), s.height += y, t.node(s.parentId);
+        const m = (s == null ? void 0 : s.padding) / 2 || 0, N = ((w = s == null ? void 0 : s.labelBBox) == null ? void 0 : w.height) || 0, S = N - m || 0;
+        i.debug("OffsetY", S, "labelHeight", N, "halfPadding", m), await K(l, s), f.get(s.id).node = s;
+      } else {
+        const m = t.node(s.parentId);
+        s.y += y / 2, i.info(
+          "A regular node XBX1 - using the padding",
+          s.id,
+          "parent",
+          s.parentId,
+          s.width,
+          s.height,
+          s.x,
+          s.y,
+          "offsetY",
+          s.offsetY,
+          "parent",
+          m,
+          m == null ? void 0 : m.offsetY,
+          s
+        ), P(s);
+      }
+    })
+  ), t.edges().forEach(function(d) {
+    const s = t.edge(d);
+    i.info("Edge " + d.v + " -> " + d.w + ": " + JSON.stringify(s), s), s.points.forEach((S) => S.y += y / 2);
+    const w = t.node(d.v);
+    var m = t.node(d.w);
+    const N = Q(v, s, f, n, w, m, o);
+    W(s, N);
+  }), t.nodes().forEach(function(d) {
+    const s = t.node(d);
+    i.info(d, s.type, s.diff), s.isGroup && (p = s.diff);
+  }), i.warn("Returning from recursive render XAX", u, p), { elem: u, diff: p };
+}, "recursiveRender"), ge = /* @__PURE__ */ X(async (e, t) => {
+  var a, r, u, l, v, C;
+  const n = new B({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: e.direction,
+    nodesep: ((a = e.config) == null ? void 0 : a.nodeSpacing) || ((u = (r = e.config) == null ? void 0 : r.flowchart) == null ? void 0 : u.nodeSpacing) || e.nodeSpacing,
+    ranksep: ((l = e.config) == null ? void 0 : l.rankSpacing) || ((C = (v = e.config) == null ? void 0 : v.flowchart) == null ? void 0 : C.rankSpacing) || e.rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  }), o = t.select("g");
+  F(o, e.markers, e.type, e.diagramId), Y(), _(), H(), te(), e.nodes.forEach((g) => {
+    n.setNode(g.id, { ...g }), g.parentId && n.setParent(g.id, g.parentId);
+  }), i.debug("Edges:", e.edges), e.edges.forEach((g) => {
+    if (g.start === g.end) {
+      const h = g.start, p = h + "---" + h + "---1", y = h + "---" + h + "---2", d = n.node(h);
+      n.setNode(p, {
+        domId: p,
+        id: p,
+        parentId: d.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      }), n.setParent(p, d.parentId), n.setNode(y, {
+        domId: y,
+        id: y,
+        parentId: d.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      }), n.setParent(y, d.parentId);
+      const s = structuredClone(g), w = structuredClone(g), m = structuredClone(g);
+      s.label = "", s.arrowTypeEnd = "none", s.id = h + "-cyclic-special-1", w.arrowTypeStart = "none", w.arrowTypeEnd = "none", w.id = h + "-cyclic-special-mid", m.label = "", d.isGroup && (s.fromCluster = h, m.toCluster = h), m.id = h + "-cyclic-special-2", m.arrowTypeStart = "none", n.setEdge(h, p, s, h + "-cyclic-special-0"), n.setEdge(p, y, w, h + "-cyclic-special-1"), n.setEdge(y, h, m, h + "-cyc<lic-special-2");
+    } else
+      n.setEdge(g.start, g.end, { ...g }, g.id);
+  }), i.warn("Graph at first:", JSON.stringify(E(n))), re(n), i.warn("Graph after XAX:", JSON.stringify(E(n)));
+  const c = V();
+  await j(
+    o,
+    n,
+    e.type,
+    e.diagramId,
+    void 0,
+    c
+  );
+}, "render");
+export {
+  ge as render
+};

package/dist/diagram-SSKATNLV-D9zp03W0.js

@@ -0,0 +1,221 @@
+import { p as k } from "./chunk-4BMEZGHF-BBaiA8MA.js";
+import { _ as l, s as I, g as R, p as E, o as _, a as D, b as F, G, x as P, C as y, D as C, E as z, l as V, I as W } from "./mermaid-CZvYCPmi.js";
+import { p as B } from "./mermaid-parser.core-Bz7ADZ88.js";
+var x = {
+  showLegend: !0,
+  ticks: 5,
+  max: null,
+  min: 0,
+  graticule: "circle"
+}, w = {
+  axes: [],
+  curves: [],
+  options: x
+}, h = structuredClone(w), H = z.radar, j = /* @__PURE__ */ l(() => y({
+  ...H,
+  ...C().radar
+}), "getConfig"), b = /* @__PURE__ */ l(() => h.axes, "getAxes"), N = /* @__PURE__ */ l(() => h.curves, "getCurves"), U = /* @__PURE__ */ l(() => h.options, "getOptions"), X = /* @__PURE__ */ l((a) => {
+  h.axes = a.map((t) => ({
+    name: t.name,
+    label: t.label ?? t.name
+  }));
+}, "setAxes"), Y = /* @__PURE__ */ l((a) => {
+  h.curves = a.map((t) => ({
+    name: t.name,
+    label: t.label ?? t.name,
+    entries: Z(t.entries)
+  }));
+}, "setCurves"), Z = /* @__PURE__ */ l((a) => {
+  if (a[0].axis == null)
+    return a.map((e) => e.value);
+  const t = b();
+  if (t.length === 0)
+    throw new Error("Axes must be populated before curves for reference entries");
+  return t.map((e) => {
+    const r = a.find((s) => {
+      var o;
+      return ((o = s.axis) == null ? void 0 : o.$refText) === e.name;
+    });
+    if (r === void 0)
+      throw new Error("Missing entry for axis " + e.label);
+    return r.value;
+  });
+}, "computeCurveEntries"), q = /* @__PURE__ */ l((a) => {
+  var e, r, s, o, i;
+  const t = a.reduce(
+    (n, c) => (n[c.name] = c, n),
+    {}
+  );
+  h.options = {
+    showLegend: ((e = t.showLegend) == null ? void 0 : e.value) ?? x.showLegend,
+    ticks: ((r = t.ticks) == null ? void 0 : r.value) ?? x.ticks,
+    max: ((s = t.max) == null ? void 0 : s.value) ?? x.max,
+    min: ((o = t.min) == null ? void 0 : o.value) ?? x.min,
+    graticule: ((i = t.graticule) == null ? void 0 : i.value) ?? x.graticule
+  };
+}, "setOptions"), J = /* @__PURE__ */ l(() => {
+  P(), h = structuredClone(w);
+}, "clear"), $ = {
+  getAxes: b,
+  getCurves: N,
+  getOptions: U,
+  setAxes: X,
+  setCurves: Y,
+  setOptions: q,
+  getConfig: j,
+  clear: J,
+  setAccTitle: F,
+  getAccTitle: D,
+  setDiagramTitle: _,
+  getDiagramTitle: E,
+  getAccDescription: R,
+  setAccDescription: I
+}, K = /* @__PURE__ */ l((a) => {
+  k(a, $);
+  const { axes: t, curves: e, options: r } = a;
+  $.setAxes(t), $.setCurves(e), $.setOptions(r);
+}, "populate"), Q = {
+  parse: /* @__PURE__ */ l(async (a) => {
+    const t = await B("radar", a);
+    V.debug(t), K(t);
+  }, "parse")
+}, tt = /* @__PURE__ */ l((a, t, e, r) => {
+  const s = r.db, o = s.getAxes(), i = s.getCurves(), n = s.getOptions(), c = s.getConfig(), d = s.getDiagramTitle(), p = G(t), u = et(p, c), g = n.max ?? Math.max(...i.map((f) => Math.max(...f.entries))), m = n.min, v = Math.min(c.width, c.height) / 2;
+  at(u, o, v, n.ticks, n.graticule), rt(u, o, v, c), M(u, o, i, m, g, n.graticule, c), T(u, i, n.showLegend, c), u.append("text").attr("class", "radarTitle").text(d).attr("x", 0).attr("y", -c.height / 2 - c.marginTop);
+}, "draw"), et = /* @__PURE__ */ l((a, t) => {
+  const e = t.width + t.marginLeft + t.marginRight, r = t.height + t.marginTop + t.marginBottom, s = {
+    x: t.marginLeft + t.width / 2,
+    y: t.marginTop + t.height / 2
+  };
+  return a.attr("viewbox", `0 0 ${e} ${r}`).attr("width", e).attr("height", r), a.append("g").attr("transform", `translate(${s.x}, ${s.y})`);
+}, "drawFrame"), at = /* @__PURE__ */ l((a, t, e, r, s) => {
+  if (s === "circle")
+    for (let o = 0; o < r; o++) {
+      const i = e * (o + 1) / r;
+      a.append("circle").attr("r", i).attr("class", "radarGraticule");
+    }
+  else if (s === "polygon") {
+    const o = t.length;
+    for (let i = 0; i < r; i++) {
+      const n = e * (i + 1) / r, c = t.map((d, p) => {
+        const u = 2 * p * Math.PI / o - Math.PI / 2, g = n * Math.cos(u), m = n * Math.sin(u);
+        return `${g},${m}`;
+      }).join(" ");
+      a.append("polygon").attr("points", c).attr("class", "radarGraticule");
+    }
+  }
+}, "drawGraticule"), rt = /* @__PURE__ */ l((a, t, e, r) => {
+  const s = t.length;
+  for (let o = 0; o < s; o++) {
+    const i = t[o].label, n = 2 * o * Math.PI / s - Math.PI / 2;
+    a.append("line").attr("x1", 0).attr("y1", 0).attr("x2", e * r.axisScaleFactor * Math.cos(n)).attr("y2", e * r.axisScaleFactor * Math.sin(n)).attr("class", "radarAxisLine"), a.append("text").text(i).attr("x", e * r.axisLabelFactor * Math.cos(n)).attr("y", e * r.axisLabelFactor * Math.sin(n)).attr("class", "radarAxisLabel");
+  }
+}, "drawAxes");
+function M(a, t, e, r, s, o, i) {
+  const n = t.length, c = Math.min(i.width, i.height) / 2;
+  e.forEach((d, p) => {
+    if (d.entries.length !== n)
+      return;
+    const u = d.entries.map((g, m) => {
+      const v = 2 * Math.PI * m / n - Math.PI / 2, f = A(g, r, s, c), O = f * Math.cos(v), S = f * Math.sin(v);
+      return { x: O, y: S };
+    });
+    o === "circle" ? a.append("path").attr("d", L(u, i.curveTension)).attr("class", `radarCurve-${p}`) : o === "polygon" && a.append("polygon").attr("points", u.map((g) => `${g.x},${g.y}`).join(" ")).attr("class", `radarCurve-${p}`);
+  });
+}
+l(M, "drawCurves");
+function A(a, t, e, r) {
+  const s = Math.min(Math.max(a, t), e);
+  return r * (s - t) / (e - t);
+}
+l(A, "relativeRadius");
+function L(a, t) {
+  const e = a.length;
+  let r = `M${a[0].x},${a[0].y}`;
+  for (let s = 0; s < e; s++) {
+    const o = a[(s - 1 + e) % e], i = a[s], n = a[(s + 1) % e], c = a[(s + 2) % e], d = {
+      x: i.x + (n.x - o.x) * t,
+      y: i.y + (n.y - o.y) * t
+    }, p = {
+      x: n.x - (c.x - i.x) * t,
+      y: n.y - (c.y - i.y) * t
+    };
+    r += ` C${d.x},${d.y} ${p.x},${p.y} ${n.x},${n.y}`;
+  }
+  return `${r} Z`;
+}
+l(L, "closedRoundCurve");
+function T(a, t, e, r) {
+  if (!e)
+    return;
+  const s = (r.width / 2 + r.marginRight) * 3 / 4, o = -(r.height / 2 + r.marginTop) * 3 / 4, i = 20;
+  t.forEach((n, c) => {
+    const d = a.append("g").attr("transform", `translate(${s}, ${o + c * i})`);
+    d.append("rect").attr("width", 12).attr("height", 12).attr("class", `radarLegendBox-${c}`), d.append("text").attr("x", 16).attr("y", 0).attr("class", "radarLegendText").text(n.label);
+  });
+}
+l(T, "drawLegend");
+var st = { draw: tt }, nt = /* @__PURE__ */ l((a, t) => {
+  let e = "";
+  for (let r = 0; r < a.THEME_COLOR_LIMIT; r++) {
+    const s = a[`cScale${r}`];
+    e += `
+		.radarCurve-${r} {
+			color: ${s};
+			fill: ${s};
+			fill-opacity: ${t.curveOpacity};
+			stroke: ${s};
+			stroke-width: ${t.curveStrokeWidth};
+		}
+		.radarLegendBox-${r} {
+			fill: ${s};
+			fill-opacity: ${t.curveOpacity};
+			stroke: ${s};
+		}
+		`;
+  }
+  return e;
+}, "genIndexStyles"), ot = /* @__PURE__ */ l((a) => {
+  const t = W(), e = C(), r = y(t, e.themeVariables), s = y(r.radar, a);
+  return { themeVariables: r, radarOptions: s };
+}, "buildRadarStyleOptions"), it = /* @__PURE__ */ l(({ radar: a } = {}) => {
+  const { themeVariables: t, radarOptions: e } = ot(a);
+  return `
+	.radarTitle {
+		font-size: ${t.fontSize};
+		color: ${t.titleColor};
+		dominant-baseline: hanging;
+		text-anchor: middle;
+	}
+	.radarAxisLine {
+		stroke: ${e.axisColor};
+		stroke-width: ${e.axisStrokeWidth};
+	}
+	.radarAxisLabel {
+		dominant-baseline: middle;
+		text-anchor: middle;
+		font-size: ${e.axisLabelFontSize}px;
+		color: ${e.axisColor};
+	}
+	.radarGraticule {
+		fill: ${e.graticuleColor};
+		fill-opacity: ${e.graticuleOpacity};
+		stroke: ${e.graticuleColor};
+		stroke-width: ${e.graticuleStrokeWidth};
+	}
+	.radarLegendText {
+		text-anchor: start;
+		font-size: ${e.legendFontSize}px;
+		dominant-baseline: hanging;
+	}
+	${nt(t, e)}
+	`;
+}, "styles"), ut = {
+  parser: Q,
+  db: $,
+  renderer: st,
+  styles: it
+};
+export {
+  ut as diagram
+};