@graphysdk/theme-botanical 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1123 @@
+import { useId as Ct, useMemo as I } from "react";
+import { DefaultGeomCircle as Ht, GROUP_VARIABLES as At, createAreaPathGenerators as It, createStableCellKeyGenerator as Rt, createStableKeyGenerator as O, defineGeomRenderer as W, getAngleExtent as $t, getBarRectBounds as Ot, getPaintedTileRect as Nt, getRadiusExtent as Q, getStackRole as Bt, getX as H, getXMax as Dt, getXMin as Gt, getY as z, getYMax as xt, getYMin as Ft, polarToUnit as kt, prepareAreaObservations as zt, readMainAxis as ot, style as p, toPaintColor as jt, toStrokeDasharray as Kt, toViewBoxX as Vt, toViewBoxY as Ut, useGeomStyleReader as J } from "@graphysdk/react";
+import { jsx as g, jsxs as w } from "react/jsx-runtime";
+var Yt = /[a-df-zA-DF-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/gu, Xt = /^[a-zA-Z]$/u, Zt = (t, e) => t === "H" ? "x" : t === "V" ? "y" : e % 2 === 0 ? "x" : "y", it = (t, e) => {
+  let r = "", a = 0;
+  return (t.match(Yt) ?? []).map((n) => {
+    if (Xt.test(n))
+      return r = n.toUpperCase(), a = 0, n;
+    const i = Zt(r, a);
+    return a += 1, String(Number(n) * (i === "x" ? e.width : e.height));
+  }).join(" ");
+}, tt = (t, e) => {
+  const r = H(t), a = z(t) ?? xt(t);
+  return r === null || a === null ? null : {
+    x: Vt(r) * e.width,
+    y: Ut(a) * e.height
+  };
+}, j = (t, e) => {
+  const r = H(t), a = z(t) ?? Q(t).outerRadius;
+  if (r === null || a === null) return null;
+  const n = kt(r, a), i = Math.min(e.width, e.height) / 2;
+  return {
+    x: e.width / 2 + n.x * i,
+    y: e.height / 2 - n.y * i
+  };
+}, qt = (t) => `${t.map((e, r) => `${r === 0 ? "M" : "L"}${e.x},${e.y}`).join(" ")} Z`, T = (t) => {
+  let e = 2166136261;
+  for (let r = 0; r < t.length; r += 1)
+    e ^= t.charCodeAt(r), e = Math.imul(e, 16777619);
+  return e >>> 0;
+}, N = (t) => {
+  let e = t || 1;
+  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;
+  };
+}, Qt = (t) => {
+  const e = [
+    0.035,
+    0.07,
+    0.13
+  ].map((a, n) => ({
+    frequency: a * (0.7 + t() * 0.6),
+    phase: t() * Math.PI * 2,
+    weight: 1 / (n + 1)
+  })), r = e.reduce((a, n) => a + n.weight, 0);
+  return (a) => e.reduce((n, i) => n + i.weight * Math.sin(a * i.frequency + i.phase), 0) / r;
+}, b = (t, { wander: e, seed: r, closed: a = !1, step: n = 9, cornered: i = !1 }) => {
+  if (t.length < 2) return "";
+  const s = Qt(N(r)), o = a ? [...t, t[0]] : [...t], l = [], c = [];
+  let h = 0;
+  for (let u = 0; u < o.length - 1; u += 1) {
+    const d = o[u], f = o[u + 1], y = Math.hypot(f.x - d.x, f.y - d.y);
+    if (y === 0) continue;
+    const P = {
+      x: -(f.y - d.y) / y,
+      y: (f.x - d.x) / y
+    }, S = Math.max(1, Math.ceil(y / n)), k = [];
+    for (let _ = 0; _ <= S; _ += 1) {
+      const M = _ / S, V = e * Math.sin(Math.PI * M) * s(h + M * y);
+      k.push({
+        x: d.x + (f.x - d.x) * M + P.x * V,
+        y: d.y + (f.y - d.y) * M + P.y * V
+      });
+    }
+    c.push(k), l.push(...k.slice(0, -1)), h += y;
+  }
+  return i ? `${c.map((u) => st(u, !1)).map((u, d) => d === 0 ? u : u.replace(/^M/u, "L")).join(" ")}${a ? " Z" : ""}` : (a || l.push(o[o.length - 1]), st(l, a));
+}, A = (t) => (Math.round(t * 100) / 100).toString(), st = (t, e) => {
+  const r = t.length, a = (o) => e ? t[(o + r) % r] : t[Math.max(0, Math.min(r - 1, o))], n = a(0), i = [`M${A(n.x)},${A(n.y)}`], s = e ? r : r - 1;
+  for (let o = 0; o < s; o += 1) {
+    const [l, c, h, u] = [
+      a(o - 1),
+      a(o),
+      a(o + 1),
+      a(o + 2)
+    ], d = {
+      x: c.x + (h.x - l.x) / 6,
+      y: c.y + (h.y - l.y) / 6
+    }, f = {
+      x: h.x - (u.x - c.x) / 6,
+      y: h.y - (u.y - c.y) / 6
+    };
+    i.push(`C${A(d.x)},${A(d.y)} ${A(f.x)},${A(f.y)} ${A(h.x)},${A(h.y)}`);
+  }
+  return `${i.join(" ")}${e ? " Z" : ""}`;
+}, Z = (t, e, r, a) => {
+  const n = {
+    x: Math.cos(a),
+    y: Math.sin(a)
+  }, i = {
+    x: -n.y,
+    y: n.x
+  }, s = (o, l) => `${A(t.x + n.x * o + i.x * l)},${A(t.y + n.y * o + i.y * l)}`;
+  return {
+    blade: `M${s(0, 0)} Q${s(e * 0.45, r)} ${s(e, 0)} Q${s(e * 0.55, -r)} ${s(0, 0)} Z`,
+    rib: `M${s(0, 0)} L${s(e * 0.8, 0)}`
+  };
+}, Et = (t) => `data:image/svg+xml,${encodeURIComponent(t)}`, Jt = (t, e) => Et(`<svg xmlns="http://www.w3.org/2000/svg" width="240" height="240"><filter id="g" x="0" y="0" width="100%" height="100%"><feTurbulence type="fractalNoise" baseFrequency="0.85" numOctaves="2" seed="4" stitchTiles="stitch"/><feColorMatrix values="0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 -1.6 1.05"/></filter><rect width="240" height="240" fill="${t}"/><rect width="240" height="240" fill="${e}" filter="url(#g)" opacity="0.07"/></svg>`), te = 74, ee = 22, lt = (t, e) => {
+  const r = N(e), a = te / 2, n = (i, s) => Array.from({ length: 6 }, (o, l) => {
+    const c = -11 + ee * l / 5;
+    return `${(i + s * r() * 3).toFixed(1)},${c.toFixed(1)}`;
+  });
+  return `<polygon points="${[...n(-37, -1), ...n(a, 1).reverse()].join(" ")}" fill="${t}" fill-opacity="0.7" stroke="#B9A776" stroke-opacity="0.35" stroke-width="0.5"/>`;
+}, U = (t, e, r, a) => `<svg x="${t}" y="${e}" width="1" height="1" overflow="visible"><g transform="${a}">${r}</g></svg>`, ht = 150, re = 0.95, ae = (t, e, r) => {
+  const a = N(r), n = Array.from({ length: 7 }, (l, c) => {
+    const h = c / 6;
+    return {
+      x: h * ht,
+      y: -Math.sin(h * Math.PI * 0.9) * 16 - h * 6
+    };
+  }), i = b(n, {
+    wander: 1.2,
+    seed: r
+  }), s = n.slice(1, -1).flatMap((l, c) => {
+    const h = c % 2 === 0 ? -1 : 1, u = 22 - c * 2.2 + a() * 4, d = -0.35 + h * (0.95 + a() * 0.25), { blade: f, rib: y } = Z(l, u, u * 0.3, d);
+    return [`<path d="${f}" fill="${e}" fill-opacity="0.55" stroke="${t}" stroke-width="0.85" stroke-linejoin="round"/>`, `<path d="${y}" fill="none" stroke="${t}" stroke-width="0.55" stroke-opacity="0.7"/>`];
+  }), o = Z(n[n.length - 1] ?? {
+    x: ht,
+    y: 0
+  }, 13, 5, -0.2);
+  return `<path d="${i}" fill="none" stroke="${t}" stroke-width="1.1" stroke-linecap="round"/>` + s.join("") + `<path d="${o.blade}" fill="#C4607C" fill-opacity="0.45" stroke="${t}" stroke-width="0.85"/>`;
+}, ne = ({ ink: t, leaf: e, tape: r }) => Et('<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%">' + U("0", "0", lt(r, 3), "translate(26 20) rotate(-36)") + U("100%", "0", lt(r, 9), "translate(-26 20) rotate(36)") + U("0", "100%", ae(t, e, 21), `translate(16 -8) scale(${re})`) + "</svg>"), v = {
+  paper: "#F4EEDD",
+  raised: "#FBF8EE",
+  text: "#1E2A21",
+  secondary: "#4A5648",
+  rule: "#CFC7B0",
+  edge: "#BFB79E",
+  ink: "#3A2C1E",
+  tape: "#D9C89A"
+}, wt = "'Kalam', 'Comic Neue', ui-rounded, sans-serif", q = "'Cormorant Garamond', 'Iowan Old Style', Georgia, serif", oe = wt, m = {
+  forest: "#2E5E3B",
+  petal: "#C4607C",
+  bark: "#5C4033",
+  sage: "#6E8A5A",
+  berry: "#8C2A3C",
+  gold: "#9A7A1E",
+  gentian: "#4A6A8C",
+  leaf: "#4E8A4A"
+}, ie = [
+  m.forest,
+  m.petal,
+  m.bark,
+  m.sage,
+  m.berry,
+  m.gold,
+  m.gentian,
+  m.leaf
+], se = ["#DDE6CC", "#1C4A2B"], Y = 1.5, le = 2, X = 0.75, L = { textColor: v.text }, C = { textColor: v.secondary }, G = { fontFamily: wt }, dt = {
+  fontFamily: q,
+  fontStyle: "italic"
+}, B = {
+  ...G,
+  textColor: v.ink,
+  fontWeight: 400,
+  fontSize: 15,
+  fill: v.paper,
+  stroke: "transparent",
+  strokeWidth: 0,
+  cornerRadius: 0,
+  paddingInline: 2,
+  paddingBlock: 0,
+  shadow: "none"
+}, he = {
+  tokens: {
+    graphBackground: v.paper,
+    graphBorder: v.ink,
+    geom: m.forest,
+    geomBorder: v.secondary,
+    textPrimary: v.text,
+    textSecondary: v.secondary,
+    ruleLine: v.ink,
+    gridLine: v.rule,
+    hoverAffordance: v.text,
+    hoverGuideFill: "rgba(30, 42, 33, 0.06)",
+    hoverGuideLine: v.secondary,
+    tooltipBackground: v.raised,
+    tooltipBorder: v.text,
+    tooltipPrimaryRow: "rgba(46, 94, 59, 0.1)",
+    annotationShape: m.gold,
+    annotationArrow: v.text,
+    differenceLabelBackground: v.paper
+  },
+  defaults: [
+    p.graph({
+      fill: {
+        image: Jt(v.paper, v.ink),
+        fit: "tile",
+        fallback: v.paper
+      },
+      overlay: {
+        image: ne({
+          ink: v.ink,
+          leaf: m.sage,
+          tape: v.tape
+        }),
+        fit: "stretch",
+        fallback: "transparent"
+      },
+      strokeWidth: 0,
+      cornerRadius: 2,
+      shadow: {
+        offsetX: 0,
+        offsetY: 2,
+        blur: 10,
+        color: "rgba(58, 44, 30, 0.18)"
+      },
+      fontFamily: oe,
+      padding: {
+        top: 26,
+        right: 26,
+        bottom: 36,
+        left: 26
+      }
+    }),
+    p.geom({ shadow: "none" }, { state: "hovered" }),
+    p.geom.bar({
+      stroke: v.paper,
+      strokeWidth: 1,
+      cornerRadius: "none"
+    }),
+    p.geom.bar({
+      stroke: v.text,
+      strokeWidth: Y
+    }, { state: "hovered" }),
+    p.geom.line({
+      strokeWidth: le,
+      dashArray: [],
+      lineCap: "round",
+      lineJoin: "round"
+    }),
+    p.geom.area({
+      fillAlpha: 0.55,
+      strokeWidth: Y,
+      dashArray: [],
+      lineCap: "round",
+      lineJoin: "round"
+    }),
+    p.geom.point({
+      size: 8,
+      stroke: v.paper,
+      strokeWidth: 1
+    }),
+    p.geom.tile({
+      cornerRadius: 0,
+      stroke: v.paper,
+      strokeWidth: 1
+    }),
+    p.geom.tile({
+      stroke: v.text,
+      strokeWidth: Y
+    }, { state: "hovered" }),
+    p.geom.rule({
+      stroke: v.secondary,
+      strokeWidth: 1,
+      dashArray: [6, 4]
+    }),
+    p.geom.rule.label({
+      ...L,
+      fontWeight: 400,
+      fontSize: 12.5
+    }),
+    p.gridLine({ dashArray: [] }),
+    p.gridLine.x({ strokeWidth: 0 }),
+    p.gridLine.y({ strokeWidth: X }),
+    p.panelBorder({ strokeWidth: 0 }),
+    p.panelBorder.bottom({
+      stroke: v.ink,
+      strokeWidth: 1,
+      dashArray: []
+    }),
+    p.tickLine({ strokeWidth: 0 }),
+    p.tickLabel({
+      ...C,
+      fontWeight: 400,
+      fontSize: 14,
+      lineHeight: 1
+    }),
+    p.tickLabel.y({
+      fontFamily: q,
+      fontWeight: 600,
+      fontSize: 13,
+      lineHeight: 1
+    }),
+    p.axisLabel({
+      ...C,
+      ...dt,
+      fontWeight: 500,
+      fontSize: 16,
+      lineHeight: 1
+    }),
+    p.heading({
+      ...L,
+      ...G
+    }),
+    p.heading.h1({
+      fontWeight: 400,
+      fontSize: 28,
+      lineHeight: 1
+    }),
+    p.heading.h2({
+      ...C,
+      ...dt,
+      fontWeight: 500,
+      fontSize: 19,
+      lineHeight: 1.1
+    }),
+    p.header({ margin: { bottom: 16 } }),
+    p.caption({
+      ...C,
+      fontWeight: 400,
+      fontSize: 12.5
+    }),
+    p.source({
+      ...C,
+      fontWeight: 400,
+      fontSize: 12
+    }),
+    p.dataLabel({
+      ...L,
+      fontFamily: q,
+      fontWeight: 600,
+      fontSize: 13,
+      lineHeight: 1,
+      paddingBlock: 1,
+      paddingInline: 4,
+      fill: "transparent"
+    }),
+    p.legendItem({
+      ...L,
+      fontWeight: 400,
+      fontSize: 15,
+      fill: "transparent",
+      stroke: "transparent"
+    }),
+    p.directLabel({
+      fontWeight: 700,
+      fontSize: 12.5
+    }),
+    p.headlineItem.number({
+      ...G,
+      fontWeight: 600,
+      fontSize: 32,
+      lineHeight: 1.1
+    }),
+    p.tooltip({
+      strokeWidth: X,
+      cornerRadius: 0,
+      paddingInline: 10,
+      paddingBlock: 8,
+      shadow: "none"
+    }),
+    p.tooltip.heading({
+      ...L,
+      ...G,
+      fontWeight: 700,
+      fontSize: 17,
+      lineHeight: 1.2
+    }),
+    p.tooltip.label({
+      ...C,
+      fontWeight: 400,
+      fontSize: 13,
+      lineHeight: 1.35
+    }),
+    p.tooltip.value({
+      ...L,
+      fontWeight: 700,
+      fontSize: 13,
+      lineHeight: 1.35
+    }),
+    p.legend.popover({
+      strokeWidth: X,
+      cornerRadius: 0,
+      shadow: "none"
+    }),
+    p.annotation.text({
+      ...B,
+      fontSize: 16,
+      lineHeight: 1.2
+    }),
+    p.annotation.pinnedNumber({
+      fill: v.ink,
+      stroke: v.paper,
+      shadow: "none"
+    }),
+    p.annotation.pinnedNumber.label({ ...B }),
+    p.annotation.comment({
+      fill: v.ink,
+      stroke: v.paper,
+      shadow: "none"
+    }),
+    p.annotation.comment.label({ ...B }),
+    p.annotation.differenceArrow({
+      stroke: v.ink,
+      strokeWidth: 1.25
+    }),
+    p.annotation.differenceArrow.label({ ...B }),
+    p.annotation.arrow({
+      stroke: v.ink,
+      strokeWidth: 1.25,
+      dashArray: []
+    }),
+    p.annotation.shape({
+      fill: m.sage,
+      fillAlpha: 0.14,
+      strokeWidth: 0
+    }),
+    p.panelBorder.bottom({ strokeWidth: 0 }, { coord: "polar" }),
+    p.geom.area({ fillAlpha: 0.35 }, { coord: "polar" }),
+    p.tickLabel({
+      ...L,
+      fontWeight: 700,
+      textOutlineColor: v.paper,
+      textOutlineWidth: 3
+    }, { coord: "polar" })
+  ]
+}, et = v.ink;
+var bt = 0.6, Mt = 0.7, de = 5, ce = 0.35, ue = (t) => `${t}-${Ct().replace(/[^a-zA-Z0-9]/gu, "")}`, K = ({ path: t, color: e, opacity: r }) => {
+  const a = ue("wash");
+  return /* @__PURE__ */ w("g", { children: [
+    /* @__PURE__ */ g("clipPath", {
+      id: a,
+      children: /* @__PURE__ */ g("path", { d: t })
+    }),
+    /* @__PURE__ */ g("path", {
+      d: t,
+      fill: e,
+      fillOpacity: r
+    }),
+    /* @__PURE__ */ g("path", {
+      d: t,
+      fill: "none",
+      stroke: e,
+      strokeOpacity: ce,
+      strokeWidth: de,
+      clipPath: `url(#${a})`
+    })
+  ] });
+}, x = ({ path: t, width: e = 1, opacity: r = 1 }) => /* @__PURE__ */ g("path", {
+  d: t,
+  fill: "none",
+  stroke: et,
+  strokeWidth: e,
+  strokeOpacity: r,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+}), rt = ({ base: t, length: e, angle: r, color: a, opacity: n = 1, washOpacity: i = 0.6 }) => {
+  const { blade: s, rib: o } = Z(t, e, e * 0.32, r);
+  return /* @__PURE__ */ w("g", {
+    opacity: n,
+    children: [/* @__PURE__ */ g("path", {
+      d: s,
+      fill: a,
+      fillOpacity: i,
+      stroke: et,
+      strokeWidth: 0.8,
+      strokeLinejoin: "round"
+    }), /* @__PURE__ */ g(x, {
+      path: o,
+      width: bt,
+      opacity: Mt
+    })]
+  });
+}, R = (t) => {
+  const e = J(t);
+  return (r, a) => ({
+    color: jt(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)
+  });
+}, Pt = (t) => {
+  const e = J(t);
+  return (r, a) => {
+    const n = e.get("strokeWidth", r, a);
+    return {
+      color: e.get("stroke", r, a),
+      opacity: e.get("alpha", r, a) * e.get("strokeAlpha", r, a),
+      width: n,
+      dashArray: Kt(e.get("dashArray", r, a), n)
+    };
+  };
+}, ge = 16, ct = (t, e) => {
+  const r = O(t.data, t.mapping, t.id), a = [];
+  return t.data.groupBy(At.group).forEach((n) => {
+    const i = [...n], [s] = i, o = e(i);
+    s === void 0 || o === null || a.push({
+      key: r(s),
+      observation: s,
+      path: o
+    });
+  }), a;
+}, pe = (t, e) => {
+  const r = t.flatMap((a) => {
+    const n = H(a), i = j(a, e);
+    return n === null || i === null ? [] : [{
+      angle: n,
+      point: i
+    }];
+  }).sort((a, n) => a.angle - n.angle).map(({ point: a }) => a);
+  return r.length === 0 ? null : qt(r);
+}, St = ({ geom: t, observation: e, panel: r, project: a, color: n, opacity: i }) => {
+  const s = a(e, r);
+  return s === null ? null : /* @__PURE__ */ g("g", {
+    "data-geom": t,
+    children: /* @__PURE__ */ g(rt, {
+      base: s,
+      length: ge,
+      angle: -Math.PI / 4,
+      color: n,
+      opacity: i
+    })
+  });
+}, fe = 1.2, ve = /^[ML\d\s.,eE+-]+$/u, ye = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/gu, me = (t) => {
+  if (!ve.test(t)) return null;
+  const e = (t.match(ye) ?? []).map(Number), r = [];
+  for (let a = 0; a + 1 < e.length; a += 2) r.push({
+    x: e[a],
+    y: e[a + 1]
+  });
+  return r;
+}, ut = (t, e, r) => {
+  const a = me(t.replace(/\s*Z\s*$/u, ""));
+  return a === null || a.length < 2 ? t : b(a, {
+    wander: fe,
+    seed: e,
+    closed: r
+  });
+}, _t = ({ layer: t, coordSystem: e, panel: r }) => {
+  const a = R(t), n = I(() => {
+    if (e === void 0) return ct(t, (l) => pe(l, r)).map((l) => ({
+      ...l,
+      fill: l.path,
+      edge: ut(l.path, T(l.key), !0)
+    }));
+    const { areaGenerator: i, lineGenerator: s } = It(e, t.params), o = /* @__PURE__ */ new Map();
+    return ct(t, (l) => {
+      const c = zt(l, t.params.missingValues), h = i(c), u = s(c);
+      if (!h) return null;
+      const d = it(h, r);
+      return u && o.set(d, it(u, r)), d;
+    }).map((l) => ({
+      ...l,
+      fill: l.path,
+      edge: ut(o.get(l.path) ?? "", T(l.key), !1)
+    }));
+  }, [
+    t,
+    e,
+    r
+  ]);
+  return r.width <= 0 || r.height <= 0 ? null : /* @__PURE__ */ g("g", {
+    "data-geom": "area",
+    children: n.map(({ key: i, observation: s, fill: o, edge: l }) => {
+      const c = a(s);
+      return /* @__PURE__ */ w("g", {
+        opacity: c.opacity,
+        children: [/* @__PURE__ */ g(K, {
+          path: o,
+          color: c.color,
+          opacity: c.fillOpacity
+        }), /* @__PURE__ */ g(x, {
+          path: l,
+          width: c.edgeWidth
+        })]
+      }, i);
+    })
+  });
+}, Lt = ({ layer: t, observation: e, panel: r, project: a }) => {
+  const n = R(t)(e, "hovered");
+  return /* @__PURE__ */ g(St, {
+    geom: "area",
+    observation: e,
+    panel: r,
+    project: a,
+    color: n.color,
+    opacity: n.opacity
+  });
+}, Ae = W("area", {
+  coord: "cartesian",
+  guideMode: "crosshair",
+  swatchShape: "area",
+  render: ({ layer: t, coordSystem: e, panelRect: r }) => e.type !== "cartesian" ? null : /* @__PURE__ */ g(_t, {
+    layer: t,
+    coordSystem: e,
+    panel: r
+  }),
+  renderHover: ({ layer: t, primary: e, panelRect: r }) => /* @__PURE__ */ g(Lt, {
+    layer: t,
+    observation: e.observation,
+    panel: r,
+    project: tt
+  }),
+  renderHoverCompanions: () => null
+}), xe = W("area", {
+  coord: "polar",
+  guideMode: "crosshair",
+  swatchShape: "area",
+  render: ({ layer: t, panelRect: e }) => /* @__PURE__ */ g(_t, {
+    layer: t,
+    panel: e
+  }),
+  renderHover: ({ layer: t, primary: e, panelRect: r }) => /* @__PURE__ */ g(Lt, {
+    layer: t,
+    observation: e.observation,
+    panel: r,
+    project: j
+  }),
+  renderHoverCompanions: () => null
+}), ke = 1.4, Ee = 0.8, we = 0.6, $ = 13, be = 14, Me = 6, Pe = 2, Se = {
+  solo: {
+    base: !0,
+    value: !0
+  },
+  floor: {
+    base: !0,
+    value: !1
+  },
+  ceiling: {
+    base: !1,
+    value: !0
+  },
+  middle: {
+    base: !1,
+    value: !1
+  }
+}, _e = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+}, Le = (t, e) => e === "x" ? (xt(t) ?? z(t) ?? 0) >= (Ft(t) ?? 0) ? "top" : "bottom" : (Dt(t) ?? 0) >= (Gt(t) ?? 0) ? "right" : "left", Te = (t, e, r) => {
+  const a = Math.max(0, t.width - r), n = Math.max(0, t.height - r);
+  return e === "top" ? {
+    ...t,
+    y: t.y + t.height - n,
+    height: n
+  } : e === "bottom" ? {
+    ...t,
+    height: n
+  } : e === "left" ? {
+    ...t,
+    x: t.x + t.width - a,
+    width: a
+  } : {
+    ...t,
+    width: a
+  };
+}, We = (t, e) => e === "top" || e === "bottom" ? {
+  breadth: t.width,
+  length: t.height
+} : {
+  breadth: t.height,
+  length: t.width
+}, E = (t, e, r, a) => {
+  const { x: n, y: i, width: s, height: o } = t;
+  return e === "top" ? {
+    x: n + r,
+    y: i + o - a
+  } : e === "bottom" ? {
+    x: n + r,
+    y: i + a
+  } : e === "right" ? {
+    x: n + a,
+    y: i + r
+  } : {
+    x: n + s - a,
+    y: i + r
+  };
+}, Ce = (t, e, r, a) => {
+  const n = r / 2, i = r * 0.36, s = [];
+  for (let o = $ * 0.8; o < a - $ * 0.6; o += $) for (const l of [-1, 1]) {
+    const c = E(t, e, n, o), h = E(t, e, n + l * i * 0.55, o + $ * 0.25), u = E(t, e, n + l * i, o + $ * 0.6);
+    s.push(`M${c.x},${c.y} Q${h.x},${h.y} ${u.x},${u.y}`);
+  }
+  return s.join(" ");
+}, He = ({ layer: t, observation: e, seedKey: r, mainAxis: a, panel: n, state: i }) => {
+  const s = R(t), o = Ot(a, e);
+  if (!o || o.width <= 0 || o.height <= 0) return null;
+  const l = s(e, i), c = Se[Bt(e)], h = Le(e, a), u = {
+    x: o.x * n.width,
+    y: o.y * n.height,
+    width: o.width * n.width,
+    height: o.height * n.height
+  }, d = [c.value ? [] : [h], c.base ? [] : [_e[h]]].flat().reduce((_, M) => Te(_, M, Pe / 2), u), { breadth: f, length: y } = We(d, h);
+  if (f <= 0 || y <= 0) return null;
+  const P = T(r), S = b([
+    E(d, h, 0, 0),
+    E(d, h, 0, y),
+    E(d, h, f, y),
+    E(d, h, f, 0)
+  ], {
+    wander: Math.min(ke, f / 8),
+    seed: P,
+    closed: !0,
+    cornered: !0
+  }), k = f >= Me && y > 8 ? b([E(d, h, f / 2, 1), E(d, h, f / 2, y - 3)], {
+    wander: Ee,
+    seed: P + 1
+  }) : "";
+  return /* @__PURE__ */ w("g", {
+    opacity: l.opacity,
+    children: [
+      /* @__PURE__ */ g(K, {
+        path: S,
+        color: l.color,
+        opacity: l.fillOpacity * we
+      }),
+      k !== "" && /* @__PURE__ */ g(x, {
+        path: k,
+        width: 0.6 * 1.4,
+        opacity: 0.7
+      }),
+      f >= be && /* @__PURE__ */ g(x, {
+        path: Ce(d, h, f, y),
+        width: 0.6,
+        opacity: 0.7 * 0.8
+      }),
+      /* @__PURE__ */ g(x, {
+        path: S,
+        width: l.edgeWidth
+      })
+    ]
+  });
+}, gt = ({ layer: t, observations: e, mainAxis: r, panel: a, state: n }) => {
+  const i = I(() => O(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  return a.width <= 0 || a.height <= 0 ? null : /* @__PURE__ */ g("g", {
+    "data-geom": "bar",
+    children: Array.from(e, (s) => {
+      const o = i(s);
+      return /* @__PURE__ */ g(He, {
+        layer: t,
+        observation: s,
+        seedKey: o,
+        mainAxis: r,
+        panel: a,
+        state: n
+      }, o);
+    })
+  });
+}, Ie = W("bar", {
+  coord: "cartesian",
+  guideMode: "band",
+  swatchShape: "square",
+  render: ({ layer: t, coordSystem: e, panelRect: r }) => /* @__PURE__ */ g(gt, {
+    layer: t,
+    observations: t.data,
+    mainAxis: ot(e),
+    panel: r
+  }),
+  renderHover: ({ layer: t, coordSystem: e, primary: r, panelRect: a }) => /* @__PURE__ */ g(gt, {
+    layer: t,
+    observations: [r.observation],
+    mainAxis: ot(e),
+    panel: a,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), Re = 1.2, $e = 15, Oe = 20, Ne = 0.75, Be = (t, e, r, a) => {
+  const n = O(t.data, t.mapping, t.id), i = [];
+  return t.data.groupBy(At.group).forEach((s) => {
+    const o = [...s], [l] = o;
+    if (l === void 0) return;
+    const c = (r === "polar" ? o.sort((u, d) => (H(u) ?? 0) - (H(d) ?? 0)) : o).flatMap((u) => {
+      const d = a(u, e);
+      return d === null ? [] : [d];
+    });
+    if (c.length < 2) return;
+    const h = n(l);
+    i.push({
+      key: h,
+      observation: l,
+      points: c,
+      stem: b(c, {
+        wander: Re,
+        seed: T(h),
+        closed: r === "polar"
+      })
+    });
+  }), i;
+}, De = (t) => {
+  const e = [];
+  let r = null;
+  return t.forEach((a, n) => {
+    if (r !== null && Math.hypot(a.x - r.x, a.y - r.y) < Oe) return;
+    const i = t[Math.max(0, n - 1)], s = t[Math.min(t.length - 1, n + 1)], o = Math.atan2(s.y - i.y, s.x - i.x), l = e.length % 2 === 0 ? -1 : 1;
+    e.push({
+      base: a,
+      angle: o + l * (Math.PI / 2 - Ne)
+    }), r = a;
+  }), e;
+}, Ge = ({ layer: t, panel: e, coord: r, project: a }) => {
+  const n = Pt(t), i = I(() => Be(t, e, r, a), [
+    t,
+    e,
+    r,
+    a
+  ]);
+  return e.width <= 0 || e.height <= 0 ? null : /* @__PURE__ */ g("g", {
+    "data-geom": "line",
+    children: i.map(({ key: s, observation: o, stem: l, points: c }) => {
+      const h = n(o);
+      return /* @__PURE__ */ w("g", {
+        opacity: h.opacity,
+        children: [/* @__PURE__ */ g("path", {
+          d: l,
+          fill: "none",
+          stroke: h.color,
+          strokeWidth: h.width,
+          strokeDasharray: h.dashArray,
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }), De(c).map(({ base: u, angle: d }, f) => /* @__PURE__ */ g(rt, {
+          base: u,
+          length: $e,
+          angle: d,
+          color: h.color
+        }, f))]
+      }, s);
+    })
+  });
+}, Fe = ({ layer: t, observation: e, panel: r, project: a }) => {
+  const n = Pt(t)(e, "hovered");
+  return /* @__PURE__ */ g(St, {
+    geom: "line",
+    observation: e,
+    panel: r,
+    project: a,
+    color: n.color,
+    opacity: n.opacity
+  });
+}, Tt = (t, e) => W("line", {
+  coord: t,
+  guideMode: "crosshair",
+  swatchShape: "line",
+  render: ({ layer: r, panelRect: a }) => /* @__PURE__ */ g(Ge, {
+    layer: r,
+    panel: a,
+    coord: t,
+    project: e
+  }),
+  renderHover: ({ layer: r, primary: a, panelRect: n }) => /* @__PURE__ */ g(Fe, {
+    layer: r,
+    observation: a.observation,
+    panel: n,
+    project: e
+  }),
+  renderHoverCompanions: () => null,
+  getOverlayAnchor: ({ observation: r }) => {
+    const a = H(r), n = z(r);
+    return a === null || n === null ? null : {
+      x: a,
+      y: n
+    };
+  }
+}), ze = Tt("cartesian", tt), je = Tt("polar", j), Ke = 2.6, Ve = 4, pt = ({ layer: t, observations: e, panel: r, project: a, state: n }) => {
+  const i = J(t), s = R(t), o = I(() => O(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]), l = n === "hovered" ? Ve : 0;
+  return /* @__PURE__ */ g("g", {
+    "data-geom": "point",
+    children: Array.from(e, (c) => {
+      const h = a(c, r);
+      if (h === null) return null;
+      const u = o(c), d = s(c, n), f = (i.get("size", c, n) + l) * Ke, y = N(T(u))() * Math.PI * 2;
+      return /* @__PURE__ */ g(rt, {
+        base: {
+          x: h.x - Math.cos(y) * f / 2,
+          y: h.y - Math.sin(y) * f / 2
+        },
+        length: f,
+        angle: y,
+        color: d.color,
+        opacity: d.opacity,
+        washOpacity: d.fillOpacity * 0.7
+      }, u);
+    })
+  });
+}, Wt = (t, e) => W("point", {
+  coord: t,
+  swatchShape: "circle",
+  render: ({ layer: r, panelRect: a }) => /* @__PURE__ */ g(pt, {
+    layer: r,
+    observations: r.data,
+    panel: a,
+    project: e
+  }),
+  renderHover: ({ layer: r, primary: a, panelRect: n }) => /* @__PURE__ */ g(pt, {
+    layer: r,
+    observations: [a.observation],
+    panel: n,
+    project: e,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), Ue = Wt("cartesian", tt), Ye = Wt("polar", j), Xe = 3, Ze = 1.6, qe = Math.PI / 30, Qe = 0.6, Je = 0.3, tr = 0.13, ft = 34, er = "#B08A2E", F = (t, e, r) => {
+  const a = kt(e, 1);
+  return {
+    x: t.width / 2 + a.x * r,
+    y: t.height / 2 - a.y * r
+  };
+}, vt = (t, e, r, a) => {
+  const n = Math.max(1, Math.ceil(Math.abs(r - e) / qe));
+  return Array.from({ length: n + 1 }, (i, s) => F(t, e + (r - e) * s / n, a));
+}, rr = (t, e, r) => {
+  const { startAngle: a, endAngle: n } = $t(t), { innerRadius: i, outerRadius: s } = Q(t);
+  if (a === null || n === null || i === null || s === null) return null;
+  const o = Math.min(e.width, e.height) / 2, l = s * o, c = i * o;
+  if (l <= 0) return null;
+  const h = Math.max(0, n - a), u = h >= 2 * Math.PI - 1e-6 ? 0 : Math.min(Xe / 2 / l, h / 4), d = a + u, f = n - u, y = vt(e, d, f, l), P = c > 0 ? vt(e, f, d, c) : [F(e, 0, 0)], S = b([...y, ...P], {
+    wander: Ze,
+    seed: r,
+    closed: !0,
+    step: 12
+  }), k = Math.max(1, Math.round((f - d) / Je)), _ = c + (l - c) * 0.12, M = l - (l - c) * 0.14;
+  return {
+    outline: S,
+    veins: Array.from({ length: k }, (V, at) => {
+      const nt = d + (f - d) * (at + 0.5) / k;
+      return b([F(e, nt, _), F(e, nt, M)], {
+        wander: 0.8,
+        seed: r + at + 1
+      });
+    }).join(" ")
+  };
+}, ar = (t, e, r) => {
+  const a = N(r), n = Math.PI * (3 - Math.sqrt(5));
+  return Array.from({ length: ft }, (i, s) => {
+    const o = e * 0.85 * Math.sqrt((s + 0.5) / ft), l = s * n + a() * 0.2, c = t.x + Math.cos(l) * o, h = t.y + Math.sin(l) * o;
+    return `M${c.toFixed(2)},${h.toFixed(2)} h0.01`;
+  }).join(" ");
+}, yt = ({ layer: t, observations: e, panel: r, state: a }) => {
+  const n = R(t), i = I(() => O(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  if (r.width <= 0 || r.height <= 0) return null;
+  const s = Array.from(e, (u) => {
+    const d = i(u);
+    return {
+      key: d,
+      observation: u,
+      paint: n(u, a),
+      petal: rr(u, r, T(d))
+    };
+  }), o = s.map(({ observation: u }) => Q(u)), l = a === void 0 && s.length > 1 && o.every(({ innerRadius: u, outerRadius: d }) => u === 0 && d === o[0]?.outerRadius), c = {
+    x: r.width / 2,
+    y: r.height / 2
+  }, h = Math.min(r.width, r.height) / 2 * tr;
+  return /* @__PURE__ */ w("g", {
+    "data-geom": "bar",
+    children: [s.map(({ key: u, paint: d, petal: f }) => f === null ? null : /* @__PURE__ */ w("g", {
+      opacity: d.opacity,
+      children: [
+        /* @__PURE__ */ g(K, {
+          path: f.outline,
+          color: d.color,
+          opacity: d.fillOpacity * Qe
+        }),
+        /* @__PURE__ */ g(x, {
+          path: f.veins,
+          width: bt,
+          opacity: Mt * 0.8
+        }),
+        /* @__PURE__ */ g(x, {
+          path: f.outline,
+          width: d.edgeWidth
+        })
+      ]
+    }, u)), l && /* @__PURE__ */ w("g", { children: [
+      /* @__PURE__ */ g("circle", {
+        cx: c.x,
+        cy: c.y,
+        r: h,
+        fill: er,
+        fillOpacity: 0.55
+      }),
+      /* @__PURE__ */ g(x, {
+        path: ar(c, h, 7),
+        width: 2.2
+      }),
+      /* @__PURE__ */ g(x, { path: b(Array.from({ length: 13 }, (u, d) => {
+        const f = d / 12 * Math.PI * 2;
+        return {
+          x: c.x + Math.cos(f) * h,
+          y: c.y + Math.sin(f) * h
+        };
+      }), {
+        wander: 0.8,
+        seed: 11
+      }) })
+    ] })]
+  });
+}, nr = W("bar", {
+  coord: "polar",
+  guideMode: "band",
+  swatchShape: "slice",
+  render: ({ layer: t, panelRect: e }) => /* @__PURE__ */ g(yt, {
+    layer: t,
+    observations: t.data,
+    panel: e
+  }),
+  renderHover: ({ layer: t, primary: e, panelRect: r }) => /* @__PURE__ */ g(yt, {
+    layer: t,
+    observations: [e.observation],
+    panel: r,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), D = 3, or = 1, ir = ({ layer: t, observation: e, seedKey: r, panel: a, state: n }) => {
+  const i = R(t), s = Nt(e);
+  if (s === null) return null;
+  const o = i(e, n), l = s.x * a.width + D / 2, c = s.y * a.height + D / 2, h = s.width * a.width - D, u = s.height * a.height - D;
+  if (h <= 0 || u <= 0) return null;
+  const d = b([
+    {
+      x: l,
+      y: c
+    },
+    {
+      x: l + h,
+      y: c
+    },
+    {
+      x: l + h,
+      y: c + u
+    },
+    {
+      x: l,
+      y: c + u
+    }
+  ], {
+    wander: Math.min(or, h / 10, u / 10),
+    seed: T(r),
+    closed: !0,
+    cornered: !0
+  });
+  return /* @__PURE__ */ w("g", {
+    opacity: o.opacity,
+    children: [/* @__PURE__ */ g(K, {
+      path: d,
+      color: o.color,
+      opacity: o.fillOpacity * 0.85
+    }), /* @__PURE__ */ g(x, {
+      path: d,
+      width: n === "hovered" ? o.edgeWidth : 0.8,
+      opacity: 0.85
+    })]
+  });
+}, mt = ({ layer: t, observations: e, panel: r, state: a }) => {
+  const n = I(() => Rt(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  return r.width <= 0 || r.height <= 0 ? null : /* @__PURE__ */ g("g", {
+    "data-geom": "tile",
+    children: Array.from(e, (i) => {
+      const s = n(i);
+      return /* @__PURE__ */ g(ir, {
+        layer: t,
+        observation: i,
+        seedKey: s,
+        panel: r,
+        state: a
+      }, s);
+    })
+  });
+}, sr = W("tile", {
+  coord: "cartesian",
+  guideMode: null,
+  swatchShape: "square",
+  render: ({ layer: t, panelRect: e }) => /* @__PURE__ */ g(mt, {
+    layer: t,
+    observations: t.data,
+    panel: e
+  }),
+  renderHover: ({ layer: t, primary: e, panelRect: r }) => /* @__PURE__ */ g(mt, {
+    layer: t,
+    observations: [e.observation],
+    panel: r,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), lr = [
+  Ie,
+  nr,
+  sr,
+  ze,
+  je,
+  Ae,
+  xe,
+  Ue,
+  Ye
+], hr = ({ fill: t, fillOpacity: e, ...r }) => /* @__PURE__ */ g(Ht, {
+  ...r,
+  fill: t,
+  fillOpacity: 0.6,
+  stroke: et,
+  strokeWidth: 0.9
+}), dr = { Circle: hr }, pr = {
+  name: "botanical",
+  styles: he,
+  palette: ie,
+  colormap: se,
+  colorScheme: "light",
+  plugins: lr,
+  shapes: dr
+};
+export {
+  pr as botanical
+};