@graphysdk/theme-shiny 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1131 @@
+import { GROUP_VARIABLES as Ot, buildPolarBarArcPath as Et, createAreaPathGenerators as Tt, createLinePathGenerator as Lt, createStableCellKeyGenerator as _t, createStableKeyGenerator as G, defineGeomRenderer as T, getAngleExtent as kt, getBarRectBounds as Pt, getPaintedTileRect as It, getRadiusExtent as pt, getStackRole as Ht, getX as M, getXMax as Ft, getXMin as Wt, getY as b, getYMax as ut, getYMin as Gt, polarToUnit as gt, prepareAreaObservations as Mt, prepareLineObservations as bt, readMainAxis as Z, style as s, toPaintColor as Bt, toStrokeDasharray as Nt, toViewBoxX as Dt, toViewBoxY as Yt, useGeomStyleReader as Y } from "@graphysdk/react";
+import { useId as zt, useMemo as k } from "react";
+import { Fragment as Vt, jsx as o, jsxs as m } from "react/jsx-runtime";
+var Ut = 90, jt = 41, Zt = 0.12, Kt = 0.38, Xt = 0.4, Jt = 0.8, qt = 0.16, Qt = (t) => {
+  let e = t;
+  return () => {
+    e = e + 1831565813 | 0;
+    let r = Math.imul(e ^ e >>> 15, 1 | e);
+    return r = r + Math.imul(r ^ r >>> 7, 61 | r) ^ r, ((r ^ r >>> 14) >>> 0) / 4294967296;
+  };
+}, te = ({ ground: t, star: e, bloom: r }) => {
+  const a = Qt(jt), i = Array.from({ length: Ut }, () => {
+    const l = a() * 100, c = a() * 100, p = Xt + a() ** 3 * Jt, h = Zt + a() * Kt;
+    return `<circle cx="${l.toFixed(2)}%" cy="${c.toFixed(2)}%" r="${p.toFixed(2)}" fill="${e}" fill-opacity="${h.toFixed(2)}"/>`;
+  }), n = r.length - 1, d = `<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%"><defs><radialGradient id="b" cx="1" cy="0" r="0.9">${r.map((l, c) => {
+    const p = c / n * 0.7, h = qt * (1 - c / r.length);
+    return `<stop offset="${p.toFixed(2)}" stop-color="${l}" stop-opacity="${h.toFixed(3)}"/>`;
+  }).join("")}<stop offset="1" stop-color="${t}" stop-opacity="0"/></radialGradient></defs><rect width="100%" height="100%" fill="${t}"/><rect width="100%" height="100%" fill="url(#b)"/>` + i.join("") + "</svg>";
+  return `data:image/svg+xml,${encodeURIComponent(d)}`;
+};
+var K = 0.32, H = 6, ee = 0.22, X = 0.08, re = 0.55, ae = 1.75, ne = 1.25, ie = 0.3, oe = 0.7, se = (t) => t.map((e, r) => `<stop offset="${(r / (t.length - 1)).toFixed(3)}" stop-color="${e}"/>`).join(""), F = (t, e, r) => `<rect x="${t}" y="${t}" rx="${Math.max(0, e - t)}" style="width:calc(100% - ${t * 2}px);height:calc(100% - ${t * 2}px)" fill="none" ${r}/>`, de = (t, { foil: e, shade: r, light: a }) => {
+  const n = H / 2, d = `<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%"><defs><linearGradient id="foil" x1="0" y1="0" x2="${K}" y2="${K}" spreadMethod="reflect">${se(e)}</linearGradient><linearGradient id="streak" x1="0" y1="1" x2="${X}" y2="${1 - X}" spreadMethod="repeat"><stop offset="0" stop-color="${a}" stop-opacity="0"/><stop offset="0.12" stop-color="${a}" stop-opacity="${re}"/><stop offset="0.24" stop-color="${a}" stop-opacity="0"/><stop offset="1" stop-color="${a}" stop-opacity="0"/></linearGradient><pattern id="plate" width="${H}" height="${H}" patternUnits="userSpaceOnUse"><path d="M${n},0 L${H},${n} L${n},${H} L0,${n} Z" fill="${a}" fill-opacity="${ee}"/></pattern><linearGradient id="catch" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="${a}" stop-opacity="0.95"/><stop offset="${ie}" stop-color="${a}" stop-opacity="0"/></linearGradient></defs>` + F(4.5, t, 'stroke="url(#foil)" stroke-width="9"') + F(4.5, t, 'stroke="url(#plate)" stroke-width="9"') + F(4.5, t, 'stroke="url(#streak)" stroke-width="9"') + F(ae, t, `stroke="url(#catch)" stroke-width="${ne}"`) + F(9.5, t, `stroke="${r}" stroke-opacity="${oe}" stroke-width="1"`) + "</svg>";
+  return `data:image/svg+xml,${encodeURIComponent(d)}`;
+}, A = {
+  pulse: "#E94FF3",
+  nebula: "#EC9BFF",
+  starlight: "#FFFBFF",
+  sirius: "#9AF2FF",
+  lagoon: "#9F98FF",
+  void: "#0C0B0F",
+  obsidian: "#1A1721"
+}, L = [
+  "#B9A2FF",
+  "#FF9DE4",
+  "#8DEEFF",
+  "#9FFCCD",
+  "#C6ADFF"
+], w = {
+  ground: A.obsidian,
+  window: "#121017",
+  text: A.starlight,
+  secondary: "#B3ABC4",
+  edge: "rgba(255, 251, 255, 0.12)",
+  grid: "rgba(236, 155, 255, 0.11)",
+  baseline: "rgba(255, 251, 255, 0.32)",
+  star: A.starlight,
+  accent: A.pulse,
+  accentEdge: "rgba(233, 79, 243, 0.6)"
+};
+var le = "'Inter Tight', 'Inter', ui-sans-serif, system-ui, sans-serif", ft = "'JetBrains Mono', 'IBM Plex Mono', ui-monospace, monospace", ce = "#A8F5C9", he = [
+  A.pulse,
+  A.sirius,
+  A.lagoon,
+  A.nebula,
+  ce,
+  A.starlight
+], pe = [
+  "#33205C",
+  "#8C3FD2",
+  A.pulse,
+  "#FFD9FB"
+], ue = 0.88, ge = 0.4, J = { fontFamily: le }, y = { fontFamily: ft }, fe = {
+  gradient: "linear",
+  angle: 135,
+  stops: L.map((t, e) => ({
+    offset: e / (L.length - 1),
+    color: t
+  }))
+}, ve = {
+  card: te({
+    ground: w.ground,
+    star: w.star,
+    bloom: L
+  }),
+  ground: w.ground,
+  edge: w.edge,
+  text: w.text,
+  secondary: w.secondary,
+  grid: w.grid,
+  baseline: w.baseline,
+  accent: w.accent,
+  accentEdge: w.accentEdge,
+  window: w.window,
+  windowGlow: "rgba(233, 79, 243, 0.18)",
+  hoverGuideFill: "rgba(236, 155, 255, 0.07)",
+  tooltipPrimaryRow: "rgba(233, 79, 243, 0.12)",
+  washAlpha: 0.16
+}, me = (t, e) => {
+  const r = { textColor: t.text }, a = { textColor: t.secondary }, i = {
+    offsetX: 0,
+    offsetY: 8,
+    blur: 24,
+    color: t.windowGlow
+  }, n = {
+    ...r,
+    ...y,
+    fontWeight: 500,
+    fontSize: 12,
+    fill: t.window,
+    stroke: t.accentEdge,
+    strokeWidth: 1,
+    cornerRadius: 8,
+    shadow: i
+  };
+  return {
+    tokens: {
+      graphBackground: t.ground,
+      graphBorder: t.edge,
+      geom: A.pulse,
+      geomBorder: t.secondary,
+      textPrimary: t.text,
+      textSecondary: t.secondary,
+      ruleLine: t.accent,
+      gridLine: t.grid,
+      hoverAffordance: t.text,
+      hoverGuideFill: t.hoverGuideFill,
+      hoverGuideLine: t.accentEdge,
+      tooltipBackground: t.window,
+      tooltipBorder: t.accentEdge,
+      tooltipPrimaryRow: t.tooltipPrimaryRow,
+      annotationShape: A.nebula,
+      annotationArrow: t.accent,
+      differenceLabelBackground: t.window
+    },
+    defaults: [
+      s.graph({
+        fill: {
+          image: t.card,
+          fit: "stretch",
+          fallback: t.ground
+        },
+        stroke: t.edge,
+        strokeWidth: 1,
+        cornerRadius: 20,
+        fontFamily: ft,
+        padding: 28
+      }),
+      s.geom({ shadow: "none" }),
+      s.geom({ shadow: "none" }, { state: "hovered" }),
+      s.geom.bar({
+        strokeWidth: 0,
+        cornerRadius: "none"
+      }),
+      s.geom.line({
+        strokeWidth: e.lineWidth,
+        dashArray: [],
+        lineCap: "round",
+        lineJoin: "round"
+      }),
+      s.geom.area({
+        fillAlpha: ue,
+        strokeWidth: 0,
+        dashArray: [],
+        lineJoin: "round"
+      }),
+      s.geom.point({
+        size: e.pointSize,
+        strokeWidth: 0
+      }),
+      s.geom.tile({
+        cornerRadius: 3,
+        strokeWidth: 0
+      }),
+      s.geom.rule({
+        stroke: t.accent,
+        strokeWidth: 1.5,
+        dashArray: [5, 4]
+      }),
+      s.geom.rule.label({
+        ...y,
+        fontWeight: 600,
+        fontSize: 11.5,
+        textTransform: "uppercase"
+      }),
+      s.gridLine({ dashArray: [] }),
+      s.gridLine.x({ strokeWidth: 0 }),
+      s.gridLine.y({ strokeWidth: 1 }),
+      s.panelBorder({ strokeWidth: 0 }),
+      s.panelBorder.bottom({
+        stroke: t.baseline,
+        strokeWidth: 1,
+        dashArray: []
+      }),
+      s.tickLine({ strokeWidth: 0 }),
+      s.tickLabel({
+        ...a,
+        ...y,
+        fontWeight: 400,
+        fontSize: 11.5,
+        lineHeight: 1
+      }),
+      s.axisLabel({
+        ...y,
+        textColor: t.accent,
+        fontWeight: 600,
+        fontSize: 11,
+        lineHeight: 1,
+        letterSpacing: 0.6,
+        textTransform: "uppercase"
+      }),
+      s.heading({
+        ...r,
+        ...J
+      }),
+      s.heading.h1({
+        fontWeight: 800,
+        fontSize: 25,
+        lineHeight: 1.1,
+        letterSpacing: -0.5
+      }),
+      s.heading.h2({
+        ...a,
+        fontWeight: 500,
+        fontSize: 14.5,
+        lineHeight: 1.3
+      }),
+      s.header({ margin: { bottom: 18 } }),
+      s.caption({
+        ...a,
+        ...y,
+        fontWeight: 400,
+        fontSize: 11.5
+      }),
+      s.source({
+        ...a,
+        ...y,
+        fontWeight: 400,
+        fontSize: 11.5
+      }),
+      s.source.link({
+        ...a,
+        ...y,
+        fontWeight: 400,
+        fontSize: 11.5
+      }),
+      s.dataLabel({
+        ...r,
+        ...y,
+        fontWeight: 600,
+        fontSize: 11.5,
+        fill: "transparent"
+      }),
+      s.legendItem({
+        ...r,
+        ...y,
+        fontWeight: 500,
+        fontSize: 12,
+        fill: "transparent",
+        stroke: "transparent"
+      }),
+      s.directLabel({
+        ...y,
+        fontWeight: 600,
+        fontSize: 12
+      }),
+      s.headlineItem.number({
+        ...J,
+        fontWeight: 800,
+        fontSize: 32,
+        lineHeight: 1.1
+      }),
+      s.tooltip({
+        fill: t.window,
+        strokeWidth: 1,
+        cornerRadius: 10,
+        paddingInline: 12,
+        paddingBlock: 9,
+        shadow: i
+      }),
+      s.tooltip.heading({
+        ...y,
+        textColor: t.accent,
+        fontWeight: 600,
+        fontSize: 12,
+        lineHeight: 1.3,
+        textTransform: "uppercase"
+      }),
+      s.tooltip.label({
+        ...a,
+        ...y,
+        fontWeight: 400,
+        fontSize: 12,
+        lineHeight: 1.4
+      }),
+      s.tooltip.value({
+        ...r,
+        ...y,
+        fontWeight: 600,
+        fontSize: 12,
+        lineHeight: 1.4
+      }),
+      s.legend.popover({
+        cornerRadius: 10,
+        shadow: i
+      }),
+      s.annotation.text({
+        ...n,
+        paddingInline: 11,
+        paddingBlock: 7,
+        lineHeight: 1.4
+      }),
+      s.annotation.pinnedNumber({
+        fill: t.accent,
+        stroke: t.ground,
+        shadow: "none"
+      }),
+      s.annotation.pinnedNumber.label({
+        ...n,
+        fontWeight: 600
+      }),
+      s.annotation.comment({
+        fill: t.accent,
+        stroke: t.ground,
+        shadow: "none"
+      }),
+      s.annotation.comment.label({ ...n }),
+      s.annotation.differenceArrow({
+        stroke: t.accent,
+        strokeWidth: 1.5
+      }),
+      s.annotation.differenceArrow.label({
+        ...n,
+        textColor: t.accent,
+        fontWeight: 700
+      }),
+      s.annotation.arrow({
+        stroke: t.accent,
+        strokeWidth: 1.5,
+        dashArray: []
+      }),
+      s.annotation.shape({
+        fill: fe,
+        fillAlpha: t.washAlpha,
+        stroke: "transparent",
+        strokeWidth: 0
+      }),
+      s.geom.area({ fillAlpha: ge }, { coord: "polar" }),
+      s.panelBorder.bottom({ strokeWidth: 0 }, { coord: "polar" }),
+      s.tickLabel({
+        ...r,
+        fontWeight: 600,
+        textOutlineColor: t.ground,
+        textOutlineWidth: 3
+      }, { coord: "polar" })
+    ]
+  };
+}, Ae = 28, q = me(ve, {
+  lineWidth: 3,
+  pointSize: 14
+}), $e = {
+  ...q,
+  defaults: [...q.defaults ?? [], s.graph({
+    strokeWidth: 0,
+    padding: 9 + Ae,
+    overlay: {
+      image: de(20, {
+        foil: L,
+        shade: A.void,
+        light: A.starlight
+      }),
+      fit: "stretch",
+      fallback: "transparent"
+    }
+  })]
+}, ye = 2.6, Re = 28, we = 0.6, Ce = 0.4, Q = 0.42, xe = 0.62, Se = 0.95, Oe = 0.42, Ee = 0.45, x = A.starlight, tt = A.void, S = (t) => `${t}-${zt().replace(/[^a-zA-Z0-9]/gu, "")}`, O = (t) => ({
+  foil: `${t}-foil`,
+  rimLight: `${t}-rim-light`,
+  rimShade: `${t}-rim-shade`,
+  gloss: `${t}-gloss`,
+  catchlight: `${t}-catchlight`,
+  reflection: `${t}-reflection`
+}), E = ({ ids: t, panel: e }) => {
+  const r = Re * Math.PI / 180, a = Math.hypot(e.width, e.height) / ye, i = L.length - 1;
+  return /* @__PURE__ */ m(Vt, { children: [
+    /* @__PURE__ */ o("linearGradient", {
+      id: t.foil,
+      gradientUnits: "userSpaceOnUse",
+      spreadMethod: "reflect",
+      x1: 0,
+      y1: 0,
+      x2: Math.cos(r) * a,
+      y2: Math.sin(r) * a,
+      children: L.map((n, d) => /* @__PURE__ */ o("stop", {
+        offset: d / i,
+        stopColor: n
+      }, n))
+    }),
+    /* @__PURE__ */ m("linearGradient", {
+      id: t.rimLight,
+      x1: 0,
+      y1: 0,
+      x2: 1,
+      y2: 1,
+      children: [/* @__PURE__ */ o("stop", {
+        offset: 0,
+        stopColor: x,
+        stopOpacity: we
+      }), /* @__PURE__ */ o("stop", {
+        offset: 0.45,
+        stopColor: x,
+        stopOpacity: 0
+      })]
+    }),
+    /* @__PURE__ */ m("linearGradient", {
+      id: t.rimShade,
+      x1: 0,
+      y1: 0,
+      x2: 1,
+      y2: 1,
+      children: [/* @__PURE__ */ o("stop", {
+        offset: 0.5,
+        stopColor: tt,
+        stopOpacity: 0
+      }), /* @__PURE__ */ o("stop", {
+        offset: 1,
+        stopColor: tt,
+        stopOpacity: Ce
+      })]
+    }),
+    /* @__PURE__ */ m("radialGradient", {
+      id: t.gloss,
+      cx: 0.22,
+      cy: 0.12,
+      r: xe,
+      children: [
+        /* @__PURE__ */ o("stop", {
+          offset: 0,
+          stopColor: x,
+          stopOpacity: Q
+        }),
+        /* @__PURE__ */ o("stop", {
+          offset: 0.6,
+          stopColor: x,
+          stopOpacity: Q / 5
+        }),
+        /* @__PURE__ */ o("stop", {
+          offset: 1,
+          stopColor: x,
+          stopOpacity: 0
+        })
+      ]
+    }),
+    /* @__PURE__ */ m("linearGradient", {
+      id: t.catchlight,
+      x1: 0,
+      y1: 0,
+      x2: 1,
+      y2: 1,
+      children: [/* @__PURE__ */ o("stop", {
+        offset: 0,
+        stopColor: x,
+        stopOpacity: Se
+      }), /* @__PURE__ */ o("stop", {
+        offset: Oe,
+        stopColor: x,
+        stopOpacity: 0
+      })]
+    }),
+    /* @__PURE__ */ m("linearGradient", {
+      id: t.reflection,
+      x1: 0,
+      y1: 0,
+      x2: 1,
+      y2: 1,
+      children: [/* @__PURE__ */ o("stop", {
+        offset: 0.6,
+        stopColor: x,
+        stopOpacity: 0
+      }), /* @__PURE__ */ o("stop", {
+        offset: 1,
+        stopColor: x,
+        stopOpacity: Ee
+      })]
+    })
+  ] });
+}, vt = ({ x: t, y: e, width: r, height: a }, i) => {
+  const n = Math.max(0, Math.min(i, r / 2, a / 2));
+  if (n === 0) return `M${t},${e} H${t + r} V${e + a} H${t} Z`;
+  const d = (l, c) => `A${n},${n} 0 0 1 ${l},${c}`;
+  return [
+    `M${t + n},${e}`,
+    `H${t + r - n}`,
+    d(t + r, e + n),
+    `V${e + a - n}`,
+    d(t + r - n, e + a),
+    `H${t + n}`,
+    d(t, e + a - n),
+    `V${e + n}`,
+    d(t + n, e),
+    "Z"
+  ].join(" ");
+}, _ = (t, e, r) => `M${t - r},${e} A${r},${r} 0 1 0 ${t + r},${e} A${r},${r} 0 1 0 ${t - r},${e} Z`, Te = 2, Le = 2.5, _e = 0.35, ke = 1.5, Pe = 0.9, Ie = ({ id: t, path: e, paint: r, state: a }) => /* @__PURE__ */ m("g", {
+  opacity: r.opacity,
+  children: [
+    /* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o("clipPath", {
+      id: t,
+      children: /* @__PURE__ */ o("path", { d: e })
+    }) }),
+    /* @__PURE__ */ o("path", {
+      d: e,
+      fill: r.color,
+      fillOpacity: r.fillOpacity
+    }),
+    /* @__PURE__ */ m("g", {
+      fill: "none",
+      clipPath: `url(#${t})`,
+      strokeLinejoin: "round",
+      children: [/* @__PURE__ */ o("path", {
+        d: e,
+        stroke: w.ground,
+        strokeWidth: Te
+      }), a === "hovered" && /* @__PURE__ */ o("path", {
+        d: e,
+        stroke: x,
+        strokeOpacity: Pe,
+        strokeWidth: ke * 2
+      })]
+    })
+  ]
+}), He = ({ path: t, paint: e, glowId: r }) => /* @__PURE__ */ m("g", {
+  opacity: e.opacity,
+  fill: "none",
+  strokeLinecap: "round",
+  strokeLinejoin: "round",
+  strokeDasharray: e.dashArray,
+  children: [/* @__PURE__ */ o("path", {
+    d: t,
+    stroke: e.color,
+    strokeOpacity: _e,
+    strokeWidth: e.width * Le,
+    filter: `url(#${r})`
+  }), /* @__PURE__ */ o("path", {
+    d: t,
+    stroke: e.color,
+    strokeWidth: e.width
+  })]
+}), Fe = {
+  Cell: Ie,
+  Tube: He,
+  rims: {
+    bar: () => 0,
+    barCorner: () => 3,
+    tile: () => 0,
+    tileCorner: 3,
+    tileGap: 0,
+    bead: () => 0,
+    ringSlice: () => 0,
+    petal: () => 0,
+    areaSide: 0,
+    areaValue: 0
+  },
+  pin: {
+    hasBezel: !1,
+    hasGlow: !1,
+    hole: null
+  }
+}, We = /[a-df-zA-DF-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/gu, Ge = /^[a-zA-Z]$/u, Me = (t, e) => t === "H" ? "x" : t === "V" ? "y" : e % 2 === 0 ? "x" : "y", D = (t, e) => {
+  let r = "", a = 0;
+  return (t.match(We) ?? []).map((i) => {
+    if (Ge.test(i))
+      return r = i.toUpperCase(), a = 0, i;
+    const n = Me(r, a);
+    return a += 1, String(Number(i) * (n === "x" ? e.width : e.height));
+  }).join(" ");
+}, z = (t, e) => {
+  const r = M(t), a = b(t) ?? ut(t);
+  return r === null || a === null ? null : {
+    x: Dt(r) * e.width,
+    y: Yt(a) * e.height
+  };
+}, B = (t, e) => {
+  const r = M(t), a = b(t) ?? pt(t).outerRadius;
+  if (r === null || a === null) return null;
+  const i = gt(r, a), n = Math.min(e.width, e.height) / 2;
+  return {
+    x: e.width / 2 + i.x * n,
+    y: e.height / 2 - i.y * n
+  };
+}, be = (t) => `${t.map((e, r) => `${r === 0 ? "M" : "L"}${e.x},${e.y}`).join(" ")} Z`, P = (t) => {
+  const e = Y(t);
+  return (r, a) => ({
+    color: Bt(e.get("fill", r, a)),
+    opacity: e.get("alpha", r, a),
+    fillOpacity: e.get("fillAlpha", r, a),
+    edge: e.get("stroke", r, a),
+    edgeWidth: e.get("strokeWidth", r, a)
+  });
+}, mt = (t) => {
+  const e = Y(t);
+  return (r, a) => {
+    const i = e.get("strokeWidth", r, a);
+    return {
+      color: e.get("stroke", r, a),
+      opacity: e.get("alpha", r, a) * e.get("strokeAlpha", r, a),
+      width: i,
+      dashArray: Nt(e.get("dashArray", r, a), i)
+    };
+  };
+}, W = (t, e) => {
+  const r = G(t.data, t.mapping, t.id), a = [];
+  return t.data.groupBy(Ot.group).forEach((i) => {
+    const n = [...i], [d] = n, l = e(n);
+    d === void 0 || l === null || a.push({
+      key: r(d),
+      observation: d,
+      path: l
+    });
+  }), a;
+}, Be = (t, e) => t.flatMap((r) => {
+  const a = M(r), i = B(r, e);
+  return a === null || i === null ? [] : [{
+    angle: a,
+    point: i
+  }];
+}).sort((r, a) => r.angle - a.angle).map(({ point: r }) => r), At = (t, e) => {
+  const r = Be(t, e);
+  return r.length === 0 ? null : be(r);
+}, et = 14, $t = ({ finish: t, layer: e, coordSystem: r, panel: a }) => {
+  const i = P(e), n = S("shiny-area"), d = k(() => {
+    if (r === void 0) return W(e, (u) => At(u, a)).map((u) => ({
+      ...u,
+      fill: u.path,
+      edge: u.path
+    }));
+    const { areaGenerator: h, lineGenerator: g } = Tt(r, e.params), v = /* @__PURE__ */ new Map();
+    return W(e, (u) => {
+      const f = Mt(u, e.params.missingValues), C = h(f), $ = g(f);
+      if (!C) return null;
+      const R = D(C, a);
+      return $ && v.set(R, D($, a)), R;
+    }).map((u) => ({
+      ...u,
+      fill: u.path,
+      edge: v.get(u.path) ?? ""
+    }));
+  }, [
+    e,
+    r,
+    a
+  ]);
+  if (a.width <= 0 || a.height <= 0) return null;
+  const l = O(n), { Cell: c, rims: p } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "area",
+    children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+      ids: l,
+      panel: a
+    }) }), d.map(({ key: h, observation: g, fill: v, edge: u }, f) => /* @__PURE__ */ o(c, {
+      id: `${n}-${f}`,
+      ids: l,
+      path: v,
+      rimWidth: p.areaSide,
+      cap: u === "" ? void 0 : u,
+      capWidth: p.areaValue,
+      paint: i(g)
+    }, h))]
+  });
+}, yt = ({ finish: t, layer: e, observation: r, panel: a, project: i }) => {
+  const n = P(e)(r, "hovered"), d = S("shiny-area-reading"), l = i(r, a);
+  if (l === null) return null;
+  const c = O(d), { Cell: p, rims: h } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "area",
+    children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+      ids: c,
+      panel: a
+    }) }), /* @__PURE__ */ o(p, {
+      id: `${d}-point`,
+      ids: c,
+      path: _(l.x, l.y, et / 2),
+      rimWidth: h.bead(et),
+      paint: {
+        ...n,
+        fillOpacity: 1
+      },
+      state: "hovered"
+    })]
+  });
+}, Ne = (t) => T("area", {
+  coord: "cartesian",
+  guideMode: "crosshair",
+  swatchShape: "area",
+  render: ({ layer: e, coordSystem: r, panelRect: a }) => r.type !== "cartesian" ? null : /* @__PURE__ */ o($t, {
+    finish: t,
+    layer: e,
+    coordSystem: r,
+    panel: a
+  }),
+  renderHover: ({ layer: e, primary: r, panelRect: a }) => /* @__PURE__ */ o(yt, {
+    finish: t,
+    layer: e,
+    observation: r.observation,
+    panel: a,
+    project: z
+  }),
+  renderHoverCompanions: () => null
+}), De = (t) => T("area", {
+  coord: "polar",
+  guideMode: "crosshair",
+  swatchShape: "area",
+  render: ({ layer: e, panelRect: r }) => /* @__PURE__ */ o($t, {
+    finish: t,
+    layer: e,
+    panel: r
+  }),
+  renderHover: ({ layer: e, primary: r, panelRect: a }) => /* @__PURE__ */ o(yt, {
+    finish: t,
+    layer: e,
+    observation: r.observation,
+    panel: a,
+    project: B
+  }),
+  renderHoverCompanions: () => null
+}), Ye = (t, e) => e === "x" ? (ut(t) ?? b(t) ?? 0) >= (Gt(t) ?? 0) ? "top" : "bottom" : (Ft(t) ?? 0) >= (Wt(t) ?? 0) ? "right" : "left", ze = ({ x: t, y: e, width: r, height: a }, i) => i === "top" ? `M${t},${e} H${t + r}` : i === "bottom" ? `M${t},${e + a} H${t + r}` : i === "left" ? `M${t},${e} V${e + a}` : `M${t + r},${e} V${e + a}`, Ve = (t, e, r) => {
+  const a = Pt(e, t);
+  return !a || a.width <= 0 || a.height <= 0 ? null : {
+    x: a.x * r.width,
+    y: a.y * r.height,
+    width: a.width * r.width,
+    height: a.height * r.height
+  };
+}, rt = ({ finish: t, layer: e, observations: r, mainAxis: a, panel: i, state: n }) => {
+  const d = P(e), l = S("shiny-bar"), c = k(() => G(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]);
+  if (i.width <= 0 || i.height <= 0) return null;
+  const p = O(l), { Cell: h, rims: g } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "bar",
+    children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+      ids: p,
+      panel: i
+    }) }), Array.from(r, (v, u) => {
+      const f = Ve(v, a, i);
+      if (f === null) return null;
+      const C = a === "x" ? f.width : f.height, $ = Ht(v), R = $ === "solo" || $ === "ceiling";
+      return /* @__PURE__ */ o(h, {
+        id: `${l}-${u}`,
+        ids: p,
+        path: vt(f, g.barCorner(C)),
+        rimWidth: g.bar(C),
+        valueEnd: R ? ze(f, Ye(v, a)) : void 0,
+        paint: d(v, n),
+        state: n
+      }, c(v));
+    })]
+  });
+}, Ue = (t) => T("bar", {
+  coord: "cartesian",
+  guideMode: "band",
+  swatchShape: "square",
+  render: ({ layer: e, coordSystem: r, panelRect: a }) => /* @__PURE__ */ o(rt, {
+    finish: t,
+    layer: e,
+    observations: e.data,
+    mainAxis: Z(r),
+    panel: a
+  }),
+  renderHover: ({ layer: e, coordSystem: r, primary: a, panelRect: i }) => /* @__PURE__ */ o(rt, {
+    finish: t,
+    layer: e,
+    observations: [a.observation],
+    mainAxis: Z(r),
+    panel: i,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), je = 4, Ze = 4, Ke = ({ finish: t, layer: e, panel: r, coord: a }) => {
+  const i = mt(e), n = S("shiny-line"), d = k(() => {
+    if (a === "polar") return W(e, (g) => At(g, r));
+    const h = Lt(e.params);
+    return W(e, (g) => {
+      const v = h(bt(g, e.params.missingValues));
+      return v ? D(v, r) : null;
+    });
+  }, [
+    e,
+    r,
+    a
+  ]);
+  if (r.width <= 0 || r.height <= 0) return null;
+  const l = O(n), c = `${n}-glow`, { Tube: p } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "line",
+    children: [/* @__PURE__ */ m("defs", { children: [/* @__PURE__ */ o(E, {
+      ids: l,
+      panel: r
+    }), /* @__PURE__ */ o("filter", {
+      id: c,
+      x: "-20%",
+      y: "-20%",
+      width: "140%",
+      height: "140%",
+      children: /* @__PURE__ */ o("feGaussianBlur", { stdDeviation: je })
+    })] }), d.map(({ key: h, path: g, observation: v }, u) => /* @__PURE__ */ o(p, {
+      id: `${n}-${u}`,
+      ids: l,
+      path: g,
+      paint: i(v),
+      panel: r,
+      glowId: c
+    }, h))]
+  });
+}, Xe = ({ finish: t, layer: e, observation: r, panel: a, project: i }) => {
+  const n = mt(e)(r, "hovered"), d = S("shiny-line-reading"), l = i(r, a);
+  if (l === null) return null;
+  const c = O(d), p = n.width * Ze, { Cell: h, rims: g } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "line",
+    children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+      ids: c,
+      panel: a
+    }) }), /* @__PURE__ */ o(h, {
+      id: `${d}-point`,
+      ids: c,
+      path: _(l.x, l.y, p / 2),
+      rimWidth: g.bead(p),
+      paint: {
+        color: n.color,
+        opacity: n.opacity,
+        fillOpacity: 1,
+        edge: n.color,
+        edgeWidth: 0
+      },
+      state: "hovered"
+    })]
+  });
+}, Rt = (t, e, r) => T("line", {
+  coord: e,
+  guideMode: "crosshair",
+  swatchShape: "line",
+  render: ({ layer: a, panelRect: i }) => /* @__PURE__ */ o(Ke, {
+    finish: t,
+    layer: a,
+    panel: i,
+    coord: e
+  }),
+  renderHover: ({ layer: a, primary: i, panelRect: n }) => /* @__PURE__ */ o(Xe, {
+    finish: t,
+    layer: a,
+    observation: i.observation,
+    panel: n,
+    project: r
+  }),
+  renderHoverCompanions: () => null,
+  getOverlayAnchor: ({ observation: a }) => {
+    const i = M(a), n = b(a);
+    return i === null || n === null ? null : {
+      x: i,
+      y: n
+    };
+  }
+}), Je = (t) => Rt(t, "cartesian", z), qe = (t) => Rt(t, "polar", B), Qe = 4, at = ({ finish: t, layer: e, observations: r, panel: a, project: i, state: n }) => {
+  const d = Y(e), l = P(e), c = S("shiny-point"), p = k(() => G(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]);
+  if (a.width <= 0 || a.height <= 0) return null;
+  const h = O(c), g = n === "hovered" ? Qe : 0, { Cell: v, rims: u } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "point",
+    children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+      ids: h,
+      panel: a
+    }) }), Array.from(r, (f, C) => {
+      const $ = i(f, a);
+      if ($ === null) return null;
+      const R = (d.get("size", f, n) + g) / 2;
+      return R <= 0 ? null : /* @__PURE__ */ o(v, {
+        id: `${c}-${C}`,
+        ids: h,
+        path: _($.x, $.y, R),
+        rimWidth: u.bead(R * 2),
+        paint: l(f, n),
+        state: n
+      }, p(f));
+    })]
+  });
+}, wt = (t, e, r) => T("point", {
+  coord: e,
+  swatchShape: "circle",
+  render: ({ layer: a, panelRect: i }) => /* @__PURE__ */ o(at, {
+    finish: t,
+    layer: a,
+    observations: a.data,
+    panel: i,
+    project: r
+  }),
+  renderHover: ({ layer: a, primary: i, panelRect: n }) => /* @__PURE__ */ o(at, {
+    finish: t,
+    layer: a,
+    observations: [i.observation],
+    panel: n,
+    project: r,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), tr = (t) => wt(t, "cartesian", z), er = (t) => wt(t, "polar", B), rr = 3, nt = 1e-6, ar = 0.16, nr = 5, ir = 10, it = 120, or = 0.45, sr = 2.5, dr = 7, lr = 0.55, ot = [
+  A.pulse,
+  "#8E5CFF",
+  "#5A8CFF"
+], st = 4, dt = (t, e) => [...t].flatMap((r) => {
+  const { startAngle: a, endAngle: i } = kt(r), { innerRadius: n, outerRadius: d } = pt(r);
+  return a === null || i === null || n === null || d === null ? [] : i <= a || d <= 0 ? [] : [{
+    key: `${e(r)}-${a}`,
+    observation: r,
+    startAngle: a,
+    endAngle: i,
+    innerRadius: n,
+    outerRadius: d
+  }];
+}), cr = (t) => {
+  const [e] = t;
+  return e === void 0 ? !1 : t.every((r) => Math.abs(r.innerRadius - e.innerRadius) < nt && Math.abs(r.outerRadius - e.outerRadius) < nt);
+}, lt = (t, e, r) => {
+  const a = gt(e, r);
+  return {
+    x: t.centre.x + a.x,
+    y: t.centre.y - a.y
+  };
+}, hr = (t, e) => Et({
+  startAngle: t.startAngle,
+  endAngle: t.endAngle,
+  innerRadius: t.innerRadius,
+  outerRadius: t.outerRadius
+}, {
+  centerX: e.centre.x,
+  centerY: e.centre.y,
+  radius: e.radius,
+  digits: rr
+}), pr = ({ id: t, circle: e, outer: r, bezel: a }) => {
+  const i = Math.PI * 2 / it, n = Array.from({ length: it / 2 }, (d, l) => {
+    const c = l * 2 * i, p = c + i, h = lt(e, c, r + st), g = lt(e, p, r + st);
+    return `M${e.centre.x},${e.centre.y} L${h.x},${h.y} L${g.x},${g.y} Z`;
+  }).join(" ");
+  return /* @__PURE__ */ m("g", { children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o("clipPath", {
+    id: t,
+    children: /* @__PURE__ */ o("path", {
+      d: `${_(e.centre.x, e.centre.y, r)} ${_(e.centre.x, e.centre.y, r - a)}`,
+      clipRule: "evenodd"
+    })
+  }) }), /* @__PURE__ */ o("path", {
+    d: n,
+    fill: x,
+    fillOpacity: or,
+    clipPath: `url(#${t})`
+  })] });
+}, ur = ({ pin: t, id: e, circle: r, inner: a, outer: i, bezel: n }) => {
+  const d = r.radius;
+  return /* @__PURE__ */ m("g", { children: [
+    /* @__PURE__ */ m("defs", { children: [/* @__PURE__ */ o("linearGradient", {
+      id: `${e}-glow-colors`,
+      gradientUnits: "userSpaceOnUse",
+      x1: r.centre.x - d,
+      y1: r.centre.y - d,
+      x2: r.centre.x + d,
+      y2: r.centre.y + d,
+      children: ot.map((l, c) => /* @__PURE__ */ o("stop", {
+        offset: c / (ot.length - 1),
+        stopColor: l
+      }, l))
+    }), /* @__PURE__ */ o("filter", {
+      id: `${e}-glow`,
+      x: "-50%",
+      y: "-50%",
+      width: "200%",
+      height: "200%",
+      children: /* @__PURE__ */ o("feGaussianBlur", { stdDeviation: dr })
+    })] }),
+    t.hasGlow && /* @__PURE__ */ o("circle", {
+      cx: r.centre.x,
+      cy: r.centre.y,
+      r: i - n / 2,
+      fill: "none",
+      stroke: `url(#${e}-glow-colors)`,
+      strokeWidth: n * sr,
+      strokeOpacity: lr,
+      filter: `url(#${e}-glow)`
+    }),
+    a > 0 && t.hole !== null && /* @__PURE__ */ o("circle", {
+      cx: r.centre.x,
+      cy: r.centre.y,
+      r: a,
+      fill: t.hole
+    })
+  ] });
+}, ct = ({ finish: t, layer: e, observations: r, panel: a, isRadialBar: i, state: n }) => {
+  const d = P(e), l = S("shiny-slice"), c = k(() => G(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]);
+  if (a.width <= 0 || a.height <= 0) return null;
+  const p = {
+    centre: {
+      x: a.width / 2,
+      y: a.height / 2
+    },
+    radius: Math.min(a.width, a.height) / 2
+  }, h = O(l), g = dt(r, c), v = n === void 0 ? g : dt(e.data, c), [u] = v, f = !i && u !== void 0 && cr(v), C = (u?.innerRadius ?? 0) * p.radius, $ = (u?.outerRadius ?? 0) * p.radius, R = Math.min(ir, Math.max(nr, ($ - C) * ar)), V = f && n === void 0, { Cell: Ct, rims: U, pin: N } = t, xt = f && N.hasBezel;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "bar",
+    children: [
+      /* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+        ids: h,
+        panel: a
+      }) }),
+      V && /* @__PURE__ */ o(ur, {
+        pin: N,
+        id: `${l}-pin`,
+        circle: p,
+        inner: C,
+        outer: $,
+        bezel: R
+      }),
+      g.map((I, St) => {
+        const j = hr(I, p);
+        return j === void 0 ? null : /* @__PURE__ */ o(Ct, {
+          id: `${l}-${St}`,
+          ids: h,
+          path: j,
+          cap: xt ? _(p.centre.x, p.centre.y, $) : void 0,
+          capWidth: R,
+          rimWidth: f ? U.ringSlice($ - C) : U.petal((I.outerRadius - I.innerRadius) * p.radius),
+          paint: d(I.observation, n),
+          state: n
+        }, I.key);
+      }),
+      V && N.hasBezel && /* @__PURE__ */ o(pr, {
+        id: `${l}-rays`,
+        circle: p,
+        outer: $,
+        bezel: R
+      })
+    ]
+  });
+}, gr = (t) => T("bar", {
+  coord: "polar",
+  guideMode: "band",
+  swatchShape: "slice",
+  render: ({ layer: e, coordSystem: r, panelRect: a }) => /* @__PURE__ */ o(ct, {
+    finish: t,
+    layer: e,
+    observations: e.data,
+    panel: a,
+    isRadialBar: r.type === "polar" && r.bandAxis === "y"
+  }),
+  renderHover: ({ layer: e, coordSystem: r, primary: a, panelRect: i }) => /* @__PURE__ */ o(ct, {
+    finish: t,
+    layer: e,
+    observations: [a.observation],
+    panel: i,
+    isRadialBar: r.type === "polar" && r.bandAxis === "y",
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), ht = ({ finish: t, layer: e, observations: r, panel: a, state: i }) => {
+  const n = P(e), d = S("shiny-tile"), l = k(() => _t(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]);
+  if (a.width <= 0 || a.height <= 0) return null;
+  const c = O(d), { Cell: p, rims: h } = t;
+  return /* @__PURE__ */ m("g", {
+    "data-geom": "tile",
+    children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o(E, {
+      ids: c,
+      panel: a
+    }) }), Array.from(r, (g, v) => {
+      const u = It(g);
+      if (u === null) return null;
+      const f = {
+        x: u.x * a.width + h.tileGap / 2,
+        y: u.y * a.height + h.tileGap / 2,
+        width: u.width * a.width - h.tileGap,
+        height: u.height * a.height - h.tileGap
+      };
+      return f.width <= 0 || f.height <= 0 ? null : /* @__PURE__ */ o(p, {
+        id: `${d}-${v}`,
+        ids: c,
+        path: vt(f, h.tileCorner),
+        rimWidth: h.tile(Math.min(f.width, f.height)),
+        isEven: !0,
+        paint: n(g, i),
+        state: i
+      }, l(g));
+    })]
+  });
+}, fr = (t) => T("tile", {
+  coord: "cartesian",
+  guideMode: null,
+  swatchShape: "square",
+  render: ({ layer: e, panelRect: r }) => /* @__PURE__ */ o(ht, {
+    finish: t,
+    layer: e,
+    observations: e.data,
+    panel: r
+  }),
+  renderHover: ({ layer: e, primary: r, panelRect: a }) => /* @__PURE__ */ o(ht, {
+    finish: t,
+    layer: e,
+    observations: [r.observation],
+    panel: a,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), vr = (t) => [
+  Ue(t),
+  gr(t),
+  fr(t),
+  Je(t),
+  qe(t),
+  Ne(t),
+  De(t),
+  tr(t),
+  er(t)
+], mr = vr(Fe), Rr = {
+  name: "shiny",
+  styles: $e,
+  palette: he,
+  colormap: pe,
+  colorScheme: "dark",
+  plugins: mr
+};
+export {
+  Rr as shiny
+};