@graphysdk/theme-bauhaus 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,882 @@
+import { useMemo as P } from "react";
+import { GROUP_VARIABLES as ge, VISUAL_VARIABLES as pe, buildPolarBarArcPath as V, createLinePathGenerator as fe, createStableKeyGenerator as M, defineGeomRenderer as H, getAngleExtent as ve, getBarRectBounds as me, getRadiusExtent as te, getStackRole as $, getX as T, getXMax as ke, getXMin as ye, getY as O, getYMax as re, getYMin as Ae, polarToUnit as be, prepareLineObservations as Se, readMainAxis as X, style as i, toPaintColor as xe, toStrokeDasharray as Re, toViewBoxX as Ee, toViewBoxY as We, useGeomStyleReader as F } from "@graphysdk/react";
+import { jsx as p, jsxs as ae } from "react/jsx-runtime";
+var we = {
+  solo: {
+    base: !0,
+    value: !0
+  },
+  floor: {
+    base: !0,
+    value: !1
+  },
+  ceiling: {
+    base: !1,
+    value: !0
+  },
+  middle: {
+    base: !1,
+    value: !1
+  }
+}, Le = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+}, _e = (e, t) => t === "x" ? (re(e) ?? O(e) ?? 0) >= (Ae(e) ?? 0) ? "top" : "bottom" : (ke(e) ?? 0) >= (ye(e) ?? 0) ? "right" : "left", Pe = (e, t, a) => {
+  const o = Math.max(0, e.width - a), r = Math.max(0, e.height - a);
+  return t === "top" ? {
+    ...e,
+    y: e.y + e.height - r,
+    height: r
+  } : t === "bottom" ? {
+    ...e,
+    height: r
+  } : t === "left" ? {
+    ...e,
+    x: e.x + e.width - o,
+    width: o
+  } : {
+    ...e,
+    width: o
+  };
+}, Me = (e, t, a, o) => {
+  const r = me(t, e);
+  if (!r || r.width <= 0 || r.height <= 0) return null;
+  const n = we[$(e)], s = _e(e, t), h = {
+    x: r.x * a.width,
+    y: r.y * a.height,
+    width: r.width * a.width,
+    height: r.height * a.height
+  }, l = [n.value ? [] : [s], n.base ? [] : [Le[s]]].flat().reduce((m, y) => Pe(m, y, o / 2), h), c = s === "top" || s === "bottom", u = c ? l.width : l.height, g = c ? l.height : l.width;
+  if (u <= 0 || g <= 0) return null;
+  const { x: f, y: k, width: R, height: E } = l, W = (m, y) => s === "top" ? {
+    x: f + m,
+    y: k + E - y
+  } : s === "bottom" ? {
+    x: f + m,
+    y: k + y
+  } : s === "right" ? {
+    x: f + y,
+    y: k + m
+  } : {
+    x: f + R - y,
+    y: k + m
+  };
+  return {
+    breadth: u,
+    length: g,
+    endsStack: n.value,
+    isSolo: n.base && n.value,
+    at: W
+  };
+}, He = ({ x: e, y: t }) => `${Math.round(e * 100) / 100},${Math.round(t * 100) / 100}`, Te = (e, t) => `${t.map((a, o) => {
+  const r = a.map(([n, s]) => He(e.at(n, s)));
+  return o === 0 ? `M${r.join(" ")}` : a.length === 3 ? `C${r.join(" ")}` : `L${r.join(" ")}`;
+}).join(" ")} Z`, D = (e) => {
+  const t = F(e);
+  return (a, o) => ({
+    color: xe(t.get("fill", a, o)),
+    opacity: t.get("alpha", a, o),
+    fillOpacity: t.get("fillAlpha", a, o),
+    edge: t.get("stroke", a, o),
+    edgeWidth: t.get("strokeWidth", a, o)
+  });
+}, oe = (e) => {
+  const t = F(e);
+  return (a, o) => {
+    const r = t.get("strokeWidth", a, o);
+    return {
+      color: t.get("stroke", a, o),
+      opacity: t.get("alpha", a, o) * t.get("strokeAlpha", a, o),
+      width: r,
+      dashArray: Re(t.get("dashArray", a, o), r)
+    };
+  };
+}, Oe = 2, Be = (e) => {
+  const { breadth: t, length: a } = e;
+  return Te(e, [
+    [[0, 0]],
+    [[0, a]],
+    [[t, a]],
+    [[t, 0]]
+  ]);
+}, j = ({ layer: e, observations: t, mainAxis: a, panel: o, state: r }) => {
+  const n = D(e), s = P(() => M(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]);
+  if (o.width <= 0 || o.height <= 0) return null;
+  const h = [...t].flatMap((c) => {
+    const u = Me(c, a, o, Oe);
+    if (u === null) return [];
+    const g = n(c, r);
+    return [{
+      key: s(c),
+      frame: u,
+      paint: g
+    }];
+  }), l = r === "hovered";
+  return /* @__PURE__ */ p("g", {
+    "data-geom": "bar",
+    children: h.map(({ key: c, frame: u, paint: g }) => /* @__PURE__ */ p("g", {
+      opacity: g.opacity,
+      children: /* @__PURE__ */ p("path", {
+        d: Be(u),
+        fill: g.color,
+        fillOpacity: g.fillOpacity,
+        stroke: l ? g.edge : void 0,
+        strokeWidth: l ? g.edgeWidth : void 0,
+        strokeLinejoin: "miter"
+      })
+    }, c))
+  });
+}, Ie = H("bar", {
+  coord: "cartesian",
+  guideMode: "band",
+  swatchShape: "square",
+  render: ({ layer: e, coordSystem: t, panelRect: a }) => /* @__PURE__ */ p(j, {
+    layer: e,
+    observations: e.data,
+    mainAxis: X(t),
+    panel: a
+  }),
+  renderHover: ({ layer: e, coordSystem: t, primary: a, panelRect: o }) => /* @__PURE__ */ p(j, {
+    layer: e,
+    observations: [a.observation],
+    mainAxis: X(t),
+    panel: o,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), d = {
+  paper: "#F3EEE1",
+  black: "#141414",
+  secondary: "#4A4640",
+  rule: "#C9C2B1"
+}, v = {
+  red: "#D62718",
+  blue: "#1B4FA3",
+  yellow: "#E9A800",
+  black: "#141414",
+  green: "#1F7A4D",
+  orange: "#CF4F14",
+  violet: "#6A3D9A"
+}, Ce = [
+  v.red,
+  v.blue,
+  v.yellow,
+  v.black,
+  v.green,
+  v.orange,
+  v.violet
+], $e = [
+  v.yellow,
+  v.red,
+  v.black
+], Fe = /[a-df-zA-DF-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/gu, De = /^[a-zA-Z]$/u, Ue = (e, t) => e === "H" ? "x" : e === "V" ? "y" : t % 2 === 0 ? "x" : "y", ze = (e, t) => {
+  let a = "", o = 0;
+  return (e.match(Fe) ?? []).map((r) => {
+    if (De.test(r))
+      return a = r.toUpperCase(), o = 0, r;
+    const n = Ue(a, o);
+    return o += 1, String(Number(r) * (n === "x" ? t.width : t.height));
+  }).join(" ");
+}, ne = (e, t) => {
+  const a = T(e), o = O(e) ?? re(e);
+  return a === null || o === null ? null : {
+    x: Ee(a) * t.width,
+    y: We(o) * t.height
+  };
+}, U = (e, t) => {
+  const a = T(e), o = O(e) ?? te(e).outerRadius;
+  if (a === null || o === null) return null;
+  const r = be(a, o), n = Math.min(t.width, t.height) / 2;
+  return {
+    x: t.width / 2 + r.x * n,
+    y: t.height / 2 - r.y * n
+  };
+}, Ne = (e) => `${e.map((t, a) => `${a === 0 ? "M" : "L"}${t.x},${t.y}`).join(" ")} Z`, ie = [
+  [v.red, "square"],
+  [v.blue, "circle"],
+  [v.yellow, "triangle"],
+  [v.black, "diamond"],
+  [v.green, "cross"],
+  [v.orange, "triangle"],
+  [v.violet, "square"]
+], Ge = new Map(ie.map(([e, t]) => [e.toUpperCase(), t])), z = (e) => Ge.get(e.toUpperCase()) ?? "circle", q = Math.sqrt(3), Ve = 5, _ = ({ x: e, y: t }) => `${Math.round(e * 100) / 100},${Math.round(t * 100) / 100}`, w = (e) => `${e.map((t, a) => `${a === 0 ? "M" : "L"}${_(t)}`).join(" ")} Z`, Xe = (e, t, a) => {
+  const o = Math.PI * (a / 2) ** 2, { x: r, y: n } = t;
+  if (e === "square" || e === "diamond") {
+    const h = Math.sqrt(o) / 2;
+    if (e === "square") return w([
+      {
+        x: r - h,
+        y: n - h
+      },
+      {
+        x: r + h,
+        y: n - h
+      },
+      {
+        x: r + h,
+        y: n + h
+      },
+      {
+        x: r - h,
+        y: n + h
+      }
+    ]);
+    const l = h * Math.SQRT2;
+    return w([
+      {
+        x: r,
+        y: n - l
+      },
+      {
+        x: r + l,
+        y: n
+      },
+      {
+        x: r,
+        y: n + l
+      },
+      {
+        x: r - l,
+        y: n
+      }
+    ]);
+  }
+  if (e === "triangle") {
+    const h = Math.sqrt(4 * o / q), l = h * q / 2;
+    return w([
+      {
+        x: r,
+        y: n - l * 2 / 3
+      },
+      {
+        x: r + h / 2,
+        y: n + l / 3
+      },
+      {
+        x: r - h / 2,
+        y: n + l / 3
+      }
+    ]);
+  }
+  if (e === "cross") {
+    const h = Math.sqrt(o / Ve), l = h / 2, c = h * 1.5;
+    return w([
+      {
+        x: r - l,
+        y: n - c
+      },
+      {
+        x: r + l,
+        y: n - c
+      },
+      {
+        x: r + l,
+        y: n - l
+      },
+      {
+        x: r + c,
+        y: n - l
+      },
+      {
+        x: r + c,
+        y: n + l
+      },
+      {
+        x: r + l,
+        y: n + l
+      },
+      {
+        x: r + l,
+        y: n + c
+      },
+      {
+        x: r - l,
+        y: n + c
+      },
+      {
+        x: r - l,
+        y: n + l
+      },
+      {
+        x: r - c,
+        y: n + l
+      },
+      {
+        x: r - c,
+        y: n - l
+      },
+      {
+        x: r - l,
+        y: n - l
+      }
+    ]);
+  }
+  const s = a / 2;
+  return `M${_({
+    x: r - s,
+    y: n
+  })} A${s},${s} 0 1 0 ${_({
+    x: r + s,
+    y: n
+  })} A${s},${s} 0 1 0 ${_({
+    x: r - s,
+    y: n
+  })} Z`;
+}, N = ({ form: e, centre: t, size: a, color: o, opacity: r, fillOpacity: n, edge: s, edgeWidth: h = 0 }) => /* @__PURE__ */ p("path", {
+  "data-form": e,
+  d: Xe(e, t, a),
+  fill: o,
+  fillOpacity: n,
+  opacity: r,
+  stroke: h > 0 ? s : void 0,
+  strokeWidth: h > 0 ? h : void 0,
+  strokeLinejoin: "miter"
+}), Y = (e, t, a, o) => {
+  const r = M(e.data, e.mapping, e.id), n = [];
+  return e.data.groupBy(ge.group).forEach((s) => {
+    const h = [...s], [l] = h, c = o(h);
+    if (l === void 0 || c === null) return;
+    const u = h.flatMap((g) => {
+      const f = a(g, t);
+      return f === null ? [] : [{
+        key: r(g),
+        observation: g,
+        point: f
+      }];
+    });
+    n.push({
+      key: r(l),
+      observation: l,
+      path: c,
+      readings: u
+    });
+  }), n;
+}, je = (e, t) => {
+  const a = e.flatMap((o) => {
+    const r = T(o), n = U(o, t);
+    return r === null || n === null ? [] : [{
+      angle: r,
+      point: n
+    }];
+  }).sort((o, r) => o.angle - r.angle).map(({ point: o }) => o);
+  return a.length === 0 ? null : Ne(a);
+}, qe = 4, Ye = 11, le = 1.5, Ke = 1.8, Ze = 5, se = (e) => Math.max(Ye, e * qe), Je = (e, t) => {
+  const a = t * Ke;
+  return e.every(({ readings: o }) => o.every(({ point: r }, n) => {
+    const s = o[n + 1]?.point;
+    return s === void 0 || Math.hypot(s.x - r.x, s.y - r.y) >= a;
+  }));
+}, Qe = ({ layer: e, panel: t, coord: a, project: o }) => {
+  const r = oe(e), n = P(() => {
+    if (a === "polar") return Y(e, t, o, (u) => je(u, t));
+    const c = fe(e.params);
+    return Y(e, t, o, (u) => {
+      const g = c(Se(u, e.params.missingValues));
+      return g ? ze(g, t) : null;
+    });
+  }, [
+    e,
+    t,
+    a,
+    o
+  ]);
+  if (t.width <= 0 || t.height <= 0) return null;
+  const [s] = n, h = s === void 0 ? 0 : se(r(s.observation).width), l = s !== void 0 && Je(n, h);
+  return /* @__PURE__ */ ae("g", {
+    "data-geom": "line",
+    children: [n.map((c) => {
+      const u = r(c.observation);
+      return /* @__PURE__ */ p("path", {
+        d: c.path,
+        fill: "none",
+        stroke: u.color,
+        strokeWidth: u.width,
+        strokeDasharray: u.dashArray,
+        strokeLinecap: "butt",
+        strokeLinejoin: "miter",
+        opacity: u.opacity
+      }, c.key);
+    }), l && n.flatMap((c) => {
+      const u = r(c.observation), g = z(u.color);
+      return c.readings.map((f) => /* @__PURE__ */ p(N, {
+        form: g,
+        centre: f.point,
+        size: h,
+        color: u.color,
+        opacity: u.opacity,
+        edge: d.paper,
+        edgeWidth: le
+      }, f.key));
+    })]
+  });
+}, et = ({ layer: e, observation: t, panel: a, project: o }) => {
+  const r = oe(e)(t, "hovered"), n = o(t, a);
+  return n === null ? null : /* @__PURE__ */ p("g", {
+    "data-geom": "line",
+    children: /* @__PURE__ */ p(N, {
+      form: z(r.color),
+      centre: n,
+      size: se(r.width) + Ze,
+      color: r.color,
+      opacity: r.opacity,
+      edge: d.black,
+      edgeWidth: le
+    })
+  });
+}, de = (e, t) => H("line", {
+  coord: e,
+  guideMode: "crosshair",
+  swatchShape: "line",
+  render: ({ layer: a, panelRect: o }) => /* @__PURE__ */ p(Qe, {
+    layer: a,
+    panel: o,
+    coord: e,
+    project: t
+  }),
+  renderHover: ({ layer: a, primary: o, panelRect: r }) => /* @__PURE__ */ p(et, {
+    layer: a,
+    observation: o.observation,
+    panel: r,
+    project: t
+  }),
+  renderHoverCompanions: () => null,
+  getOverlayAnchor: ({ observation: a }) => {
+    const o = T(a), r = O(a);
+    return o === null || r === null ? null : {
+      x: o,
+      y: r
+    };
+  }
+}), tt = de("cartesian", ne), rt = de("polar", U), at = { isolation: "isolate" }, ot = { mixBlendMode: "multiply" }, nt = 5, it = /* @__PURE__ */ new Set([
+  "square",
+  "circle",
+  "triangle",
+  "diamond",
+  "cross"
+]), lt = (e, t) => it.has(e) ? e : z(t), K = ({ layer: e, observations: t, panel: a, project: o, state: r }) => {
+  const n = F(e), s = D(e), h = P(() => M(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]), l = r === "hovered", c = l ? nt : 0;
+  return /* @__PURE__ */ p("g", {
+    "data-geom": "point",
+    style: l ? void 0 : at,
+    children: Array.from(t, (u) => {
+      const g = o(u, a);
+      if (g === null) return null;
+      const f = s(u, r);
+      return /* @__PURE__ */ p("g", {
+        style: l ? void 0 : ot,
+        children: /* @__PURE__ */ p(N, {
+          form: lt(String(n.get("symbol", u, r)), f.color),
+          centre: g,
+          size: n.get("size", u, r) + c,
+          color: f.color,
+          opacity: f.opacity,
+          fillOpacity: f.fillOpacity,
+          edge: f.edge,
+          edgeWidth: l ? f.edgeWidth : 0
+        })
+      }, h(u));
+    })
+  });
+}, he = (e, t) => H("point", {
+  coord: e,
+  swatchShape: "circle",
+  render: ({ layer: a, panelRect: o }) => /* @__PURE__ */ p(K, {
+    layer: a,
+    observations: a.data,
+    panel: o,
+    project: t
+  }),
+  renderHover: ({ layer: a, primary: o, panelRect: r }) => /* @__PURE__ */ p(K, {
+    layer: a,
+    observations: [o.observation],
+    panel: r,
+    project: t,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), st = he("cartesian", ne), dt = he("polar", U), ht = 4, ct = 0.5, ut = 2, gt = 3, Z = 1e-6, J = (e, t, a) => [...e].flatMap((o) => {
+  const { startAngle: r, endAngle: n } = ve(o), { innerRadius: s, outerRadius: h } = te(o);
+  return r === null || n === null || s === null || h === null ? [] : n <= r || h <= 0 ? [] : [{
+    key: `${a(o)}-${r}`,
+    observation: o,
+    paint: t(o),
+    startAngle: r,
+    endAngle: n,
+    innerRadius: s,
+    outerRadius: h
+  }];
+}), pt = (e) => {
+  const [t] = e;
+  return t === void 0 ? !1 : e.every((a) => Math.abs(a.innerRadius - t.innerRadius) < Z && Math.abs(a.outerRadius - t.outerRadius) < Z);
+}, Q = ({ layer: e, observations: t, panel: a, state: o }) => {
+  const r = D(e), n = P(() => M(e.data, e.mapping, e.id), [
+    e.data,
+    e.mapping,
+    e.id
+  ]), s = Math.min(a.width, a.height) / 2;
+  if (s <= 0) return null;
+  const h = J(t, (g) => r(g, o), n), l = pt(J(e.data, (g) => r(g), n)), c = o === "hovered", u = {
+    centerX: a.width / 2,
+    centerY: a.height / 2,
+    radius: s,
+    digits: gt
+  };
+  return /* @__PURE__ */ p("g", {
+    "data-geom": "bar",
+    children: h.map(({ key: g, observation: f, paint: k, startAngle: R, endAngle: E, innerRadius: W, outerRadius: m }) => {
+      const y = V({
+        startAngle: R,
+        endAngle: E,
+        innerRadius: W,
+        outerRadius: m
+      }, u);
+      if (y === void 0) return null;
+      const ce = (m - W) * s, ue = Math.min(ht, ce * ct) / s, G = !l && $(f) !== "floor" && $(f) !== "middle" ? V({
+        startAngle: R,
+        endAngle: E,
+        innerRadius: m - ue,
+        outerRadius: m
+      }, u) : void 0;
+      return /* @__PURE__ */ ae("g", {
+        opacity: k.opacity,
+        children: [/* @__PURE__ */ p("path", {
+          d: y,
+          fill: k.color,
+          fillOpacity: k.fillOpacity,
+          stroke: c ? k.edge : d.paper,
+          strokeWidth: c ? k.edgeWidth : ut,
+          strokeLinejoin: "miter"
+        }), G !== void 0 && /* @__PURE__ */ p("path", {
+          "data-value-rule": "",
+          d: G,
+          fill: d.black
+        })]
+      }, g);
+    })
+  });
+}, ft = H("bar", {
+  coord: "polar",
+  guideMode: "band",
+  swatchShape: "slice",
+  render: ({ layer: e, panelRect: t }) => /* @__PURE__ */ p(Q, {
+    layer: e,
+    observations: e.data,
+    panel: t
+  }),
+  renderHover: ({ layer: e, primary: t, panelRect: a }) => /* @__PURE__ */ p(Q, {
+    layer: e,
+    observations: [t.observation],
+    panel: a,
+    state: "hovered"
+  }),
+  renderHoverCompanions: () => null
+}), vt = [
+  Ie,
+  ft,
+  tt,
+  rt,
+  st,
+  dt
+];
+var mt = (e) => {
+  const t = `<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%"><rect x="0" y="0" width="100%" height="10" fill="${e}"/></svg>`;
+  return `data:image/svg+xml,${encodeURIComponent(t)}`;
+}, kt = "'Jost', 'Futura', ui-sans-serif, system-ui, sans-serif", yt = 2.5, L = 24, B = 1, I = 2.5, At = 14, C = 3, bt = 0.18, St = 18, xt = 3.5, b = { textColor: d.black }, S = { textColor: d.secondary }, A = {
+  textTransform: "uppercase",
+  letterSpacing: 1.2
+}, x = {
+  ...A,
+  textColor: d.paper,
+  fill: d.black,
+  stroke: d.black,
+  strokeWidth: 0,
+  cornerRadius: 0,
+  paddingInline: 8,
+  paddingBlock: 4,
+  fontWeight: 700,
+  fontSize: 11,
+  shadow: "none"
+}, ee = {
+  stroke: d.black,
+  strokeWidth: yt,
+  dashArray: []
+}, Rt = {
+  tokens: {
+    graphBackground: d.paper,
+    graphBorder: d.black,
+    geom: v.red,
+    geomBorder: d.black,
+    textPrimary: d.black,
+    textSecondary: d.secondary,
+    ruleLine: d.black,
+    gridLine: d.rule,
+    hoverAffordance: d.black,
+    hoverGuideFill: "rgba(20, 20, 20, 0.07)",
+    hoverGuideLine: d.black,
+    tooltipBackground: d.paper,
+    tooltipBorder: d.black,
+    tooltipPrimaryRow: "rgba(20, 20, 20, 0.08)",
+    annotationShape: v.yellow,
+    annotationArrow: d.black,
+    differenceLabelBackground: d.paper
+  },
+  defaults: [
+    i.graph({
+      strokeWidth: 0,
+      cornerRadius: 0,
+      fontFamily: kt,
+      padding: {
+        top: L + 10,
+        bottom: L,
+        left: L,
+        right: L
+      },
+      overlay: {
+        image: mt(d.black),
+        fit: "stretch",
+        fallback: "transparent"
+      }
+    }),
+    i.geom({ shadow: "none" }, { state: "hovered" }),
+    i.geom.bar({
+      stroke: d.paper,
+      strokeWidth: B,
+      cornerRadius: "none"
+    }),
+    i.geom.bar({
+      stroke: d.black,
+      strokeWidth: I
+    }, { state: "hovered" }),
+    i.geom.line({
+      strokeWidth: xt,
+      dashArray: [],
+      lineCap: "butt",
+      lineJoin: "miter"
+    }),
+    i.geom.area({
+      fillAlpha: 1,
+      strokeWidth: B,
+      dashArray: [],
+      lineCap: "butt",
+      lineJoin: "miter"
+    }),
+    i.geom.area({ stroke: d.paper }, { coord: "cartesian" }),
+    i.geom.point({
+      size: At,
+      stroke: d.paper,
+      strokeWidth: B
+    }),
+    i.geom.point({
+      stroke: d.black,
+      strokeWidth: I
+    }, { state: "hovered" }),
+    ...ie.map(([e, t]) => i.geom.point({ symbol: t }, { where: {
+      variable: pe.color,
+      eq: e
+    } })),
+    i.geom.tile({
+      cornerRadius: 0,
+      stroke: d.paper,
+      strokeWidth: 2
+    }),
+    i.geom.tile({
+      stroke: d.black,
+      strokeWidth: I
+    }, { state: "hovered" }),
+    i.geom.rule({
+      stroke: d.black,
+      strokeWidth: C,
+      dashArray: []
+    }),
+    i.geom.rule.label({ ...x }),
+    i.gridLine.x({ strokeWidth: 0 }),
+    i.gridLine.y({ strokeWidth: 0 }),
+    i.panelBorder({
+      strokeWidth: 0,
+      cornerRadius: 0
+    }),
+    i.panelBorder.left(ee),
+    i.panelBorder.bottom(ee),
+    i.tickLine({
+      stroke: d.black,
+      strokeWidth: 1.5,
+      length: 6
+    }),
+    i.tickLabel({
+      ...b,
+      ...A,
+      fontWeight: 500,
+      fontSize: 11,
+      lineHeight: 1,
+      letterSpacing: 0.8
+    }),
+    i.axisLabel({
+      ...b,
+      ...A,
+      fontWeight: 700,
+      fontSize: 11,
+      lineHeight: 1,
+      letterSpacing: 1.6
+    }),
+    i.heading({ ...b }),
+    i.heading.h1({
+      fontWeight: 700,
+      fontSize: 28,
+      lineHeight: 1.05,
+      letterSpacing: -0.3
+    }),
+    i.heading.h2({
+      ...S,
+      fontWeight: 400,
+      fontSize: 15,
+      lineHeight: 1.2
+    }),
+    i.header({ margin: { bottom: St } }),
+    i.caption({
+      ...S,
+      fontWeight: 400,
+      fontSize: 12
+    }),
+    i.source({
+      ...S,
+      ...A,
+      fontWeight: 500,
+      fontSize: 10
+    }),
+    i.source.link({
+      ...S,
+      ...A,
+      fontWeight: 500,
+      fontSize: 10
+    }),
+    i.dataLabel({
+      ...b,
+      fontWeight: 700,
+      fontSize: 12,
+      fill: "transparent"
+    }),
+    i.legendItem({
+      ...b,
+      ...A,
+      fontWeight: 500,
+      fontSize: 11,
+      fill: "transparent",
+      stroke: "transparent",
+      cornerRadius: 0
+    }),
+    i.directLabel({
+      ...A,
+      fontWeight: 700,
+      fontSize: 11,
+      dashArray: []
+    }),
+    i.tooltip({
+      strokeWidth: 2,
+      cornerRadius: 0,
+      paddingInline: 12,
+      paddingBlock: 10,
+      shadow: "none"
+    }),
+    i.tooltip.heading({
+      ...b,
+      ...A,
+      fontWeight: 700,
+      fontSize: 11,
+      lineHeight: 1.3
+    }),
+    i.tooltip.label({
+      ...S,
+      fontWeight: 400,
+      fontSize: 13,
+      lineHeight: 1.3
+    }),
+    i.tooltip.value({
+      ...b,
+      fontWeight: 700,
+      fontSize: 13,
+      lineHeight: 1.3
+    }),
+    i.legend.popover({
+      strokeWidth: 2,
+      cornerRadius: 0,
+      shadow: "none"
+    }),
+    i.annotation.text({
+      ...x,
+      lineHeight: 1.3
+    }),
+    i.annotation.shape({
+      fillAlpha: bt,
+      strokeWidth: 0
+    }),
+    i.annotation.arrow({
+      stroke: d.black,
+      strokeWidth: C,
+      dashArray: []
+    }),
+    i.annotation.pinnedNumber({
+      fill: d.black,
+      stroke: d.paper,
+      shadow: "none"
+    }),
+    i.annotation.pinnedNumber.label({ ...x }),
+    i.annotation.comment({
+      fill: d.black,
+      stroke: d.paper,
+      shadow: "none"
+    }),
+    i.annotation.comment.label({ ...x }),
+    i.annotation.differenceArrow({
+      stroke: d.black,
+      strokeWidth: C
+    }),
+    i.annotation.differenceArrow.label({ ...x }),
+    i.geom.area({
+      fillAlpha: 0.35,
+      strokeWidth: 3
+    }, { coord: "polar" }),
+    i.panelBorder.left({ strokeWidth: 0 }, { coord: "polar" }),
+    i.panelBorder.bottom({ strokeWidth: 0 }, { coord: "polar" }),
+    i.tickLine({ strokeWidth: 0 }, { coord: "polar" }),
+    i.gridLine.x({
+      strokeWidth: 1,
+      dashArray: []
+    }, { coord: "polar" }),
+    i.gridLine.y({
+      strokeWidth: 1,
+      dashArray: []
+    }, { coord: "polar" }),
+    i.tickLabel({
+      fontWeight: 700,
+      textOutlineColor: d.paper,
+      textOutlineWidth: 3
+    }, { coord: "polar" })
+  ]
+}, Lt = {
+  name: "bauhaus",
+  styles: Rt,
+  palette: Ce,
+  colormap: $e,
+  config: {
+    axes: { y: { position: "left" } },
+    legend: {
+      position: "top",
+      align: "start"
+    }
+  },
+  colorScheme: "light",
+  plugins: vt
+};
+export {
+  Lt as bauhaus
+};