dynamic-mui 2.0.26 → 2.2.0

package/dist/index-Dlimbnxj.mjs

@@ -0,0 +1,2965 @@
+import { j as y, s as W, h as B, a as F, _ as T, P as e, e as Se, c as se, g as re, w as Rn, b as Ie, m as qn, u as jn } from "./index-BhaKvHkU.mjs";
+import * as U from "react";
+import { u as Pn, b as Le, d as Z, A as J, c as ae, g as Ae, f as he, e as vn, C as Sn, h as In, i as Ln, j as An } from "./ChartsWrapper-CO5_Z6BD.mjs";
+import { o as we, c as wn, u as K, a as X, i as Ce, d as me, b as Cn } from "./useAxis-SiNBMMWq.mjs";
+import { r as j, T as De, t as le, o as z, p as pe, l as ie, k as Me, j as _e, J as Ne, U as Ee, H as Q, V as $e, Q as Dn, R as Mn, z as Nn, A as En, S as $n, B as Hn, D as Fn, E as Gn, u as zn, C as Vn, a as Un } from "./useChartContainerProps-Bl3hO-r1.mjs";
+import { g as ce, u as ye, s as He, C as Kn, a as Xn, b as Yn } from "./ChartsGrid-C_HT7qpL.mjs";
+import { w as Oe, u as Wn } from "./useItemHighlightedGetter-CTISrNdV.mjs";
+import { C as Bn } from "./ChartsAxis-CANvBdY9.mjs";
+import { r as Zn } from "./isDeepEqual-BHfPvf9U.mjs";
+function Fe(n) {
+  this._context = n;
+}
+Fe.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._point = 0;
+  },
+  lineEnd: function() {
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  },
+  point: function(n, t) {
+    switch (n = +n, t = +t, this._point) {
+      case 0:
+        this._point = 1, this._line ? this._context.lineTo(n, t) : this._context.moveTo(n, t);
+        break;
+      case 1:
+        this._point = 2;
+      // falls through
+      default:
+        this._context.lineTo(n, t);
+        break;
+    }
+  }
+};
+function ge(n) {
+  return new Fe(n);
+}
+function Ge(n) {
+  return n[0];
+}
+function ze(n) {
+  return n[1];
+}
+function Ve(n, t) {
+  var i = j(!0), o = null, r = ge, s = null, c = Oe(a);
+  n = typeof n == "function" ? n : n === void 0 ? Ge : j(n), t = typeof t == "function" ? t : t === void 0 ? ze : j(t);
+  function a(u) {
+    var f, m = (u = De(u)).length, l, d = !1, p;
+    for (o == null && (s = r(p = c())), f = 0; f <= m; ++f)
+      !(f < m && i(l = u[f], f, u)) === d && ((d = !d) ? s.lineStart() : s.lineEnd()), d && s.point(+n(l, f, u), +t(l, f, u));
+    if (p) return s = null, p + "" || null;
+  }
+  return a.x = function(u) {
+    return arguments.length ? (n = typeof u == "function" ? u : j(+u), a) : n;
+  }, a.y = function(u) {
+    return arguments.length ? (t = typeof u == "function" ? u : j(+u), a) : t;
+  }, a.defined = function(u) {
+    return arguments.length ? (i = typeof u == "function" ? u : j(!!u), a) : i;
+  }, a.curve = function(u) {
+    return arguments.length ? (r = u, o != null && (s = r(o)), a) : r;
+  }, a.context = function(u) {
+    return arguments.length ? (u == null ? o = s = null : s = r(o = u), a) : o;
+  }, a;
+}
+function Jn(n, t, i) {
+  var o = null, r = j(!0), s = null, c = ge, a = null, u = Oe(f);
+  n = typeof n == "function" ? n : n === void 0 ? Ge : j(+n), t = typeof t == "function" ? t : t === void 0 ? j(0) : j(+t), i = typeof i == "function" ? i : i === void 0 ? ze : j(+i);
+  function f(l) {
+    var d, p, b, k = (l = De(l)).length, h, O = !1, g, S = new Array(k), q = new Array(k);
+    for (s == null && (a = c(g = u())), d = 0; d <= k; ++d) {
+      if (!(d < k && r(h = l[d], d, l)) === O)
+        if (O = !O)
+          p = d, a.areaStart(), a.lineStart();
+        else {
+          for (a.lineEnd(), a.lineStart(), b = d - 1; b >= p; --b)
+            a.point(S[b], q[b]);
+          a.lineEnd(), a.areaEnd();
+        }
+      O && (S[d] = +n(h, d, l), q[d] = +t(h, d, l), a.point(o ? +o(h, d, l) : S[d], i ? +i(h, d, l) : q[d]));
+    }
+    if (g) return a = null, g + "" || null;
+  }
+  function m() {
+    return Ve().defined(r).curve(c).context(s);
+  }
+  return f.x = function(l) {
+    return arguments.length ? (n = typeof l == "function" ? l : j(+l), o = null, f) : n;
+  }, f.x0 = function(l) {
+    return arguments.length ? (n = typeof l == "function" ? l : j(+l), f) : n;
+  }, f.x1 = function(l) {
+    return arguments.length ? (o = l == null ? null : typeof l == "function" ? l : j(+l), f) : o;
+  }, f.y = function(l) {
+    return arguments.length ? (t = typeof l == "function" ? l : j(+l), i = null, f) : t;
+  }, f.y0 = function(l) {
+    return arguments.length ? (t = typeof l == "function" ? l : j(+l), f) : t;
+  }, f.y1 = function(l) {
+    return arguments.length ? (i = l == null ? null : typeof l == "function" ? l : j(+l), f) : i;
+  }, f.lineX0 = f.lineY0 = function() {
+    return m().x(n).y(t);
+  }, f.lineY1 = function() {
+    return m().x(n).y(i);
+  }, f.lineX1 = function() {
+    return m().x(o).y(t);
+  }, f.defined = function(l) {
+    return arguments.length ? (r = typeof l == "function" ? l : j(!!l), f) : r;
+  }, f.curve = function(l) {
+    return arguments.length ? (c = l, s != null && (a = c(s)), f) : c;
+  }, f.context = function(l) {
+    return arguments.length ? (l == null ? s = a = null : a = c(s = l), f) : s;
+  }, f;
+}
+class Ue {
+  constructor(t, i) {
+    this._context = t, this._x = i;
+  }
+  areaStart() {
+    this._line = 0;
+  }
+  areaEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  }
+  point(t, i) {
+    switch (t = +t, i = +i, this._point) {
+      case 0: {
+        this._point = 1, this._line ? this._context.lineTo(t, i) : this._context.moveTo(t, i);
+        break;
+      }
+      case 1:
+        this._point = 2;
+      // falls through
+      default: {
+        this._x ? this._context.bezierCurveTo(this._x0 = (this._x0 + t) / 2, this._y0, this._x0, i, t, i) : this._context.bezierCurveTo(this._x0, this._y0 = (this._y0 + i) / 2, t, this._y0, t, i);
+        break;
+      }
+    }
+    this._x0 = t, this._y0 = i;
+  }
+}
+function Qn(n) {
+  return new Ue(n, !0);
+}
+function et(n) {
+  return new Ue(n, !1);
+}
+const Ke = {
+  draw(n, t) {
+    const i = z(t / pe);
+    n.moveTo(i, 0), n.arc(0, 0, i, 0, le);
+  }
+}, nt = {
+  draw(n, t) {
+    const i = z(t / 5) / 2;
+    n.moveTo(-3 * i, -i), n.lineTo(-i, -i), n.lineTo(-i, -3 * i), n.lineTo(i, -3 * i), n.lineTo(i, -i), n.lineTo(3 * i, -i), n.lineTo(3 * i, i), n.lineTo(i, i), n.lineTo(i, 3 * i), n.lineTo(-i, 3 * i), n.lineTo(-i, i), n.lineTo(-3 * i, i), n.closePath();
+  }
+}, Xe = z(1 / 3), tt = Xe * 2, it = {
+  draw(n, t) {
+    const i = z(t / tt), o = i * Xe;
+    n.moveTo(0, -i), n.lineTo(o, 0), n.lineTo(0, i), n.lineTo(-o, 0), n.closePath();
+  }
+}, ot = {
+  draw(n, t) {
+    const i = z(t), o = -i / 2;
+    n.rect(o, o, i, i);
+  }
+}, st = 0.8908130915292852, Ye = ie(pe / 10) / ie(7 * pe / 10), rt = ie(le / 10) * Ye, at = -Me(le / 10) * Ye, lt = {
+  draw(n, t) {
+    const i = z(t * st), o = rt * i, r = at * i;
+    n.moveTo(0, -i), n.lineTo(o, r);
+    for (let s = 1; s < 5; ++s) {
+      const c = le * s / 5, a = Me(c), u = ie(c);
+      n.lineTo(u * i, -a * i), n.lineTo(a * o - u * r, u * o + a * r);
+    }
+    n.closePath();
+  }
+}, fe = z(3), ct = {
+  draw(n, t) {
+    const i = -z(t / (fe * 3));
+    n.moveTo(0, i * 2), n.lineTo(-fe * i, -i), n.lineTo(fe * i, -i), n.closePath();
+  }
+}, $ = -0.5, H = z(3) / 2, be = 1 / z(12), ut = (be / 2 + 1) * 3, ft = {
+  draw(n, t) {
+    const i = z(t / ut), o = i / 2, r = i * be, s = o, c = i * be + i, a = -s, u = c;
+    n.moveTo(o, r), n.lineTo(s, c), n.lineTo(a, u), n.lineTo($ * o - H * r, H * o + $ * r), n.lineTo($ * s - H * c, H * s + $ * c), n.lineTo($ * a - H * u, H * a + $ * u), n.lineTo($ * o + H * r, $ * r - H * o), n.lineTo($ * s + H * c, $ * c - H * s), n.lineTo($ * a + H * u, $ * u - H * a), n.closePath();
+  }
+}, We = [
+  Ke,
+  nt,
+  it,
+  ot,
+  lt,
+  ct,
+  ft
+];
+function Be(n, t) {
+  let i = null, o = Oe(r);
+  n = typeof n == "function" ? n : j(n || Ke), t = typeof t == "function" ? t : j(t === void 0 ? 64 : +t);
+  function r() {
+    let s;
+    if (i || (i = s = o()), n.apply(this, arguments).draw(i, +t.apply(this, arguments)), s) return i = null, s + "" || null;
+  }
+  return r.type = function(s) {
+    return arguments.length ? (n = typeof s == "function" ? s : j(s), r) : n;
+  }, r.size = function(s) {
+    return arguments.length ? (t = typeof s == "function" ? s : j(+s), r) : t;
+  }, r.context = function(s) {
+    return arguments.length ? (i = s ?? null, r) : i;
+  }, r;
+}
+function xe(n, t, i) {
+  n._context.bezierCurveTo(
+    n._x1 + n._k * (n._x2 - n._x0),
+    n._y1 + n._k * (n._y2 - n._y0),
+    n._x2 + n._k * (n._x1 - t),
+    n._y2 + n._k * (n._y1 - i),
+    n._x2,
+    n._y2
+  );
+}
+function Te(n, t) {
+  this._context = n, this._k = (1 - t) / 6;
+}
+Te.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x2, this._y2);
+        break;
+      case 3:
+        xe(this, this._x1, this._y1);
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  },
+  point: function(n, t) {
+    switch (n = +n, t = +t, this._point) {
+      case 0:
+        this._point = 1, this._line ? this._context.lineTo(n, t) : this._context.moveTo(n, t);
+        break;
+      case 1:
+        this._point = 2, this._x1 = n, this._y1 = t;
+        break;
+      case 2:
+        this._point = 3;
+      // falls through
+      default:
+        xe(this, n, t);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = this._x2, this._x2 = n, this._y0 = this._y1, this._y1 = this._y2, this._y2 = t;
+  }
+};
+(function n(t) {
+  function i(o) {
+    return new Te(o, t);
+  }
+  return i.tension = function(o) {
+    return n(+o);
+  }, i;
+})(0);
+function dt(n, t, i) {
+  var o = n._x1, r = n._y1, s = n._x2, c = n._y2;
+  if (n._l01_a > _e) {
+    var a = 2 * n._l01_2a + 3 * n._l01_a * n._l12_a + n._l12_2a, u = 3 * n._l01_a * (n._l01_a + n._l12_a);
+    o = (o * a - n._x0 * n._l12_2a + n._x2 * n._l01_2a) / u, r = (r * a - n._y0 * n._l12_2a + n._y2 * n._l01_2a) / u;
+  }
+  if (n._l23_a > _e) {
+    var f = 2 * n._l23_2a + 3 * n._l23_a * n._l12_a + n._l12_2a, m = 3 * n._l23_a * (n._l23_a + n._l12_a);
+    s = (s * f + n._x1 * n._l23_2a - t * n._l12_2a) / m, c = (c * f + n._y1 * n._l23_2a - i * n._l12_2a) / m;
+  }
+  n._context.bezierCurveTo(o, r, s, c, n._x2, n._y2);
+}
+function Ze(n, t) {
+  this._context = n, this._alpha = t;
+}
+Ze.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x2, this._y2);
+        break;
+      case 3:
+        this.point(this._x2, this._y2);
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  },
+  point: function(n, t) {
+    if (n = +n, t = +t, this._point) {
+      var i = this._x2 - n, o = this._y2 - t;
+      this._l23_a = Math.sqrt(this._l23_2a = Math.pow(i * i + o * o, this._alpha));
+    }
+    switch (this._point) {
+      case 0:
+        this._point = 1, this._line ? this._context.lineTo(n, t) : this._context.moveTo(n, t);
+        break;
+      case 1:
+        this._point = 2;
+        break;
+      case 2:
+        this._point = 3;
+      // falls through
+      default:
+        dt(this, n, t);
+        break;
+    }
+    this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = n, this._y0 = this._y1, this._y1 = this._y2, this._y2 = t;
+  }
+};
+const pt = (function n(t) {
+  function i(o) {
+    return t ? new Ze(o, t) : new Te(o, 0);
+  }
+  return i.alpha = function(o) {
+    return n(+o);
+  }, i;
+})(0.5);
+function Re(n) {
+  return n < 0 ? -1 : 1;
+}
+function qe(n, t, i) {
+  var o = n._x1 - n._x0, r = t - n._x1, s = (n._y1 - n._y0) / (o || r < 0 && -0), c = (i - n._y1) / (r || o < 0 && -0), a = (s * r + c * o) / (o + r);
+  return (Re(s) + Re(c)) * Math.min(Math.abs(s), Math.abs(c), 0.5 * Math.abs(a)) || 0;
+}
+function je(n, t) {
+  var i = n._x1 - n._x0;
+  return i ? (3 * (n._y1 - n._y0) / i - t) / 2 : t;
+}
+function de(n, t, i) {
+  var o = n._x0, r = n._y0, s = n._x1, c = n._y1, a = (s - o) / 3;
+  n._context.bezierCurveTo(o + a, r + a * t, s - a, c - a * i, s, c);
+}
+function oe(n) {
+  this._context = n;
+}
+oe.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+      case 3:
+        de(this, this._t0, je(this, this._t0));
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  },
+  point: function(n, t) {
+    var i = NaN;
+    if (n = +n, t = +t, !(n === this._x1 && t === this._y1)) {
+      switch (this._point) {
+        case 0:
+          this._point = 1, this._line ? this._context.lineTo(n, t) : this._context.moveTo(n, t);
+          break;
+        case 1:
+          this._point = 2;
+          break;
+        case 2:
+          this._point = 3, de(this, je(this, i = qe(this, n, t)), i);
+          break;
+        default:
+          de(this, this._t0, i = qe(this, n, t));
+          break;
+      }
+      this._x0 = this._x1, this._x1 = n, this._y0 = this._y1, this._y1 = t, this._t0 = i;
+    }
+  }
+};
+function Je(n) {
+  this._context = new Qe(n);
+}
+(Je.prototype = Object.create(oe.prototype)).point = function(n, t) {
+  oe.prototype.point.call(this, t, n);
+};
+function Qe(n) {
+  this._context = n;
+}
+Qe.prototype = {
+  moveTo: function(n, t) {
+    this._context.moveTo(t, n);
+  },
+  closePath: function() {
+    this._context.closePath();
+  },
+  lineTo: function(n, t) {
+    this._context.lineTo(t, n);
+  },
+  bezierCurveTo: function(n, t, i, o, r, s) {
+    this._context.bezierCurveTo(t, n, o, i, s, r);
+  }
+};
+function Pe(n) {
+  return new oe(n);
+}
+function bt(n) {
+  return new Je(n);
+}
+function en(n) {
+  this._context = n;
+}
+en.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x = [], this._y = [];
+  },
+  lineEnd: function() {
+    var n = this._x, t = this._y, i = n.length;
+    if (i)
+      if (this._line ? this._context.lineTo(n[0], t[0]) : this._context.moveTo(n[0], t[0]), i === 2)
+        this._context.lineTo(n[1], t[1]);
+      else
+        for (var o = ve(n), r = ve(t), s = 0, c = 1; c < i; ++s, ++c)
+          this._context.bezierCurveTo(o[0][s], r[0][s], o[1][s], r[1][s], n[c], t[c]);
+    (this._line || this._line !== 0 && i === 1) && this._context.closePath(), this._line = 1 - this._line, this._x = this._y = null;
+  },
+  point: function(n, t) {
+    this._x.push(+n), this._y.push(+t);
+  }
+};
+function ve(n) {
+  var t, i = n.length - 1, o, r = new Array(i), s = new Array(i), c = new Array(i);
+  for (r[0] = 0, s[0] = 2, c[0] = n[0] + 2 * n[1], t = 1; t < i - 1; ++t) r[t] = 1, s[t] = 4, c[t] = 4 * n[t] + 2 * n[t + 1];
+  for (r[i - 1] = 2, s[i - 1] = 7, c[i - 1] = 8 * n[i - 1] + n[i], t = 1; t < i; ++t) o = r[t] / s[t - 1], s[t] -= o, c[t] -= o * c[t - 1];
+  for (r[i - 1] = c[i - 1] / s[i - 1], t = i - 2; t >= 0; --t) r[t] = (c[t] - r[t + 1]) / s[t];
+  for (s[i - 1] = (n[i] + r[i - 1]) / 2, t = 0; t < i - 1; ++t) s[t] = 2 * n[t + 1] - r[t + 1];
+  return [r, s];
+}
+function ht(n) {
+  return new en(n);
+}
+function ue(n, t) {
+  this._context = n, this._t = t;
+}
+ue.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x = this._y = NaN, this._point = 0;
+  },
+  lineEnd: function() {
+    0 < this._t && this._t < 1 && this._point === 2 && this._context.lineTo(this._x, this._y), (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);
+  },
+  point: function(n, t) {
+    switch (n = +n, t = +t, this._point) {
+      case 0:
+        this._point = 1, this._line ? this._context.lineTo(n, t) : this._context.moveTo(n, t);
+        break;
+      case 1:
+        this._point = 2;
+      // falls through
+      default: {
+        if (this._t <= 0)
+          this._context.lineTo(this._x, t), this._context.lineTo(n, t);
+        else {
+          var i = this._x * (1 - this._t) + n * this._t;
+          this._context.lineTo(i, this._y), this._context.lineTo(i, t);
+        }
+        break;
+      }
+    }
+    this._x = n, this._y = t;
+  }
+};
+function mt(n) {
+  return new ue(n, 0.5);
+}
+function yt(n) {
+  return new ue(n, 0);
+}
+function Ot(n) {
+  return new ue(n, 1);
+}
+function ee() {
+  return Pn("line");
+}
+function gt(n) {
+  return Le({
+    d: n.d
+  }, {
+    createInterpolator: (t, i) => {
+      const o = we(t.d, i.d);
+      return (r) => ({
+        d: o(r)
+      });
+    },
+    applyProps: (t, {
+      d: i
+    }) => t.setAttribute("d", i),
+    transformProps: (t) => t,
+    skip: n.skipAnimation,
+    ref: n.ref
+  });
+}
+function Tt(n) {
+  return Le({
+    d: n.d
+  }, {
+    createInterpolator: (t, i) => {
+      const o = we(t.d, i.d);
+      return (r) => ({
+        d: o(r)
+      });
+    },
+    applyProps: (t, {
+      d: i
+    }) => t.setAttribute("d", i),
+    skip: n.skipAnimation,
+    transformProps: (t) => t,
+    ref: n.ref
+  });
+}
+function nn(n) {
+  return n.replace(" ", "_");
+}
+const tn = B("MuiAppearingMask", ["animate"]), kt = W("rect", {
+  slot: "internal",
+  shouldForwardProp: void 0
+})({
+  animationName: "animate-width",
+  animationTimingFunction: J,
+  animationDuration: "0s",
+  [`&.${tn.animate}`]: {
+    animationDuration: `${Z}ms`
+  },
+  "@keyframes animate-width": {
+    from: {
+      width: 0
+    }
+  }
+});
+function on(n) {
+  const t = wn(), i = Ne(), o = nn(`${i}-${n.id}`);
+  return /* @__PURE__ */ y.jsxs(U.Fragment, {
+    children: [/* @__PURE__ */ y.jsx("clipPath", {
+      id: o,
+      children: /* @__PURE__ */ y.jsx(kt, {
+        className: n.skipAnimation ? "" : tn.animate,
+        x: 0,
+        y: 0,
+        width: t.left + t.width + t.right,
+        height: t.top + t.height + t.bottom
+      })
+    }), /* @__PURE__ */ y.jsx("g", {
+      clipPath: `url(#${o})`,
+      children: n.children
+    })]
+  });
+}
+const _t = ["skipAnimation", "ownerState"];
+function sn(n) {
+  const {
+    skipAnimation: t,
+    ownerState: i
+  } = n, o = F(n, _t), r = gt(n);
+  return /* @__PURE__ */ y.jsx(on, {
+    skipAnimation: t,
+    id: `${i.id}-area-clip`,
+    children: /* @__PURE__ */ y.jsx("path", T({
+      fill: i.gradientId ? `url(#${i.gradientId})` : i.color,
+      filter: (
+        // eslint-disable-next-line no-nested-ternary
+        i.isHighlighted ? "brightness(140%)" : i.gradientId ? void 0 : "brightness(120%)"
+      ),
+      opacity: i.isFaded ? 0.3 : 1,
+      stroke: "none",
+      "data-series": i.id,
+      "data-highlighted": i.isHighlighted || void 0,
+      "data-faded": i.isFaded || void 0
+    }, o, r))
+  });
+}
+process.env.NODE_ENV !== "production" && (sn.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  d: e.string.isRequired,
+  ownerState: e.shape({
+    classes: e.object,
+    color: e.string.isRequired,
+    gradientId: e.string,
+    id: e.oneOfType([e.number, e.string]).isRequired,
+    isFaded: e.bool.isRequired,
+    isHighlighted: e.bool.isRequired
+  }).isRequired,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: e.bool
+});
+const xt = ["id", "classes", "color", "gradientId", "slots", "slotProps", "onClick"];
+function Rt(n) {
+  return re("MuiAreaElement", n);
+}
+const qt = B("MuiAreaElement", ["root", "highlighted", "faded", "series"]), jt = (n) => {
+  const {
+    classes: t,
+    id: i,
+    isFaded: o,
+    isHighlighted: r
+  } = n, s = {
+    root: ["root", `series-${i}`, r && "highlighted", o && "faded"]
+  };
+  return se(s, Rt, t);
+};
+function rn(n) {
+  const {
+    id: t,
+    classes: i,
+    color: o,
+    gradientId: r,
+    slots: s,
+    slotProps: c,
+    onClick: a
+  } = n, u = F(n, xt), f = ae({
+    type: "line",
+    seriesId: t
+  }), {
+    isFaded: m,
+    isHighlighted: l
+  } = Ae({
+    seriesId: t
+  }), d = {
+    id: t,
+    classes: i,
+    color: o,
+    gradientId: r,
+    isFaded: m,
+    isHighlighted: l
+  }, p = jt(d), b = s?.area ?? sn, k = Se({
+    elementType: b,
+    externalSlotProps: c?.area,
+    additionalProps: T({}, f, {
+      onClick: a,
+      cursor: a ? "pointer" : "unset"
+    }),
+    className: p.root,
+    ownerState: d
+  });
+  return /* @__PURE__ */ y.jsx(b, T({}, u, k));
+}
+process.env.NODE_ENV !== "production" && (rn.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,
+  color: e.string.isRequired,
+  d: e.string.isRequired,
+  gradientId: e.string,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * 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 an(n) {
+  switch (n) {
+    case "catmullRom":
+      return pt.alpha(0.5);
+    case "linear":
+      return ge;
+    case "monotoneX":
+      return Pe;
+    case "monotoneY":
+      return bt;
+    case "natural":
+      return ht;
+    case "step":
+      return mt;
+    case "stepBefore":
+      return yt;
+    case "stepAfter":
+      return Ot;
+    case "bumpY":
+      return et;
+    case "bumpX":
+      return Qn;
+    default:
+      return Pe;
+  }
+}
+function Pt(n, t) {
+  const i = ee(), o = K().xAxisIds[0], r = X().yAxisIds[0], s = Ee();
+  return U.useMemo(() => {
+    if (i === void 0)
+      return [];
+    const {
+      series: a,
+      stackingGroups: u
+    } = i, f = [];
+    for (const m of u) {
+      const l = m.ids;
+      for (let d = l.length - 1; d >= 0; d -= 1) {
+        const p = l[d], {
+          xAxisId: b = o,
+          yAxisId: k = r,
+          visibleStackedData: h,
+          stackedData: O,
+          data: g,
+          connectNulls: S,
+          baseline: q,
+          curve: x,
+          strictStepCurve: C,
+          area: L
+        } = a[p];
+        if (!L || !(b in n) || !(k in t))
+          continue;
+        const P = n[b].scale, G = ce(P), A = t[k].scale, R = n[b].data, M = t[k].colorScale && s(k) || n[b].colorScale && s(b) || void 0;
+        if (process.env.NODE_ENV !== "production") {
+          if (R === void 0)
+            throw new Error(`MUI X Charts: ${b === Q ? "The first `xAxis`" : `The x-axis with id "${b}"`} should have data property to be able to display a line plot.`);
+          if (R.length < O.length)
+            throw new Error(`MUI X Charts: The data length of the x axis (${R.length} items) is lower than the length of series (${O.length} items).`);
+        }
+        const w = x?.includes("step") && !C && Ce(P), N = R?.flatMap((_, I) => {
+          const V = g[I] == null;
+          if (w) {
+            const Y = [{
+              x: _,
+              y: h[I],
+              nullData: V,
+              isExtension: !1
+            }];
+            return !V && (I === 0 || g[I - 1] == null) && Y.unshift({
+              x: (P(_) ?? 0) - (P.step() - P.bandwidth()) / 2,
+              y: h[I],
+              nullData: V,
+              isExtension: !0
+            }), !V && (I === g.length - 1 || g[I + 1] == null) && Y.push({
+              x: (P(_) ?? 0) + (P.step() + P.bandwidth()) / 2,
+              y: h[I],
+              nullData: V,
+              isExtension: !0
+            }), Y;
+          }
+          return {
+            x: _,
+            y: h[I],
+            nullData: V
+          };
+        }) ?? [], E = S ? N.filter((_) => !_.nullData) : N, D = Jn().x((_) => _.isExtension ? _.x : G(_.x)).defined((_) => S || !_.nullData || !!_.isExtension).y0((_) => {
+          if (typeof q == "number")
+            return A(q);
+          if (q === "max")
+            return A.range()[1];
+          if (q === "min")
+            return A.range()[0];
+          const I = _.y && A(_.y[0]);
+          return Number.isNaN(I) ? A.range()[0] : I;
+        }).y1((_) => _.y && A(_.y[1])).curve(an(x))(E) || "";
+        f.push({
+          area: a[p].area,
+          color: a[p].color,
+          gradientId: M,
+          d: D,
+          seriesId: p
+        });
+      }
+    }
+    return f;
+  }, [i, o, r, n, t, s]);
+}
+const vt = ["slots", "slotProps", "onItemClick", "skipAnimation"], St = W("g", {
+  name: "MuiAreaPlot",
+  slot: "Root"
+})({
+  [`& .${qt.root}`]: {
+    transitionProperty: "opacity, fill",
+    transitionDuration: `${Z}ms`,
+    transitionTimingFunction: J
+  }
+}), It = () => {
+  const {
+    xAxis: n
+  } = K(), {
+    yAxis: t
+  } = X();
+  return Pt(n, t);
+};
+function ln(n) {
+  const {
+    slots: t,
+    slotProps: i,
+    onItemClick: o,
+    skipAnimation: r
+  } = n, s = F(n, vt), c = ye(), a = he(c || r), u = It();
+  return /* @__PURE__ */ y.jsx(St, T({}, s, {
+    children: u.map(({
+      d: f,
+      seriesId: m,
+      color: l,
+      area: d,
+      gradientId: p
+    }) => !!d && /* @__PURE__ */ y.jsx(rn, {
+      id: m,
+      d: f,
+      color: l,
+      gradientId: p,
+      slots: t,
+      slotProps: i,
+      onClick: o && ((b) => o(b, {
+        type: "line",
+        seriesId: m
+      })),
+      skipAnimation: a
+    }, m))
+  }));
+}
+process.env.NODE_ENV !== "production" && (ln.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 line area item is clicked.
+   * @param {React.MouseEvent<SVGPathElement, MouseEvent>} event The event source of the callback.
+   * @param {LineItemIdentifier} lineItemIdentifier The line item identifier.
+   */
+  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 Lt = ["skipAnimation", "ownerState"], ke = /* @__PURE__ */ U.forwardRef(function(t, i) {
+  const {
+    skipAnimation: o,
+    ownerState: r
+  } = t, s = F(t, Lt), c = Tt({
+    d: t.d,
+    skipAnimation: o,
+    ref: i
+  }), a = r.isFaded ? 0.3 : 1;
+  return /* @__PURE__ */ y.jsx(on, {
+    skipAnimation: o,
+    id: `${r.id}-line-clip`,
+    children: /* @__PURE__ */ y.jsx("path", T({
+      stroke: r.gradientId ? `url(#${r.gradientId})` : r.color,
+      strokeWidth: 2,
+      strokeLinejoin: "round",
+      fill: "none",
+      filter: r.isHighlighted ? "brightness(120%)" : void 0,
+      opacity: r.hidden ? 0 : a,
+      "data-series": r.id,
+      "data-highlighted": r.isHighlighted || void 0,
+      "data-faded": r.isFaded || void 0
+    }, s, c))
+  });
+});
+process.env.NODE_ENV !== "production" && (ke.displayName = "AnimatedLine");
+process.env.NODE_ENV !== "production" && (ke.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  d: e.string.isRequired,
+  ownerState: e.shape({
+    classes: e.object,
+    color: e.string.isRequired,
+    gradientId: e.string,
+    hidden: e.bool,
+    id: e.oneOfType([e.number, e.string]).isRequired,
+    isFaded: e.bool.isRequired,
+    isHighlighted: e.bool.isRequired
+  }).isRequired,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: e.bool
+});
+const At = ["id", "classes", "color", "gradientId", "slots", "slotProps", "onClick", "hidden"];
+function wt(n) {
+  return re("MuiLineElement", n);
+}
+const Ct = B("MuiLineElement", ["root", "highlighted", "faded", "series"]), Dt = (n) => {
+  const {
+    classes: t,
+    id: i,
+    isFaded: o,
+    isHighlighted: r
+  } = n, s = {
+    root: ["root", `series-${i}`, r && "highlighted", o && "faded"]
+  };
+  return se(s, wt, t);
+};
+function cn(n) {
+  const {
+    id: t,
+    classes: i,
+    color: o,
+    gradientId: r,
+    slots: s,
+    slotProps: c,
+    onClick: a,
+    hidden: u
+  } = n, f = F(n, At), m = ae({
+    type: "line",
+    seriesId: t
+  }), {
+    isFaded: l,
+    isHighlighted: d
+  } = Ae({
+    seriesId: t
+  }), p = {
+    id: t,
+    classes: i,
+    color: o,
+    gradientId: r,
+    isFaded: l,
+    isHighlighted: d,
+    hidden: u
+  }, b = Dt(p), k = s?.line ?? ke, h = Se({
+    elementType: k,
+    externalSlotProps: c?.line,
+    additionalProps: T({}, m, {
+      onClick: a,
+      cursor: a ? "pointer" : "unset"
+    }),
+    className: b.root,
+    ownerState: p
+  });
+  return /* @__PURE__ */ y.jsx(k, T({}, f, h));
+}
+process.env.NODE_ENV !== "production" && (cn.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,
+  color: e.string.isRequired,
+  d: e.string.isRequired,
+  gradientId: e.string,
+  /** If `true`, the line is hidden. */
+  hidden: e.bool,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * 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 Mt(n, t) {
+  const i = ee(), o = K().xAxisIds[0], r = X().yAxisIds[0], s = Ee();
+  return U.useMemo(() => {
+    if (i === void 0)
+      return [];
+    const {
+      series: a,
+      stackingGroups: u
+    } = i, f = [];
+    for (const m of u) {
+      const l = m.ids;
+      for (const d of l) {
+        const {
+          xAxisId: p = o,
+          yAxisId: b = r,
+          stackedData: k,
+          visibleStackedData: h,
+          data: O,
+          connectNulls: g,
+          curve: S,
+          strictStepCurve: q
+        } = a[d];
+        if (!(p in n) || !(b in t))
+          continue;
+        const x = n[p].scale, C = ce(x), L = t[b].scale, P = n[p].data, G = t[b].colorScale && s(b) || n[p].colorScale && s(p) || void 0;
+        if (process.env.NODE_ENV !== "production") {
+          if (P === void 0)
+            throw new Error(`MUI X Charts: ${p === Q ? "The first `xAxis`" : `The x-axis with id "${p}"`} should have data property to be able to display a line plot.`);
+          P.length < k.length && Rn(`MUI X Charts: The data length of the x axis (${P.length} items) is lower than the length of series (${k.length} items).`, "error");
+        }
+        const A = S?.includes("step") && !q && Ce(x), R = P?.flatMap((v, D) => {
+          const _ = O[D] == null;
+          if (A) {
+            const I = [{
+              x: v,
+              y: h[D],
+              nullData: _,
+              isExtension: !1
+            }];
+            return !_ && (D === 0 || O[D - 1] == null) && I.unshift({
+              x: (x(v) ?? 0) - (x.step() - x.bandwidth()) / 2,
+              y: h[D],
+              nullData: _,
+              isExtension: !0
+            }), !_ && (D === O.length - 1 || O[D + 1] == null) && I.push({
+              x: (x(v) ?? 0) + (x.step() + x.bandwidth()) / 2,
+              y: h[D],
+              nullData: _,
+              isExtension: !0
+            }), I;
+          }
+          return {
+            x: v,
+            y: h[D],
+            nullData: _
+          };
+        }) ?? [], M = g ? R.filter((v) => !v.nullData) : R, w = a[d].hidden, E = Ve().x((v) => v.isExtension ? v.x : C(v.x)).defined((v) => g || !v.nullData || !!v.isExtension).y((v) => L(w ? L.domain()[0] : v.y[1])).curve(an(S))(M) || "";
+        f.push({
+          color: a[d].color,
+          gradientId: G,
+          d: E,
+          seriesId: d,
+          hidden: a[d].hidden
+        });
+      }
+    }
+    return f;
+  }, [i, o, r, n, t, s]);
+}
+const Nt = ["slots", "slotProps", "skipAnimation", "onItemClick"], Et = W("g", {
+  name: "MuiAreaPlot",
+  slot: "Root"
+})({
+  [`& .${Ct.root}`]: {
+    transitionProperty: "opacity, fill",
+    transitionDuration: `${Z}ms`,
+    transitionTimingFunction: J
+  }
+}), $t = () => {
+  const {
+    xAxis: n
+  } = K(), {
+    yAxis: t
+  } = X();
+  return Mt(n, t);
+};
+function un(n) {
+  const {
+    slots: t,
+    slotProps: i,
+    skipAnimation: o,
+    onItemClick: r
+  } = n, s = F(n, Nt), c = ye(), a = he(c || o), u = $t();
+  return /* @__PURE__ */ y.jsx(Et, T({}, s, {
+    children: u.map(({
+      d: f,
+      seriesId: m,
+      color: l,
+      gradientId: d,
+      hidden: p
+    }) => /* @__PURE__ */ y.jsx(cn, {
+      id: m,
+      d: f,
+      color: l,
+      gradientId: d,
+      hidden: p,
+      skipAnimation: a,
+      slots: t,
+      slotProps: i,
+      onClick: r && ((b) => r(b, {
+        type: "line",
+        seriesId: m
+      }))
+    }, m))
+  }));
+}
+process.env.NODE_ENV !== "production" && (un.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 line item is clicked.
+   * @param {React.MouseEvent<SVGPathElement, MouseEvent>} event The event source of the callback.
+   * @param {LineItemIdentifier} lineItemIdentifier The line item identifier.
+   */
+  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
+});
+function Ht(n) {
+  return re("MuiMarkElement", n);
+}
+const fn = B("MuiMarkElement", ["root", "highlighted", "faded", "animate", "series"]), dn = (n) => {
+  const {
+    classes: t,
+    id: i,
+    isFaded: o,
+    isHighlighted: r,
+    skipAnimation: s
+  } = n, c = {
+    root: ["root", `series-${i}`, r && "highlighted", o && "faded", s ? void 0 : "animate"]
+  };
+  return se(c, Ht, t);
+}, Ft = ["x", "y", "id", "classes", "color", "dataIndex", "onClick", "skipAnimation", "isFaded", "isHighlighted", "shape", "hidden"], Gt = W("circle", {
+  slot: "internal",
+  shouldForwardProp: void 0
+})({
+  [`&.${fn.animate}`]: {
+    transitionDuration: `${Z}ms`,
+    transitionProperty: "cx, cy, opacity",
+    transitionTimingFunction: J
+  }
+});
+function pn(n) {
+  const {
+    x: t,
+    y: i,
+    id: o,
+    classes: r,
+    color: s,
+    dataIndex: c,
+    onClick: a,
+    skipAnimation: u,
+    isFaded: f = !1,
+    isHighlighted: m = !1,
+    hidden: l
+  } = n, d = F(n, Ft), p = Ie(), b = ae({
+    type: "line",
+    seriesId: o,
+    dataIndex: c
+  }), h = dn({
+    id: o,
+    classes: r,
+    isHighlighted: m,
+    isFaded: f,
+    skipAnimation: u
+  });
+  return /* @__PURE__ */ y.jsx(Gt, T({}, d, {
+    cx: t,
+    cy: i,
+    r: 5,
+    fill: (p.vars || p).palette.background.paper,
+    stroke: s,
+    strokeWidth: 2,
+    className: h.root,
+    onClick: a,
+    cursor: a ? "pointer" : "unset",
+    pointerEvents: l ? "none" : void 0
+  }, b, {
+    "data-highlighted": m || void 0,
+    "data-faded": f || void 0,
+    opacity: l ? 0 : 1
+  }));
+}
+process.env.NODE_ENV !== "production" && (pn.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,
+  /**
+   * The index to the element in the series' data array.
+   */
+  dataIndex: e.number.isRequired,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * The shape of the marker.
+   */
+  shape: e.oneOf(["circle", "cross", "diamond", "square", "star", "triangle", "wye"]).isRequired,
+  /**
+   * If `true`, animations are skipped.
+   * @default false
+   */
+  skipAnimation: e.bool
+});
+function bn(n) {
+  switch (n) {
+    case "circle":
+      return 0;
+    case "cross":
+      return 1;
+    case "diamond":
+      return 2;
+    case "square":
+      return 3;
+    case "star":
+      return 4;
+    case "triangle":
+      return 5;
+    case "wye":
+      return 6;
+    default:
+      return 0;
+  }
+}
+const zt = ["x", "y", "id", "classes", "color", "shape", "dataIndex", "onClick", "skipAnimation", "isFaded", "isHighlighted", "hidden", "style"], Vt = W("path", {
+  name: "MuiMarkElement",
+  slot: "Root"
+})(({
+  theme: n
+}) => ({
+  fill: (n.vars || n).palette.background.paper,
+  [`&.${fn.animate}`]: {
+    transitionDuration: `${Z}ms`,
+    transitionProperty: "transform, transform-origin, opacity",
+    transitionTimingFunction: J
+  }
+}));
+function hn(n) {
+  const {
+    x: t,
+    y: i,
+    id: o,
+    classes: r,
+    color: s,
+    shape: c,
+    dataIndex: a,
+    onClick: u,
+    skipAnimation: f,
+    isFaded: m = !1,
+    isHighlighted: l = !1,
+    hidden: d,
+    style: p
+  } = n, b = F(n, zt), k = ae({
+    type: "line",
+    seriesId: o,
+    dataIndex: a
+  }), h = {
+    id: o,
+    classes: r,
+    isHighlighted: l,
+    isFaded: m,
+    skipAnimation: f
+  }, O = dn(h);
+  return /* @__PURE__ */ y.jsx(Vt, T({}, b, {
+    style: T({}, p, {
+      transform: `translate(${t}px, ${i}px)`,
+      transformOrigin: `${t}px ${i}px`
+    }),
+    ownerState: h,
+    className: O.root,
+    d: Be(We[bn(c)])(),
+    onClick: u,
+    cursor: u ? "pointer" : "unset",
+    pointerEvents: d ? "none" : void 0
+  }, k, {
+    "data-highlighted": l || void 0,
+    "data-faded": m || void 0,
+    opacity: d ? 0 : 1,
+    strokeWidth: 2,
+    stroke: s
+  }));
+}
+process.env.NODE_ENV !== "production" && (hn.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,
+  /**
+   * The index to the element in the series' data array.
+   */
+  dataIndex: e.number.isRequired,
+  /**
+   * If `true`, the marker is hidden.
+   * @default false
+   */
+  hidden: e.bool,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * If `true`, the marker is faded.
+   * @default false
+   */
+  isFaded: e.bool,
+  /**
+   * If `true`, the marker is highlighted.
+   * @default false
+   */
+  isHighlighted: e.bool,
+  /**
+   * The shape of the marker.
+   */
+  shape: e.oneOf(["circle", "cross", "diamond", "square", "star", "triangle", "wye"]).isRequired,
+  /**
+   * If `true`, animations are skipped.
+   */
+  skipAnimation: e.bool
+});
+function Ut(n, t) {
+  const i = ee(), o = K().xAxisIds[0], r = X().yAxisIds[0], s = Ne(), {
+    instance: c
+  } = me();
+  return U.useMemo(() => {
+    if (i === void 0)
+      return [];
+    const {
+      series: u,
+      stackingGroups: f
+    } = i, m = [];
+    for (const l of f) {
+      const d = l.ids;
+      for (const p of d) {
+        const {
+          xAxisId: b = o,
+          yAxisId: k = r,
+          visibleStackedData: h,
+          data: O,
+          showMark: g = !0,
+          shape: S = "circle",
+          hidden: q
+        } = u[p];
+        if (g === !1 || !(b in n) || !(k in t))
+          continue;
+        const x = ce(n[b].scale), C = t[k].scale, L = n[b].data;
+        if (process.env.NODE_ENV !== "production" && L === void 0)
+          throw new Error(`MUI X Charts: ${b === Q ? "The first `xAxis`" : `The x-axis with id "${b}"`} should have data property to be able to display a line plot.`);
+        const P = nn(`${s}-${p}-line-clip`), G = $e(u[p], n[b], t[k]), A = [];
+        if (L)
+          for (let R = 0; R < L.length; R += 1) {
+            const M = L[R], w = O[R] == null ? null : h[R][1];
+            if (w === null)
+              continue;
+            const N = C(q ? C.domain()[0] : w), E = x(M);
+            c.isPointInside(E, N) && (g !== !0 && !g({
+              x: E,
+              y: N,
+              index: R,
+              position: M,
+              value: w
+            }) || A.push({
+              x: E,
+              y: N,
+              index: R,
+              color: G(R)
+            }));
+          }
+        m.push({
+          seriesId: p,
+          clipId: P,
+          shape: S,
+          xAxisId: b,
+          marks: A,
+          hidden: q
+        });
+      }
+    }
+    return m;
+  }, [i, o, r, s, n, t, c]);
+}
+const Kt = ["slots", "slotProps", "skipAnimation", "onItemClick"];
+function mn(n) {
+  const {
+    slots: t,
+    slotProps: i,
+    skipAnimation: o,
+    onItemClick: r
+  } = n, s = F(n, Kt), c = ye(), a = he(c || o), {
+    xAxis: u
+  } = K(), {
+    yAxis: f
+  } = X(), {
+    store: m
+  } = me(), {
+    isFaded: l,
+    isHighlighted: d
+  } = Wn(), p = m.use(He), b = U.useMemo(() => {
+    const h = {};
+    for (const {
+      dataIndex: O,
+      axisId: g
+    } of p)
+      h[g] === void 0 ? h[g] = /* @__PURE__ */ new Set([O]) : h[g].add(O);
+    return h;
+  }, [p]), k = Ut(u, f);
+  return /* @__PURE__ */ y.jsx("g", T({}, s, {
+    children: k.map(({
+      seriesId: h,
+      clipId: O,
+      shape: g,
+      xAxisId: S,
+      marks: q,
+      hidden: x
+    }) => {
+      const C = t?.mark ?? (g === "circle" ? pn : hn), L = d({
+        seriesId: h
+      }), P = !L && l({
+        seriesId: h
+      });
+      return /* @__PURE__ */ y.jsx("g", {
+        clipPath: `url(#${O})`,
+        "data-series": h,
+        children: q.map(({
+          x: G,
+          y: A,
+          index: R,
+          color: M
+        }) => /* @__PURE__ */ y.jsx(C, T({
+          id: h,
+          dataIndex: R,
+          shape: g,
+          color: M,
+          x: G,
+          y: A,
+          skipAnimation: a,
+          onClick: r && ((w) => r(w, {
+            type: "line",
+            seriesId: h,
+            dataIndex: R
+          })),
+          isHighlighted: b[S]?.has(R) || L,
+          isFaded: P,
+          hidden: x
+        }, i?.mark), `${h}-${R}`))
+      }, h);
+    })
+  }));
+}
+process.env.NODE_ENV !== "production" && (mn.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 line mark item is clicked.
+   * @param {React.MouseEvent<SVGPathElement, MouseEvent>} event The event source of the callback.
+   * @param {LineItemIdentifier} lineItemIdentifier The line mark item identifier.
+   */
+  onItemClick: e.func,
+  /**
+   * If `true`, animations are skipped.
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object
+});
+const Xt = ["x", "y", "id", "classes", "color", "shape"];
+function Yt(n) {
+  return re("MuiHighlightElement", n);
+}
+const ui = B("MuiHighlightElement", ["root"]), Wt = (n) => {
+  const {
+    classes: t,
+    id: i
+  } = n, o = {
+    root: ["root", `series-${i}`]
+  };
+  return se(o, Yt, t);
+};
+function yn(n) {
+  const {
+    x: t,
+    y: i,
+    color: o,
+    shape: r
+  } = n, s = F(n, Xt), c = Wt(n), a = r === "circle" ? "circle" : "path", u = r === "circle" ? {
+    cx: 0,
+    cy: 0,
+    r: s.r === void 0 ? 5 : s.r
+  } : {
+    d: Be(We[bn(r)])()
+  }, f = Zn > 18 ? {
+    transformOrigin: `${t} ${i}`
+  } : {
+    "transform-origin": `${t} ${i}`
+  };
+  return /* @__PURE__ */ y.jsx(a, T({
+    pointerEvents: "none",
+    className: c.root,
+    transform: `translate(${t} ${i})`,
+    fill: o
+  }, f, u, s));
+}
+process.env.NODE_ENV !== "production" && (yn.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,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  shape: e.oneOf(["circle", "cross", "diamond", "square", "star", "triangle", "wye"]).isRequired
+});
+const Bt = ["slots", "slotProps"];
+function On(n) {
+  const {
+    slots: t,
+    slotProps: i
+  } = n, o = F(n, Bt), r = ee(), {
+    xAxis: s,
+    xAxisIds: c
+  } = K(), {
+    yAxis: a,
+    yAxisIds: u
+  } = X(), {
+    instance: f
+  } = me(), l = Cn().use(He);
+  if (l.length === 0 || r === void 0)
+    return null;
+  const {
+    series: d,
+    stackingGroups: p
+  } = r, b = c[0], k = u[0], h = t?.lineHighlight ?? yn;
+  return /* @__PURE__ */ y.jsx("g", T({}, o, {
+    children: l.flatMap(({
+      dataIndex: O,
+      axisId: g
+    }) => p.flatMap(({
+      ids: S
+    }) => S.flatMap((q) => {
+      const {
+        xAxisId: x = b,
+        yAxisId: C = k,
+        visibleStackedData: L,
+        data: P,
+        disableHighlight: G,
+        shape: A = "circle"
+      } = d[q];
+      if (G || P[O] == null || g !== x)
+        return null;
+      const R = ce(s[x].scale), M = a[C].scale, w = s[x].data;
+      if (w === void 0)
+        throw new Error(`MUI X Charts: ${x === Q ? "The first `xAxis`" : `The x-axis with id "${x}"`} should have data property to be able to display a line plot.`);
+      const N = R(w[O]), E = M(L[O][1]);
+      if (!f.isPointInside(N, E))
+        return null;
+      const v = $e(d[q], s[x], a[C]);
+      return /* @__PURE__ */ y.jsx(h, T({
+        id: q,
+        color: v(O),
+        x: N,
+        y: E,
+        shape: A
+      }, i?.lineHighlight), `${q}`);
+    })))
+  }));
+}
+process.env.NODE_ENV !== "production" && (On.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object
+});
+const Zt = [Dn, Mn, Nn, En, $n, Hn, Fn, Gn], Jt = ["xAxis", "yAxis", "series", "width", "height", "margin", "colors", "dataset", "sx", "onAreaClick", "onLineClick", "onMarkClick", "axisHighlight", "disableLineItemHighlight", "hideLegend", "grid", "children", "slots", "slotProps", "skipAnimation", "loading", "highlightedItem", "onHighlightChange", "className", "showToolbar", "brushConfig"], Qt = (n) => {
+  const {
+    xAxis: t,
+    yAxis: i,
+    series: o,
+    width: r,
+    height: s,
+    margin: c,
+    colors: a,
+    dataset: u,
+    sx: f,
+    onAreaClick: m,
+    onLineClick: l,
+    onMarkClick: d,
+    axisHighlight: p,
+    disableLineItemHighlight: b,
+    grid: k,
+    children: h,
+    slots: O,
+    slotProps: g,
+    skipAnimation: S,
+    loading: q,
+    highlightedItem: x,
+    onHighlightChange: C,
+    className: L,
+    brushConfig: P
+  } = n, G = F(n, Jt), R = `${qn()}-clip-path`, M = U.useMemo(() => o.map((ne) => T({
+    disableHighlight: !!b,
+    type: "line"
+  }, ne)), [b, o]), w = T({}, G, {
+    series: M,
+    width: r,
+    height: s,
+    margin: c,
+    colors: a,
+    dataset: u,
+    xAxis: t ?? [{
+      id: Q,
+      scaleType: "point",
+      data: Array.from({
+        length: Math.max(...o.map((ne) => (ne.data ?? u ?? []).length))
+      }, (ne, xn) => xn)
+    }],
+    yAxis: i,
+    highlightedItem: x,
+    onHighlightChange: C,
+    disableAxisListener: g?.tooltip?.trigger !== "axis" && p?.x === "none" && p?.y === "none",
+    className: L,
+    skipAnimation: S,
+    brushConfig: P,
+    plugins: Zt
+  }), N = {
+    vertical: k?.vertical,
+    horizontal: k?.horizontal
+  }, E = {
+    clipPath: `url(#${R})`
+  }, v = {
+    id: R
+  }, D = {
+    slots: O,
+    slotProps: g,
+    onItemClick: m
+  }, _ = {
+    slots: O,
+    slotProps: g,
+    onItemClick: l
+  }, I = {
+    slots: O,
+    slotProps: g,
+    onItemClick: d,
+    skipAnimation: S
+  }, V = {
+    slots: O,
+    slotProps: g,
+    loading: q
+  }, Y = {
+    slots: O,
+    slotProps: g
+  }, Tn = T({
+    x: "line"
+  }, p), kn = {
+    slots: O,
+    slotProps: g
+  }, _n = {
+    slots: O,
+    slotProps: g
+  };
+  return {
+    chartsWrapperProps: {
+      sx: f,
+      legendPosition: n.slotProps?.legend?.position,
+      legendDirection: n.slotProps?.legend?.direction,
+      hideLegend: n.hideLegend ?? !1
+    },
+    chartContainerProps: w,
+    gridProps: N,
+    clipPathProps: v,
+    clipPathGroupProps: E,
+    areaPlotProps: D,
+    linePlotProps: _,
+    markPlotProps: I,
+    overlayProps: V,
+    chartsAxisProps: Y,
+    axisHighlightProps: Tn,
+    lineHighlightPlotProps: kn,
+    legendProps: _n,
+    children: h
+  };
+}, te = 6;
+function ei() {
+  const n = Ie(), t = vn(), i = ee(), {
+    xAxis: o,
+    xAxisIds: r
+  } = K(), {
+    yAxis: s,
+    yAxisIds: c
+  } = X();
+  if (t === null || t.type !== "line" || !i)
+    return null;
+  const a = i.series[t.seriesId];
+  if (a.data[t.dataIndex] == null)
+    return null;
+  const u = a.xAxisId ?? r[0], f = a.yAxisId ?? c[0];
+  return /* @__PURE__ */ y.jsx("rect", {
+    fill: "none",
+    stroke: (n.vars ?? n).palette.text.primary,
+    strokeWidth: 2,
+    x: o[u].scale(o[u].data[t.dataIndex]) - te,
+    y: s[f].scale(a.visibleStackedData[t.dataIndex][1]) - te,
+    width: 2 * te,
+    height: 2 * te,
+    rx: 3,
+    ry: 3
+  });
+}
+const gn = /* @__PURE__ */ U.forwardRef(function(t, i) {
+  const o = jn({
+    props: t,
+    name: "MuiLineChart"
+  }), {
+    chartsWrapperProps: r,
+    chartContainerProps: s,
+    gridProps: c,
+    clipPathProps: a,
+    clipPathGroupProps: u,
+    areaPlotProps: f,
+    linePlotProps: m,
+    markPlotProps: l,
+    overlayProps: d,
+    chartsAxisProps: p,
+    axisHighlightProps: b,
+    lineHighlightPlotProps: k,
+    legendProps: h,
+    children: O
+  } = Qt(o), {
+    chartDataProviderProps: g,
+    chartsSurfaceProps: S
+  } = zn(s, i), q = o.slots?.tooltip ?? Sn, x = o.slots?.toolbar;
+  return /* @__PURE__ */ y.jsx(Vn, T({}, g, {
+    children: /* @__PURE__ */ y.jsxs(In, T({}, r, {
+      children: [o.showToolbar && x ? /* @__PURE__ */ y.jsx(x, T({}, o.slotProps?.toolbar)) : null, !o.hideLegend && /* @__PURE__ */ y.jsx(Ln, T({}, h)), /* @__PURE__ */ y.jsxs(Un, T({}, S, {
+        children: [/* @__PURE__ */ y.jsx(Kn, T({}, c)), /* @__PURE__ */ y.jsxs("g", T({}, u, {
+          children: [/* @__PURE__ */ y.jsx(ln, T({}, f)), /* @__PURE__ */ y.jsx(un, T({}, m)), /* @__PURE__ */ y.jsx(An, T({}, d)), /* @__PURE__ */ y.jsx(Xn, T({}, b))]
+        })), /* @__PURE__ */ y.jsx(ei, {}), /* @__PURE__ */ y.jsx(Bn, T({}, p)), /* @__PURE__ */ y.jsx("g", {
+          "data-drawing-container": !0,
+          children: /* @__PURE__ */ y.jsx(mn, T({}, l))
+        }), /* @__PURE__ */ y.jsx(On, T({}, k)), /* @__PURE__ */ y.jsx(Yn, T({}, a)), O]
+      })), !o.loading && /* @__PURE__ */ y.jsx(q, T({}, o.slotProps?.tooltip))]
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (gn.displayName = "LineChart");
+process.env.NODE_ENV !== "production" && (gn.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
+  }),
+  /**
+   * The configuration of axes highlight.
+   * @see See {@link https://mui.com/x/react-charts/highlighting/ highlighting docs} for more details.
+   * @default { x: 'line' }
+   */
+  axisHighlight: e.shape({
+    x: e.oneOf(["band", "line", "none"]),
+    y: e.oneOf(["band", "line", "none"])
+  }),
+  /**
+   * Configuration for the brush interaction.
+   */
+  brushConfig: e.shape({
+    enabled: e.bool,
+    preventHighlight: e.bool,
+    preventTooltip: e.bool
+  }),
+  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,
+  /**
+   * If `true`, the charts will not listen to the mouse move event.
+   * It might break interactive features, but will improve performance.
+   * @default false
+   */
+  disableAxisListener: e.bool,
+  /**
+   * If `true`, render the line highlight item.
+   */
+  disableLineItemHighlight: e.bool,
+  enableKeyboardNavigation: e.bool,
+  /**
+   * Options to enable features planned for the next major.
+   */
+  experimentalFeatures: e.shape({
+    preferStrictDomainInLineCharts: e.bool
+  }),
+  /**
+   * Option to display a cartesian grid in the background.
+   */
+  grid: e.shape({
+    horizontal: e.bool,
+    vertical: 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(["line"]).isRequired
+  })),
+  /**
+   * If `true`, the legend is not rendered.
+   */
+  hideLegend: e.bool,
+  /**
+   * The controlled axis highlight.
+   * Identified by the axis id, and data index.
+   */
+  highlightedAxis: e.arrayOf(e.shape({
+    axisId: e.oneOfType([e.number, e.string]).isRequired,
+    dataIndex: e.number.isRequired
+  })),
+  /**
+   * 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(["line"]).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 an area element is clicked.
+   */
+  onAreaClick: e.func,
+  /**
+   * The function called for onClick events.
+   * The second argument contains information about all line/bar elements at the current mouse position.
+   * @param {MouseEvent} event The mouse event recorded on the `<svg/>` element.
+   * @param {null | ChartsAxisData} data The data about the clicked axis and items associated with it.
+   */
+  onAxisClick: e.func,
+  /**
+   * 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,
+  /**
+   * The function called when the pointer position corresponds to a new axis data item.
+   * This update can either be caused by a pointer movement, or an axis update.
+   * In case of multiple axes, the function is called if at least one axis is updated.
+   * The argument contains the identifier for all axes with a `data` property.
+   * @param {AxisItemIdentifier[]} axisItems The array of axes item identifiers.
+   */
+  onHighlightedAxisChange: e.func,
+  /**
+   * Callback fired when a line element is clicked.
+   */
+  onLineClick: e.func,
+  /**
+   * Callback fired when a mark element is clicked.
+   */
+  onMarkClick: 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 line chart.
+   * An array of [[LineSeries]] objects.
+   */
+  series: e.arrayOf(e.object).isRequired,
+  /**
+   * If true, shows the default chart toolbar.
+   * @default false
+   */
+  showToolbar: e.bool,
+  /**
+   * 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,
+  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,
+    seriesId: e.oneOfType([e.number, e.string]).isRequired,
+    type: e.oneOf(["line"]).isRequired
+  }),
+  /**
+   * The width of the chart in px. If not defined, it takes the width of the parent element.
+   */
+  width: e.number,
+  /**
+   * The configuration of the x-axes.
+   * If not provided, a default axis config is used.
+   * An array of [[AxisConfig]] objects.
+   */
+  xAxis: e.arrayOf(e.oneOfType([e.shape({
+    axis: e.oneOf(["x"]),
+    barGapRatio: e.number,
+    categoryGapRatio: e.number,
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["band"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["point"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["log"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    constant: e.number,
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["symlog"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["pow"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["sqrt"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["time"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["utc"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["linear"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  })]).isRequired),
+  /**
+   * The configuration of the y-axes.
+   * If not provided, a default axis config is used.
+   * An array of [[AxisConfig]] objects.
+   */
+  yAxis: e.arrayOf(e.oneOfType([e.shape({
+    axis: e.oneOf(["y"]),
+    barGapRatio: e.number,
+    categoryGapRatio: e.number,
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["band"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["point"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["log"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    constant: e.number,
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["symlog"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["pow"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["sqrt"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["time"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["utc"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["linear"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  })]).isRequired)
+});
+export {
+  sn as AnimatedArea,
+  ke as AnimatedLine,
+  rn as AreaElement,
+  ln as AreaPlot,
+  ei as FocusedLineMark,
+  Zt as LINE_CHART_PLUGINS,
+  gn as LineChart,
+  cn as LineElement,
+  yn as LineHighlightElement,
+  On as LineHighlightPlot,
+  un as LinePlot,
+  hn as MarkElement,
+  mn as MarkPlot,
+  qt as areaElementClasses,
+  Rt as getAreaElementUtilityClass,
+  Yt as getHighlightElementUtilityClass,
+  wt as getLineElementUtilityClass,
+  Ht as getMarkElementUtilityClass,
+  Ct as lineElementClasses,
+  ui as lineHighlightElementClasses,
+  fn as markElementClasses
+};