qaema-ui 0.0.1

package/dist/node_modules/recharts/es6/chart/generateCategoricalChart.js

@@ -0,0 +1,1383 @@
+import U, { forwardRef as ye, isValidElement as xe, cloneElement as X, Component as ge } from "react";
+import vt from "../../../../_virtual/isNil.js";
+import $ from "../../../../_virtual/isFunction.js";
+import wt from "../../../../_virtual/range.js";
+import ht from "../../../../_virtual/get.js";
+import me from "../../../../_virtual/sortBy.js";
+import Ie from "../../../../_virtual/throttle.js";
+import { clsx as _t } from "../../../clsx/dist/clsx.js";
+import Ht from "../../../tiny-invariant/dist/esm/tiny-invariant.js";
+import { Surface as Yt } from "../container/Surface.js";
+import { Layer as Ae } from "../container/Layer.js";
+import { Tooltip as tt } from "../component/Tooltip.js";
+import { Legend as be } from "../component/Legend.js";
+import { Dot as Me } from "../shape/Dot.js";
+import { isInRectangle as Te } from "../shape/Rectangle.js";
+import { isChildrenEqual as Ut, findChildByType as F, validateWidthHeight as Xt, findAllByType as se, getDisplayName as At, parseChildIndex as Ee, filterProps as Ft, renderByOrder as $t, getReactEventByType as Pe } from "../util/ReactUtils.js";
+import { Brush as bt } from "../cartesian/Brush.js";
+import { getOffset as Se } from "../util/DOMUtils.js";
+import { getAnyElementOfObject as nt, findEntryInArray as Bt, hasDuplicate as ke, isNumber as yt, uniqueId as Ce } from "../util/DataUtils.js";
+import { getStackGroupsByAxisId as Oe, calculateActiveTickIndex as De, appendOffsetOfLegend as we, getTicksOfAxis as ft, getBandSizeOfAxis as Gt, getStackedDataOfItem as Be, getBarSizeList as Ge, getBarPosition as Le, getTooltipItem as Re, parseSpecifiedDomain as Lt, getDomainOfDataByKey as Ct, parseDomainOfCategoryAxis as Vt, parseErrorBarsOfAxis as Ne, getDomainOfStackGroups as de, getDomainOfItemsWithSameAxis as le, isCategoricalAxis as ce, combineEventHandlers as mt, getMainColorOfGraphicItem as je } from "../util/ChartUtils.js";
+import { detectReferenceElementsDomain as Rt } from "../util/DetectReferenceElementsDomain.js";
+import { polarToCartesian as qt, inRangeOfSector as Jt } from "../util/PolarUtils.js";
+import { shallowEqual as ze } from "../util/ShallowEqual.js";
+import { eventCenter as Ot, SYNC_EVENT as Dt } from "../util/Events.js";
+import { adaptEventHandlers as Qt } from "../util/types.js";
+import { AccessibilityManager as Ke } from "./AccessibilityManager.js";
+import { isDomainSpecifiedByUser as We } from "../util/isDomainSpecifiedByUser.js";
+import { isFunnel as _e, isPie as He, isScatter as Zt, getActiveShapeIndexForTooltip as Ye } from "../util/ActiveShapeUtils.js";
+import { Cursor as Ue } from "../component/Cursor.js";
+import { ChartLayoutContextProvider as te } from "../context/chartLayoutContext.js";
+import { getLegendProps as Xe } from "../util/getLegendProps.js";
+var Fe = ["item"], $e = ["children", "className", "width", "height", "style", "compact", "title", "desc"];
+function st(n) {
+  "@babel/helpers - typeof";
+  return st = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(a) {
+    return typeof a;
+  } : function(a) {
+    return a && typeof Symbol == "function" && a.constructor === Symbol && a !== Symbol.prototype ? "symbol" : typeof a;
+  }, st(n);
+}
+function ot() {
+  return ot = Object.assign ? Object.assign.bind() : function(n) {
+    for (var a = 1; a < arguments.length; a++) {
+      var o = arguments[a];
+      for (var c in o)
+        Object.prototype.hasOwnProperty.call(o, c) && (n[c] = o[c]);
+    }
+    return n;
+  }, ot.apply(this, arguments);
+}
+function ee(n, a) {
+  return Je(n) || qe(n, a) || ue(n, a) || Ve();
+}
+function Ve() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function qe(n, a) {
+  var o = n == null ? null : typeof Symbol < "u" && n[Symbol.iterator] || n["@@iterator"];
+  if (o != null) {
+    var c, m, S, E, C = [], G = !0, w = !1;
+    try {
+      if (S = (o = o.call(n)).next, a !== 0) for (; !(G = (c = S.call(o)).done) && (C.push(c.value), C.length !== a); G = !0) ;
+    } catch (B) {
+      w = !0, m = B;
+    } finally {
+      try {
+        if (!G && o.return != null && (E = o.return(), Object(E) !== E)) return;
+      } finally {
+        if (w) throw m;
+      }
+    }
+    return C;
+  }
+}
+function Je(n) {
+  if (Array.isArray(n)) return n;
+}
+function ae(n, a) {
+  if (n == null) return {};
+  var o = Qe(n, a), c, m;
+  if (Object.getOwnPropertySymbols) {
+    var S = Object.getOwnPropertySymbols(n);
+    for (m = 0; m < S.length; m++)
+      c = S[m], !(a.indexOf(c) >= 0) && Object.prototype.propertyIsEnumerable.call(n, c) && (o[c] = n[c]);
+  }
+  return o;
+}
+function Qe(n, a) {
+  if (n == null) return {};
+  var o = {};
+  for (var c in n)
+    if (Object.prototype.hasOwnProperty.call(n, c)) {
+      if (a.indexOf(c) >= 0) continue;
+      o[c] = n[c];
+    }
+  return o;
+}
+function Ze(n, a) {
+  if (!(n instanceof a))
+    throw new TypeError("Cannot call a class as a function");
+}
+function ta(n, a) {
+  for (var o = 0; o < a.length; o++) {
+    var c = a[o];
+    c.enumerable = c.enumerable || !1, c.configurable = !0, "value" in c && (c.writable = !0), Object.defineProperty(n, fe(c.key), c);
+  }
+}
+function ea(n, a, o) {
+  return a && ta(n.prototype, a), Object.defineProperty(n, "prototype", { writable: !1 }), n;
+}
+function aa(n, a, o) {
+  return a = Mt(a), ra(n, pe() ? Reflect.construct(a, o || [], Mt(n).constructor) : a.apply(n, o));
+}
+function ra(n, a) {
+  if (a && (st(a) === "object" || typeof a == "function"))
+    return a;
+  if (a !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return ia(n);
+}
+function ia(n) {
+  if (n === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return n;
+}
+function pe() {
+  try {
+    var n = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (pe = function() {
+    return !!n;
+  })();
+}
+function Mt(n) {
+  return Mt = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  }, Mt(n);
+}
+function na(n, a) {
+  if (typeof a != "function" && a !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  n.prototype = Object.create(a && a.prototype, { constructor: { value: n, writable: !0, configurable: !0 } }), Object.defineProperty(n, "prototype", { writable: !1 }), a && Nt(n, a);
+}
+function Nt(n, a) {
+  return Nt = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(c, m) {
+    return c.__proto__ = m, c;
+  }, Nt(n, a);
+}
+function dt(n) {
+  return da(n) || sa(n) || ue(n) || oa();
+}
+function oa() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function ue(n, a) {
+  if (n) {
+    if (typeof n == "string") return jt(n, a);
+    var o = Object.prototype.toString.call(n).slice(8, -1);
+    if (o === "Object" && n.constructor && (o = n.constructor.name), o === "Map" || o === "Set") return Array.from(n);
+    if (o === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(o)) return jt(n, a);
+  }
+}
+function sa(n) {
+  if (typeof Symbol < "u" && n[Symbol.iterator] != null || n["@@iterator"] != null) return Array.from(n);
+}
+function da(n) {
+  if (Array.isArray(n)) return jt(n);
+}
+function jt(n, a) {
+  (a == null || a > n.length) && (a = n.length);
+  for (var o = 0, c = new Array(a); o < a; o++) c[o] = n[o];
+  return c;
+}
+function re(n, a) {
+  var o = Object.keys(n);
+  if (Object.getOwnPropertySymbols) {
+    var c = Object.getOwnPropertySymbols(n);
+    a && (c = c.filter(function(m) {
+      return Object.getOwnPropertyDescriptor(n, m).enumerable;
+    })), o.push.apply(o, c);
+  }
+  return o;
+}
+function i(n) {
+  for (var a = 1; a < arguments.length; a++) {
+    var o = arguments[a] != null ? arguments[a] : {};
+    a % 2 ? re(Object(o), !0).forEach(function(c) {
+      T(n, c, o[c]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(n, Object.getOwnPropertyDescriptors(o)) : re(Object(o)).forEach(function(c) {
+      Object.defineProperty(n, c, Object.getOwnPropertyDescriptor(o, c));
+    });
+  }
+  return n;
+}
+function T(n, a, o) {
+  return a = fe(a), a in n ? Object.defineProperty(n, a, { value: o, enumerable: !0, configurable: !0, writable: !0 }) : n[a] = o, n;
+}
+function fe(n) {
+  var a = la(n, "string");
+  return st(a) == "symbol" ? a : a + "";
+}
+function la(n, a) {
+  if (st(n) != "object" || !n) return n;
+  var o = n[Symbol.toPrimitive];
+  if (o !== void 0) {
+    var c = o.call(n, a);
+    if (st(c) != "object") return c;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (a === "string" ? String : Number)(n);
+}
+var ca = {
+  xAxis: ["bottom", "top"],
+  yAxis: ["left", "right"]
+}, pa = {
+  width: "100%",
+  height: "100%"
+}, ve = {
+  x: 0,
+  y: 0
+};
+function It(n) {
+  return n;
+}
+var ua = function(a, o) {
+  return o === "horizontal" ? a.x : o === "vertical" ? a.y : o === "centric" ? a.angle : a.radius;
+}, fa = function(a, o, c, m) {
+  var S = o.find(function(B) {
+    return B && B.index === c;
+  });
+  if (S) {
+    if (a === "horizontal")
+      return {
+        x: S.coordinate,
+        y: m.y
+      };
+    if (a === "vertical")
+      return {
+        x: m.x,
+        y: S.coordinate
+      };
+    if (a === "centric") {
+      var E = S.coordinate, C = m.radius;
+      return i(i(i({}, m), qt(m.cx, m.cy, C, E)), {}, {
+        angle: E,
+        radius: C
+      });
+    }
+    var G = S.coordinate, w = m.angle;
+    return i(i(i({}, m), qt(m.cx, m.cy, G, w)), {}, {
+      angle: w,
+      radius: G
+    });
+  }
+  return ve;
+}, Tt = function(a, o) {
+  var c = o.graphicalItems, m = o.dataStartIndex, S = o.dataEndIndex, E = (c ?? []).reduce(function(C, G) {
+    var w = G.props.data;
+    return w && w.length ? [].concat(dt(C), dt(w)) : C;
+  }, []);
+  return E.length > 0 ? E : a && a.length && yt(m) && yt(S) ? a.slice(m, S + 1) : [];
+};
+function he(n) {
+  return n === "number" ? [0, "auto"] : void 0;
+}
+var zt = function(a, o, c, m) {
+  var S = a.graphicalItems, E = a.tooltipAxis, C = Tt(o, a);
+  return c < 0 || !S || !S.length || c >= C.length ? null : S.reduce(function(G, w) {
+    var B, N = (B = w.props.data) !== null && B !== void 0 ? B : o;
+    N && a.dataStartIndex + a.dataEndIndex !== 0 && // https://github.com/recharts/recharts/issues/4717
+    // The data is sliced only when the active index is within the start/end index range.
+    a.dataEndIndex - a.dataStartIndex >= c && (N = N.slice(a.dataStartIndex, a.dataEndIndex + 1));
+    var j;
+    if (E.dataKey && !E.allowDuplicatedCategory) {
+      var R = N === void 0 ? C : N;
+      j = Bt(R, E.dataKey, m);
+    } else
+      j = N && N[c] || C[c];
+    return j ? [].concat(dt(G), [Re(w, j)]) : G;
+  }, []);
+}, ie = function(a, o, c, m) {
+  var S = m || {
+    x: a.chartX,
+    y: a.chartY
+  }, E = ua(S, c), C = a.orderedTooltipTicks, G = a.tooltipAxis, w = a.tooltipTicks, B = De(E, C, w, G);
+  if (B >= 0 && w) {
+    var N = w[B] && w[B].value, j = zt(a, o, B, N), R = fa(c, C, B, S);
+    return {
+      activeTooltipIndex: B,
+      activeLabel: N,
+      activePayload: j,
+      activeCoordinate: R
+    };
+  }
+  return null;
+}, va = function(a, o) {
+  var c = o.axes, m = o.graphicalItems, S = o.axisType, E = o.axisIdKey, C = o.stackGroups, G = o.dataStartIndex, w = o.dataEndIndex, B = a.layout, N = a.children, j = a.stackOffset, R = ce(B, S);
+  return c.reduce(function(W, _) {
+    var O, u = _.type.defaultProps !== void 0 ? i(i({}, _.type.defaultProps), _.props) : _.props, x = u.type, l = u.dataKey, p = u.allowDataOverflow, t = u.allowDuplicatedCategory, e = u.scale, r = u.ticks, d = u.includeHidden, s = u[E];
+    if (W[s])
+      return W;
+    var v = Tt(a.data, {
+      graphicalItems: m.filter(function(I) {
+        var D, z = E in I.props ? I.props[E] : (D = I.type.defaultProps) === null || D === void 0 ? void 0 : D[E];
+        return z === s;
+      }),
+      dataStartIndex: G,
+      dataEndIndex: w
+    }), h = v.length, f, A, g;
+    We(u.domain, p, x) && (f = Lt(u.domain, null, p), R && (x === "number" || e !== "auto") && (g = Ct(v, l, "category")));
+    var y = he(x);
+    if (!f || f.length === 0) {
+      var b, M = (b = u.domain) !== null && b !== void 0 ? b : y;
+      if (l) {
+        if (f = Ct(v, l, x), x === "category" && R) {
+          var k = ke(f);
+          t && k ? (A = f, f = wt(0, h)) : t || (f = Vt(M, f, _).reduce(function(I, D) {
+            return I.indexOf(D) >= 0 ? I : [].concat(dt(I), [D]);
+          }, []));
+        } else if (x === "category")
+          t ? f = f.filter(function(I) {
+            return I !== "" && !vt(I);
+          }) : f = Vt(M, f, _).reduce(function(I, D) {
+            return I.indexOf(D) >= 0 || D === "" || vt(D) ? I : [].concat(dt(I), [D]);
+          }, []);
+        else if (x === "number") {
+          var P = Ne(v, m.filter(function(I) {
+            var D, z, H = E in I.props ? I.props[E] : (D = I.type.defaultProps) === null || D === void 0 ? void 0 : D[E], V = "hide" in I.props ? I.props.hide : (z = I.type.defaultProps) === null || z === void 0 ? void 0 : z.hide;
+            return H === s && (d || !V);
+          }), l, S, B);
+          P && (f = P);
+        }
+        R && (x === "number" || e !== "auto") && (g = Ct(v, l, "category"));
+      } else R ? f = wt(0, h) : C && C[s] && C[s].hasStack && x === "number" ? f = j === "expand" ? [0, 1] : de(C[s].stackGroups, G, w) : f = le(v, m.filter(function(I) {
+        var D = E in I.props ? I.props[E] : I.type.defaultProps[E], z = "hide" in I.props ? I.props.hide : I.type.defaultProps.hide;
+        return D === s && (d || !z);
+      }), x, B, !0);
+      if (x === "number")
+        f = Rt(N, f, s, S, r), M && (f = Lt(M, f, p));
+      else if (x === "category" && M) {
+        var L = M, K = f.every(function(I) {
+          return L.indexOf(I) >= 0;
+        });
+        K && (f = L);
+      }
+    }
+    return i(i({}, W), {}, T({}, s, i(i({}, u), {}, {
+      axisType: S,
+      domain: f,
+      categoricalDomain: g,
+      duplicateDomain: A,
+      originalDomain: (O = u.domain) !== null && O !== void 0 ? O : y,
+      isCategorical: R,
+      layout: B
+    })));
+  }, {});
+}, ha = function(a, o) {
+  var c = o.graphicalItems, m = o.Axis, S = o.axisType, E = o.axisIdKey, C = o.stackGroups, G = o.dataStartIndex, w = o.dataEndIndex, B = a.layout, N = a.children, j = Tt(a.data, {
+    graphicalItems: c,
+    dataStartIndex: G,
+    dataEndIndex: w
+  }), R = j.length, W = ce(B, S), _ = -1;
+  return c.reduce(function(O, u) {
+    var x = u.type.defaultProps !== void 0 ? i(i({}, u.type.defaultProps), u.props) : u.props, l = x[E], p = he("number");
+    if (!O[l]) {
+      _++;
+      var t;
+      return W ? t = wt(0, R) : C && C[l] && C[l].hasStack ? (t = de(C[l].stackGroups, G, w), t = Rt(N, t, l, S)) : (t = Lt(p, le(j, c.filter(function(e) {
+        var r, d, s = E in e.props ? e.props[E] : (r = e.type.defaultProps) === null || r === void 0 ? void 0 : r[E], v = "hide" in e.props ? e.props.hide : (d = e.type.defaultProps) === null || d === void 0 ? void 0 : d.hide;
+        return s === l && !v;
+      }), "number", B), m.defaultProps.allowDataOverflow), t = Rt(N, t, l, S)), i(i({}, O), {}, T({}, l, i(i({
+        axisType: S
+      }, m.defaultProps), {}, {
+        hide: !0,
+        orientation: ht(ca, "".concat(S, ".").concat(_ % 2), null),
+        domain: t,
+        originalDomain: p,
+        isCategorical: W,
+        layout: B
+        // specify scale when no Axis
+        // scale: isCategorical ? 'band' : 'linear',
+      })));
+    }
+    return O;
+  }, {});
+}, ya = function(a, o) {
+  var c = o.axisType, m = c === void 0 ? "xAxis" : c, S = o.AxisComp, E = o.graphicalItems, C = o.stackGroups, G = o.dataStartIndex, w = o.dataEndIndex, B = a.children, N = "".concat(m, "Id"), j = se(B, S), R = {};
+  return j && j.length ? R = va(a, {
+    axes: j,
+    graphicalItems: E,
+    axisType: m,
+    axisIdKey: N,
+    stackGroups: C,
+    dataStartIndex: G,
+    dataEndIndex: w
+  }) : E && E.length && (R = ha(a, {
+    Axis: S,
+    graphicalItems: E,
+    axisType: m,
+    axisIdKey: N,
+    stackGroups: C,
+    dataStartIndex: G,
+    dataEndIndex: w
+  })), R;
+}, xa = function(a) {
+  var o = nt(a), c = ft(o, !1, !0);
+  return {
+    tooltipTicks: c,
+    orderedTooltipTicks: me(c, function(m) {
+      return m.coordinate;
+    }),
+    tooltipAxis: o,
+    tooltipAxisBandSize: Gt(o, c)
+  };
+}, ne = function(a) {
+  var o = a.children, c = a.defaultShowTooltip, m = F(o, bt), S = 0, E = 0;
+  return a.data && a.data.length !== 0 && (E = a.data.length - 1), m && m.props && (m.props.startIndex >= 0 && (S = m.props.startIndex), m.props.endIndex >= 0 && (E = m.props.endIndex)), {
+    chartX: 0,
+    chartY: 0,
+    dataStartIndex: S,
+    dataEndIndex: E,
+    activeTooltipIndex: -1,
+    isTooltipActive: !!c
+  };
+}, ga = function(a) {
+  return !a || !a.length ? !1 : a.some(function(o) {
+    var c = At(o && o.type);
+    return c && c.indexOf("Bar") >= 0;
+  });
+}, oe = function(a) {
+  return a === "horizontal" ? {
+    numericAxisName: "yAxis",
+    cateAxisName: "xAxis"
+  } : a === "vertical" ? {
+    numericAxisName: "xAxis",
+    cateAxisName: "yAxis"
+  } : a === "centric" ? {
+    numericAxisName: "radiusAxis",
+    cateAxisName: "angleAxis"
+  } : {
+    numericAxisName: "angleAxis",
+    cateAxisName: "radiusAxis"
+  };
+}, ma = function(a, o) {
+  var c = a.props, m = a.graphicalItems, S = a.xAxisMap, E = S === void 0 ? {} : S, C = a.yAxisMap, G = C === void 0 ? {} : C, w = c.width, B = c.height, N = c.children, j = c.margin || {}, R = F(N, bt), W = F(N, be), _ = Object.keys(G).reduce(function(t, e) {
+    var r = G[e], d = r.orientation;
+    return !r.mirror && !r.hide ? i(i({}, t), {}, T({}, d, t[d] + r.width)) : t;
+  }, {
+    left: j.left || 0,
+    right: j.right || 0
+  }), O = Object.keys(E).reduce(function(t, e) {
+    var r = E[e], d = r.orientation;
+    return !r.mirror && !r.hide ? i(i({}, t), {}, T({}, d, ht(t, "".concat(d)) + r.height)) : t;
+  }, {
+    top: j.top || 0,
+    bottom: j.bottom || 0
+  }), u = i(i({}, O), _), x = u.bottom;
+  R && (u.bottom += R.props.height || bt.defaultProps.height), W && o && (u = we(u, m, c, o));
+  var l = w - u.left - u.right, p = B - u.top - u.bottom;
+  return i(i({
+    brushBottom: x
+  }, u), {}, {
+    // never return negative values for height and width
+    width: Math.max(l, 0),
+    height: Math.max(p, 0)
+  });
+}, Ia = function(a, o) {
+  if (o === "xAxis")
+    return a[o].width;
+  if (o === "yAxis")
+    return a[o].height;
+}, Qa = function(a) {
+  var o = a.chartName, c = a.GraphicalChild, m = a.defaultTooltipEventType, S = m === void 0 ? "axis" : m, E = a.validateTooltipEventTypes, C = E === void 0 ? ["axis"] : E, G = a.axisComponents, w = a.legendContent, B = a.formatAxisMap, N = a.defaultProps, j = function(u, x) {
+    var l = x.graphicalItems, p = x.stackGroups, t = x.offset, e = x.updateId, r = x.dataStartIndex, d = x.dataEndIndex, s = u.barSize, v = u.layout, h = u.barGap, f = u.barCategoryGap, A = u.maxBarSize, g = oe(v), y = g.numericAxisName, b = g.cateAxisName, M = ga(l), k = [];
+    return l.forEach(function(P, L) {
+      var K = Tt(u.data, {
+        graphicalItems: [P],
+        dataStartIndex: r,
+        dataEndIndex: d
+      }), I = P.type.defaultProps !== void 0 ? i(i({}, P.type.defaultProps), P.props) : P.props, D = I.dataKey, z = I.maxBarSize, H = I["".concat(y, "Id")], V = I["".concat(b, "Id")], Et = {}, Y = G.reduce(function(Z, q) {
+        var Pt, St, kt = x["".concat(q.axisType, "Map")], Kt = I["".concat(q.axisType, "Id")];
+        kt && kt[Kt] || q.axisType === "zAxis" || (process.env.NODE_ENV !== "production" ? Ht(!1, "Specifying a(n) ".concat(q.axisType, "Id requires a corresponding ").concat(
+          q.axisType,
+          "Id on the targeted graphical component "
+        ).concat((Pt = P == null || (St = P.type) === null || St === void 0 ? void 0 : St.displayName) !== null && Pt !== void 0 ? Pt : "")) : Ht());
+        var Wt = kt[Kt];
+        return i(i({}, Z), {}, T(T({}, q.axisType, Wt), "".concat(q.axisType, "Ticks"), ft(Wt)));
+      }, Et), J = Y[b], xt = Y["".concat(b, "Ticks")], et = p && p[H] && p[H].hasStack && Be(P, p[H].stackGroups), lt = At(P.type).indexOf("Bar") >= 0, Q = Gt(J, xt), at = [], ct = M && Ge({
+        barSize: s,
+        stackGroups: p,
+        totalSize: Ia(Y, b)
+      });
+      if (lt) {
+        var pt, rt, ut = vt(z) ? A : z, it = (pt = (rt = Gt(J, xt, !0)) !== null && rt !== void 0 ? rt : ut) !== null && pt !== void 0 ? pt : 0;
+        at = Le({
+          barGap: h,
+          barCategoryGap: f,
+          bandSize: it !== Q ? it : Q,
+          sizeList: ct[V],
+          maxBarSize: ut
+        }), it !== Q && (at = at.map(function(Z) {
+          return i(i({}, Z), {}, {
+            position: i(i({}, Z.position), {}, {
+              offset: Z.position.offset - it / 2
+            })
+          });
+        }));
+      }
+      var gt = P && P.type && P.type.getComposedData;
+      gt && k.push({
+        props: i(i({}, gt(i(i({}, Y), {}, {
+          displayedData: K,
+          props: u,
+          dataKey: D,
+          item: P,
+          bandSize: Q,
+          barPosition: at,
+          offset: t,
+          stackedData: et,
+          layout: v,
+          dataStartIndex: r,
+          dataEndIndex: d
+        }))), {}, T(T(T({
+          key: P.key || "item-".concat(L)
+        }, y, Y[y]), b, Y[b]), "animationId", e)),
+        childIndex: Ee(P, u.children),
+        item: P
+      });
+    }), k;
+  }, R = function(u, x) {
+    var l = u.props, p = u.dataStartIndex, t = u.dataEndIndex, e = u.updateId;
+    if (!Xt({
+      props: l
+    }))
+      return null;
+    var r = l.children, d = l.layout, s = l.stackOffset, v = l.data, h = l.reverseStackOrder, f = oe(d), A = f.numericAxisName, g = f.cateAxisName, y = se(r, c), b = Oe(v, y, "".concat(A, "Id"), "".concat(g, "Id"), s, h), M = G.reduce(function(I, D) {
+      var z = "".concat(D.axisType, "Map");
+      return i(i({}, I), {}, T({}, z, ya(l, i(i({}, D), {}, {
+        graphicalItems: y,
+        stackGroups: D.axisType === A && b,
+        dataStartIndex: p,
+        dataEndIndex: t
+      }))));
+    }, {}), k = ma(i(i({}, M), {}, {
+      props: l,
+      graphicalItems: y
+    }), x == null ? void 0 : x.legendBBox);
+    Object.keys(M).forEach(function(I) {
+      M[I] = B(l, M[I], k, I.replace("Map", ""), o);
+    });
+    var P = M["".concat(g, "Map")], L = xa(P), K = j(l, i(i({}, M), {}, {
+      dataStartIndex: p,
+      dataEndIndex: t,
+      updateId: e,
+      graphicalItems: y,
+      stackGroups: b,
+      offset: k
+    }));
+    return i(i({
+      formattedGraphicalItems: K,
+      graphicalItems: y,
+      offset: k,
+      stackGroups: b
+    }, L), M);
+  }, W = /* @__PURE__ */ (function(O) {
+    function u(x) {
+      var l, p, t;
+      return Ze(this, u), t = aa(this, u, [x]), T(t, "eventEmitterSymbol", Symbol("rechartsEventEmitter")), T(t, "accessibilityManager", new Ke()), T(t, "handleLegendBBoxUpdate", function(e) {
+        if (e) {
+          var r = t.state, d = r.dataStartIndex, s = r.dataEndIndex, v = r.updateId;
+          t.setState(i({
+            legendBBox: e
+          }, R({
+            props: t.props,
+            dataStartIndex: d,
+            dataEndIndex: s,
+            updateId: v
+          }, i(i({}, t.state), {}, {
+            legendBBox: e
+          }))));
+        }
+      }), T(t, "handleReceiveSyncEvent", function(e, r, d) {
+        if (t.props.syncId === e) {
+          if (d === t.eventEmitterSymbol && typeof t.props.syncMethod != "function")
+            return;
+          t.applySyncEvent(r);
+        }
+      }), T(t, "handleBrushChange", function(e) {
+        var r = e.startIndex, d = e.endIndex;
+        if (r !== t.state.dataStartIndex || d !== t.state.dataEndIndex) {
+          var s = t.state.updateId;
+          t.setState(function() {
+            return i({
+              dataStartIndex: r,
+              dataEndIndex: d
+            }, R({
+              props: t.props,
+              dataStartIndex: r,
+              dataEndIndex: d,
+              updateId: s
+            }, t.state));
+          }), t.triggerSyncEvent({
+            dataStartIndex: r,
+            dataEndIndex: d
+          });
+        }
+      }), T(t, "handleMouseEnter", function(e) {
+        var r = t.getMouseInfo(e);
+        if (r) {
+          var d = i(i({}, r), {}, {
+            isTooltipActive: !0
+          });
+          t.setState(d), t.triggerSyncEvent(d);
+          var s = t.props.onMouseEnter;
+          $(s) && s(d, e);
+        }
+      }), T(t, "triggeredAfterMouseMove", function(e) {
+        var r = t.getMouseInfo(e), d = r ? i(i({}, r), {}, {
+          isTooltipActive: !0
+        }) : {
+          isTooltipActive: !1
+        };
+        t.setState(d), t.triggerSyncEvent(d);
+        var s = t.props.onMouseMove;
+        $(s) && s(d, e);
+      }), T(t, "handleItemMouseEnter", function(e) {
+        t.setState(function() {
+          return {
+            isTooltipActive: !0,
+            activeItem: e,
+            activePayload: e.tooltipPayload,
+            activeCoordinate: e.tooltipPosition || {
+              x: e.cx,
+              y: e.cy
+            }
+          };
+        });
+      }), T(t, "handleItemMouseLeave", function() {
+        t.setState(function() {
+          return {
+            isTooltipActive: !1
+          };
+        });
+      }), T(t, "handleMouseMove", function(e) {
+        e.persist(), t.throttleTriggeredAfterMouseMove(e);
+      }), T(t, "handleMouseLeave", function(e) {
+        t.throttleTriggeredAfterMouseMove.cancel();
+        var r = {
+          isTooltipActive: !1
+        };
+        t.setState(r), t.triggerSyncEvent(r);
+        var d = t.props.onMouseLeave;
+        $(d) && d(r, e);
+      }), T(t, "handleOuterEvent", function(e) {
+        var r = Pe(e), d = ht(t.props, "".concat(r));
+        if (r && $(d)) {
+          var s, v;
+          /.*touch.*/i.test(r) ? v = t.getMouseInfo(e.changedTouches[0]) : v = t.getMouseInfo(e), d((s = v) !== null && s !== void 0 ? s : {}, e);
+        }
+      }), T(t, "handleClick", function(e) {
+        var r = t.getMouseInfo(e);
+        if (r) {
+          var d = i(i({}, r), {}, {
+            isTooltipActive: !0
+          });
+          t.setState(d), t.triggerSyncEvent(d);
+          var s = t.props.onClick;
+          $(s) && s(d, e);
+        }
+      }), T(t, "handleMouseDown", function(e) {
+        var r = t.props.onMouseDown;
+        if ($(r)) {
+          var d = t.getMouseInfo(e);
+          r(d, e);
+        }
+      }), T(t, "handleMouseUp", function(e) {
+        var r = t.props.onMouseUp;
+        if ($(r)) {
+          var d = t.getMouseInfo(e);
+          r(d, e);
+        }
+      }), T(t, "handleTouchMove", function(e) {
+        e.changedTouches != null && e.changedTouches.length > 0 && t.throttleTriggeredAfterMouseMove(e.changedTouches[0]);
+      }), T(t, "handleTouchStart", function(e) {
+        e.changedTouches != null && e.changedTouches.length > 0 && t.handleMouseDown(e.changedTouches[0]);
+      }), T(t, "handleTouchEnd", function(e) {
+        e.changedTouches != null && e.changedTouches.length > 0 && t.handleMouseUp(e.changedTouches[0]);
+      }), T(t, "handleDoubleClick", function(e) {
+        var r = t.props.onDoubleClick;
+        if ($(r)) {
+          var d = t.getMouseInfo(e);
+          r(d, e);
+        }
+      }), T(t, "handleContextMenu", function(e) {
+        var r = t.props.onContextMenu;
+        if ($(r)) {
+          var d = t.getMouseInfo(e);
+          r(d, e);
+        }
+      }), T(t, "triggerSyncEvent", function(e) {
+        t.props.syncId !== void 0 && Ot.emit(Dt, t.props.syncId, e, t.eventEmitterSymbol);
+      }), T(t, "applySyncEvent", function(e) {
+        var r = t.props, d = r.layout, s = r.syncMethod, v = t.state.updateId, h = e.dataStartIndex, f = e.dataEndIndex;
+        if (e.dataStartIndex !== void 0 || e.dataEndIndex !== void 0)
+          t.setState(i({
+            dataStartIndex: h,
+            dataEndIndex: f
+          }, R({
+            props: t.props,
+            dataStartIndex: h,
+            dataEndIndex: f,
+            updateId: v
+          }, t.state)));
+        else if (e.activeTooltipIndex !== void 0) {
+          var A = e.chartX, g = e.chartY, y = e.activeTooltipIndex, b = t.state, M = b.offset, k = b.tooltipTicks;
+          if (!M)
+            return;
+          if (typeof s == "function")
+            y = s(k, e);
+          else if (s === "value") {
+            y = -1;
+            for (var P = 0; P < k.length; P++)
+              if (k[P].value === e.activeLabel) {
+                y = P;
+                break;
+              }
+          }
+          var L = i(i({}, M), {}, {
+            x: M.left,
+            y: M.top
+          }), K = Math.min(A, L.x + L.width), I = Math.min(g, L.y + L.height), D = k[y] && k[y].value, z = zt(t.state, t.props.data, y), H = k[y] ? {
+            x: d === "horizontal" ? k[y].coordinate : K,
+            y: d === "horizontal" ? I : k[y].coordinate
+          } : ve;
+          t.setState(i(i({}, e), {}, {
+            activeLabel: D,
+            activeCoordinate: H,
+            activePayload: z,
+            activeTooltipIndex: y
+          }));
+        } else
+          t.setState(e);
+      }), T(t, "renderCursor", function(e) {
+        var r, d = t.state, s = d.isTooltipActive, v = d.activeCoordinate, h = d.activePayload, f = d.offset, A = d.activeTooltipIndex, g = d.tooltipAxisBandSize, y = t.getTooltipEventType(), b = (r = e.props.active) !== null && r !== void 0 ? r : s, M = t.props.layout, k = e.key || "_recharts-cursor";
+        return /* @__PURE__ */ U.createElement(Ue, {
+          key: k,
+          activeCoordinate: v,
+          activePayload: h,
+          activeTooltipIndex: A,
+          chartName: o,
+          element: e,
+          isActive: b,
+          layout: M,
+          offset: f,
+          tooltipAxisBandSize: g,
+          tooltipEventType: y
+        });
+      }), T(t, "renderPolarAxis", function(e, r, d) {
+        var s = ht(e, "type.axisType"), v = ht(t.state, "".concat(s, "Map")), h = e.type.defaultProps, f = h !== void 0 ? i(i({}, h), e.props) : e.props, A = v && v[f["".concat(s, "Id")]];
+        return /* @__PURE__ */ X(e, i(i({}, A), {}, {
+          className: _t(s, A.className),
+          key: e.key || "".concat(r, "-").concat(d),
+          ticks: ft(A, !0)
+        }));
+      }), T(t, "renderPolarGrid", function(e) {
+        var r = e.props, d = r.radialLines, s = r.polarAngles, v = r.polarRadius, h = t.state, f = h.radiusAxisMap, A = h.angleAxisMap, g = nt(f), y = nt(A), b = y.cx, M = y.cy, k = y.innerRadius, P = y.outerRadius;
+        return /* @__PURE__ */ X(e, {
+          polarAngles: Array.isArray(s) ? s : ft(y, !0).map(function(L) {
+            return L.coordinate;
+          }),
+          polarRadius: Array.isArray(v) ? v : ft(g, !0).map(function(L) {
+            return L.coordinate;
+          }),
+          cx: b,
+          cy: M,
+          innerRadius: k,
+          outerRadius: P,
+          key: e.key || "polar-grid",
+          radialLines: d
+        });
+      }), T(t, "renderLegend", function() {
+        var e = t.state.formattedGraphicalItems, r = t.props, d = r.children, s = r.width, v = r.height, h = t.props.margin || {}, f = s - (h.left || 0) - (h.right || 0), A = Xe({
+          children: d,
+          formattedGraphicalItems: e,
+          legendWidth: f,
+          legendContent: w
+        });
+        if (!A)
+          return null;
+        var g = A.item, y = ae(A, Fe);
+        return /* @__PURE__ */ X(g, i(i({}, y), {}, {
+          chartWidth: s,
+          chartHeight: v,
+          margin: h,
+          onBBoxUpdate: t.handleLegendBBoxUpdate
+        }));
+      }), T(t, "renderTooltip", function() {
+        var e, r = t.props, d = r.children, s = r.accessibilityLayer, v = F(d, tt);
+        if (!v)
+          return null;
+        var h = t.state, f = h.isTooltipActive, A = h.activeCoordinate, g = h.activePayload, y = h.activeLabel, b = h.offset, M = (e = v.props.active) !== null && e !== void 0 ? e : f;
+        return /* @__PURE__ */ X(v, {
+          viewBox: i(i({}, b), {}, {
+            x: b.left,
+            y: b.top
+          }),
+          active: M,
+          label: y,
+          payload: M ? g : [],
+          coordinate: A,
+          accessibilityLayer: s
+        });
+      }), T(t, "renderBrush", function(e) {
+        var r = t.props, d = r.margin, s = r.data, v = t.state, h = v.offset, f = v.dataStartIndex, A = v.dataEndIndex, g = v.updateId;
+        return /* @__PURE__ */ X(e, {
+          key: e.key || "_recharts-brush",
+          onChange: mt(t.handleBrushChange, e.props.onChange),
+          data: s,
+          x: yt(e.props.x) ? e.props.x : h.left,
+          y: yt(e.props.y) ? e.props.y : h.top + h.height + h.brushBottom - (d.bottom || 0),
+          width: yt(e.props.width) ? e.props.width : h.width,
+          startIndex: f,
+          endIndex: A,
+          updateId: "brush-".concat(g)
+        });
+      }), T(t, "renderReferenceElement", function(e, r, d) {
+        if (!e)
+          return null;
+        var s = t, v = s.clipPathId, h = t.state, f = h.xAxisMap, A = h.yAxisMap, g = h.offset, y = e.type.defaultProps || {}, b = e.props, M = b.xAxisId, k = M === void 0 ? y.xAxisId : M, P = b.yAxisId, L = P === void 0 ? y.yAxisId : P;
+        return /* @__PURE__ */ X(e, {
+          key: e.key || "".concat(r, "-").concat(d),
+          xAxis: f[k],
+          yAxis: A[L],
+          viewBox: {
+            x: g.left,
+            y: g.top,
+            width: g.width,
+            height: g.height
+          },
+          clipPathId: v
+        });
+      }), T(t, "renderActivePoints", function(e) {
+        var r = e.item, d = e.activePoint, s = e.basePoint, v = e.childIndex, h = e.isRange, f = [], A = r.props.key, g = r.item.type.defaultProps !== void 0 ? i(i({}, r.item.type.defaultProps), r.item.props) : r.item.props, y = g.activeDot, b = g.dataKey, M = i(i({
+          index: v,
+          dataKey: b,
+          cx: d.x,
+          cy: d.y,
+          r: 4,
+          fill: je(r.item),
+          strokeWidth: 2,
+          stroke: "#fff",
+          payload: d.payload,
+          value: d.value
+        }, Ft(y, !1)), Qt(y));
+        return f.push(u.renderActiveDot(y, M, "".concat(A, "-activePoint-").concat(v))), s ? f.push(u.renderActiveDot(y, i(i({}, M), {}, {
+          cx: s.x,
+          cy: s.y
+        }), "".concat(A, "-basePoint-").concat(v))) : h && f.push(null), f;
+      }), T(t, "renderGraphicChild", function(e, r, d) {
+        var s = t.filterFormatItem(e, r, d);
+        if (!s)
+          return null;
+        var v = t.getTooltipEventType(), h = t.state, f = h.isTooltipActive, A = h.tooltipAxis, g = h.activeTooltipIndex, y = h.activeLabel, b = t.props.children, M = F(b, tt), k = s.props, P = k.points, L = k.isRange, K = k.baseLine, I = s.item.type.defaultProps !== void 0 ? i(i({}, s.item.type.defaultProps), s.item.props) : s.item.props, D = I.activeDot, z = I.hide, H = I.activeBar, V = I.activeShape, Et = !!(!z && f && M && (D || H || V)), Y = {};
+        v !== "axis" && M && M.props.trigger === "click" ? Y = {
+          onClick: mt(t.handleItemMouseEnter, e.props.onClick)
+        } : v !== "axis" && (Y = {
+          onMouseLeave: mt(t.handleItemMouseLeave, e.props.onMouseLeave),
+          onMouseEnter: mt(t.handleItemMouseEnter, e.props.onMouseEnter)
+        });
+        var J = /* @__PURE__ */ X(e, i(i({}, s.props), Y));
+        function xt(q) {
+          return typeof A.dataKey == "function" ? A.dataKey(q.payload) : null;
+        }
+        if (Et)
+          if (g >= 0) {
+            var et, lt;
+            if (A.dataKey && !A.allowDuplicatedCategory) {
+              var Q = typeof A.dataKey == "function" ? xt : "payload.".concat(A.dataKey.toString());
+              et = Bt(P, Q, y), lt = L && K && Bt(K, Q, y);
+            } else
+              et = P == null ? void 0 : P[g], lt = L && K && K[g];
+            if (V || H) {
+              var at = e.props.activeIndex !== void 0 ? e.props.activeIndex : g;
+              return [/* @__PURE__ */ X(e, i(i(i({}, s.props), Y), {}, {
+                activeIndex: at
+              })), null, null];
+            }
+            if (!vt(et))
+              return [J].concat(dt(t.renderActivePoints({
+                item: s,
+                activePoint: et,
+                basePoint: lt,
+                childIndex: g,
+                isRange: L
+              })));
+          } else {
+            var ct, pt = (ct = t.getItemByXY(t.state.activeCoordinate)) !== null && ct !== void 0 ? ct : {
+              graphicalItem: J
+            }, rt = pt.graphicalItem, ut = rt.item, it = ut === void 0 ? e : ut, gt = rt.childIndex, Z = i(i(i({}, s.props), Y), {}, {
+              activeIndex: gt
+            });
+            return [/* @__PURE__ */ X(it, Z), null, null];
+          }
+        return L ? [J, null, null] : [J, null];
+      }), T(t, "renderCustomized", function(e, r, d) {
+        return /* @__PURE__ */ X(e, i(i({
+          key: "recharts-customized-".concat(d)
+        }, t.props), t.state));
+      }), T(t, "renderMap", {
+        CartesianGrid: {
+          handler: It,
+          once: !0
+        },
+        ReferenceArea: {
+          handler: t.renderReferenceElement
+        },
+        ReferenceLine: {
+          handler: It
+        },
+        ReferenceDot: {
+          handler: t.renderReferenceElement
+        },
+        XAxis: {
+          handler: It
+        },
+        YAxis: {
+          handler: It
+        },
+        Brush: {
+          handler: t.renderBrush,
+          once: !0
+        },
+        Bar: {
+          handler: t.renderGraphicChild
+        },
+        Line: {
+          handler: t.renderGraphicChild
+        },
+        Area: {
+          handler: t.renderGraphicChild
+        },
+        Radar: {
+          handler: t.renderGraphicChild
+        },
+        RadialBar: {
+          handler: t.renderGraphicChild
+        },
+        Scatter: {
+          handler: t.renderGraphicChild
+        },
+        Pie: {
+          handler: t.renderGraphicChild
+        },
+        Funnel: {
+          handler: t.renderGraphicChild
+        },
+        Tooltip: {
+          handler: t.renderCursor,
+          once: !0
+        },
+        PolarGrid: {
+          handler: t.renderPolarGrid,
+          once: !0
+        },
+        PolarAngleAxis: {
+          handler: t.renderPolarAxis
+        },
+        PolarRadiusAxis: {
+          handler: t.renderPolarAxis
+        },
+        Customized: {
+          handler: t.renderCustomized
+        }
+      }), t.clipPathId = "".concat((l = x.id) !== null && l !== void 0 ? l : Ce("recharts"), "-clip"), t.throttleTriggeredAfterMouseMove = Ie(t.triggeredAfterMouseMove, (p = x.throttleDelay) !== null && p !== void 0 ? p : 1e3 / 60), t.state = {}, t;
+    }
+    return na(u, O), ea(u, [{
+      key: "componentDidMount",
+      value: function() {
+        var l, p;
+        this.addListener(), this.accessibilityManager.setDetails({
+          container: this.container,
+          offset: {
+            left: (l = this.props.margin.left) !== null && l !== void 0 ? l : 0,
+            top: (p = this.props.margin.top) !== null && p !== void 0 ? p : 0
+          },
+          coordinateList: this.state.tooltipTicks,
+          mouseHandlerCallback: this.triggeredAfterMouseMove,
+          layout: this.props.layout
+        }), this.displayDefaultTooltip();
+      }
+    }, {
+      key: "displayDefaultTooltip",
+      value: function() {
+        var l = this.props, p = l.children, t = l.data, e = l.height, r = l.layout, d = F(p, tt);
+        if (d) {
+          var s = d.props.defaultIndex;
+          if (!(typeof s != "number" || s < 0 || s > this.state.tooltipTicks.length - 1)) {
+            var v = this.state.tooltipTicks[s] && this.state.tooltipTicks[s].value, h = zt(this.state, t, s, v), f = this.state.tooltipTicks[s].coordinate, A = (this.state.offset.top + e) / 2, g = r === "horizontal", y = g ? {
+              x: f,
+              y: A
+            } : {
+              y: f,
+              x: A
+            }, b = this.state.formattedGraphicalItems.find(function(k) {
+              var P = k.item;
+              return P.type.name === "Scatter";
+            });
+            b && (y = i(i({}, y), b.props.points[s].tooltipPosition), h = b.props.points[s].tooltipPayload);
+            var M = {
+              activeTooltipIndex: s,
+              isTooltipActive: !0,
+              activeLabel: v,
+              activePayload: h,
+              activeCoordinate: y
+            };
+            this.setState(M), this.renderCursor(d), this.accessibilityManager.setIndex(s);
+          }
+        }
+      }
+    }, {
+      key: "getSnapshotBeforeUpdate",
+      value: function(l, p) {
+        if (!this.props.accessibilityLayer)
+          return null;
+        if (this.state.tooltipTicks !== p.tooltipTicks && this.accessibilityManager.setDetails({
+          coordinateList: this.state.tooltipTicks
+        }), this.props.layout !== l.layout && this.accessibilityManager.setDetails({
+          layout: this.props.layout
+        }), this.props.margin !== l.margin) {
+          var t, e;
+          this.accessibilityManager.setDetails({
+            offset: {
+              left: (t = this.props.margin.left) !== null && t !== void 0 ? t : 0,
+              top: (e = this.props.margin.top) !== null && e !== void 0 ? e : 0
+            }
+          });
+        }
+        return null;
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function(l) {
+        Ut([F(l.children, tt)], [F(this.props.children, tt)]) || this.displayDefaultTooltip();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function() {
+        this.removeListener(), this.throttleTriggeredAfterMouseMove.cancel();
+      }
+    }, {
+      key: "getTooltipEventType",
+      value: function() {
+        var l = F(this.props.children, tt);
+        if (l && typeof l.props.shared == "boolean") {
+          var p = l.props.shared ? "axis" : "item";
+          return C.indexOf(p) >= 0 ? p : S;
+        }
+        return S;
+      }
+      /**
+       * Get the information of mouse in chart, return null when the mouse is not in the chart
+       * @param  {MousePointer} event    The event object
+       * @return {Object}          Mouse data
+       */
+    }, {
+      key: "getMouseInfo",
+      value: function(l) {
+        if (!this.container)
+          return null;
+        var p = this.container, t = p.getBoundingClientRect(), e = Se(t), r = {
+          chartX: Math.round(l.pageX - e.left),
+          chartY: Math.round(l.pageY - e.top)
+        }, d = t.width / p.offsetWidth || 1, s = this.inRange(r.chartX, r.chartY, d);
+        if (!s)
+          return null;
+        var v = this.state, h = v.xAxisMap, f = v.yAxisMap, A = this.getTooltipEventType(), g = ie(this.state, this.props.data, this.props.layout, s);
+        if (A !== "axis" && h && f) {
+          var y = nt(h).scale, b = nt(f).scale, M = y && y.invert ? y.invert(r.chartX) : null, k = b && b.invert ? b.invert(r.chartY) : null;
+          return i(i({}, r), {}, {
+            xValue: M,
+            yValue: k
+          }, g);
+        }
+        return g ? i(i({}, r), g) : null;
+      }
+    }, {
+      key: "inRange",
+      value: function(l, p) {
+        var t = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, e = this.props.layout, r = l / t, d = p / t;
+        if (e === "horizontal" || e === "vertical") {
+          var s = this.state.offset, v = r >= s.left && r <= s.left + s.width && d >= s.top && d <= s.top + s.height;
+          return v ? {
+            x: r,
+            y: d
+          } : null;
+        }
+        var h = this.state, f = h.angleAxisMap, A = h.radiusAxisMap;
+        if (f && A) {
+          var g = nt(f);
+          return Jt({
+            x: r,
+            y: d
+          }, g);
+        }
+        return null;
+      }
+    }, {
+      key: "parseEventsOfWrapper",
+      value: function() {
+        var l = this.props.children, p = this.getTooltipEventType(), t = F(l, tt), e = {};
+        t && p === "axis" && (t.props.trigger === "click" ? e = {
+          onClick: this.handleClick
+        } : e = {
+          onMouseEnter: this.handleMouseEnter,
+          onDoubleClick: this.handleDoubleClick,
+          onMouseMove: this.handleMouseMove,
+          onMouseLeave: this.handleMouseLeave,
+          onTouchMove: this.handleTouchMove,
+          onTouchStart: this.handleTouchStart,
+          onTouchEnd: this.handleTouchEnd,
+          onContextMenu: this.handleContextMenu
+        });
+        var r = Qt(this.props, this.handleOuterEvent);
+        return i(i({}, r), e);
+      }
+    }, {
+      key: "addListener",
+      value: function() {
+        Ot.on(Dt, this.handleReceiveSyncEvent);
+      }
+    }, {
+      key: "removeListener",
+      value: function() {
+        Ot.removeListener(Dt, this.handleReceiveSyncEvent);
+      }
+    }, {
+      key: "filterFormatItem",
+      value: function(l, p, t) {
+        for (var e = this.state.formattedGraphicalItems, r = 0, d = e.length; r < d; r++) {
+          var s = e[r];
+          if (s.item === l || s.props.key === l.key || p === At(s.item.type) && t === s.childIndex)
+            return s;
+        }
+        return null;
+      }
+    }, {
+      key: "renderClipPath",
+      value: function() {
+        var l = this.clipPathId, p = this.state.offset, t = p.left, e = p.top, r = p.height, d = p.width;
+        return /* @__PURE__ */ U.createElement("defs", null, /* @__PURE__ */ U.createElement("clipPath", {
+          id: l
+        }, /* @__PURE__ */ U.createElement("rect", {
+          x: t,
+          y: e,
+          height: r,
+          width: d
+        })));
+      }
+    }, {
+      key: "getXScales",
+      value: function() {
+        var l = this.state.xAxisMap;
+        return l ? Object.entries(l).reduce(function(p, t) {
+          var e = ee(t, 2), r = e[0], d = e[1];
+          return i(i({}, p), {}, T({}, r, d.scale));
+        }, {}) : null;
+      }
+    }, {
+      key: "getYScales",
+      value: function() {
+        var l = this.state.yAxisMap;
+        return l ? Object.entries(l).reduce(function(p, t) {
+          var e = ee(t, 2), r = e[0], d = e[1];
+          return i(i({}, p), {}, T({}, r, d.scale));
+        }, {}) : null;
+      }
+    }, {
+      key: "getXScaleByAxisId",
+      value: function(l) {
+        var p;
+        return (p = this.state.xAxisMap) === null || p === void 0 || (p = p[l]) === null || p === void 0 ? void 0 : p.scale;
+      }
+    }, {
+      key: "getYScaleByAxisId",
+      value: function(l) {
+        var p;
+        return (p = this.state.yAxisMap) === null || p === void 0 || (p = p[l]) === null || p === void 0 ? void 0 : p.scale;
+      }
+    }, {
+      key: "getItemByXY",
+      value: function(l) {
+        var p = this.state, t = p.formattedGraphicalItems, e = p.activeItem;
+        if (t && t.length)
+          for (var r = 0, d = t.length; r < d; r++) {
+            var s = t[r], v = s.props, h = s.item, f = h.type.defaultProps !== void 0 ? i(i({}, h.type.defaultProps), h.props) : h.props, A = At(h.type);
+            if (A === "Bar") {
+              var g = (v.data || []).find(function(k) {
+                return Te(l, k);
+              });
+              if (g)
+                return {
+                  graphicalItem: s,
+                  payload: g
+                };
+            } else if (A === "RadialBar") {
+              var y = (v.data || []).find(function(k) {
+                return Jt(l, k);
+              });
+              if (y)
+                return {
+                  graphicalItem: s,
+                  payload: y
+                };
+            } else if (_e(s, e) || He(s, e) || Zt(s, e)) {
+              var b = Ye({
+                graphicalItem: s,
+                activeTooltipItem: e,
+                itemData: f.data
+              }), M = f.activeIndex === void 0 ? b : f.activeIndex;
+              return {
+                graphicalItem: i(i({}, s), {}, {
+                  childIndex: M
+                }),
+                payload: Zt(s, e) ? f.data[b] : s.props.data[b]
+              };
+            }
+          }
+        return null;
+      }
+    }, {
+      key: "render",
+      value: function() {
+        var l = this;
+        if (!Xt(this))
+          return null;
+        var p = this.props, t = p.children, e = p.className, r = p.width, d = p.height, s = p.style, v = p.compact, h = p.title, f = p.desc, A = ae(p, $e), g = Ft(A, !1);
+        if (v)
+          return /* @__PURE__ */ U.createElement(te, {
+            state: this.state,
+            width: this.props.width,
+            height: this.props.height,
+            clipPathId: this.clipPathId
+          }, /* @__PURE__ */ U.createElement(Yt, ot({}, g, {
+            width: r,
+            height: d,
+            title: h,
+            desc: f
+          }), this.renderClipPath(), $t(t, this.renderMap)));
+        if (this.props.accessibilityLayer) {
+          var y, b;
+          g.tabIndex = (y = this.props.tabIndex) !== null && y !== void 0 ? y : 0, g.role = (b = this.props.role) !== null && b !== void 0 ? b : "application", g.onKeyDown = function(k) {
+            l.accessibilityManager.keyboardEvent(k);
+          }, g.onFocus = function() {
+            l.accessibilityManager.focus();
+          };
+        }
+        var M = this.parseEventsOfWrapper();
+        return /* @__PURE__ */ U.createElement(te, {
+          state: this.state,
+          width: this.props.width,
+          height: this.props.height,
+          clipPathId: this.clipPathId
+        }, /* @__PURE__ */ U.createElement("div", ot({
+          className: _t("recharts-wrapper", e),
+          style: i({
+            position: "relative",
+            cursor: "default",
+            width: r,
+            height: d
+          }, s)
+        }, M, {
+          ref: function(P) {
+            l.container = P;
+          }
+        }), /* @__PURE__ */ U.createElement(Yt, ot({}, g, {
+          width: r,
+          height: d,
+          title: h,
+          desc: f,
+          style: pa
+        }), this.renderClipPath(), $t(t, this.renderMap)), this.renderLegend(), this.renderTooltip()));
+      }
+    }]);
+  })(ge);
+  T(W, "displayName", o), T(W, "defaultProps", i({
+    layout: "horizontal",
+    stackOffset: "none",
+    barCategoryGap: "10%",
+    barGap: 4,
+    margin: {
+      top: 5,
+      right: 5,
+      bottom: 5,
+      left: 5
+    },
+    reverseStackOrder: !1,
+    syncMethod: "index"
+  }, N)), T(W, "getDerivedStateFromProps", function(O, u) {
+    var x = O.dataKey, l = O.data, p = O.children, t = O.width, e = O.height, r = O.layout, d = O.stackOffset, s = O.margin, v = u.dataStartIndex, h = u.dataEndIndex;
+    if (u.updateId === void 0) {
+      var f = ne(O);
+      return i(i(i({}, f), {}, {
+        updateId: 0
+      }, R(i(i({
+        props: O
+      }, f), {}, {
+        updateId: 0
+      }), u)), {}, {
+        prevDataKey: x,
+        prevData: l,
+        prevWidth: t,
+        prevHeight: e,
+        prevLayout: r,
+        prevStackOffset: d,
+        prevMargin: s,
+        prevChildren: p
+      });
+    }
+    if (x !== u.prevDataKey || l !== u.prevData || t !== u.prevWidth || e !== u.prevHeight || r !== u.prevLayout || d !== u.prevStackOffset || !ze(s, u.prevMargin)) {
+      var A = ne(O), g = {
+        // (chartX, chartY) are (0,0) in default state, but we want to keep the last mouse position to avoid
+        // any flickering
+        chartX: u.chartX,
+        chartY: u.chartY,
+        // The tooltip should stay active when it was active in the previous render. If this is not
+        // the case, the tooltip disappears and immediately re-appears, causing a flickering effect
+        isTooltipActive: u.isTooltipActive
+      }, y = i(i({}, ie(u, l, r)), {}, {
+        updateId: u.updateId + 1
+      }), b = i(i(i({}, A), g), y);
+      return i(i(i({}, b), R(i({
+        props: O
+      }, b), u)), {}, {
+        prevDataKey: x,
+        prevData: l,
+        prevWidth: t,
+        prevHeight: e,
+        prevLayout: r,
+        prevStackOffset: d,
+        prevMargin: s,
+        prevChildren: p
+      });
+    }
+    if (!Ut(p, u.prevChildren)) {
+      var M, k, P, L, K = F(p, bt), I = K && (M = (k = K.props) === null || k === void 0 ? void 0 : k.startIndex) !== null && M !== void 0 ? M : v, D = K && (P = (L = K.props) === null || L === void 0 ? void 0 : L.endIndex) !== null && P !== void 0 ? P : h, z = I !== v || D !== h, H = !vt(l), V = H && !z ? u.updateId : u.updateId + 1;
+      return i(i({
+        updateId: V
+      }, R(i(i({
+        props: O
+      }, u), {}, {
+        updateId: V,
+        dataStartIndex: I,
+        dataEndIndex: D
+      }), u)), {}, {
+        prevChildren: p,
+        dataStartIndex: I,
+        dataEndIndex: D
+      });
+    }
+    return null;
+  }), T(W, "renderActiveDot", function(O, u, x) {
+    var l;
+    return /* @__PURE__ */ xe(O) ? l = /* @__PURE__ */ X(O, u) : $(O) ? l = O(u) : l = /* @__PURE__ */ U.createElement(Me, u), /* @__PURE__ */ U.createElement(Ae, {
+      className: "recharts-active-dot",
+      key: x
+    }, l);
+  });
+  var _ = /* @__PURE__ */ ye(function(u, x) {
+    return /* @__PURE__ */ U.createElement(W, ot({}, u, {
+      ref: x
+    }));
+  });
+  return _.displayName = W.displayName, _;
+};
+export {
+  ne as createDefaultState,
+  Qa as generateCategoricalChart,
+  va as getAxisMapByAxes
+};