@graphysdk/theme-chalkboard 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1220 @@
+import { useId as bt, useMemo as O } from "react";
+import { DefaultGeomCircle as Ot, GROUP_VARIABLES as kt, createAreaPathGenerators as Dt, createStableCellKeyGenerator as Lt, createStableKeyGenerator as W, defineGeomRenderer as P, getAngleExtent as Wt, getBarRectBounds as Nt, getPaintedTileRect as Gt, getRadiusExtent as St, getStackRole as Bt, getX as b, getXMax as Ft, getXMin as Kt, getY as Y, getYMax as Et, getYMin as Ut, polarToUnit as Rt, prepareAreaObservations as zt, readMainAxis as at, style as v, toPaintColor as jt, toStrokeDasharray as Vt, toViewBoxX as Yt, toViewBoxY as Xt, useGeomStyleReader as X } from "@graphysdk/react";
+import { jsx as c, jsxs as _ } from "react/jsx-runtime";
+var Zt = /[a-df-zA-DF-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/gu, qt = /^[a-zA-Z]$/u, Jt = (t, r) => t === "H" ? "x" : t === "V" ? "y" : r % 2 === 0 ? "x" : "y", ot = (t, r) => {
+  let e = "", a = 0;
+  return (t.match(Zt) ?? []).map((o) => {
+    if (qt.test(o))
+      return e = o.toUpperCase(), a = 0, o;
+    const l = Jt(e, a);
+    return a += 1, String(Number(o) * (l === "x" ? r.width : r.height));
+  }).join(" ");
+}, J = (t, r) => {
+  const e = b(t), a = Y(t) ?? Et(t);
+  return e === null || a === null ? null : {
+    x: Yt(e) * r.width,
+    y: Xt(a) * r.height
+  };
+}, Z = (t, r) => {
+  const e = b(t), a = Y(t) ?? St(t).outerRadius;
+  if (e === null || a === null) return null;
+  const o = Rt(e, a), l = Math.min(r.width, r.height) / 2;
+  return {
+    x: r.width / 2 + o.x * l,
+    y: r.height / 2 - o.y * l
+  };
+}, Qt = (t) => ({
+  x: 0,
+  y: 0,
+  width: t.width,
+  height: t.height
+}), te = (t) => `${t.map((r, e) => `${e === 0 ? "M" : "L"}${r.x},${r.y}`).join(" ")} Z`;
+var ee = 34, q = 8, G = 72, nt = 11, B = 6, re = (t, r, e) => `<svg x="${t}" y="${r}" width="1" height="1" overflow="visible">${e}</svg>`, ae = ({ wood: t, woodLight: r, woodDark: e }) => {
+  const a = (o, l, s, n = 1) => `<rect x="${o}" y="${o}" rx="3" style="width:calc(100% - ${o * 2}px);height:calc(100% - ${o * 2}px)" fill="none" stroke="${s}" stroke-width="${l}" stroke-opacity="${n}"/>`;
+  return a(8 / 2, 8, t) + a(0.5, 1, e) + a(8 - 0.5, 1, r, 0.7) + a(9, 2, "#000000", 0.18);
+}, oe = ({ wood: t, woodLight: r, woodDark: e, dust: a }) => `<svg x="0" y="100%" width="100%" height="1" overflow="visible"><rect x="0" y="-13" width="100%" height="13" fill="${t}"/><rect x="0" y="-13" width="100%" height="1.5" fill="${r}"/><rect x="0" y="-1" width="100%" height="1" fill="${e}"/><rect x="12" y="-13" style="width:calc(100% - 24px)" height="1.5" fill="${a}" fill-opacity="0.45"/></svg>`, ne = ({ wood: t, woodDark: r, felt: e, dust: a, chalks: o }) => {
+  let s = -34 - G;
+  return `<rect x="${s}" y="${-13 - B}" width="${G}" height="${B}" rx="1" fill="${e}"/><rect x="${s + 1}" y="${-13 - B}" width="${G - 2}" height="1.5" fill="${a}" fill-opacity="0.35"/><rect x="${s}" y="${-13 - B - nt}" width="${G}" height="${nt}" rx="2.5" fill="${t}" stroke="${r}" stroke-width="0.75"/>` + o.map((n, h) => {
+    const d = ee - h * 6;
+    return s -= d + 14, `<rect x="${s}" y="${-13 - q}" width="${d}" height="${q}" rx="${q / 2}" fill="${n}"/><rect x="${s + 2}" y="-20" width="${d - 4}" height="1.2" fill="#FFFFFF" fill-opacity="0.35"/>`;
+  }).join("");
+}, ie = (t) => `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%">' + ae(t) + oe(t) + re("100%", "100%", ne(t)) + "</svg>")}`, f = {
+  board: "#27362F",
+  wiped: "#1F2C26",
+  chalk: "#F4F1E8",
+  dusty: "#C9D1C8",
+  grid: "rgba(244, 241, 232, 0.24)",
+  edge: "rgba(244, 241, 232, 0.45)",
+  axis: "rgba(244, 241, 232, 0.85)",
+  wood: "#86643F",
+  woodLight: "#A88456",
+  woodDark: "#4F3923",
+  felt: "#5E5A55"
+}, he = "'Gochi Hand', 'Comic Sans MS', cursive", S = {
+  white: "#F4F1E8",
+  yellow: "#F7DC6F",
+  pink: "#F49AC2",
+  blue: "#8FD3F4",
+  green: "#A8E6A1",
+  orange: "#F9A65A"
+}, _t = [
+  S.white,
+  S.yellow,
+  S.pink,
+  S.blue,
+  S.green,
+  S.orange
+], le = [
+  "#668F99",
+  S.blue,
+  S.white
+], se = (t, r) => `data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" width="${t}" height="${t}" viewBox="0 0 ${t} ${t}">${r}</svg>`)}`, F = 480, de = {
+  image: se(F, `<filter id="smear" x="0" y="0" width="100%" height="100%"><feTurbulence type="fractalNoise" baseFrequency="0.004 0.021" numOctaves="4" seed="11" stitchTiles="stitch"/><feColorMatrix values="0 0 0 0 0.96  0 0 0 0 0.95  0 0 0 0 0.91  0.3 0 0 0 -0.1"/></filter><rect width="${F}" height="${F}" filter="url(#smear)"/>`),
+  size: F,
+  fallback: f.board
+}, ce = {
+  image: ie({
+    wood: f.wood,
+    woodLight: f.woodLight,
+    woodDark: f.woodDark,
+    felt: f.felt,
+    dust: f.chalk,
+    chalks: [
+      S.white,
+      S.yellow,
+      S.pink
+    ]
+  }),
+  fit: "stretch",
+  fallback: "transparent"
+}, K = 22, ge = 6, ue = 0.82, it = 2.4, I = {
+  fontWeight: 400,
+  textColor: f.chalk
+}, T = {
+  fontWeight: 400,
+  textColor: f.dusty
+}, ht = {
+  dashArray: [],
+  lineCap: "round",
+  lineJoin: "round"
+}, U = {
+  ...I,
+  fontSize: 16,
+  textOutlineColor: f.board,
+  textOutlineWidth: 4,
+  fill: "transparent",
+  stroke: "transparent",
+  strokeWidth: 0,
+  cornerRadius: 0,
+  paddingInline: 3,
+  paddingBlock: 0,
+  shadow: "none"
+}, pe = {
+  tokens: {
+    graphBackground: f.board,
+    graphBorder: f.edge,
+    geom: S.white,
+    geomBorder: f.axis,
+    textPrimary: f.chalk,
+    textSecondary: f.dusty,
+    ruleLine: f.chalk,
+    gridLine: f.grid,
+    hoverAffordance: f.board,
+    hoverGuideFill: "rgba(244, 241, 232, 0.07)",
+    hoverGuideLine: f.edge,
+    tooltipBackground: f.wiped,
+    tooltipBorder: f.edge,
+    tooltipPrimaryRow: "rgba(244, 241, 232, 0.1)",
+    annotationShape: S.yellow,
+    annotationArrow: f.chalk,
+    differenceLabelBackground: f.wiped
+  },
+  defaults: [
+    v.graph({
+      fill: de,
+      overlay: ce,
+      strokeWidth: 0,
+      cornerRadius: 4,
+      fontFamily: he,
+      padding: {
+        top: K,
+        right: K,
+        bottom: K + 13 + ge,
+        left: K
+      }
+    }),
+    v.geom({ shadow: "none" }),
+    v.geom({ shadow: "none" }, { state: "hovered" }),
+    v.geom.bar({
+      fillAlpha: ue,
+      stroke: f.chalk,
+      strokeWidth: it,
+      cornerRadius: 2
+    }),
+    v.geom.bar({
+      fillAlpha: 1,
+      stroke: f.chalk,
+      strokeWidth: 3,
+      shadow: "none"
+    }, { state: "hovered" }),
+    v.geom.line({
+      strokeWidth: 4,
+      ...ht
+    }),
+    v.geom.area({
+      fillAlpha: 0.72,
+      strokeWidth: 3,
+      ...ht
+    }),
+    v.geom.point({
+      size: 14,
+      stroke: f.board,
+      strokeWidth: 1.5
+    }),
+    v.geom.tile({
+      fillAlpha: 0.9,
+      cornerRadius: 2,
+      stroke: f.board,
+      strokeWidth: 3
+    }),
+    v.geom.tile({
+      fillAlpha: 1,
+      stroke: f.chalk,
+      strokeWidth: it
+    }, { state: "hovered" }),
+    v.geom.rule({
+      strokeWidth: 2.5,
+      dashArray: [2, 7],
+      lineCap: "round"
+    }),
+    v.geom.rule.label({
+      ...I,
+      fontSize: 15
+    }),
+    v.gridLine({ dashArray: [7, 7] }),
+    v.gridLine.y({ strokeWidth: 1.5 }),
+    v.panelBorder({ strokeWidth: 0 }),
+    v.panelBorder.left({
+      stroke: f.axis,
+      strokeWidth: 2.5,
+      dashArray: []
+    }),
+    v.panelBorder.bottom({
+      stroke: f.axis,
+      strokeWidth: 2.5,
+      dashArray: []
+    }),
+    v.tickLine({ strokeWidth: 0 }),
+    v.tickLabel({
+      ...T,
+      fontSize: 15,
+      lineHeight: 1
+    }),
+    v.axisLabel({
+      ...T,
+      fontSize: 16,
+      lineHeight: 1
+    }),
+    v.heading({ ...I }),
+    v.heading.h1({
+      fontSize: 27,
+      lineHeight: 1
+    }),
+    v.heading.h2({
+      ...T,
+      fontSize: 18,
+      lineHeight: 1.1
+    }),
+    v.header({ margin: { bottom: 16 } }),
+    v.caption({
+      ...T,
+      fontSize: 14
+    }),
+    v.source({
+      ...T,
+      fontSize: 14
+    }),
+    v.dataLabel({
+      ...I,
+      fontSize: 15,
+      lineHeight: 1,
+      fill: "transparent",
+      paddingBlock: 1,
+      paddingInline: 3
+    }),
+    v.legendItem({
+      ...I,
+      fontSize: 16,
+      fill: "transparent",
+      stroke: "transparent"
+    }),
+    v.directLabel({
+      fontWeight: 400,
+      fontSize: 16
+    }),
+    v.tooltip({
+      strokeWidth: 2,
+      cornerRadius: 3,
+      paddingInline: 12,
+      paddingBlock: 9,
+      shadow: "none"
+    }),
+    v.tooltip.heading({
+      ...I,
+      fontSize: 17,
+      lineHeight: 1.15
+    }),
+    v.tooltip.label({
+      ...T,
+      fontSize: 15,
+      lineHeight: 1.25
+    }),
+    v.tooltip.value({
+      ...I,
+      fontSize: 15,
+      lineHeight: 1.25
+    }),
+    v.annotation.text({
+      ...U,
+      paddingInline: 6,
+      paddingBlock: 2,
+      fontSize: 17,
+      lineHeight: 1.15
+    }),
+    v.annotation.pinnedNumber({
+      fill: f.chalk,
+      stroke: f.board
+    }),
+    v.annotation.pinnedNumber.label({ ...U }),
+    v.annotation.comment({
+      fill: f.chalk,
+      stroke: f.board
+    }),
+    v.annotation.comment.label({ ...U }),
+    v.annotation.differenceArrow({
+      stroke: f.chalk,
+      strokeWidth: 2.5
+    }),
+    v.annotation.differenceArrow.label({ ...U }),
+    v.annotation.arrow({
+      stroke: f.chalk,
+      strokeWidth: 3,
+      dashArray: []
+    }),
+    v.annotation.shape({
+      fill: f.chalk,
+      fillAlpha: 0.1,
+      strokeWidth: 0
+    }),
+    v.tickLabel({
+      textOutlineColor: f.board,
+      textOutlineWidth: 3
+    }, { coord: "polar" }),
+    v.panelBorder.left({ strokeWidth: 0 }, { coord: "polar" }),
+    v.panelBorder.bottom({ strokeWidth: 0 }, { coord: "polar" })
+  ]
+}, R = (t) => {
+  let r = 2166136261;
+  for (let e = 0; e < t.length; e += 1)
+    r ^= t.charCodeAt(e), r = Math.imul(r, 16777619);
+  return r >>> 0;
+}, D = (t) => {
+  let r = t || 1;
+  return () => {
+    r = r + 1831565813 | 0;
+    let e = Math.imul(r ^ r >>> 15, 1 | r);
+    return e = e + Math.imul(e ^ e >>> 7, 61 | e) ^ e, ((e ^ e >>> 14) >>> 0) / 4294967296;
+  };
+}, ve = (t) => {
+  const r = [
+    0.035,
+    0.07,
+    0.13
+  ].map((a, o) => ({
+    frequency: a * (0.7 + t() * 0.6),
+    phase: t() * Math.PI * 2,
+    weight: 1 / (o + 1)
+  })), e = r.reduce((a, o) => a + o.weight, 0);
+  return (a) => r.reduce((o, l) => o + l.weight * Math.sin(a * l.frequency + l.phase), 0) / e;
+}, H = (t, { wander: r, seed: e, closed: a = !1, step: o = 9, cornered: l = !1 }) => {
+  if (t.length < 2) return "";
+  const s = ve(D(e)), n = a ? [...t, t[0]] : [...t], h = [], d = [];
+  let g = 0;
+  for (let p = 0; p < n.length - 1; p += 1) {
+    const i = n[p], u = n[p + 1], y = Math.hypot(u.x - i.x, u.y - i.y);
+    if (y === 0) continue;
+    const x = {
+      x: -(u.y - i.y) / y,
+      y: (u.x - i.x) / y
+    }, E = Math.max(1, Math.ceil(y / o)), w = [];
+    for (let m = 0; m <= E; m += 1) {
+      const A = m / E, C = r * Math.sin(Math.PI * A) * s(g + A * y);
+      w.push({
+        x: i.x + (u.x - i.x) * A + x.x * C,
+        y: i.y + (u.y - i.y) * A + x.y * C
+      });
+    }
+    d.push(w), h.push(...w.slice(0, -1)), g += y;
+  }
+  return l ? `${d.map((p) => lt(p, !1)).map((p, i) => i === 0 ? p : p.replace(/^M/u, "L")).join(" ")}${a ? " Z" : ""}` : (a || h.push(n[n.length - 1]), lt(h, a));
+}, k = (t) => (Math.round(t * 100) / 100).toString(), lt = (t, r) => {
+  const e = t.length, a = (n) => r ? t[(n + e) % e] : t[Math.max(0, Math.min(e - 1, n))], o = a(0), l = [`M${k(o.x)},${k(o.y)}`], s = r ? e : e - 1;
+  for (let n = 0; n < s; n += 1) {
+    const [h, d, g, p] = [
+      a(n - 1),
+      a(n),
+      a(n + 1),
+      a(n + 2)
+    ], i = {
+      x: d.x + (g.x - h.x) / 6,
+      y: d.y + (g.y - h.y) / 6
+    }, u = {
+      x: g.x - (p.x - d.x) / 6,
+      y: g.y - (p.y - d.y) / 6
+    };
+    l.push(`C${k(i.x)},${k(i.y)} ${k(u.x)},${k(u.y)} ${k(g.x)},${k(g.y)}`);
+  }
+  return `${l.join(" ")}${r ? " Z" : ""}`;
+}, fe = 9, L = ({ run: t, skip: r }, e) => {
+  const a = D(e), o = ([l, s]) => k(l + a() * (s - l));
+  return Array.from({ length: fe }, () => `${o(t)} ${o(r)}`).join(" ");
+}, ye = 0.07, me = 40, xe = (t, { angle: r, spacing: e, seed: a }) => {
+  const o = D(a), l = {
+    x: t.x + t.width / 2,
+    y: t.y + t.height / 2
+  }, s = Math.hypot(t.width, t.height) / 2 + e, n = [];
+  for (let h = -s; h <= s; h += e * (0.75 + o() * 0.5)) {
+    const d = r + (o() - 0.5) * Math.min(ye, e / s), g = {
+      x: Math.cos(d),
+      y: Math.sin(d)
+    }, p = {
+      x: -Math.sin(r),
+      y: Math.cos(r)
+    }, i = {
+      x: l.x + p.x * h,
+      y: l.y + p.y * h
+    }, u = s + o() * me;
+    n.push(H([{
+      x: i.x - g.x * u,
+      y: i.y - g.y * u
+    }, {
+      x: i.x + g.x * s,
+      y: i.y + g.y * s
+    }], {
+      wander: 1.1,
+      seed: a + n.length + 1,
+      step: 14
+    }));
+  }
+  return n.join(" ");
+}, Ae = (t, r, e) => {
+  const a = (D(e)() - 0.5) * 0.25, o = (l) => {
+    const s = {
+      x: Math.cos(l) * r,
+      y: Math.sin(l) * r
+    };
+    return `M${k(t.x - s.x)},${k(t.y - s.y)} L${k(t.x + s.x)},${k(t.y + s.y)}`;
+  };
+  return `${o(Math.PI / 4 + a)} ${o(-Math.PI / 4 - a)}`;
+}, Q = (t, r, { seed: e, overshoot: a, wander: o, drift: l = 0 }) => {
+  const s = D(e)() * Math.PI * 2, n = Math.PI * 2 + a, h = Math.max(8, Math.ceil(n * r / 10)), d = Array.from({ length: h + 1 }, (g, p) => {
+    const i = n * p / h, u = Math.max(0, i - Math.PI * 2) / Math.max(a, 1e-6), y = r + l * u * u, x = s + i;
+    return {
+      x: t.x + Math.cos(x) * y,
+      y: t.y + Math.sin(x) * y
+    };
+  });
+  return H(d, {
+    wander: o,
+    seed: e + 1,
+    step: 6
+  });
+}, we = 0.4, ke = 0.85, Se = {
+  run: [14, 46],
+  skip: [1.5, 4]
+}, Ee = 0.35, Re = {
+  run: [1.5, 6],
+  skip: [2, 7]
+}, st = {
+  x: 0.45,
+  y: -0.35
+}, j = {
+  x: -0.6,
+  y: 0.55
+}, _e = {
+  run: [18, 70],
+  skip: [1.5, 5]
+}, $e = {
+  run: [1, 4],
+  skip: [3, 9]
+}, Ce = 0.55, He = 0.16, dt = [
+  -Math.PI / 4,
+  Math.PI / 4,
+  -Math.PI / 2.6,
+  Math.PI / 2.6,
+  -Math.PI / 8,
+  Math.PI / 8
+], tt = (t, r = 0) => {
+  const e = _t.indexOf(t);
+  return dt[(e < 0 ? r : e) % dt.length];
+}, $t = (t) => `${t}-${bt().replace(/[^a-zA-Z0-9]/gu, "")}`, $ = ({ path: t, color: r, width: e, seed: a, opacity: o = 1 }) => /* @__PURE__ */ _("g", {
+  opacity: o,
+  fill: "none",
+  stroke: r,
+  strokeLinejoin: "round",
+  children: [
+    /* @__PURE__ */ c("path", {
+      d: t,
+      strokeWidth: e,
+      strokeOpacity: we,
+      strokeLinecap: "round"
+    }),
+    /* @__PURE__ */ c("path", {
+      d: t,
+      strokeWidth: e * ke,
+      strokeDasharray: L(Se, a),
+      transform: `translate(${st.x} ${st.y})`
+    }),
+    /* @__PURE__ */ c("path", {
+      d: t,
+      strokeWidth: Math.max(0.8, e * Ee),
+      strokeDasharray: L(Re, a + 1),
+      transform: `translate(${j.x} ${j.y})`
+    })
+  ]
+}), et = ({ region: t, bounds: r, color: e, angle: a, spacing: o, width: l, seed: s, pressure: n }) => {
+  const h = $t("shade"), d = xe(r, {
+    angle: a,
+    spacing: o,
+    seed: s
+  });
+  return /* @__PURE__ */ _("g", { children: [
+    /* @__PURE__ */ c("clipPath", {
+      id: h,
+      children: /* @__PURE__ */ c("path", { d: t })
+    }),
+    /* @__PURE__ */ c("path", {
+      d: t,
+      fill: f.board,
+      fillOpacity: Ce
+    }),
+    /* @__PURE__ */ c("path", {
+      d: t,
+      fill: e,
+      fillOpacity: n * He
+    }),
+    /* @__PURE__ */ _("g", {
+      clipPath: `url(#${h})`,
+      fill: "none",
+      stroke: e,
+      children: [/* @__PURE__ */ c("path", {
+        d,
+        strokeWidth: l,
+        strokeOpacity: n * 0.72,
+        strokeDasharray: L(_e, s + 2)
+      }), /* @__PURE__ */ c("path", {
+        d,
+        strokeWidth: l * 0.4,
+        strokeOpacity: n,
+        strokeDasharray: L($e, s + 3),
+        transform: `translate(${j.x} ${j.y})`
+      })]
+    })
+  ] });
+}, M = (t) => {
+  const r = X(t);
+  return (e, a) => ({
+    color: jt(r.get("fill", e, a)),
+    opacity: r.get("alpha", e, a),
+    fillOpacity: r.get("fillAlpha", e, a),
+    edge: r.get("stroke", e, a),
+    edgeWidth: r.get("strokeWidth", e, a)
+  });
+}, Ct = (t) => {
+  const r = X(t);
+  return (e, a) => {
+    const o = r.get("strokeWidth", e, a);
+    return {
+      color: r.get("stroke", e, a),
+      opacity: r.get("alpha", e, a) * r.get("strokeAlpha", e, a),
+      width: o,
+      dashArray: Vt(r.get("dashArray", e, a), o)
+    };
+  };
+}, Ie = 10, Pe = 2.2, Me = 0.5, ct = (t, r) => {
+  const e = W(t.data, t.mapping, t.id), a = [];
+  return t.data.groupBy(kt.group).forEach((o) => {
+    const l = [...o], [s] = l, n = r(l);
+    s === void 0 || n === null || a.push({
+      key: e(s),
+      observation: s,
+      path: n
+    });
+  }), a;
+}, Te = (t, r) => {
+  const e = t.flatMap((a) => {
+    const o = b(a), l = Z(a, r);
+    return o === null || l === null ? [] : [{
+      angle: o,
+      point: l
+    }];
+  }).sort((a, o) => a.angle - o.angle).map(({ point: a }) => a);
+  return e.length === 0 ? null : te(e);
+}, rt = ({ geom: t, observation: r, panel: e, project: a, color: o, opacity: l, radius: s = Ie }) => {
+  const n = a(r, e);
+  return n === null ? null : /* @__PURE__ */ c("g", {
+    "data-geom": t,
+    children: /* @__PURE__ */ c($, {
+      path: Q(n, s, {
+        seed: 19,
+        overshoot: Me,
+        wander: 0.5
+      }),
+      color: o,
+      width: Pe,
+      seed: 23,
+      opacity: l
+    })
+  });
+}, be = 1.3, Oe = 3.2, De = 8, Le = /^[ML\d\s.,eE+-]+$/u, We = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/gu, Ne = (t) => {
+  if (!Le.test(t)) return null;
+  const r = (t.match(We) ?? []).map(Number), e = [];
+  for (let a = 0; a + 1 < r.length; a += 2) e.push({
+    x: r[a],
+    y: r[a + 1]
+  });
+  return e;
+}, gt = (t, r, e) => {
+  const a = Ne(t.replace(/\s*Z\s*$/u, ""));
+  return a === null || a.length < 2 ? t : H(a, {
+    wander: be,
+    seed: r,
+    closed: e
+  });
+}, Ht = ({ layer: t, coordSystem: r, panel: e }) => {
+  const a = M(t), o = O(() => {
+    if (r === void 0) return ct(t, (h) => Te(h, e)).map((h) => ({
+      ...h,
+      fill: h.path,
+      edge: gt(h.path, R(h.key), !0)
+    }));
+    const { areaGenerator: l, lineGenerator: s } = Dt(r, t.params), n = /* @__PURE__ */ new Map();
+    return ct(t, (h) => {
+      const d = zt(h, t.params.missingValues), g = l(d), p = s(d);
+      if (!g) return null;
+      const i = ot(g, e);
+      return p && n.set(i, ot(p, e)), i;
+    }).map((h) => ({
+      ...h,
+      fill: h.path,
+      edge: gt(n.get(h.path) ?? "", R(h.key), !1)
+    }));
+  }, [
+    t,
+    r,
+    e
+  ]);
+  return e.width <= 0 || e.height <= 0 ? null : /* @__PURE__ */ c("g", {
+    "data-geom": "area",
+    children: o.map(({ key: l, observation: s, fill: n, edge: h }, d) => {
+      const g = a(s), p = R(l);
+      return /* @__PURE__ */ _("g", {
+        opacity: g.opacity,
+        children: [/* @__PURE__ */ c(et, {
+          region: n,
+          bounds: Qt(e),
+          color: g.color,
+          angle: tt(g.color, d),
+          spacing: De,
+          width: Oe,
+          seed: p,
+          pressure: g.fillOpacity
+        }), h !== "" && /* @__PURE__ */ c($, {
+          path: h,
+          color: g.color,
+          width: g.edgeWidth,
+          seed: p
+        })]
+      }, l);
+    })
+  });
+}, It = ({ layer: t, observation: r, panel: e, project: a }) => {
+  const o = M(t)(r, "hovered");
+  return /* @__PURE__ */ c(rt, {
+    geom: "area",
+    observation: r,
+    panel: e,
+    project: a,
+    color: o.color,
+    opacity: o.opacity
+  });
+}, Ge = P("area", {
+  coord: "cartesian",
+  guideMode: "crosshair",
+  swatchShape: "area",
+  render: ({ layer: t, coordSystem: r, panelRect: e }) => r.type !== "cartesian" ? null : /* @__PURE__ */ c(Ht, {
+    layer: t,
+    coordSystem: r,
+    panel: e
+  }),
+  renderHover: ({ layer: t, primary: r, panelRect: e }) => /* @__PURE__ */ c(It, {
+    layer: t,
+    observation: r.observation,
+    panel: e,
+    project: J
+  }),
+  renderHoverCompanions: () => null
+}), Be = P("area", {
+  coord: "polar",
+  guideMode: "crosshair",
+  swatchShape: "area",
+  render: ({ layer: t, panelRect: r }) => /* @__PURE__ */ c(Ht, {
+    layer: t,
+    panel: r
+  }),
+  renderHover: ({ layer: t, primary: r, panelRect: e }) => /* @__PURE__ */ c(It, {
+    layer: t,
+    observation: r.observation,
+    panel: e,
+    project: Z
+  }),
+  renderHoverCompanions: () => null
+}), Fe = 1.6, Ke = 0.55, Ue = 0.6, ze = 3.8, ut = 7.5, je = 0.55, Ve = 3, Ye = {
+  solo: {
+    base: !0,
+    value: !0
+  },
+  floor: {
+    base: !0,
+    value: !1
+  },
+  ceiling: {
+    base: !1,
+    value: !0
+  },
+  middle: {
+    base: !1,
+    value: !1
+  }
+}, Xe = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+}, Ze = (t, r) => r === "x" ? (Et(t) ?? Y(t) ?? 0) >= (Ut(t) ?? 0) ? "top" : "bottom" : (Ft(t) ?? 0) >= (Kt(t) ?? 0) ? "right" : "left", qe = (t, r, e) => {
+  const a = Math.max(0, t.width - e), o = Math.max(0, t.height - e);
+  return r === "top" ? {
+    ...t,
+    y: t.y + t.height - o,
+    height: o
+  } : r === "bottom" ? {
+    ...t,
+    height: o
+  } : r === "left" ? {
+    ...t,
+    x: t.x + t.width - a,
+    width: a
+  } : {
+    ...t,
+    width: a
+  };
+}, Je = (t) => [
+  {
+    x: t.x,
+    y: t.y + t.height
+  },
+  {
+    x: t.x,
+    y: t.y
+  },
+  {
+    x: t.x + t.width,
+    y: t.y
+  },
+  {
+    x: t.x + t.width,
+    y: t.y + t.height
+  }
+], Qe = ({ layer: t, observation: r, seedKey: e, mainAxis: a, panel: o, state: l }) => {
+  const s = M(t), n = Nt(a, r);
+  if (!n || n.width <= 0 || n.height <= 0) return null;
+  const h = s(r, l), d = Ye[Bt(r)], g = Ze(r, a), p = {
+    x: n.x * o.width,
+    y: n.y * o.height,
+    width: n.width * o.width,
+    height: n.height * o.height
+  }, i = [d.value ? [] : [g], d.base ? [] : [Xe[g]]].flat().reduce((C, N) => qe(C, N, Ve / 2), p);
+  if (i.width <= 0 || i.height <= 0) return null;
+  const u = R(e), y = Je(i), x = Math.min(Fe, i.width / 10, i.height / 10), E = H(y, {
+    wander: x,
+    seed: u,
+    closed: !0,
+    cornered: !0
+  }), w = H(y, {
+    wander: x,
+    seed: u + 7,
+    closed: !0,
+    cornered: !0
+  }), m = l === "hovered", A = tt(h.color) + (a === "x" ? 0 : Math.PI / 2);
+  return /* @__PURE__ */ _("g", {
+    opacity: h.opacity,
+    children: [
+      /* @__PURE__ */ c(et, {
+        region: E,
+        bounds: i,
+        color: h.color,
+        angle: A,
+        spacing: m ? ut * je : ut,
+        width: ze,
+        seed: u,
+        pressure: h.fillOpacity
+      }),
+      /* @__PURE__ */ c($, {
+        path: E,
+        color: m ? h.edge : h.color,
+        width: h.edgeWidth,
+        seed: u
+      }),
+      /* @__PURE__ */ c($, {
+        path: w,
+        color: h.color,
+        width: h.edgeWidth * Ue,
+        seed: u + 3,
+        opacity: Ke
+      })
+    ]
+  });
+}, pt = ({ layer: t, observations: r, mainAxis: e, panel: a, state: o }) => {
+  const l = O(() => W(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  return a.width <= 0 || a.height <= 0 ? null : /* @__PURE__ */ c("g", {
+    "data-geom": "bar",
+    children: Array.from(r, (s) => {
+      const n = l(s);
+      return /* @__PURE__ */ c(Qe, {
+        layer: t,
+        observation: s,
+        seedKey: n,
+        mainAxis: e,
+        panel: a,
+        state: o
+      }, n);
+    })
+  });
+}, tr = P("bar", {
+  coord: "cartesian",
+  guideMode: "band",
+  swatchShape: "square",
+  render: ({ layer: t, coordSystem: r, panelRect: e }) => /* @__PURE__ */ c(pt, {
+    layer: t,
+    observations: t.data,
+    mainAxis: at(r),
+    panel: e
+  }),
+  renderHover: ({ layer: t, coordSystem: r, primary: e, panelRect: a }) => /* @__PURE__ */ c(pt, {
+    layer: t,
+    observations: [e.observation],
+    mainAxis: at(r),
+    panel: a,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), er = 1.3, rr = 5, ar = 2.2, or = 16, nr = (t, r, e, a) => {
+  const o = W(t.data, t.mapping, t.id), l = [];
+  return t.data.groupBy(kt.group).forEach((s) => {
+    const n = [...s], [h] = n;
+    if (h === void 0) return;
+    const d = (e === "polar" ? n.sort((p, i) => (b(p) ?? 0) - (b(i) ?? 0)) : n).flatMap((p) => {
+      const i = a(p, r);
+      return i === null ? [] : [i];
+    });
+    if (d.length < 2) return;
+    const g = o(h);
+    l.push({
+      key: g,
+      observation: h,
+      points: d,
+      stroke: H(d, {
+        wander: er,
+        seed: R(g),
+        closed: e === "polar"
+      })
+    });
+  }), l;
+}, ir = (t) => t.every((r, e) => e === 0 || Math.hypot(r.x - t[e - 1].x, r.y - t[e - 1].y) >= or), hr = ({ layer: t, panel: r, coord: e, project: a }) => {
+  const o = Ct(t), l = O(() => nr(t, r, e, a), [
+    t,
+    r,
+    e,
+    a
+  ]);
+  return r.width <= 0 || r.height <= 0 ? null : /* @__PURE__ */ c("g", {
+    "data-geom": "line",
+    children: l.map(({ key: s, observation: n, stroke: h, points: d }) => {
+      const g = o(n), p = R(s), i = ir(d) ? d.map((u, y) => Ae(u, rr, p + y)).join(" ") : "";
+      return /* @__PURE__ */ _("g", {
+        opacity: g.opacity,
+        children: [/* @__PURE__ */ c($, {
+          path: h,
+          color: g.color,
+          width: g.width,
+          seed: p
+        }), i !== "" && /* @__PURE__ */ c($, {
+          path: i,
+          color: g.color,
+          width: ar,
+          seed: p + 1
+        })]
+      }, s);
+    })
+  });
+}, lr = ({ layer: t, observation: r, panel: e, project: a }) => {
+  const o = Ct(t)(r, "hovered");
+  return /* @__PURE__ */ c(rt, {
+    geom: "line",
+    observation: r,
+    panel: e,
+    project: a,
+    color: o.color,
+    opacity: o.opacity
+  });
+}, Pt = (t, r) => P("line", {
+  coord: t,
+  guideMode: "crosshair",
+  swatchShape: "line",
+  render: ({ layer: e, panelRect: a }) => /* @__PURE__ */ c(hr, {
+    layer: e,
+    panel: a,
+    coord: t,
+    project: r
+  }),
+  renderHover: ({ layer: e, primary: a, panelRect: o }) => /* @__PURE__ */ c(lr, {
+    layer: e,
+    observation: a.observation,
+    panel: o,
+    project: r
+  }),
+  renderHoverCompanions: () => null,
+  getOverlayAnchor: ({ observation: e }) => {
+    const a = b(e), o = Y(e);
+    return a === null || o === null ? null : {
+      x: a,
+      y: o
+    };
+  }
+}), sr = Pt("cartesian", J), dr = Pt("polar", Z), cr = 0.35, gr = 0.35, ur = 2, pr = 0.3, vr = 5, fr = ({ layer: t, observations: r, panel: e, project: a, state: o }) => {
+  const l = X(t), s = M(t), n = O(() => W(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  return /* @__PURE__ */ c("g", {
+    "data-geom": "point",
+    children: Array.from(r, (h) => {
+      const d = a(h, e);
+      if (d === null) return null;
+      const g = n(h), p = R(g), i = s(h, o), u = l.get("size", h, o) / 2;
+      return /* @__PURE__ */ _("g", {
+        opacity: i.opacity,
+        children: [/* @__PURE__ */ c("circle", {
+          cx: d.x,
+          cy: d.y,
+          r: u,
+          fill: i.color,
+          fillOpacity: i.fillOpacity * pr
+        }), /* @__PURE__ */ c($, {
+          path: Q(d, u, {
+            seed: p,
+            overshoot: gr,
+            wander: cr
+          }),
+          color: i.color,
+          width: ur,
+          seed: p + 1
+        })]
+      }, g);
+    })
+  });
+}, yr = ({ layer: t, observation: r, panel: e, project: a }) => {
+  const o = M(t)(r, "hovered"), l = X(t).get("size", r, "hovered");
+  return /* @__PURE__ */ c(rt, {
+    geom: "point",
+    observation: r,
+    panel: e,
+    project: a,
+    color: o.color,
+    opacity: o.opacity,
+    radius: l / 2 + vr
+  });
+}, Mt = (t, r) => P("point", {
+  coord: t,
+  swatchShape: "circle",
+  render: ({ layer: e, panelRect: a }) => /* @__PURE__ */ c(fr, {
+    layer: e,
+    observations: e.data,
+    panel: a,
+    project: r
+  }),
+  renderHover: ({ layer: e, primary: a, panelRect: o }) => /* @__PURE__ */ c(yr, {
+    layer: e,
+    observation: a.observation,
+    panel: o,
+    project: r
+  }),
+  renderHoverCompanions: () => null
+}), mr = Mt("cartesian", J), xr = Mt("polar", Z), Ar = Math.PI / 40, wr = 1.2, kr = 3.4, vt = 8, Sr = 0.55, Er = 3, Rr = 0.42, _r = 5, $r = 1.1, Cr = 3, Hr = 2.2, ft = f.chalk, V = (t, r, e) => {
+  const a = Rt(r, 1);
+  return {
+    x: t.width / 2 + a.x * e,
+    y: t.height / 2 - a.y * e
+  };
+}, yt = (t, r, e, a) => {
+  const o = Math.max(1, Math.ceil(Math.abs(e - r) / Ar));
+  return Array.from({ length: o + 1 }, (l, s) => V(t, r + (e - r) * s / o, a));
+}, mt = (t, r, e, a) => {
+  const { startAngle: o, endAngle: l } = Wt(t), { innerRadius: s, outerRadius: n } = St(t);
+  if (o === null || l === null || s === null || n === null) return null;
+  const h = Math.min(e.width, e.height) / 2, d = n * h, g = s * h;
+  if (d <= 0) return null;
+  const p = Math.max(0, l - o), i = p >= 2 * Math.PI - 1e-6 ? 0 : Math.min(a / 2 / d, p / 4), u = o + i, y = l - i, x = yt(e, u, y, d), E = g > 0 ? yt(e, y, u, g) : [V(e, 0, 0)], w = [...x, ...E];
+  return {
+    key: r,
+    observation: t,
+    region: `${w.map((m, A) => `${A === 0 ? "M" : "L"}${m.x},${m.y}`).join(" ")} Z`,
+    outline: H(w, {
+      wander: wr,
+      seed: R(r),
+      closed: !0,
+      step: 12
+    }),
+    bounds: {
+      x: e.width / 2 - d,
+      y: e.height / 2 - d,
+      width: d * 2,
+      height: d * 2
+    },
+    startAngle: o,
+    inner: g,
+    outer: d
+  };
+}, Ir = (t) => t.length > 1 && t.every(({ inner: r, outer: e }) => Math.abs(e - (t[0]?.outer ?? 0)) < 0.5 && Math.abs(r - (t[0]?.inner ?? 0)) < 0.5), xt = ({ layer: t, observations: r, panel: e, state: a }) => {
+  const o = M(t), l = O(() => W(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  if (e.width <= 0 || e.height <= 0) return null;
+  const s = a === "hovered", n = Array.from(r, (i) => ({
+    key: l(i),
+    observation: i
+  })), h = n.flatMap(({ key: i, observation: u }) => mt(u, i, e, 0) ?? []), d = !s && Ir(h), g = d ? h : n.flatMap(({ key: i, observation: u }) => mt(u, i, e, Er) ?? []), p = {
+    x: e.width / 2,
+    y: e.height / 2
+  };
+  return /* @__PURE__ */ _("g", {
+    "data-geom": "bar",
+    children: [g.map(({ key: i, observation: u, region: y, outline: x, bounds: E }, w) => {
+      const m = o(u, a), A = R(i);
+      return /* @__PURE__ */ _("g", {
+        opacity: m.opacity,
+        children: [/* @__PURE__ */ c(et, {
+          region: y,
+          bounds: E,
+          color: m.color,
+          angle: tt(m.color, w) + (w % 2 === 0 ? 0 : Math.PI / 2),
+          spacing: s ? vt * Sr : vt,
+          width: kr,
+          seed: A,
+          pressure: m.fillOpacity
+        }), !d && /* @__PURE__ */ c($, {
+          path: x,
+          color: s ? m.edge : m.color,
+          width: m.edgeWidth,
+          seed: A
+        })]
+      }, i);
+    }), d && /* @__PURE__ */ _("g", { children: [g.map(({ key: i, startAngle: u, inner: y, outer: x }) => /* @__PURE__ */ c($, {
+      path: H([V(e, u, y), V(e, u, x)], {
+        wander: 0.8,
+        seed: R(i) + 5,
+        step: 14
+      }),
+      color: ft,
+      width: Hr,
+      seed: R(i) + 6
+    }, i)), [g[0]?.outer ?? 0, g[0]?.inner ?? 0].filter((i) => i > 0).map((i, u) => /* @__PURE__ */ c($, {
+      path: Q(p, i, {
+        seed: 31 + u * 17,
+        overshoot: Rr,
+        wander: $r,
+        drift: u === 0 ? _r : -5
+      }),
+      color: ft,
+      width: Cr,
+      seed: 41 + u
+    }, i))] })]
+  });
+}, Pr = P("bar", {
+  coord: "polar",
+  guideMode: "band",
+  swatchShape: "slice",
+  render: ({ layer: t, panelRect: r }) => /* @__PURE__ */ c(xt, {
+    layer: t,
+    observations: t.data,
+    panel: r
+  }),
+  renderHover: ({ layer: t, primary: r, panelRect: e }) => /* @__PURE__ */ c(xt, {
+    layer: t,
+    observations: [r.observation],
+    panel: e,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), z = 4, Mr = 1, Tr = 0.82, At = 3, br = 0.28, Or = {
+  run: [16, 60],
+  skip: [2, 7]
+}, Dr = 50, Lr = ({ layer: t, observation: r, seedKey: e, panel: a, state: o }) => {
+  const l = M(t), s = $t("cell"), n = Gt(r);
+  if (n === null) return null;
+  const h = l(r, o), d = n.x * a.width + z / 2, g = n.y * a.height + z / 2, p = n.width * a.width - z, i = n.height * a.height - z;
+  if (p <= 0 || i <= 0) return null;
+  const u = R(e), y = D(u), x = H([
+    {
+      x: d,
+      y: g
+    },
+    {
+      x: d + p,
+      y: g
+    },
+    {
+      x: d + p,
+      y: g + i
+    },
+    {
+      x: d,
+      y: g + i
+    }
+  ], {
+    wander: Math.min(Mr, p / 10, i / 10),
+    seed: u,
+    closed: !0,
+    cornered: !0
+  }), E = i / At, w = Array.from({ length: At }, (A, C) => {
+    const N = g + E * (C + 0.5), Tt = y() * Dr;
+    return H([{
+      x: d - 2 - Tt,
+      y: N + (y() - 0.5) * 2
+    }, {
+      x: d + p + 2,
+      y: N + (y() - 0.5) * 2
+    }], {
+      wander: 1.2,
+      seed: u + C + 1,
+      step: 16
+    });
+  }), m = o === "hovered";
+  return /* @__PURE__ */ _("g", {
+    opacity: h.opacity,
+    children: [
+      /* @__PURE__ */ c("clipPath", {
+        id: s,
+        children: /* @__PURE__ */ c("path", { d: x })
+      }),
+      /* @__PURE__ */ c("path", {
+        d: x,
+        fill: h.color,
+        fillOpacity: h.fillOpacity * Tr
+      }),
+      /* @__PURE__ */ c("g", {
+        clipPath: `url(#${s})`,
+        fill: "none",
+        stroke: h.color,
+        strokeOpacity: br,
+        children: w.map((A, C) => /* @__PURE__ */ c("path", {
+          d: A,
+          strokeWidth: E * 0.8,
+          strokeDasharray: L(Or, u + C)
+        }, C))
+      }),
+      m && /* @__PURE__ */ c($, {
+        path: x,
+        color: h.edge,
+        width: h.edgeWidth,
+        seed: u
+      })
+    ]
+  });
+}, wt = ({ layer: t, observations: r, panel: e, state: a }) => {
+  const o = O(() => Lt(t.data, t.mapping, t.id), [
+    t.data,
+    t.mapping,
+    t.id
+  ]);
+  return e.width <= 0 || e.height <= 0 ? null : /* @__PURE__ */ c("g", {
+    "data-geom": "tile",
+    children: Array.from(r, (l) => {
+      const s = o(l);
+      return /* @__PURE__ */ c(Lr, {
+        layer: t,
+        observation: l,
+        seedKey: s,
+        panel: e,
+        state: a
+      }, s);
+    })
+  });
+}, Wr = P("tile", {
+  coord: "cartesian",
+  guideMode: null,
+  swatchShape: "square",
+  render: ({ layer: t, panelRect: r }) => /* @__PURE__ */ c(wt, {
+    layer: t,
+    observations: t.data,
+    panel: r
+  }),
+  renderHover: ({ layer: t, primary: r, panelRect: e }) => /* @__PURE__ */ c(wt, {
+    layer: t,
+    observations: [r.observation],
+    panel: e,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), Nr = [
+  tr,
+  Pr,
+  Wr,
+  sr,
+  dr,
+  Ge,
+  Be,
+  mr,
+  xr
+], Gr = 0.3, Br = 2, Fr = ({ fill: t, fillOpacity: r, ...e }) => /* @__PURE__ */ c(Ot, {
+  ...e,
+  fill: t,
+  fillOpacity: Gr,
+  stroke: t,
+  strokeWidth: Br
+}), Kr = { Circle: Fr }, Vr = {
+  name: "chalkboard",
+  styles: pe,
+  palette: _t,
+  colormap: le,
+  config: {
+    axes: { y: { position: "left" } },
+    legend: {
+      position: "top",
+      align: "start"
+    }
+  },
+  colorScheme: "dark",
+  plugins: Nr,
+  shapes: Kr
+};
+export {
+  Vr as chalkboard
+};