dynamic-mui 2.0.26 → 2.2.0

package/dist/ChartsWrapper-CO5_Z6BD.mjs

@@ -0,0 +1,1878 @@
+import { n as ft, p as te, m as Y, h as pt, s as ht, f as gt, q as G, r as mt, t as re, i as xt, b as E, d as ve, u as $e, a as Le, v as qe, w as yt, x as bt, y as Ct, z as It, A as vt, B as Tt, C as Ot, E as Rt, F as At, c as Fe, G as jt, H as kt } from "./useAxis-SiNBMMWq.mjs";
+import { w as wt, o as Nt, f as me, _ as j, p as Pt, n as xe, c as le, g as ce, h as se, s as $, T as Te, u as Oe, r as De, b as ze, j as c, a as F, i as _, P as r, q as Et, t as St, k as Mt, v as _t, H as Ve, e as $t, x as Lt } from "./index-BhaKvHkU.mjs";
+import { a as A, c as J, b as qt } from "./createSelector-B-9FwV16.mjs";
+import { W as Ft, d as Re, X as Ue, Y as Dt, Z as zt, _ as He, $ as Vt, a0 as Ut, a1 as Ht, a2 as Wt, y as Ne, O as Bt, a3 as Yt, a4 as Gt, a5 as Jt } from "./useChartContainerProps-Bl3hO-r1.mjs";
+import * as T from "react";
+import { a as Kt } from "./clampAngle-BvZjnf53.mjs";
+import { i as Qt } from "./isDeepEqual-BHfPvf9U.mjs";
+import * as Zt from "react-dom";
+const Xt = (e) => e.animation, es = A(Xt, (e) => e.skip || e.skipAnimationRequests > 0), ts = (e) => e.tooltip, We = A(ts, (e) => e?.item ?? null), ss = A(We, (e) => e !== null), Ae = A(Re, We, Ue, (e, t, s) => e === "keyboard" ? s : t ?? null), rs = A(Re, ss, Ft, (e, t, s) => e === "keyboard" ? s : t), ns = J(Ae, ht, gt, G, mt, Y, function(t, {
+  axis: s,
+  axisIds: n
+}, {
+  axis: o,
+  axisIds: i
+}, a, d, p) {
+  if (!t)
+    return {};
+  const y = p[t.type]?.series[t.seriesId];
+  if (!y)
+    return {};
+  const g = {
+    rotationAxes: a,
+    radiusAxes: d
+  }, m = re(y) ? y.xAxisId ?? n[0] : void 0, h = re(y) ? y.yAxisId ?? i[0] : void 0;
+  return m !== void 0 && (g.x = s[m]), h !== void 0 && (g.y = o[h]), g;
+}), os = J(Ae, ft, te, Y, pt, ns, function(t, s, n, o, i, a, d = "top") {
+  if (!t)
+    return null;
+  const p = o[t.type]?.series[t.seriesId];
+  return p ? n[p.type].tooltipItemPositionGetter?.({
+    series: o,
+    seriesLayout: i,
+    drawingArea: s,
+    axesConfig: a,
+    identifier: t,
+    placement: d
+  }) ?? null : null;
+}), is = (e) => (t, s) => Math.atan2(t - e.cx, e.cy - s);
+function Pe(e, t) {
+  const {
+    scale: s,
+    data: n,
+    reverse: o
+  } = e;
+  if (!xt(s))
+    throw new Error("MUI X Charts: getAxisValue is not implemented for polare continuous axes.");
+  if (!n)
+    return -1;
+  const i = Kt(t - Math.min(...s.range())), a = s.bandwidth() === 0 ? Math.floor((i + s.step() / 2) / s.step()) % n.length : Math.floor(i / s.step());
+  return a < 0 || a >= n.length ? -1 : o ? n.length - 1 - a : a;
+}
+function ue() {
+  return E().use(Y);
+}
+const as = A(Y, (e, t) => e[t]);
+J(Y, (e, t, s) => {
+  if (s === void 0 || Array.isArray(s) && s.length === 0)
+    return e[t]?.seriesOrder?.map((i) => e[t]?.series[i]) ?? [];
+  if (!Array.isArray(s))
+    return e[t]?.series?.[s];
+  const n = [], o = [];
+  for (const i of s) {
+    const a = e[t]?.series?.[i];
+    a ? n.push(a) : o.push(i);
+  }
+  if (process.env.NODE_ENV !== "production" && o.length > 0) {
+    const i = o.map((d) => JSON.stringify(d)).join(", "), a = `use${t.charAt(0).toUpperCase()}${t.slice(1)}Series`;
+    wt([`MUI X Charts: The following ids provided to "${a}" could not be found: ${i}.`, `Make sure that they exist and their series are using the "${t}" series type.`]);
+  }
+  return n;
+});
+const Nr = (e) => E().use(as, e);
+function ls() {
+  return !1;
+}
+function Be(e, t) {
+  return !e || !t ? ls : function(n) {
+    return n ? e.highlight === "series" ? n.seriesId === t.seriesId : e.highlight === "item" ? n.dataIndex === t.dataIndex && n.seriesId === t.seriesId : !1 : !1;
+  };
+}
+function cs() {
+  return !1;
+}
+function Ye(e, t) {
+  return !e || !t ? cs : function(n) {
+    return n ? e.fade === "series" ? n.seriesId === t.seriesId && n.dataIndex !== t.dataIndex : e.fade === "global" ? n.seriesId !== t.seriesId || n.dataIndex !== t.dataIndex : !1 : !1;
+  };
+}
+function je(e, t, s) {
+  return e?.highlight === "series" && t?.seriesId === s;
+}
+function us(e, t, s) {
+  return je(e, t, s) ? !1 : e?.fade === "global" && t != null || e?.fade === "series" && t?.seriesId === s;
+}
+function Ge(e, t, s) {
+  return e?.highlight === "item" && t?.seriesId === s ? t.dataIndex : null;
+}
+function ds(e, t, s) {
+  return je(e, t, s) || Ge(e, t, s) === t?.dataIndex ? null : (e?.fade === "series" || e?.fade === "global") && t?.seriesId === s ? t.dataIndex : null;
+}
+const fs = (e) => e.highlight, ps = A(Y, (e) => {
+  const t = /* @__PURE__ */ new Map();
+  return Object.keys(e).forEach((s) => {
+    const n = e[s];
+    n?.seriesOrder?.forEach((o) => {
+      const i = n?.series[o];
+      t.set(o, i?.highlightScope);
+    });
+  }), t;
+}), q = J(fs, Ue, function(t, s) {
+  return t.isControlled || t.lastUpdate === "pointer" ? t.item : s;
+}), D = A(ps, q, function(t, s) {
+  if (!s)
+    return null;
+  const n = t.get(s.seriesId);
+  return n === void 0 ? null : n;
+}), Pr = J(D, q, Be), Er = J(D, q, Ye), hs = A(D, q, function(t, s, n) {
+  return Be(t, s)(n);
+}), Sr = A(D, q, je), Mr = A(D, q, us), _r = A(D, q, ds), $r = A(D, q, Ge), gs = A(D, q, function(t, s, n) {
+  return Ye(t, s)(n);
+});
+function Lr(e) {
+  const t = E(), s = t.use(hs, e), n = t.use(gs, e);
+  return {
+    isHighlighted: s,
+    isFaded: !s && n
+  };
+}
+function ms(e, t) {
+  return Object.keys(e).flatMap((s) => {
+    const n = t[s].legendGetter;
+    return n === void 0 ? [] : n(e[s]);
+  });
+}
+function xs() {
+  const e = ue(), s = E().use(te);
+  return {
+    items: ms(e, s)
+  };
+}
+var pe, Ee;
+function ys() {
+  if (Ee) return pe;
+  Ee = 1;
+  var e = 4, t = 1e-3, s = 1e-7, n = 10, o = 11, i = 1 / (o - 1), a = typeof Float32Array == "function";
+  function d(u, l) {
+    return 1 - 3 * l + 3 * u;
+  }
+  function p(u, l) {
+    return 3 * l - 6 * u;
+  }
+  function y(u) {
+    return 3 * u;
+  }
+  function g(u, l, f) {
+    return ((d(l, f) * u + p(l, f)) * u + y(l)) * u;
+  }
+  function m(u, l, f) {
+    return 3 * d(l, f) * u * u + 2 * p(l, f) * u + y(l);
+  }
+  function h(u, l, f, x, C) {
+    var v, b, w = 0;
+    do
+      b = l + (f - l) / 2, v = g(b, x, C) - u, v > 0 ? f = b : l = b;
+    while (Math.abs(v) > s && ++w < n);
+    return b;
+  }
+  function I(u, l, f, x) {
+    for (var C = 0; C < e; ++C) {
+      var v = m(l, f, x);
+      if (v === 0)
+        return l;
+      var b = g(l, f, x) - u;
+      l -= b / v;
+    }
+    return l;
+  }
+  function k(u) {
+    return u;
+  }
+  return pe = function(l, f, x, C) {
+    if (!(0 <= l && l <= 1 && 0 <= x && x <= 1))
+      throw new Error("bezier x values must be in [0, 1] range");
+    if (l === f && x === C)
+      return k;
+    for (var v = a ? new Float32Array(o) : new Array(o), b = 0; b < o; ++b)
+      v[b] = g(b * i, l, x);
+    function w(N) {
+      for (var O = 0, R = 1, P = o - 1; R !== P && v[R] <= N; ++R)
+        O += i;
+      --R;
+      var S = (N - v[R]) / (v[R + 1] - v[R]), M = O + S * i, L = m(M, l, x);
+      return L >= t ? I(N, M, l, x) : L === 0 ? M : h(N, O, O + i, l, x);
+    }
+    return function(O) {
+      return O === 0 ? 0 : O === 1 ? 1 : g(w(O), f, C);
+    };
+  }, pe;
+}
+var bs = ys();
+const Cs = /* @__PURE__ */ Nt(bs), Is = 300, qr = "cubic-bezier(0.66, 0, 0.34, 1)", vs = Cs(0.66, 0, 0.34, 1);
+var B = 0, Q = 0, K = 0, Je = 1e3, ne, Z, oe = 0, z = 0, de = 0, X = typeof performance == "object" && performance.now ? performance : Date, Ke = typeof window == "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(e) {
+  setTimeout(e, 17);
+};
+function ke() {
+  return z || (Ke(Ts), z = X.now() + de);
+}
+function Ts() {
+  z = 0;
+}
+function ie() {
+  this._call = this._time = this._next = null;
+}
+ie.prototype = Qe.prototype = {
+  constructor: ie,
+  restart: function(e, t, s) {
+    if (typeof e != "function") throw new TypeError("callback is not a function");
+    s = (s == null ? ke() : +s) + (t == null ? 0 : +t), !this._next && Z !== this && (Z ? Z._next = this : ne = this, Z = this), this._call = e, this._time = s, ye();
+  },
+  stop: function() {
+    this._call && (this._call = null, this._time = 1 / 0, ye());
+  }
+};
+function Qe(e, t, s) {
+  var n = new ie();
+  return n.restart(e, t, s), n;
+}
+function Os() {
+  ke(), ++B;
+  for (var e = ne, t; e; )
+    (t = z - e._time) >= 0 && e._call.call(void 0, t), e = e._next;
+  --B;
+}
+function Se() {
+  z = (oe = X.now()) + de, B = Q = 0;
+  try {
+    Os();
+  } finally {
+    B = 0, As(), z = 0;
+  }
+}
+function Rs() {
+  var e = X.now(), t = e - oe;
+  t > Je && (de -= t, oe = e);
+}
+function As() {
+  for (var e, t = ne, s, n = 1 / 0; t; )
+    t._call ? (n > t._time && (n = t._time), e = t, t = t._next) : (s = t._next, t._next = null, t = e ? e._next = s : ne = s);
+  Z = e, ye(n);
+}
+function ye(e) {
+  if (!B) {
+    Q && (Q = clearTimeout(Q));
+    var t = e - z;
+    t > 24 ? (e < 1 / 0 && (Q = setTimeout(Se, e - X.now() - de)), K && (K = clearInterval(K))) : (K || (oe = X.now(), K = setInterval(Rs, Je)), B = 1, Ke(Se));
+  }
+}
+function js(e, t, s) {
+  var n = new ie();
+  return t = t == null ? 0 : +t, n.restart((o) => {
+    n.stop(), e(o + t);
+  }, t, s), n;
+}
+class ks {
+  elapsed = 0;
+  timer = null;
+  /**
+   * Create a new ResumableTransition.
+   * @param duration Duration in milliseconds
+   * @param easingFn The easing function
+   * @param onTick Callback function called on each animation frame with the eased time in range [0, 1].
+   */
+  constructor(t, s, n) {
+    this.duration = t, this.easingFn = s, this.onTickCallback = n, this.resume();
+  }
+  get running() {
+    return this.timer !== null;
+  }
+  timerCallback(t) {
+    this.elapsed = Math.min(t, this.duration);
+    const s = this.duration === 0 ? 1 : this.elapsed / this.duration, n = this.easingFn(s);
+    this.onTickCallback(n), this.elapsed >= this.duration && this.stop();
+  }
+  /**
+   * Resume the transition
+   */
+  resume() {
+    if (this.running || this.elapsed >= this.duration)
+      return this;
+    const t = ke() - this.elapsed;
+    return this.timer = Qe((s) => this.timerCallback(s), 0, t), this;
+  }
+  /**
+   * Stops the transition.
+   */
+  stop() {
+    return this.running ? (this.timer && (this.timer.stop(), this.timer = null), this) : this;
+  }
+  /**
+   * Immediately finishes the transition and calls the tick callback with the final value.
+   */
+  finish() {
+    return this.stop(), js(() => this.timerCallback(this.duration)), this;
+  }
+}
+function ws(e, t) {
+  if (Object.is(e, t))
+    return !0;
+  if (typeof e != "object" || e === null || typeof t != "object" || t === null)
+    return !1;
+  const s = Object.keys(e), n = Object.keys(t);
+  if (s.length !== n.length)
+    return !1;
+  for (let o = 0; o < s.length; o += 1) {
+    const i = s[o];
+    if (!Object.prototype.hasOwnProperty.call(t, i) || // @ts-ignore
+    !Object.is(e[i], t[i]))
+      return !1;
+  }
+  return !0;
+}
+function Ns(e, {
+  createInterpolator: t,
+  applyProps: s,
+  skip: n,
+  initialProps: o = e
+}) {
+  const i = T.useRef(o), a = T.useRef(null), d = T.useRef(null), p = T.useRef(e);
+  me(() => {
+    p.current = e;
+  }, [e]), me(() => {
+    n && (a.current?.finish(), a.current = null, d.current = null, i.current = e);
+  }, [e, n]);
+  const y = T.useCallback((m) => {
+    const h = i.current, I = t(h, e);
+    a.current = new ks(Is, vs, (k) => {
+      const u = I(k);
+      i.current = u, s(m, u);
+    });
+  }, [s, t, e]);
+  return [T.useCallback((m) => {
+    if (m === null) {
+      a.current?.stop();
+      return;
+    }
+    const h = d.current;
+    if (h === m) {
+      if (ws(p.current, e)) {
+        a.current?.resume();
+        return;
+      }
+      a.current?.stop();
+    }
+    h && a.current?.stop(), d.current = m, (a.current || !n) && y(m);
+  }, [y, e, n]), i.current];
+}
+function Fr(e, {
+  createInterpolator: t,
+  transformProps: s,
+  applyProps: n,
+  skip: o,
+  initialProps: i = e,
+  ref: a
+}) {
+  const d = s ?? ((m) => m), [p, y] = Ns(e, {
+    initialProps: i,
+    createInterpolator: t,
+    applyProps: (m, h) => n(m, d(h)),
+    skip: o
+  }), g = s(o ? e : y);
+  return j({}, g, {
+    ref: Pt(p, a)
+  });
+}
+function Ps() {
+  return ve().chartRootRef;
+}
+const Ze = () => {
+  const e = T.useContext(Dt);
+  if (e === null)
+    throw new Error(["MUI X Charts: Can not find the charts localization context.", "It looks like you forgot to wrap your component in ChartsLocalizationProvider.", "This can also happen if you are bundling multiple versions of the `@mui/x-charts` package"].join(`
+`));
+  return e;
+};
+function Dr() {
+  return E().use(zt);
+}
+function zr(e) {
+  const s = E().use(es);
+  return e || s;
+}
+function Es(e) {
+  "hasPointerCapture" in e.currentTarget && e.currentTarget.hasPointerCapture(e.pointerId) && e.currentTarget.releasePointerCapture(e.pointerId);
+}
+const Vr = (e, t) => {
+  const {
+    instance: s
+  } = ve(), n = T.useRef(!1), o = xe(() => {
+    n.current = !0, s.setLastUpdateSource("pointer"), s.setTooltipItem(e), s.setHighlight(
+      // @ts-ignore
+      e.type === "sankey" ? e : {
+        seriesId: e.seriesId,
+        dataIndex: e.dataIndex
+      }
+    );
+  }), i = xe(() => {
+    n.current = !1, s.removeTooltipItem(e), s.clearHighlight();
+  });
+  return T.useEffect(() => () => {
+    n.current && i();
+  }, [i]), T.useMemo(() => t ? {} : {
+    onPointerEnter: o,
+    onPointerLeave: i,
+    onPointerDown: Es
+  }, [t, o, i]);
+};
+function Ss(e) {
+  return ce("MuiChartsTooltip", e);
+}
+const H = se("MuiChartsTooltip", ["root", "paper", "table", "row", "cell", "mark", "markContainer", "labelCell", "valueCell", "axisValueCell"]), fe = (e) => le({
+  root: ["root"],
+  paper: ["paper"],
+  table: ["table"],
+  row: ["row"],
+  cell: ["cell"],
+  mark: ["mark"],
+  markContainer: ["markContainer"],
+  labelCell: ["labelCell"],
+  valueCell: ["valueCell"],
+  axisValueCell: ["axisValueCell"]
+}, Ss, e);
+function Ms() {
+  const e = E(), t = e.use(Ae), s = e.use(te), n = ue(), {
+    xAxis: o,
+    xAxisIds: i
+  } = $e(), {
+    yAxis: a,
+    yAxisIds: d
+  } = Le(), {
+    zAxis: p,
+    zAxisIds: y
+  } = He(), {
+    rotationAxis: g,
+    rotationAxisIds: m
+  } = qe();
+  if (!t)
+    return null;
+  const h = n[t.type]?.series[t.seriesId];
+  if (!h)
+    return null;
+  const I = re(h) ? h.xAxisId ?? i[0] : void 0, k = re(h) ? h.yAxisId ?? d[0] : void 0, u = "zAxisId" in h ? h.zAxisId ?? y[0] : y[0], l = m[0], f = s[h.type].colorProcessor?.(h, I !== void 0 ? o[I] : void 0, k !== void 0 ? a[k] : void 0, u !== void 0 ? p[u] : void 0) ?? (() => ""), x = {};
+  return I !== void 0 && (x.x = o[I]), k !== void 0 && (x.y = a[k]), l !== void 0 && (x.rotation = g[l]), s[h.type].tooltipGetter({
+    series: h,
+    axesConfig: x,
+    getColor: f,
+    identifier: t
+  });
+}
+const be = $("div", {
+  name: "MuiChartsTooltip",
+  slot: "Container",
+  overridesResolver: (e, t) => t.paper
+  // FIXME: Inconsistent naming with slot
+})(({
+  theme: e
+}) => ({
+  backgroundColor: (e.vars || e).palette.background.paper,
+  color: (e.vars || e).palette.text.primary,
+  borderRadius: (e.vars || e).shape?.borderRadius,
+  border: `solid ${(e.vars || e).palette.divider} 1px`
+})), Ce = $("table", {
+  name: "MuiChartsTooltip",
+  slot: "Table"
+})(({
+  theme: e
+}) => ({
+  borderSpacing: 0,
+  [`& .${H.markContainer}`]: {
+    display: "inline-block",
+    width: `calc(20px + ${e.spacing(1.5)})`,
+    verticalAlign: "middle"
+  },
+  "& caption": {
+    borderBottom: `solid ${(e.vars || e).palette.divider} 1px`,
+    padding: e.spacing(0.5, 1.5),
+    textAlign: "start",
+    whiteSpace: "nowrap",
+    "& span": {
+      marginRight: e.spacing(1.5)
+    }
+  }
+})), Ie = $("tr", {
+  name: "MuiChartsTooltip",
+  slot: "Row"
+})(({
+  theme: e
+}) => ({
+  "tr:first-of-type& td": {
+    paddingTop: e.spacing(0.5)
+  },
+  "tr:last-of-type& td": {
+    paddingBottom: e.spacing(0.5)
+  }
+})), W = $(Te, {
+  name: "MuiChartsTooltip",
+  slot: "Cell"
+})(({
+  theme: e
+}) => ({
+  verticalAlign: "middle",
+  color: (e.vars || e).palette.text.secondary,
+  textAlign: "start",
+  [`&.${H.cell}`]: {
+    paddingLeft: e.spacing(1),
+    paddingRight: e.spacing(1)
+  },
+  [`&.${H.labelCell}`]: {
+    whiteSpace: "nowrap",
+    fontWeight: e.typography.fontWeightRegular
+  },
+  [`&.${H.valueCell}, &.${H.axisValueCell}`]: {
+    color: (e.vars || e).palette.text.primary,
+    fontWeight: e.typography.fontWeightMedium
+  },
+  [`&.${H.valueCell}`]: {
+    paddingLeft: e.spacing(1.5),
+    paddingRight: e.spacing(1.5)
+  },
+  "td:first-of-type&, th:first-of-type&": {
+    paddingLeft: e.spacing(1.5)
+  },
+  "td:last-of-type&, th:last-of-type&": {
+    paddingRight: e.spacing(1.5)
+  }
+}));
+function _s(e) {
+  return ce("MuiChartsLabelMark", e);
+}
+const U = se("MuiChartsLabelMark", ["root", "line", "square", "circle", "mask", "fill"]), $s = (e) => {
+  const {
+    type: t
+  } = e;
+  return le({
+    root: typeof t == "function" ? ["root"] : ["root", t],
+    mask: ["mask"],
+    fill: ["fill"]
+  }, _s, e.classes);
+}, we = (e, t, s) => /* @__PURE__ */ T.forwardRef(function(o, i) {
+  const a = Oe({
+    props: o,
+    // eslint-disable-next-line material-ui/mui-name-matches-component-name
+    name: e
+  }), d = typeof t.defaultProps == "function" ? t.defaultProps(a) : t.defaultProps ?? {}, p = De(d, a), y = ze(), g = t.classesResolver?.(p, y), m = /* @__PURE__ */ T.forwardRef(s);
+  return process.env.NODE_ENV !== "production" && (m.displayName = "OutComponent"), process.env.NODE_ENV !== "production" && (m.displayName = `consumeThemeProps(${e})`), /* @__PURE__ */ c.jsx(m, j({}, p, {
+    classes: g,
+    ref: i
+  }));
+});
+process.env.NODE_ENV !== "production" && (we.displayName = "consumeThemeProps");
+const Ls = ["type", "color", "className", "classes"], qs = $("div", {
+  name: "MuiChartsLabelMark",
+  slot: "Root"
+})(() => ({
+  display: "flex",
+  width: 14,
+  height: 14,
+  [`&.${U.line}`]: {
+    width: 16,
+    height: "unset",
+    alignItems: "center",
+    [`.${U.mask}`]: {
+      height: 4,
+      width: "100%",
+      borderRadius: 1,
+      overflow: "hidden"
+    }
+  },
+  [`&.${U.square}`]: {
+    height: 13,
+    width: 13,
+    borderRadius: 2,
+    overflow: "hidden"
+  },
+  [`&.${U.circle}`]: {
+    height: 15,
+    width: 15
+  },
+  svg: {
+    display: "block"
+  },
+  [`& .${U.mask} > *`]: {
+    height: "100%",
+    width: "100%"
+  },
+  [`& .${U.mask}`]: {
+    height: "100%",
+    width: "100%"
+  }
+})), ee = we("MuiChartsLabelMark", {
+  defaultProps: {
+    type: "square"
+  },
+  classesResolver: $s
+}, function(t, s) {
+  const {
+    type: n,
+    color: o,
+    className: i,
+    classes: a
+  } = t, d = F(t, Ls), p = n;
+  return /* @__PURE__ */ c.jsx(qs, j({
+    className: _(a?.root, i),
+    ownerState: t,
+    "aria-hidden": "true",
+    ref: s
+  }, d, {
+    children: /* @__PURE__ */ c.jsx("div", {
+      className: a?.mask,
+      children: typeof p == "function" ? /* @__PURE__ */ c.jsx(p, {
+        className: a?.fill,
+        color: o
+      }) : /* @__PURE__ */ c.jsx("svg", {
+        viewBox: "0 0 24 24",
+        preserveAspectRatio: n === "line" ? "none" : void 0,
+        children: n === "circle" ? /* @__PURE__ */ c.jsx("circle", {
+          className: a?.fill,
+          r: "12",
+          cx: "12",
+          cy: "12",
+          fill: o
+        }) : /* @__PURE__ */ c.jsx("rect", {
+          className: a?.fill,
+          width: "24",
+          height: "24",
+          fill: o
+        })
+      })
+    })
+  }));
+});
+process.env.NODE_ENV !== "production" && (ee.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * The color of the mark.
+   */
+  color: r.string,
+  /**
+   * The type of the mark.
+   * @default 'square'
+   */
+  type: r.oneOf(["circle", "line", "square"])
+});
+function Xe(e) {
+  const {
+    classes: t,
+    sx: s
+  } = e, n = Ms(), o = fe(t);
+  if (!n)
+    return null;
+  if ("values" in n) {
+    const {
+      label: y,
+      color: g,
+      markType: m
+    } = n;
+    return /* @__PURE__ */ c.jsx(be, {
+      sx: s,
+      className: o.paper,
+      children: /* @__PURE__ */ c.jsxs(Ce, {
+        className: o.table,
+        children: [/* @__PURE__ */ c.jsxs(Te, {
+          component: "caption",
+          children: [/* @__PURE__ */ c.jsx("div", {
+            className: o.markContainer,
+            children: /* @__PURE__ */ c.jsx(ee, {
+              type: m,
+              color: g,
+              className: o.mark
+            })
+          }), y]
+        }), /* @__PURE__ */ c.jsx("tbody", {
+          children: n.values.map(({
+            formattedValue: h,
+            label: I
+          }) => /* @__PURE__ */ c.jsxs(Ie, {
+            className: o.row,
+            children: [/* @__PURE__ */ c.jsx(W, {
+              className: _(o.labelCell, o.cell),
+              component: "th",
+              children: I
+            }), /* @__PURE__ */ c.jsx(W, {
+              className: _(o.valueCell, o.cell),
+              component: "td",
+              children: h
+            })]
+          }, I))
+        })]
+      })
+    });
+  }
+  const {
+    color: i,
+    label: a,
+    formattedValue: d,
+    markType: p
+  } = n;
+  return /* @__PURE__ */ c.jsx(be, {
+    sx: s,
+    className: o.paper,
+    children: /* @__PURE__ */ c.jsx(Ce, {
+      className: o.table,
+      children: /* @__PURE__ */ c.jsx("tbody", {
+        children: /* @__PURE__ */ c.jsxs(Ie, {
+          className: o.row,
+          children: [/* @__PURE__ */ c.jsxs(W, {
+            className: _(o.labelCell, o.cell),
+            component: "th",
+            children: [/* @__PURE__ */ c.jsx("div", {
+              className: o.markContainer,
+              children: /* @__PURE__ */ c.jsx(ee, {
+                type: p,
+                color: i,
+                className: o.mark
+              })
+            }), a]
+          }), /* @__PURE__ */ c.jsx(W, {
+            className: _(o.valueCell, o.cell),
+            component: "td",
+            children: d
+          })]
+        })
+      })
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (Xe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object])
+});
+function Fs(e) {
+  const s = E().use(te);
+  return T.useMemo(() => {
+    const o = {};
+    return Object.keys(s).forEach((i) => {
+      o[i] = s[i].colorProcessor;
+    }), o;
+  }, [s]);
+}
+function Ds(e) {
+  return e instanceof Date ? e.toUTCString() : e.toLocaleString();
+}
+const zs = "@media (pointer: fine)", Vs = () => Et(zs, {
+  defaultMatches: !0
+}), et = (e, t) => t, tt = (e, t) => t;
+function st(e, t, s) {
+  return Array.isArray(s) ? s.map((n) => Pe(t.axis[n], e)) : Pe(t.axis[s], e);
+}
+const rt = A(Ut, Vt, yt, (e, t, s) => e === null || t === null ? null : is(s)(e, t)), Us = A(rt, G, et, (e, t, s = t.axisIds[0]) => e === null ? null : st(e, t, s)), nt = A(rt, G, tt, (e, t, s = t.axisIds) => e === null ? null : st(e, t, s));
+A(G, Us, et, (e, t, s = e.axisIds[0]) => {
+  if (t === null || t === -1 || e.axisIds.length === 0)
+    return null;
+  const n = e.axis[s]?.data;
+  return n ? n[t] : null;
+});
+A(G, nt, tt, (e, t, s = e.axisIds) => t === null ? null : s.map((n, o) => {
+  const i = t[o];
+  return i === -1 ? null : e.axis[n].data?.[i];
+}));
+const ot = qt({
+  memoizeOptions: {
+    // Keep the same reference if array content is the same.
+    // If possible, avoid this pattern by creating selectors that
+    // uses string/number as arguments.
+    resultEqualityCheck: Qt
+  }
+})(nt, G, (e, t) => e === null ? [] : t.axisIds.map((s, n) => ({
+  axisId: s,
+  dataIndex: e[n]
+})).filter(({
+  axisId: s,
+  dataIndex: n
+}) => t.axis[s].triggerTooltip && n >= 0)), Hs = A(ot, (e) => e.length > 0);
+function he(e, t, s) {
+  const n = e.data?.[t] ?? null, i = (e.valueFormatter ?? ((a) => e.scaleType === "utc" ? Ds(a) : a.toLocaleString()))(n, {
+    location: "tooltip",
+    scale: e.scale
+  });
+  return {
+    axisDirection: s,
+    axisId: e.id,
+    mainAxis: e,
+    dataIndex: t,
+    axisValue: n,
+    axisFormattedValue: i,
+    seriesItems: []
+  };
+}
+function Ws(e = {}) {
+  const {
+    multipleAxes: t,
+    directions: s
+  } = e, n = bt(), o = Ct(), i = It(), a = E(), d = a.use(Ht), p = a.use(Wt), y = a.use(ot), g = ue(), {
+    xAxis: m
+  } = $e(), {
+    yAxis: h
+  } = Le(), {
+    zAxis: I,
+    zAxisIds: k
+  } = He(), {
+    rotationAxis: u
+  } = qe(), l = Fs();
+  if (d.length === 0 && p.length === 0 && y.length === 0)
+    return null;
+  const f = [];
+  return (s === void 0 || s.includes("x")) && d.forEach(({
+    axisId: x,
+    dataIndex: C
+  }) => {
+    !t && f.length > 1 || f.push(he(m[x], C, "x"));
+  }), (s === void 0 || s.includes("y")) && p.forEach(({
+    axisId: x,
+    dataIndex: C
+  }) => {
+    !t && f.length > 1 || f.push(he(h[x], C, "y"));
+  }), (s === void 0 || s.includes("rotation")) && y.forEach(({
+    axisId: x,
+    dataIndex: C
+  }) => {
+    !t && f.length > 1 || f.push(he(u[x], C, "rotation"));
+  }), Object.keys(g).filter(vt).forEach((x) => {
+    const C = g[x];
+    return C ? C.seriesOrder.forEach((v) => {
+      const b = C.series[v], w = b.xAxisId ?? n.id, N = b.yAxisId ?? o.id, O = f.findIndex(({
+        axisDirection: R,
+        axisId: P
+      }) => R === "x" && P === w || R === "y" && P === N);
+      if (O >= 0) {
+        const R = "zAxisId" in b ? b.zAxisId : k[0], {
+          dataIndex: P
+        } = f[O], S = l[x]?.(b, m[w], h[N], R ? I[R] : void 0)(P) ?? "", M = b.data[P] ?? null, L = b.valueFormatter(M, {
+          dataIndex: P
+        }), V = Ne(b.label, "tooltip") ?? null;
+        f[O].seriesItems.push({
+          seriesId: v,
+          color: S,
+          value: M,
+          formattedValue: L,
+          formattedLabel: V,
+          markType: b.labelMarkType
+        });
+      }
+    }) : [];
+  }), Object.keys(g).filter(Tt).forEach((x) => {
+    const C = g[x];
+    return C ? C.seriesOrder.forEach((v) => {
+      const b = C.series[v], w = (
+        // @ts-expect-error Should be fixed when we introduce a polar series with a rotationAxisId
+        b.rotationAxisId ?? i?.id
+      ), N = f.findIndex(({
+        axisDirection: O,
+        axisId: R
+      }) => O === "rotation" && R === w);
+      if (N >= 0) {
+        const {
+          dataIndex: O
+        } = f[N], R = l[x]?.(b)(O) ?? "", P = b.data[O] ?? null, S = b.valueFormatter(P, {
+          dataIndex: O
+        }), M = Ne(b.label, "tooltip") ?? null;
+        f[N].seriesItems.push({
+          seriesId: v,
+          color: R,
+          value: P,
+          formattedValue: S,
+          formattedLabel: M,
+          markType: b.labelMarkType
+        });
+      }
+    }) : [];
+  }), t ? f : f.length === 0 ? f[0] : null;
+}
+function Bs(e) {
+  return Ws(j({}, e, {
+    multipleAxes: !0
+  }));
+}
+function it(e) {
+  const t = fe(e.classes), s = Bs();
+  return s === null ? null : /* @__PURE__ */ c.jsx(be, {
+    sx: e.sx,
+    className: t.paper,
+    children: s.map(({
+      axisId: n,
+      mainAxis: o,
+      axisValue: i,
+      axisFormattedValue: a,
+      seriesItems: d
+    }) => /* @__PURE__ */ c.jsxs(Ce, {
+      className: t.table,
+      children: [i != null && !o.hideTooltip && /* @__PURE__ */ c.jsx(Te, {
+        component: "caption",
+        children: a
+      }), /* @__PURE__ */ c.jsx("tbody", {
+        children: d.map(({
+          seriesId: p,
+          color: y,
+          formattedValue: g,
+          formattedLabel: m,
+          markType: h
+        }) => g == null ? null : /* @__PURE__ */ c.jsxs(Ie, {
+          className: t.row,
+          children: [/* @__PURE__ */ c.jsxs(W, {
+            className: _(t.labelCell, t.cell),
+            component: "th",
+            children: [/* @__PURE__ */ c.jsx("div", {
+              className: t.markContainer,
+              children: /* @__PURE__ */ c.jsx(ee, {
+                type: h,
+                color: y,
+                className: t.mark
+              })
+            }), m || null]
+          }), /* @__PURE__ */ c.jsx(W, {
+            className: _(t.valueCell, t.cell),
+            component: "td",
+            children: g
+          })]
+        }, p))
+      })]
+    }, n))
+  });
+}
+process.env.NODE_ENV !== "production" && (it.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object])
+});
+function ae(e) {
+  const {
+    children: t,
+    defer: s = !1,
+    fallback: n = null
+  } = e, [o, i] = T.useState(!1);
+  return me(() => {
+    s || i(!0);
+  }, [s]), T.useEffect(() => {
+    s && i(!0);
+  }, [s]), o ? t : n;
+}
+process.env.NODE_ENV !== "production" && (ae.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * You can wrap a node.
+   */
+  children: r.node,
+  /**
+   * If `true`, the component will not only prevent server-side rendering.
+   * It will also defer the rendering of the children into a different screen frame.
+   * @default false
+   */
+  defer: r.bool,
+  /**
+   * The fallback content to display.
+   * @default null
+   */
+  fallback: r.node
+});
+process.env.NODE_ENV !== "production" && (ae.propTypes = St(ae.propTypes));
+function Ys(e) {
+  let t, s;
+  const n = () => {
+    s = null, e(...t);
+  };
+  function o(...i) {
+    t = i, s || (s = requestAnimationFrame(n));
+  }
+  return o.clear = () => {
+    s && (cancelAnimationFrame(s), s = null);
+  }, o;
+}
+function Gs() {
+  const e = E(), t = e.use(Ot), s = e.use(Rt);
+  return t !== void 0 ? "polar" : s !== void 0 ? "cartesian" : "none";
+}
+const Js = ["trigger", "position", "anchor", "classes", "children"], Me = () => !1, Ks = () => null;
+function Qs(e, t, s) {
+  return s ? Me : e === "item" ? rs : t === "polar" ? Hs : t === "cartesian" ? Jt : Me;
+}
+const Zs = $(_t, {
+  name: "MuiChartsTooltip",
+  slot: "Root"
+})(({
+  theme: e
+}) => ({
+  pointerEvents: "none",
+  zIndex: e.zIndex.modal
+}));
+function at(e) {
+  const t = Oe({
+    props: e,
+    name: "MuiChartsTooltipContainer"
+  }), {
+    trigger: s = "axis",
+    position: n,
+    anchor: o = "pointer",
+    classes: i,
+    children: a
+  } = t, d = F(t, Js), p = E(), y = Bt(), g = T.useRef(null), m = fe(i), h = p.use(Yt), I = Vs(), k = T.useRef(null), u = Mt(() => ({
+    x: 0,
+    y: 0
+  })), l = Gs(), f = p.use(Gt), x = p.use(Qs(s, l, f)), v = p.use(Re) === "keyboard" || h === null ? "node" : o, b = p.use(s === "item" && v === "node" ? os : Ks, n), w = b !== null;
+  T.useEffect(() => {
+    const S = y.current;
+    if (S === null)
+      return () => {
+      };
+    if (w)
+      return;
+    const M = Ys((V, dt) => {
+      u.current = {
+        x: V,
+        y: dt
+      }, k.current?.update();
+    }), L = (V) => {
+      M(V.clientX, V.clientY);
+    };
+    return S.addEventListener("pointermove", L), S.addEventListener("pointerenter", L), () => {
+      S.removeEventListener("pointermove", L), S.removeEventListener("pointerenter", L), M.clear();
+    };
+  }, [y, u, w]);
+  const N = T.useMemo(() => ({
+    getBoundingClientRect: () => ({
+      x: u.current.x,
+      y: u.current.y,
+      top: u.current.y,
+      left: u.current.x,
+      right: u.current.x,
+      bottom: u.current.y,
+      width: 0,
+      height: 0,
+      toJSON: () => ""
+    })
+  }), [u]), O = h === "mouse" || I, R = h === "touch" || !I, P = T.useMemo(() => [
+    {
+      name: "offset",
+      options: {
+        offset: () => R && !w ? [0, 64] : [0, 8]
+      }
+    },
+    ...O ? [] : [{
+      name: "flip",
+      options: {
+        fallbackPlacements: ["top-end", "top-start", "bottom-end", "bottom"]
+      }
+    }],
+    // Keep default behavior
+    {
+      name: "preventOverflow",
+      options: {
+        altAxis: !0
+      }
+    }
+  ], [O, w, R]);
+  return s === "none" ? null : /* @__PURE__ */ c.jsxs(T.Fragment, {
+    children: [y.current && /* @__PURE__ */ Zt.createPortal(/* @__PURE__ */ c.jsx("rect", j({
+      ref: g
+    }, b, {
+      display: "hidden",
+      pointerEvents: "none",
+      opacity: 0,
+      width: 1,
+      height: 1
+    })), y.current), /* @__PURE__ */ c.jsx(ae, {
+      children: x && /* @__PURE__ */ c.jsx(Zs, j({}, d, {
+        className: m?.root,
+        open: x,
+        placement: d.placement ?? n ?? (!w && O ? "right-start" : "top"),
+        popperRef: k,
+        anchorEl: b ? g.current : N,
+        modifiers: P,
+        children: a
+      }))
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (at.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Determine if the tooltip should be placed on the pointer location or on the node.
+   * @default 'pointer'
+   */
+  anchor: r.oneOf(["node", "pointer"]),
+  /**
+   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
+   * or a function that returns either.
+   * It's used to set the position of the popper.
+   * The return value will passed as the reference object of the Popper instance.
+   */
+  anchorEl: r.oneOfType([Ve, r.object, r.func]),
+  /**
+   * Popper render function or node.
+   */
+  children: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: r.elementType,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   * @default {}
+   */
+  components: r.shape({
+    Root: r.elementType
+  }),
+  /**
+   * The props used for each slot inside the Popper.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   * @default {}
+   */
+  componentsProps: r.shape({
+    root: r.oneOfType([r.func, r.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: r.oneOfType([(e, t) => e[t] == null ? new Error(`Prop '${t}' is required but wasn't specified`) : typeof e[t] != "object" || e[t].nodeType !== 1 ? new Error(`Expected prop '${t}' to be of type Element`) : null, r.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: r.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Popper.
+   * @default false
+   */
+  keepMounted: r.bool,
+  /**
+   * Popper.js is based on a "plugin-like" architecture,
+   * most of its features are fully encapsulated "modifiers".
+   *
+   * A modifier is a function that is called each time Popper.js needs to
+   * compute the position of the popper.
+   * For this reason, modifiers should be very performant to avoid bottlenecks.
+   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
+   */
+  modifiers: r.arrayOf(r.shape({
+    data: r.object,
+    effect: r.func,
+    enabled: r.bool,
+    fn: r.func,
+    name: r.any,
+    options: r.object,
+    phase: r.oneOf(["afterMain", "afterRead", "afterWrite", "beforeMain", "beforeRead", "beforeWrite", "main", "read", "write"]),
+    requires: r.arrayOf(r.string),
+    requiresIfExists: r.arrayOf(r.string)
+  })),
+  /**
+   * If `true`, the component is shown.
+   */
+  open: r.bool,
+  /**
+   * Popper placement.
+   * @default 'bottom'
+   */
+  placement: r.oneOf(["auto-end", "auto-start", "auto", "bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]),
+  /**
+   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
+   * @default {}
+   */
+  popperOptions: r.shape({
+    modifiers: r.array,
+    onFirstUpdate: r.func,
+    placement: r.oneOf(["auto-end", "auto-start", "auto", "bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]),
+    strategy: r.oneOf(["absolute", "fixed"])
+  }),
+  /**
+   * A ref that points to the used popper instance.
+   */
+  popperRef: r.oneOfType([r.func, r.shape({
+    current: r.shape({
+      destroy: r.func.isRequired,
+      forceUpdate: r.func.isRequired,
+      setOptions: r.func.isRequired,
+      state: r.shape({
+        attributes: r.object.isRequired,
+        elements: r.object.isRequired,
+        modifiersData: r.object.isRequired,
+        options: r.object.isRequired,
+        orderedModifiers: r.arrayOf(r.object).isRequired,
+        placement: r.oneOf(["auto-end", "auto-start", "auto", "bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]).isRequired,
+        rects: r.object.isRequired,
+        reset: r.bool.isRequired,
+        scrollParents: r.object.isRequired,
+        strategy: r.oneOf(["absolute", "fixed"]).isRequired,
+        styles: r.object.isRequired
+      }).isRequired,
+      update: r.func.isRequired
+    })
+  })]),
+  /**
+   * Determines the tooltip position relatively to the anchor.
+   */
+  position: r.oneOf(["bottom", "left", "right", "top"]),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  slotProps: r.object,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * Help supporting a react-transition-group/Transition component.
+   * @default false
+   */
+  transition: r.bool,
+  /**
+   * Select the kind of tooltip to display
+   * - 'item': Shows data about the item below the mouse;
+   * - 'axis': Shows values associated with the hovered x value;
+   * - 'none': Does not display tooltip.
+   * @default 'axis'
+   */
+  trigger: r.oneOf(["axis", "item", "none"])
+});
+function Xs(e) {
+  const {
+    classes: t,
+    trigger: s = "axis"
+  } = e, n = fe(t);
+  return /* @__PURE__ */ c.jsx(at, j({}, e, {
+    classes: t,
+    children: s === "axis" ? /* @__PURE__ */ c.jsx(it, {
+      classes: n
+    }) : /* @__PURE__ */ c.jsx(Xe, {
+      classes: n
+    })
+  }));
+}
+process.env.NODE_ENV !== "production" && (Xs.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Determine if the tooltip should be placed on the pointer location or on the node.
+   * @default 'pointer'
+   */
+  anchor: r.oneOf(["node", "pointer"]),
+  /**
+   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
+   * or a function that returns either.
+   * It's used to set the position of the popper.
+   * The return value will passed as the reference object of the Popper instance.
+   */
+  anchorEl: r.oneOfType([Ve, r.object, r.func]),
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: r.elementType,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   * @default {}
+   */
+  components: r.shape({
+    Root: r.elementType
+  }),
+  /**
+   * The props used for each slot inside the Popper.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   * @default {}
+   */
+  componentsProps: r.shape({
+    root: r.oneOfType([r.func, r.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: r.oneOfType([(e, t) => e[t] == null ? new Error(`Prop '${t}' is required but wasn't specified`) : typeof e[t] != "object" || e[t].nodeType !== 1 ? new Error(`Expected prop '${t}' to be of type Element`) : null, r.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: r.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Popper.
+   * @default false
+   */
+  keepMounted: r.bool,
+  /**
+   * Popper.js is based on a "plugin-like" architecture,
+   * most of its features are fully encapsulated "modifiers".
+   *
+   * A modifier is a function that is called each time Popper.js needs to
+   * compute the position of the popper.
+   * For this reason, modifiers should be very performant to avoid bottlenecks.
+   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
+   */
+  modifiers: r.arrayOf(r.shape({
+    data: r.object,
+    effect: r.func,
+    enabled: r.bool,
+    fn: r.func,
+    name: r.any,
+    options: r.object,
+    phase: r.oneOf(["afterMain", "afterRead", "afterWrite", "beforeMain", "beforeRead", "beforeWrite", "main", "read", "write"]),
+    requires: r.arrayOf(r.string),
+    requiresIfExists: r.arrayOf(r.string)
+  })),
+  /**
+   * If `true`, the component is shown.
+   */
+  open: r.bool,
+  /**
+   * Popper placement.
+   * @default 'bottom'
+   */
+  placement: r.oneOf(["auto-end", "auto-start", "auto", "bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]),
+  /**
+   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
+   * @default {}
+   */
+  popperOptions: r.shape({
+    modifiers: r.array,
+    onFirstUpdate: r.func,
+    placement: r.oneOf(["auto-end", "auto-start", "auto", "bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]),
+    strategy: r.oneOf(["absolute", "fixed"])
+  }),
+  /**
+   * A ref that points to the used popper instance.
+   */
+  popperRef: r.oneOfType([r.func, r.shape({
+    current: r.shape({
+      destroy: r.func.isRequired,
+      forceUpdate: r.func.isRequired,
+      setOptions: r.func.isRequired,
+      state: r.shape({
+        attributes: r.object.isRequired,
+        elements: r.object.isRequired,
+        modifiersData: r.object.isRequired,
+        options: r.object.isRequired,
+        orderedModifiers: r.arrayOf(r.object).isRequired,
+        placement: r.oneOf(["auto-end", "auto-start", "auto", "bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]).isRequired,
+        rects: r.object.isRequired,
+        reset: r.bool.isRequired,
+        scrollParents: r.object.isRequired,
+        strategy: r.oneOf(["absolute", "fixed"]).isRequired,
+        styles: r.object.isRequired
+      }).isRequired,
+      update: r.func.isRequired
+    })
+  })]),
+  /**
+   * Determines the tooltip position relatively to the anchor.
+   */
+  position: r.oneOf(["bottom", "left", "right", "top"]),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  slotProps: r.object,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * Help supporting a react-transition-group/Transition component.
+   * @default false
+   */
+  transition: r.bool,
+  /**
+   * Select the kind of tooltip to display
+   * - 'item': Shows data about the item below the mouse;
+   * - 'axis': Shows values associated with the hovered x value;
+   * - 'none': Does not display tooltip.
+   * @default 'axis'
+   */
+  trigger: r.oneOf(["axis", "item", "none"])
+});
+const er = (e) => ({
+  type: "series",
+  color: e.color,
+  label: e.label,
+  seriesId: e.seriesId,
+  itemId: e.itemId,
+  dataIndex: e.dataIndex
+});
+function tr(e) {
+  return ce("MuiChartsLegend", e);
+}
+const sr = (e) => {
+  const {
+    classes: t,
+    direction: s
+  } = e;
+  return le({
+    root: ["root", s],
+    item: ["item"],
+    mark: ["mark"],
+    label: ["label"],
+    series: ["series"],
+    hidden: ["hidden"]
+  }, tr, t);
+}, ge = se("MuiChartsLegend", ["root", "item", "series", "mark", "label", "vertical", "horizontal", "hidden"]), rr = ["slots", "slotProps"], nr = ["ownerState"], lt = (e, t, s, n) => {
+  function o(i, a) {
+    const d = Oe({
+      props: i,
+      // eslint-disable-next-line material-ui/mui-name-matches-component-name
+      name: e
+    }), p = typeof s.defaultProps == "function" ? s.defaultProps(d) : s.defaultProps ?? {}, y = De(p, d), g = y, {
+      slots: m,
+      slotProps: h
+    } = g, I = F(g, rr), k = ze(), u = s.classesResolver?.(y, k), l = m?.[t] ?? n, f = s.propagateSlots && !m?.[t], x = $t({
+      elementType: l,
+      externalSlotProps: h?.[t],
+      additionalProps: j({}, I, {
+        classes: u
+      }, f && {
+        slots: m,
+        slotProps: h
+      }),
+      ownerState: {}
+    }), C = F(x, nr), v = j({}, C);
+    for (const b of s.omitProps ?? [])
+      delete v[b];
+    return process.env.NODE_ENV !== "production" && (l.displayName = `${e}.slots.${t}`), /* @__PURE__ */ c.jsx(l, j({}, v, {
+      ref: a
+    }));
+  }
+  return /* @__PURE__ */ T.forwardRef(o);
+};
+process.env.NODE_ENV !== "production" && (lt.displayName = "consumeSlots");
+function or(e) {
+  return ce("MuiChartsLabel", e);
+}
+se("MuiChartsLabel", ["root"]);
+const ir = (e) => le({
+  root: ["root"]
+}, or, e.classes), ar = ["children", "className", "classes"], ct = we("MuiChartsLabel", {
+  classesResolver: ir
+}, function(t, s) {
+  const {
+    children: n,
+    className: o,
+    classes: i
+  } = t, a = F(t, ar);
+  return /* @__PURE__ */ c.jsx("span", j({
+    className: _(i?.root, o),
+    ref: s
+  }, a, {
+    children: n
+  }));
+});
+process.env.NODE_ENV !== "production" && (ct.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  children: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object
+});
+const lr = ["direction", "onItemClick", "className", "classes", "toggleVisibilityOnClick"], cr = $("ul", {
+  name: "MuiChartsLegend",
+  slot: "Root"
+})(({
+  ownerState: e,
+  theme: t
+}) => j({}, t.typography.caption, {
+  color: (t.vars || t).palette.text.primary,
+  lineHeight: "100%",
+  display: "flex",
+  flexDirection: e.direction === "vertical" ? "column" : "row",
+  alignItems: e.direction === "vertical" ? void 0 : "center",
+  flexShrink: 0,
+  gap: t.spacing(2),
+  listStyleType: "none",
+  paddingInlineStart: 0,
+  marginBlock: t.spacing(1),
+  marginInline: t.spacing(1),
+  flexWrap: "wrap",
+  li: {
+    display: e.direction === "horizontal" ? "inline-flex" : void 0
+  },
+  [`button.${ge.series}`]: {
+    // Reset button styles
+    background: "none",
+    border: "none",
+    padding: 0,
+    fontFamily: "inherit",
+    fontWeight: "inherit",
+    fontSize: "inherit",
+    letterSpacing: "inherit",
+    color: "inherit"
+  },
+  [`& .${ge.series}`]: {
+    display: e.direction === "vertical" ? "flex" : "inline-flex",
+    alignItems: "center",
+    gap: t.spacing(1),
+    cursor: e.onItemClick || e.toggleVisibilityOnClick ? "pointer" : "default",
+    [`&.${ge.hidden}`]: {
+      opacity: 0.5
+    }
+  },
+  gridArea: "legend"
+})), ut = lt("MuiChartsLegend", "legend", {
+  defaultProps: {
+    direction: "horizontal"
+  },
+  // @ts-expect-error position is used only in the slots, but it is passed to the SVG wrapper.
+  // We omit it here to avoid passing to slots.
+  omitProps: ["position"],
+  classesResolver: sr
+}, /* @__PURE__ */ T.forwardRef(function(t, s) {
+  const n = xs(), {
+    instance: o
+  } = ve(), i = E(), a = i.use(te), d = i.use(At), {
+    onItemClick: p,
+    className: y,
+    classes: g,
+    toggleVisibilityOnClick: m
+  } = t, h = F(t, lr), I = !!(p || m), k = I ? "button" : "div", u = xe((l, f) => (x) => {
+    p && l && p(x, er(l), f), m && o.toggleItemVisibility({
+      // TODO: Remove in v9
+      // @ts-expect-error item always has type defined.
+      type: l.type,
+      seriesId: l.seriesId,
+      dataIndex: l.dataIndex
+    });
+  });
+  return n.items.length === 0 ? null : /* @__PURE__ */ c.jsx(cr, j({
+    className: _(g?.root, y),
+    ref: s
+  }, h, {
+    ownerState: t,
+    children: n.items.map((l, f) => {
+      const x = d(a, {
+        // TODO: Remove in v9
+        // @ts-expect-error item always has type defined.
+        type: l.type,
+        seriesId: l.seriesId,
+        dataIndex: l.dataIndex
+      });
+      return /* @__PURE__ */ c.jsx("li", {
+        className: g?.item,
+        "data-series": l.seriesId,
+        "data-index": l.dataIndex,
+        children: /* @__PURE__ */ c.jsxs(k, {
+          className: _(g?.series, !x && g?.hidden),
+          role: I ? "button" : void 0,
+          type: I ? "button" : void 0,
+          onClick: I ? u(l, f) : void 0,
+          children: [/* @__PURE__ */ c.jsx(ee, {
+            className: g?.mark,
+            color: l.color,
+            type: l.markType
+          }), /* @__PURE__ */ c.jsx(ct, {
+            className: g?.label,
+            children: l.label
+          })]
+        })
+      }, `${l.seriesId}-${l.dataIndex}`);
+    })
+  }));
+}));
+process.env.NODE_ENV !== "production" && (ut.displayName = "ChartsLegend");
+process.env.NODE_ENV !== "production" && (ut.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  className: r.string,
+  /**
+   * The direction of the legend layout.
+   * The default depends on the chart.
+   */
+  direction: r.oneOf(["horizontal", "vertical"]),
+  /**
+   * Callback fired when a legend item is clicked.
+   * @param {React.MouseEvent<HTMLButtonElement, MouseEvent>} event The click event.
+   * @param {SeriesLegendItemContext} legendItem The legend item data.
+   * @param {number} index The index of the clicked legend item.
+   */
+  onItemClick: r.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: r.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: r.object,
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * If `true`, clicking on a legend item will toggle the visibility of the corresponding series.
+   * @default false
+   */
+  toggleVisibilityOnClick: r.bool
+});
+const ur = ["message"], dr = $("text", {
+  slot: "internal",
+  shouldForwardProp: void 0
+})(({
+  theme: e
+}) => j({}, e.typography.body2, {
+  stroke: "none",
+  fill: (e.vars || e).palette.text.primary,
+  shapeRendering: "crispEdges",
+  textAnchor: "middle",
+  dominantBaseline: "middle"
+}));
+function fr(e) {
+  const {
+    message: t
+  } = e, s = F(e, ur), {
+    top: n,
+    left: o,
+    height: i,
+    width: a
+  } = Fe(), {
+    localeText: d
+  } = Ze();
+  return /* @__PURE__ */ c.jsx(dr, j({
+    x: o + a / 2,
+    y: n + i / 2
+  }, s, {
+    children: t ?? d.loading
+  }));
+}
+const pr = ["message"], hr = $("text", {
+  slot: "internal",
+  shouldForwardProp: void 0
+})(({
+  theme: e
+}) => j({}, e.typography.body2, {
+  stroke: "none",
+  fill: (e.vars || e).palette.text.primary,
+  shapeRendering: "crispEdges",
+  textAnchor: "middle",
+  dominantBaseline: "middle"
+}));
+function gr(e) {
+  const {
+    message: t
+  } = e, s = F(e, pr), {
+    top: n,
+    left: o,
+    height: i,
+    width: a
+  } = Fe(), {
+    localeText: d
+  } = Ze();
+  return /* @__PURE__ */ c.jsx(hr, j({
+    x: o + a / 2,
+    y: n + i / 2
+  }, s, {
+    children: t ?? d.noData
+  }));
+}
+function mr() {
+  const e = ue();
+  return Object.values(e).every((t) => {
+    if (!t)
+      return !0;
+    const {
+      series: s,
+      seriesOrder: n
+    } = t;
+    return n.every((o) => {
+      const i = s[o];
+      return i.type === "sankey" ? i.data.links.length === 0 : i.data.length === 0;
+    });
+  });
+}
+function Ur(e) {
+  const t = mr();
+  if (e.loading) {
+    const s = e.slots?.loadingOverlay ?? fr;
+    return /* @__PURE__ */ c.jsx(s, j({}, e.slotProps?.loadingOverlay));
+  }
+  if (t) {
+    const s = e.slots?.noDataOverlay ?? gr;
+    return /* @__PURE__ */ c.jsx(s, j({}, e.slotProps?.noDataOverlay));
+  }
+  return null;
+}
+const _e = se("MuiChartsToolbar", ["root"]), xr = (e) => e?.horizontal === "start" ? "start" : e?.horizontal === "end" ? "end" : "center", yr = (e) => e?.vertical === "top" ? "flex-start" : e?.vertical === "bottom" ? "flex-end" : "center", br = (e, t, s) => e ? '"chart"' : t === "vertical" ? s?.horizontal === "start" ? '"legend chart"' : '"chart legend"' : s?.vertical === "bottom" ? `"chart"
+            "legend"` : `"legend"
+          "chart"`, Cr = (e = !1, t = "horizontal", s = "end", n = void 0) => {
+  const o = n ? "auto" : "1fr";
+  return t === "horizontal" || e ? o : s === "start" ? `auto ${o}` : `${o} auto`;
+}, Ir = (e = !1, t = "horizontal", s = "top") => t === "vertical" || e ? "1fr" : s === "bottom" ? "1fr auto" : "auto 1fr", vr = $("div", {
+  name: "MuiChartsWrapper",
+  slot: "Root",
+  shouldForwardProp: (e) => Lt(e) && e !== "extendVertically" && e !== "width"
+})(({
+  ownerState: e,
+  width: t
+}) => {
+  const s = Cr(e.hideLegend, e.legendDirection, e.legendPosition?.horizontal, t), n = Ir(e.hideLegend, e.legendDirection, e.legendPosition?.vertical), o = br(e.hideLegend, e.legendDirection, e.legendPosition);
+  return {
+    variants: [{
+      props: {
+        extendVertically: !0
+      },
+      style: {
+        height: "100%",
+        minHeight: 0
+      }
+    }],
+    flex: 1,
+    display: "grid",
+    gridTemplateColumns: s,
+    gridTemplateRows: n,
+    gridTemplateAreas: o,
+    [`&:has(.${_e.root})`]: {
+      // Add a row for toolbar if there is one.
+      gridTemplateRows: `auto ${n}`,
+      gridTemplateAreas: `"${s.split(" ").map(() => "toolbar").join(" ")}"
+        ${o}`
+    },
+    [`& .${_e.root}`]: {
+      gridArea: "toolbar",
+      justifySelf: "center"
+    },
+    justifyContent: "safe center",
+    justifyItems: xr(e.legendPosition),
+    alignItems: yr(e.legendPosition)
+  };
+});
+function Tr(e) {
+  const {
+    children: t,
+    sx: s,
+    extendVertically: n
+  } = e, o = Ps(), i = E(), a = i.use(jt), d = i.use(kt);
+  return /* @__PURE__ */ c.jsx(vr, {
+    ref: o,
+    ownerState: e,
+    sx: s,
+    extendVertically: n ?? d === void 0,
+    width: a,
+    children: t
+  });
+}
+process.env.NODE_ENV !== "production" && (Tr.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  children: r.node,
+  /**
+   * If `true`, the chart wrapper set `height: 100%`.
+   * @default `false` if the `height` prop is set. And `true` otherwise.
+   */
+  extendVertically: r.bool,
+  /**
+   * If `true`, the legend is not rendered.
+   * @default false
+   */
+  hideLegend: r.bool,
+  /**
+   * The direction of the legend.
+   * @default 'horizontal'
+   */
+  legendDirection: r.oneOf(["horizontal", "vertical"]),
+  /**
+   * The position of the legend.
+   * @default { horizontal: 'center', vertical: 'bottom' }
+   */
+  legendPosition: r.shape({
+    horizontal: r.oneOf(["center", "end", "start"]),
+    vertical: r.oneOf(["bottom", "middle", "top"])
+  }),
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object])
+});
+export {
+  qr as A,
+  Xs as C,
+  Er as a,
+  Fr as b,
+  Vr as c,
+  Is as d,
+  Dr as e,
+  zr as f,
+  Lr as g,
+  Tr as h,
+  ut as i,
+  Ur as j,
+  Sr as k,
+  Mr as l,
+  $r as m,
+  _r as n,
+  Pr as s,
+  Nr as u
+};