dynamic-mui 2.0.26 → 2.2.0

package/dist/index-CuV0MQzZ.mjs

@@ -0,0 +1,1173 @@
+import { a as W, b as ye, j as P, _ as C, i as Fe, h as ue, c as le, s as xe, g as ce, P as e, u as He } from "./index-BhaKvHkU.mjs";
+import * as Y from "react";
+import { b as Me, h as Ee, j as E, e as Se, D as De } from "./useAxis-SiNBMMWq.mjs";
+import { u as $e, b as Pe, c as we, A as oe, d as de, e as Ie, f as Ve, g as _e, C as Ue, h as Ge, i as We, j as ze } from "./ChartsWrapper-CO5_Z6BD.mjs";
+import { i as he, j as N, t as Be, k as V, l as S, m as te, n as Ae, p as me, o as G, q as T, r as $, v as be, w as Ke, x as Je, y as fe, z as Qe, A as Xe, B as Ye, D as Ze, E as en, F as nn, u as sn, C as an, a as rn } from "./useChartContainerProps-Bl3hO-r1.mjs";
+import { G as Kn } from "./useChartContainerProps-Bl3hO-r1.mjs";
+import { w as tn, u as on } from "./useItemHighlightedGetter-CTISrNdV.mjs";
+import { f as dn } from "./isDeepEqual-BHfPvf9U.mjs";
+function un(n) {
+  return n.innerRadius;
+}
+function ln(n) {
+  return n.outerRadius;
+}
+function cn(n) {
+  return n.startAngle;
+}
+function gn(n) {
+  return n.endAngle;
+}
+function Rn(n) {
+  return n && n.padAngle;
+}
+function pn(n, a, i, d, g, A, c, r) {
+  var R = i - n, l = d - a, s = c - g, t = r - A, o = t * R - s * l;
+  if (!(o * o < N))
+    return o = (s * (a - A) - t * (n - g)) / o, [n + o * R, a + o * l];
+}
+function X(n, a, i, d, g, A, c) {
+  var r = n - i, R = a - d, l = (c ? A : -A) / G(r * r + R * R), s = l * R, t = -l * r, o = n + s, u = a + t, p = i + s, f = d + t, m = (o + p) / 2, y = (u + f) / 2, b = p - o, I = f - u, v = b * b + I * I, j = g - A, O = o * f - p * u, F = (I < 0 ? -1 : 1) * G(Je(0, j * j * v - O * O)), L = (O * I - b * F) / v, H = (-O * b - I * F) / v, q = (O * I + b * F) / v, k = (-O * b + I * F) / v, M = L - m, h = H - y, x = q - m, w = k - y;
+  return M * M + h * h > x * x + w * w && (L = q, H = k), {
+    cx: L,
+    cy: H,
+    x01: -s,
+    y01: -t,
+    x11: L * (g / j - 1),
+    y11: H * (g / j - 1)
+  };
+}
+function Le() {
+  var n = un, a = ln, i = $(0), d = null, g = cn, A = gn, c = Rn, r = null, R = tn(l);
+  function l() {
+    var s, t, o = +n.apply(this, arguments), u = +a.apply(this, arguments), p = g.apply(this, arguments) - he, f = A.apply(this, arguments) - he, m = Ae(f - p), y = f > p;
+    if (r || (r = s = R()), u < o && (t = u, u = o, o = t), !(u > N)) r.moveTo(0, 0);
+    else if (m > Be - N)
+      r.moveTo(u * V(p), u * S(p)), r.arc(0, 0, u, p, f, !y), o > N && (r.moveTo(o * V(f), o * S(f)), r.arc(0, 0, o, f, p, y));
+    else {
+      var b = p, I = f, v = p, j = f, O = m, F = m, L = c.apply(this, arguments) / 2, H = L > N && (d ? +d.apply(this, arguments) : G(o * o + u * u)), q = te(Ae(u - o) / 2, +i.apply(this, arguments)), k = q, M = q, h, x;
+      if (H > N) {
+        var w = be(H / o * S(L)), z = be(H / u * S(L));
+        (O -= w * 2) > N ? (w *= y ? 1 : -1, v += w, j -= w) : (O = 0, v = j = (p + f) / 2), (F -= z * 2) > N ? (z *= y ? 1 : -1, b += z, I -= z) : (F = 0, b = I = (p + f) / 2);
+      }
+      var _ = u * V(b), U = u * S(b), B = o * V(j), K = o * S(j);
+      if (q > N) {
+        var J = u * V(I), Q = u * S(I), ee = o * V(v), ne = o * S(v), D;
+        if (m < me)
+          if (D = pn(_, U, ee, ne, J, Q, B, K)) {
+            var ie = _ - D[0], se = U - D[1], ae = J - D[0], re = Q - D[1], Re = 1 / S(Ke((ie * ae + se * re) / (G(ie * ie + se * se) * G(ae * ae + re * re))) / 2), pe = G(D[0] * D[0] + D[1] * D[1]);
+            k = te(q, (o - pe) / (Re - 1)), M = te(q, (u - pe) / (Re + 1));
+          } else
+            k = M = 0;
+      }
+      F > N ? M > N ? (h = X(ee, ne, _, U, u, M, y), x = X(J, Q, B, K, u, M, y), r.moveTo(h.cx + h.x01, h.cy + h.y01), M < q ? r.arc(h.cx, h.cy, M, T(h.y01, h.x01), T(x.y01, x.x01), !y) : (r.arc(h.cx, h.cy, M, T(h.y01, h.x01), T(h.y11, h.x11), !y), r.arc(0, 0, u, T(h.cy + h.y11, h.cx + h.x11), T(x.cy + x.y11, x.cx + x.x11), !y), r.arc(x.cx, x.cy, M, T(x.y11, x.x11), T(x.y01, x.x01), !y))) : (r.moveTo(_, U), r.arc(0, 0, u, b, I, !y)) : r.moveTo(_, U), !(o > N) || !(O > N) ? r.lineTo(B, K) : k > N ? (h = X(B, K, J, Q, o, -k, y), x = X(_, U, ee, ne, o, -k, y), r.lineTo(h.cx + h.x01, h.cy + h.y01), k < q ? r.arc(h.cx, h.cy, k, T(h.y01, h.x01), T(x.y01, x.x01), !y) : (r.arc(h.cx, h.cy, k, T(h.y01, h.x01), T(h.y11, h.x11), !y), r.arc(0, 0, o, T(h.cy + h.y11, h.cx + h.x11), T(x.cy + x.y11, x.cx + x.x11), y), r.arc(x.cx, x.cy, k, T(x.y11, x.x11), T(x.y01, x.x01), !y))) : r.arc(0, 0, o, j, v, y);
+    }
+    if (r.closePath(), s) return r = null, s + "" || null;
+  }
+  return l.centroid = function() {
+    var s = (+n.apply(this, arguments) + +a.apply(this, arguments)) / 2, t = (+g.apply(this, arguments) + +A.apply(this, arguments)) / 2 - me / 2;
+    return [V(t) * s, S(t) * s];
+  }, l.innerRadius = function(s) {
+    return arguments.length ? (n = typeof s == "function" ? s : $(+s), l) : n;
+  }, l.outerRadius = function(s) {
+    return arguments.length ? (a = typeof s == "function" ? s : $(+s), l) : a;
+  }, l.cornerRadius = function(s) {
+    return arguments.length ? (i = typeof s == "function" ? s : $(+s), l) : i;
+  }, l.padRadius = function(s) {
+    return arguments.length ? (d = s == null ? null : typeof s == "function" ? s : $(+s), l) : d;
+  }, l.startAngle = function(s) {
+    return arguments.length ? (g = typeof s == "function" ? s : $(+s), l) : g;
+  }, l.endAngle = function(s) {
+    return arguments.length ? (A = typeof s == "function" ? s : $(+s), l) : A;
+  }, l.padAngle = function(s) {
+    return arguments.length ? (c = typeof s == "function" ? s : $(+s), l) : c;
+  }, l.context = function(s) {
+    return arguments.length ? (r = s ?? null, l) : r;
+  }, l;
+}
+function Ce() {
+  return $e("pie");
+}
+function ke() {
+  return Me().use(Ee).pie ?? {};
+}
+function hn(n, a) {
+  const i = E(n.startAngle, a.startAngle), d = E(n.endAngle, a.endAngle), g = E(n.innerRadius, a.innerRadius), A = E(n.outerRadius, a.outerRadius), c = E(n.paddingAngle, a.paddingAngle), r = E(n.cornerRadius, a.cornerRadius);
+  return (R) => ({
+    startAngle: i(R),
+    endAngle: d(R),
+    innerRadius: g(R),
+    outerRadius: A(R),
+    paddingAngle: c(R),
+    cornerRadius: r(R)
+  });
+}
+function An(n) {
+  const a = {
+    startAngle: (n.startAngle + n.endAngle) / 2,
+    endAngle: (n.startAngle + n.endAngle) / 2,
+    innerRadius: n.innerRadius,
+    outerRadius: n.outerRadius,
+    paddingAngle: n.paddingAngle,
+    cornerRadius: n.cornerRadius
+  };
+  return Pe({
+    startAngle: n.startAngle,
+    endAngle: n.endAngle,
+    innerRadius: n.innerRadius,
+    outerRadius: n.outerRadius,
+    paddingAngle: n.paddingAngle,
+    cornerRadius: n.cornerRadius
+  }, {
+    createInterpolator: hn,
+    transformProps: (i) => ({
+      d: Le().cornerRadius(i.cornerRadius)({
+        padAngle: i.paddingAngle,
+        innerRadius: i.innerRadius,
+        outerRadius: i.outerRadius,
+        startAngle: i.startAngle,
+        endAngle: i.endAngle
+      }),
+      visibility: i.startAngle === i.endAngle ? "hidden" : "visible"
+    }),
+    applyProps(i, d) {
+      i.setAttribute("d", d.d), i.setAttribute("visibility", d.visibility);
+    },
+    initialProps: a,
+    skip: n.skipAnimation,
+    ref: n.ref
+  });
+}
+function mn(n, a) {
+  const i = E(n.startAngle, a.startAngle), d = E(n.endAngle, a.endAngle), g = E(n.innerRadius, a.innerRadius), A = E(n.outerRadius, a.outerRadius), c = E(n.paddingAngle, a.paddingAngle), r = E(n.cornerRadius, a.cornerRadius);
+  return (R) => ({
+    startAngle: i(R),
+    endAngle: d(R),
+    innerRadius: g(R),
+    outerRadius: A(R),
+    paddingAngle: c(R),
+    cornerRadius: r(R)
+  });
+}
+function bn(n) {
+  const a = {
+    startAngle: (n.startAngle + n.endAngle) / 2,
+    endAngle: (n.startAngle + n.endAngle) / 2,
+    innerRadius: n.arcLabelRadius ?? n.innerRadius,
+    outerRadius: n.arcLabelRadius ?? n.outerRadius,
+    paddingAngle: n.paddingAngle,
+    cornerRadius: n.cornerRadius
+  };
+  return Pe({
+    startAngle: n.startAngle,
+    endAngle: n.endAngle,
+    innerRadius: n.arcLabelRadius ?? n.innerRadius,
+    outerRadius: n.arcLabelRadius ?? n.outerRadius,
+    paddingAngle: n.paddingAngle,
+    cornerRadius: n.cornerRadius
+  }, {
+    createInterpolator: mn,
+    transformProps: (i) => {
+      const [d, g] = Le().cornerRadius(i.cornerRadius).centroid({
+        padAngle: i.paddingAngle,
+        startAngle: i.startAngle,
+        endAngle: i.endAngle,
+        innerRadius: i.innerRadius,
+        outerRadius: i.outerRadius
+      });
+      return {
+        x: d,
+        y: g
+      };
+    },
+    applyProps(i, {
+      x: d,
+      y: g
+    }) {
+      i.setAttribute("x", d.toString()), i.setAttribute("y", g.toString());
+    },
+    initialProps: a,
+    skip: n.skipAnimation,
+    ref: n.ref
+  });
+}
+const fn = ["className", "classes", "color", "dataIndex", "id", "isFaded", "isHighlighted", "isFocused", "onClick", "cornerRadius", "startAngle", "endAngle", "innerRadius", "outerRadius", "paddingAngle", "skipAnimation", "stroke", "skipInteraction"];
+function yn(n) {
+  return ce("MuiPieArc", n);
+}
+const xn = ue("MuiPieArc", ["root", "highlighted", "faded", "series", "focusIndicator"]), Pn = (n) => {
+  const {
+    classes: a,
+    id: i,
+    isFaded: d,
+    isHighlighted: g,
+    dataIndex: A
+  } = n, c = {
+    root: ["root", `series-${i}`, `data-index-${A}`, g && "highlighted", d && "faded"]
+  };
+  return le(c, yn, a);
+}, In = xe("path", {
+  name: "MuiPieArc",
+  slot: "Root",
+  overridesResolver: (n, a) => a.arc
+  // FIXME: Inconsistent naming with slot
+})({
+  transitionProperty: "opacity, fill, filter",
+  transitionDuration: `${de}ms`,
+  transitionTimingFunction: oe
+}), Z = /* @__PURE__ */ Y.forwardRef(function(a, i) {
+  const {
+    className: d,
+    classes: g,
+    color: A,
+    dataIndex: c,
+    id: r,
+    isFaded: R,
+    isHighlighted: l,
+    isFocused: s,
+    onClick: t,
+    cornerRadius: o,
+    startAngle: u,
+    endAngle: p,
+    innerRadius: f,
+    outerRadius: m,
+    paddingAngle: y,
+    skipAnimation: b,
+    stroke: I,
+    skipInteraction: v
+  } = a, j = W(a, fn), O = ye(), F = I ?? (O.vars || O).palette.background.paper, L = {
+    id: r,
+    dataIndex: c,
+    classes: g,
+    color: A,
+    isFaded: R,
+    isHighlighted: l,
+    isFocused: s
+  }, H = Pn(L), q = we({
+    type: "pie",
+    seriesId: r,
+    dataIndex: c
+  }, v), k = An({
+    cornerRadius: o,
+    startAngle: u,
+    endAngle: p,
+    innerRadius: f,
+    outerRadius: m,
+    paddingAngle: y,
+    skipAnimation: b,
+    ref: i
+  });
+  return /* @__PURE__ */ P.jsx(In, C({
+    onClick: t,
+    cursor: t ? "pointer" : "unset",
+    ownerState: L,
+    className: Fe(H.root, d),
+    fill: L.color,
+    opacity: L.isFaded ? 0.3 : 1,
+    filter: L.isHighlighted ? "brightness(120%)" : "none",
+    stroke: F,
+    strokeWidth: 1,
+    strokeLinejoin: "round",
+    "data-highlighted": L.isHighlighted || void 0,
+    "data-faded": L.isFaded || void 0
+  }, j, q, k));
+});
+process.env.NODE_ENV !== "production" && (Z.displayName = "PieArc");
+process.env.NODE_ENV !== "production" && (Z.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: e.object,
+  cornerRadius: e.number.isRequired,
+  dataIndex: e.number.isRequired,
+  endAngle: e.number.isRequired,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  innerRadius: e.number.isRequired,
+  isFaded: e.bool.isRequired,
+  isFocused: e.bool.isRequired,
+  isHighlighted: e.bool.isRequired,
+  outerRadius: e.number.isRequired,
+  paddingAngle: e.number.isRequired,
+  /**
+   * If `true`, the animation is disabled.
+   */
+  skipAnimation: e.bool,
+  /**
+   * If `true`, the default event handlers are disabled.
+   * Those are used, for example, to display a tooltip or highlight the arc on hover.
+   */
+  skipInteraction: e.bool,
+  startAngle: e.number.isRequired
+});
+function Ln() {
+  const n = Ie();
+  return (a) => n !== null && dn(n, a);
+}
+function Te(n, a, i, d) {
+  const {
+    faded: g,
+    highlighted: A,
+    paddingAngle: c = 0,
+    cornerRadius: r = 0
+  } = n, {
+    radius: {
+      inner: R = 0,
+      label: l,
+      outer: s
+    }
+  } = a, t = C({
+    additionalRadius: 0
+  }, d && g || i && A || {}), o = Math.max(0, Se(t.paddingAngle ?? c)), u = Math.max(0, t.innerRadius ?? R), p = Math.max(0, t.outerRadius ?? s + t.additionalRadius), f = t.cornerRadius ?? r, m = t.arcLabelRadius ?? l ?? (u + p) / 2;
+  return {
+    paddingAngle: o,
+    innerRadius: u,
+    outerRadius: p,
+    cornerRadius: f,
+    arcLabelRadius: m
+  };
+}
+function ve(n) {
+  const {
+    id: a,
+    data: i,
+    faded: d,
+    highlighted: g
+  } = n, {
+    isFaded: A,
+    isHighlighted: c
+  } = on(), r = Ln();
+  return Y.useMemo(() => i.map((l, s) => {
+    const t = {
+      seriesId: a,
+      dataIndex: s
+    }, o = c(t), u = !o && A(t), p = r({
+      type: "pie",
+      seriesId: a,
+      dataIndex: s
+    }), f = Te(n, {
+      radius: {
+        inner: n.innerRadius ?? 0,
+        outer: n.outerRadius,
+        label: n.arcLabelRadius ?? 0,
+        available: 0
+      }
+    }, o, u), m = C({
+      additionalRadius: 0
+    }, u && d || o && g || {});
+    return C({}, l, m, {
+      dataIndex: s,
+      isFaded: u,
+      isHighlighted: o,
+      isFocused: p
+    }, f);
+  }), [i, a, c, A, r, n, d, g]);
+}
+const Cn = ["slots", "slotProps", "innerRadius", "outerRadius", "cornerRadius", "paddingAngle", "id", "highlighted", "faded", "data", "onItemClick", "skipAnimation"];
+function Oe(n) {
+  const {
+    slots: a,
+    slotProps: i,
+    innerRadius: d = 0,
+    outerRadius: g,
+    cornerRadius: A = 0,
+    paddingAngle: c = 0,
+    id: r,
+    highlighted: R,
+    faded: l = {
+      additionalRadius: -5
+    },
+    data: s,
+    onItemClick: t,
+    skipAnimation: o
+  } = n, u = W(n, Cn), p = ve({
+    innerRadius: d,
+    outerRadius: g,
+    cornerRadius: A,
+    paddingAngle: c,
+    id: r,
+    highlighted: R,
+    faded: l,
+    data: s
+  });
+  if (s.length === 0)
+    return null;
+  const f = a?.pieArc ?? Z;
+  return /* @__PURE__ */ P.jsx("g", C({}, u, {
+    children: p.map((m, y) => /* @__PURE__ */ P.jsx(f, C({
+      startAngle: m.startAngle,
+      endAngle: m.endAngle,
+      paddingAngle: m.paddingAngle,
+      innerRadius: m.innerRadius,
+      outerRadius: m.outerRadius,
+      cornerRadius: m.cornerRadius,
+      skipAnimation: o ?? !1,
+      id: r,
+      color: m.color,
+      dataIndex: y,
+      isFaded: m.isFaded,
+      isHighlighted: m.isHighlighted,
+      isFocused: m.isFocused,
+      onClick: t && ((b) => {
+        t(b, {
+          type: "pie",
+          seriesId: r,
+          dataIndex: y
+        }, m);
+      })
+    }, i?.pieArc), m.dataIndex))
+  }));
+}
+process.env.NODE_ENV !== "production" && (Oe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The radius between circle center and the arc label in px.
+   * @default (innerRadius - outerRadius) / 2
+   */
+  arcLabelRadius: e.number,
+  /**
+   * The radius applied to arc corners (similar to border radius).
+   * @default 0
+   */
+  cornerRadius: e.number,
+  data: e.arrayOf(e.shape({
+    color: e.string.isRequired,
+    endAngle: e.number.isRequired,
+    formattedValue: e.string.isRequired,
+    id: e.oneOfType([e.number, e.string]),
+    index: e.number.isRequired,
+    label: e.oneOfType([e.func, e.string]),
+    labelMarkType: e.oneOfType([e.oneOf(["circle", "line", "square"]), e.func]),
+    padAngle: e.number.isRequired,
+    startAngle: e.number.isRequired,
+    value: e.number.isRequired
+  })).isRequired,
+  /**
+   * Override the arc attributes when it is faded.
+   * @default { additionalRadius: -5 }
+   */
+  faded: e.shape({
+    additionalRadius: e.number,
+    arcLabelRadius: e.number,
+    color: e.string,
+    cornerRadius: e.number,
+    innerRadius: e.number,
+    outerRadius: e.number,
+    paddingAngle: e.number
+  }),
+  /**
+   * Override the arc attributes when it is highlighted.
+   */
+  highlighted: e.shape({
+    additionalRadius: e.number,
+    arcLabelRadius: e.number,
+    color: e.string,
+    cornerRadius: e.number,
+    innerRadius: e.number,
+    outerRadius: e.number,
+    paddingAngle: e.number
+  }),
+  /**
+   * The id of this series.
+   */
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * The radius between circle center and the beginning of the arc.
+   * @default 0
+   */
+  innerRadius: e.number,
+  /**
+   * Callback fired when a pie item is clicked.
+   * @param {React.MouseEvent<SVGPathElement, MouseEvent>} event The event source of the callback.
+   * @param {PieItemIdentifier} pieItemIdentifier The pie item identifier.
+   * @param {DefaultizedPieValueType} item The pie item.
+   */
+  onItemClick: e.func,
+  /**
+   * The radius between circle center and the end of the arc.
+   */
+  outerRadius: e.number.isRequired,
+  /**
+   * The padding angle (deg) between two arcs.
+   * @default 0
+   */
+  paddingAngle: e.number,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object
+});
+const kn = ["id", "classes", "color", "startAngle", "endAngle", "paddingAngle", "arcLabelRadius", "innerRadius", "outerRadius", "cornerRadius", "formattedArcLabel", "isHighlighted", "isFaded", "skipAnimation", "hidden"];
+function Tn(n) {
+  return ce("MuiPieArcLabel", n);
+}
+const vn = ue("MuiPieArcLabel", ["root", "highlighted", "faded", "animate", "series"]), On = (n) => {
+  const {
+    classes: a,
+    id: i,
+    isFaded: d,
+    isHighlighted: g,
+    skipAnimation: A
+  } = n, c = {
+    root: ["root", `series-${i}`, g && "highlighted", d && "faded", !A && "animate"]
+  };
+  return le(c, Tn, a);
+}, qn = xe("text", {
+  name: "MuiPieArcLabel",
+  slot: "Root"
+})(({
+  theme: n
+}) => ({
+  fill: (n.vars || n).palette.text.primary,
+  textAnchor: "middle",
+  dominantBaseline: "middle",
+  pointerEvents: "none",
+  animationName: "animate-opacity",
+  animationDuration: "0s",
+  animationTimingFunction: oe,
+  transitionDuration: `${de}ms`,
+  transitionProperty: "opacity",
+  transitionTimingFunction: oe,
+  [`&.${vn.animate}`]: {
+    animationDuration: `${de}ms`
+  },
+  "@keyframes animate-opacity": {
+    from: {
+      opacity: 0
+    }
+  }
+})), ge = /* @__PURE__ */ Y.forwardRef(function(a, i) {
+  const {
+    id: d,
+    classes: g,
+    color: A,
+    startAngle: c,
+    endAngle: r,
+    paddingAngle: R,
+    arcLabelRadius: l,
+    cornerRadius: s,
+    formattedArcLabel: t,
+    isHighlighted: o,
+    isFaded: u,
+    skipAnimation: p,
+    hidden: f
+  } = a, m = W(a, kn), b = On({
+    id: d,
+    classes: g,
+    isFaded: u,
+    isHighlighted: o,
+    skipAnimation: p
+  }), I = bn({
+    cornerRadius: s,
+    startAngle: c,
+    endAngle: r,
+    innerRadius: l,
+    outerRadius: l,
+    paddingAngle: R,
+    skipAnimation: p,
+    ref: i
+  });
+  return /* @__PURE__ */ P.jsx(qn, C({
+    className: b.root
+  }, m, I, {
+    opacity: f ? 0 : 1,
+    children: t
+  }));
+});
+process.env.NODE_ENV !== "production" && (ge.displayName = "PieArcLabel");
+process.env.NODE_ENV !== "production" && (ge.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  arcLabelRadius: e.number.isRequired,
+  classes: e.object,
+  color: e.string.isRequired,
+  cornerRadius: e.number.isRequired,
+  endAngle: e.number.isRequired,
+  formattedArcLabel: e.string,
+  hidden: e.bool,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  innerRadius: e.number.isRequired,
+  isFaded: e.bool.isRequired,
+  isHighlighted: e.bool.isRequired,
+  outerRadius: e.number.isRequired,
+  paddingAngle: e.number.isRequired,
+  skipAnimation: e.bool.isRequired,
+  startAngle: e.number.isRequired
+});
+const jn = ["arcLabel", "arcLabelMinAngle", "arcLabelRadius", "cornerRadius", "data", "faded", "highlighted", "id", "innerRadius", "outerRadius", "paddingAngle", "skipAnimation", "slotProps", "slots"], Nn = 180 / Math.PI;
+function Fn(n, a, i) {
+  if (!n || (i.endAngle - i.startAngle) * Nn < a)
+    return null;
+  switch (n) {
+    case "label":
+      return fe(i.label, "arc");
+    case "value":
+      return i.value?.toString();
+    case "formattedValue":
+      return i.formattedValue;
+    default:
+      return n(C({}, i, {
+        label: fe(i.label, "arc")
+      }));
+  }
+}
+function qe(n) {
+  const {
+    arcLabel: a,
+    arcLabelMinAngle: i = 0,
+    arcLabelRadius: d,
+    cornerRadius: g = 0,
+    data: A,
+    faded: c = {
+      additionalRadius: -5
+    },
+    highlighted: r,
+    id: R,
+    innerRadius: l,
+    outerRadius: s,
+    paddingAngle: t = 0,
+    skipAnimation: o,
+    slotProps: u,
+    slots: p
+  } = n, f = W(n, jn), m = ve({
+    innerRadius: l,
+    outerRadius: s,
+    arcLabelRadius: d,
+    cornerRadius: g,
+    paddingAngle: t,
+    id: R,
+    highlighted: r,
+    faded: c,
+    data: A
+  });
+  if (A.length === 0)
+    return null;
+  const y = p?.pieArcLabel ?? ge;
+  return /* @__PURE__ */ P.jsx("g", C({}, f, {
+    children: m.map((b) => /* @__PURE__ */ P.jsx(y, C({
+      startAngle: b.startAngle,
+      endAngle: b.endAngle,
+      paddingAngle: b.paddingAngle,
+      innerRadius: b.innerRadius,
+      outerRadius: b.outerRadius,
+      arcLabelRadius: b.arcLabelRadius,
+      cornerRadius: b.cornerRadius,
+      hidden: b.hidden,
+      id: R,
+      color: b.color,
+      isFaded: b.isFaded,
+      isHighlighted: b.isHighlighted,
+      formattedArcLabel: Fn(a, i, b),
+      skipAnimation: o ?? !1
+    }, u?.pieArcLabel), b.id ?? b.dataIndex))
+  }));
+}
+process.env.NODE_ENV !== "production" && (qe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The label displayed into the arc.
+   */
+  arcLabel: e.oneOfType([e.oneOf(["formattedValue", "label", "value"]), e.func]),
+  /**
+   * The minimal angle required to display the arc label.
+   * @default 0
+   */
+  arcLabelMinAngle: e.number,
+  /**
+   * The radius between circle center and the arc label in px.
+   * @default (innerRadius - outerRadius) / 2
+   */
+  arcLabelRadius: e.number,
+  /**
+   * The radius applied to arc corners (similar to border radius).
+   * @default 0
+   */
+  cornerRadius: e.number,
+  data: e.arrayOf(e.shape({
+    color: e.string.isRequired,
+    endAngle: e.number.isRequired,
+    formattedValue: e.string.isRequired,
+    id: e.oneOfType([e.number, e.string]),
+    index: e.number.isRequired,
+    label: e.oneOfType([e.func, e.string]),
+    labelMarkType: e.oneOfType([e.oneOf(["circle", "line", "square"]), e.func]),
+    padAngle: e.number.isRequired,
+    startAngle: e.number.isRequired,
+    value: e.number.isRequired
+  })).isRequired,
+  /**
+   * Override the arc attributes when it is faded.
+   * @default { additionalRadius: -5 }
+   */
+  faded: e.shape({
+    additionalRadius: e.number,
+    arcLabelRadius: e.number,
+    color: e.string,
+    cornerRadius: e.number,
+    innerRadius: e.number,
+    outerRadius: e.number,
+    paddingAngle: e.number
+  }),
+  /**
+   * Override the arc attributes when it is highlighted.
+   */
+  highlighted: e.shape({
+    additionalRadius: e.number,
+    arcLabelRadius: e.number,
+    color: e.string,
+    cornerRadius: e.number,
+    innerRadius: e.number,
+    outerRadius: e.number,
+    paddingAngle: e.number
+  }),
+  /**
+   * The id of this series.
+   */
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * The radius between circle center and the beginning of the arc.
+   * @default 0
+   */
+  innerRadius: e.number,
+  /**
+   * The radius between circle center and the end of the arc.
+   */
+  outerRadius: e.number.isRequired,
+  /**
+   * The padding angle (deg) between two arcs.
+   * @default 0
+   */
+  paddingAngle: e.number,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object
+});
+function Hn(n) {
+  return ce("MuiPieChart", n);
+}
+ue("MuiPieChart", ["root", "series", "seriesLabels"]);
+const Mn = (n) => le({
+  root: ["root"],
+  series: ["series"],
+  seriesLabels: ["seriesLabels"]
+}, Hn, n);
+function je(n) {
+  const {
+    skipAnimation: a,
+    slots: i,
+    slotProps: d,
+    onItemClick: g
+  } = n, A = Ce(), c = ke(), r = Ve(a), R = Mn();
+  if (A === void 0)
+    return null;
+  const {
+    series: l,
+    seriesOrder: s
+  } = A;
+  return /* @__PURE__ */ P.jsxs("g", {
+    children: [s.map((t) => {
+      const {
+        cornerRadius: o,
+        paddingAngle: u,
+        data: p,
+        highlighted: f,
+        faded: m
+      } = l[t];
+      return /* @__PURE__ */ P.jsx("g", {
+        className: R.series,
+        transform: `translate(${c[t].center.x}, ${c[t].center.y})`,
+        "data-series": t,
+        children: /* @__PURE__ */ P.jsx(Oe, {
+          innerRadius: c[t].radius.inner,
+          outerRadius: c[t].radius.outer,
+          cornerRadius: o,
+          paddingAngle: u,
+          id: t,
+          data: p,
+          skipAnimation: r,
+          highlighted: f,
+          faded: m,
+          onItemClick: g,
+          slots: i,
+          slotProps: d
+        })
+      }, t);
+    }), s.map((t) => {
+      const {
+        cornerRadius: o,
+        paddingAngle: u,
+        arcLabel: p,
+        arcLabelMinAngle: f,
+        data: m
+      } = l[t];
+      return /* @__PURE__ */ P.jsx("g", {
+        className: R.seriesLabels,
+        transform: `translate(${c[t].center.x}, ${c[t].center.y})`,
+        "data-series": t,
+        children: /* @__PURE__ */ P.jsx(qe, {
+          innerRadius: c[t].radius.inner,
+          outerRadius: c[t].radius.outer,
+          arcLabelRadius: c[t].radius.label,
+          cornerRadius: o,
+          paddingAngle: u,
+          id: t,
+          data: m,
+          skipAnimation: r,
+          arcLabel: p,
+          arcLabelMinAngle: f,
+          slots: i,
+          slotProps: d
+        })
+      }, t);
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (je.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Callback fired when a pie item is clicked.
+   * @param {React.MouseEvent<SVGPathElement, MouseEvent>} event The event source of the callback.
+   * @param {PieItemIdentifier} pieItemIdentifier The pie item identifier.
+   * @param {DefaultizedPieValueType} item The pie item.
+   */
+  onItemClick: e.func,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object
+});
+const En = [Qe, Xe, Ye, Ze, en], Sn = ["arcLabelRadius"];
+function Dn(n) {
+  const a = ye(), i = Ie(), d = ke(), {
+    isHighlighted: g,
+    isFaded: A
+  } = _e(i), c = Ce();
+  if (i === null || i.type !== "pie" || !c)
+    return null;
+  const r = c?.series[i.seriesId], {
+    center: R,
+    radius: l
+  } = d[i.seriesId];
+  if (!r || !R || !l)
+    return null;
+  const s = r.data[i.dataIndex], t = Te(r, d[i.seriesId], g, A), o = W(t, Sn);
+  return /* @__PURE__ */ P.jsx(Z, C({
+    transform: `translate(${d[r.id].center.x}, ${d[r.id].center.y})`,
+    startAngle: s.startAngle,
+    endAngle: s.endAngle,
+    color: "transparent",
+    pointerEvents: "none",
+    skipInteraction: !0,
+    skipAnimation: !0,
+    stroke: (a.vars ?? a).palette.text.primary,
+    id: r.id,
+    className: xn.focusIndicator,
+    dataIndex: i.dataIndex,
+    isFaded: !1,
+    isHighlighted: !1,
+    isFocused: !1,
+    strokeWidth: 3
+  }, o, n));
+}
+const $n = ["series", "width", "height", "margin", "colors", "sx", "skipAnimation", "hideLegend", "children", "slots", "slotProps", "onItemClick", "loading", "highlightedItem", "onHighlightChange", "className", "showToolbar"], Ne = /* @__PURE__ */ Y.forwardRef(function(a, i) {
+  const d = He({
+    props: a,
+    name: "MuiPieChart"
+  }), {
+    series: g,
+    width: A,
+    height: c,
+    margin: r,
+    colors: R,
+    sx: l,
+    skipAnimation: s,
+    hideLegend: t,
+    children: o,
+    slots: u,
+    slotProps: p,
+    onItemClick: f,
+    loading: m,
+    highlightedItem: y,
+    onHighlightChange: b,
+    className: I,
+    showToolbar: v
+  } = d, j = W(d, $n), O = nn(r, De), {
+    chartDataProviderProps: F,
+    chartsSurfaceProps: L
+  } = sn(C({}, j, {
+    series: g.map((k) => C({
+      type: "pie"
+    }, k)),
+    width: A,
+    height: c,
+    margin: O,
+    colors: R,
+    highlightedItem: y,
+    onHighlightChange: b,
+    className: I,
+    skipAnimation: s,
+    plugins: En
+  }), i), H = u?.tooltip ?? Ue, q = u?.toolbar;
+  return /* @__PURE__ */ P.jsx(an, C({}, F, {
+    children: /* @__PURE__ */ P.jsxs(Ge, {
+      legendPosition: p?.legend?.position,
+      legendDirection: p?.legend?.direction ?? "vertical",
+      sx: l,
+      hideLegend: t ?? !1,
+      children: [v && q ? /* @__PURE__ */ P.jsx(q, C({}, p?.toolbar)) : null, !t && /* @__PURE__ */ P.jsx(We, {
+        direction: p?.legend?.direction ?? "vertical",
+        slots: u,
+        slotProps: p
+      }), /* @__PURE__ */ P.jsxs(rn, C({}, L, {
+        children: [/* @__PURE__ */ P.jsx(je, {
+          slots: u,
+          slotProps: p,
+          onItemClick: f
+        }), /* @__PURE__ */ P.jsx(Dn, {}), /* @__PURE__ */ P.jsx(ze, {
+          loading: m,
+          slots: u,
+          slotProps: p
+        }), o]
+      })), !m && /* @__PURE__ */ P.jsx(H, C({
+        trigger: "item"
+      }, p?.tooltip))]
+    })
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ne.displayName = "PieChart");
+process.env.NODE_ENV !== "production" && (Ne.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  apiRef: e.shape({
+    current: e.object
+  }),
+  children: e.node,
+  className: e.string,
+  /**
+   * Color palette used to colorize multiple series.
+   * @default rainbowSurgePalette
+   */
+  colors: e.oneOfType([e.arrayOf(e.string), e.func]),
+  /**
+   * An array of objects that can be used to populate series and axes data using their `dataKey` property.
+   */
+  dataset: e.arrayOf(e.object),
+  desc: e.string,
+  enableKeyboardNavigation: e.bool,
+  /**
+   * The height of the chart in px. If not defined, it takes the height of the parent element.
+   */
+  height: e.number,
+  /**
+   * List of hidden series and/or items.
+   *
+   * Different chart types use different keys.
+   *
+   * @example
+   * ```ts
+   * [
+   *   {
+   *     type: 'pie',
+   *     seriesId: 'series-1',
+   *     dataIndex: 3,
+   *   },
+   *   {
+   *     type: 'line',
+   *     seriesId: 'series-2',
+   *   }
+   * ]
+   * ```
+   */
+  hiddenItems: e.arrayOf(e.shape({
+    dataIndex: e.number,
+    seriesId: e.oneOfType([e.number, e.string]),
+    type: e.oneOf(["pie"]).isRequired
+  })),
+  /**
+   * If `true`, the legend is not rendered.
+   */
+  hideLegend: e.bool,
+  /**
+   * The highlighted item.
+   * Used when the highlight is controlled.
+   */
+  highlightedItem: e.shape({
+    dataIndex: e.number,
+    seriesId: e.oneOfType([e.number, e.string]).isRequired
+  }),
+  /**
+   * This prop is used to help implement the accessibility logic.
+   * If you don't provide this prop. It falls back to a randomly generated id.
+   */
+  id: e.string,
+  /**
+   * List of initially hidden series and/or items.
+   * Used for uncontrolled state.
+   *
+   * Different chart types use different keys.
+   *
+   * @example
+   * ```ts
+   * [
+   *   {
+   *     type: 'pie',
+   *     seriesId: 'series-1',
+   *     dataIndex: 3,
+   *   },
+   *   {
+   *     type: 'line',
+   *     seriesId: 'series-2',
+   *   }
+   * ]
+   * ```
+   */
+  initialHiddenItems: e.arrayOf(e.shape({
+    dataIndex: e.number,
+    seriesId: e.oneOfType([e.number, e.string]),
+    type: e.oneOf(["pie"]).isRequired
+  })),
+  /**
+   * If `true`, a loading overlay is displayed.
+   * @default false
+   */
+  loading: e.bool,
+  /**
+   * Localized text for chart components.
+   */
+  localeText: e.object,
+  /**
+   * The margin between the SVG and the drawing area.
+   * It's used for leaving some space for extra information such as the x- and y-axis or legend.
+   *
+   * Accepts a `number` to be used on all sides or an object with the optional properties: `top`, `bottom`, `left`, and `right`.
+   */
+  margin: e.oneOfType([e.number, e.shape({
+    bottom: e.number,
+    left: e.number,
+    right: e.number,
+    top: e.number
+  })]),
+  /**
+   * Callback fired when any hidden identifiers change.
+   * @param {VisibilityIdentifier[]} hiddenItems The new list of hidden identifiers.
+   */
+  onHiddenItemsChange: e.func,
+  /**
+   * The callback fired when the highlighted item changes.
+   *
+   * @param {HighlightItemData | null} highlightedItem  The newly highlighted item.
+   */
+  onHighlightChange: e.func,
+  /**
+   * Callback fired when a pie arc is clicked.
+   */
+  onItemClick: e.func,
+  /**
+   * The callback fired when the tooltip item changes.
+   *
+   * @param {SeriesItemIdentifier<TSeries> | null} tooltipItem  The newly highlighted item.
+   */
+  onTooltipItemChange: e.func,
+  /**
+   * The series to display in the pie chart.
+   * An array of [[PieSeries]] objects.
+   */
+  series: e.arrayOf(e.object).isRequired,
+  /**
+   * If true, shows the default chart toolbar.
+   * @default false
+   */
+  showToolbar: e.bool,
+  /**
+   * If `true`, animations are skipped.
+   * If unset or `false`, the animations respects the user's `prefers-reduced-motion` setting.
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object,
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  theme: e.oneOf(["dark", "light"]),
+  title: e.string,
+  /**
+   * The tooltip item.
+   * Used when the tooltip is controlled.
+   */
+  tooltipItem: e.shape({
+    dataIndex: e.number.isRequired,
+    seriesId: e.oneOfType([e.number, e.string]).isRequired,
+    type: e.oneOf(["pie"]).isRequired
+  }),
+  /**
+   * The width of the chart in px. If not defined, it takes the width of the parent element.
+   */
+  width: e.number
+});
+export {
+  En as PIE_CHART_PLUGINS,
+  Z as PieArc,
+  ge as PieArcLabel,
+  qe as PieArcLabelPlot,
+  Oe as PieArcPlot,
+  Ne as PieChart,
+  je as PiePlot,
+  Tn as getPieArcLabelUtilityClass,
+  yn as getPieArcUtilityClass,
+  Kn as getPieCoordinates,
+  xn as pieArcClasses,
+  vn as pieArcLabelClasses
+};