qaema-ui 0.0.1

package/dist/node_modules/recharts/es6/cartesian/Line.js

@@ -0,0 +1,499 @@
+import y, { PureComponent as it } from "react";
+import at from "../../../react-smooth/es6/Animate.js";
+import ot from "../../../../_virtual/isFunction.js";
+import V from "../../../../_virtual/isNil.js";
+import st from "../../../../_virtual/isEqual.js";
+import { clsx as G } from "../../../clsx/dist/clsx.js";
+import { Curve as lt } from "../shape/Curve.js";
+import { Dot as ut } from "../shape/Dot.js";
+import { Layer as z } from "../container/Layer.js";
+import { LabelList as ct } from "../component/LabelList.js";
+import { ErrorBar as pt } from "./ErrorBar.js";
+import { interpolateNumber as N, uniqueId as ft } from "../util/DataUtils.js";
+import { findAllByType as mt, filterProps as W, hasClipDot as ht } from "../util/ReactUtils.js";
+import { Global as vt } from "../util/Global.js";
+import { getValueByDataKey as Q, getCateCoordinateOfLine as H } from "../util/ChartUtils.js";
+var yt = ["type", "layout", "connectNulls", "ref"], dt = ["key"];
+function j(t) {
+  "@babel/helpers - typeof";
+  return j = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, j(t);
+}
+function X(t, r) {
+  if (t == null) return {};
+  var n = gt(t, r), e, i;
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(t);
+    for (i = 0; i < o.length; i++)
+      e = o[i], !(r.indexOf(e) >= 0) && Object.prototype.propertyIsEnumerable.call(t, e) && (n[e] = t[e]);
+  }
+  return n;
+}
+function gt(t, r) {
+  if (t == null) return {};
+  var n = {};
+  for (var e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e)) {
+      if (r.indexOf(e) >= 0) continue;
+      n[e] = t[e];
+    }
+  return n;
+}
+function B() {
+  return B = Object.assign ? Object.assign.bind() : function(t) {
+    for (var r = 1; r < arguments.length; r++) {
+      var n = arguments[r];
+      for (var e in n)
+        Object.prototype.hasOwnProperty.call(n, e) && (t[e] = n[e]);
+    }
+    return t;
+  }, B.apply(this, arguments);
+}
+function Y(t, r) {
+  var n = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var e = Object.getOwnPropertySymbols(t);
+    r && (e = e.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(t, i).enumerable;
+    })), n.push.apply(n, e);
+  }
+  return n;
+}
+function g(t) {
+  for (var r = 1; r < arguments.length; r++) {
+    var n = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? Y(Object(n), !0).forEach(function(e) {
+      A(t, e, n[e]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : Y(Object(n)).forEach(function(e) {
+      Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(n, e));
+    });
+  }
+  return t;
+}
+function _(t) {
+  return xt(t) || Pt(t) || At(t) || bt();
+}
+function bt() {
+  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 At(t, r) {
+  if (t) {
+    if (typeof t == "string") return M(t, r);
+    var n = Object.prototype.toString.call(t).slice(8, -1);
+    if (n === "Object" && t.constructor && (n = t.constructor.name), n === "Map" || n === "Set") return Array.from(t);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return M(t, r);
+  }
+}
+function Pt(t) {
+  if (typeof Symbol < "u" && t[Symbol.iterator] != null || t["@@iterator"] != null) return Array.from(t);
+}
+function xt(t) {
+  if (Array.isArray(t)) return M(t);
+}
+function M(t, r) {
+  (r == null || r > t.length) && (r = t.length);
+  for (var n = 0, e = new Array(r); n < r; n++) e[n] = t[n];
+  return e;
+}
+function Ot(t, r) {
+  if (!(t instanceof r))
+    throw new TypeError("Cannot call a class as a function");
+}
+function J(t, r) {
+  for (var n = 0; n < r.length; n++) {
+    var e = r[n];
+    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(t, tt(e.key), e);
+  }
+}
+function St(t, r, n) {
+  return r && J(t.prototype, r), n && J(t, n), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+}
+function wt(t, r, n) {
+  return r = R(r), Dt(t, Z() ? Reflect.construct(r, n || [], R(t).constructor) : r.apply(t, n));
+}
+function Dt(t, r) {
+  if (r && (j(r) === "object" || typeof r == "function"))
+    return r;
+  if (r !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return _t(t);
+}
+function _t(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function Z() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (Z = function() {
+    return !!t;
+  })();
+}
+function R(t) {
+  return R = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(n) {
+    return n.__proto__ || Object.getPrototypeOf(n);
+  }, R(t);
+}
+function jt(t, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(r && r.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), r && U(t, r);
+}
+function U(t, r) {
+  return U = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, i) {
+    return e.__proto__ = i, e;
+  }, U(t, r);
+}
+function A(t, r, n) {
+  return r = tt(r), r in t ? Object.defineProperty(t, r, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : t[r] = n, t;
+}
+function tt(t) {
+  var r = Et(t, "string");
+  return j(r) == "symbol" ? r : r + "";
+}
+function Et(t, r) {
+  if (j(t) != "object" || !t) return t;
+  var n = t[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var e = n.call(t, r);
+    if (j(e) != "object") return e;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var q = /* @__PURE__ */ (function(t) {
+  function r() {
+    var n;
+    Ot(this, r);
+    for (var e = arguments.length, i = new Array(e), o = 0; o < e; o++)
+      i[o] = arguments[o];
+    return n = wt(this, r, [].concat(i)), A(n, "state", {
+      isAnimationFinished: !0,
+      totalLength: 0
+    }), A(n, "generateSimpleStrokeDasharray", function(a, s) {
+      return "".concat(s, "px ").concat(a - s, "px");
+    }), A(n, "getStrokeDasharray", function(a, s, l) {
+      var c = l.reduce(function(P, O) {
+        return P + O;
+      });
+      if (!c)
+        return n.generateSimpleStrokeDasharray(s, a);
+      for (var f = Math.floor(a / c), m = a % c, p = s - a, h = [], u = 0, v = 0; u < l.length; v += l[u], ++u)
+        if (v + l[u] > m) {
+          h = [].concat(_(l.slice(0, u)), [m - v]);
+          break;
+        }
+      var b = h.length % 2 === 0 ? [0, p] : [p];
+      return [].concat(_(r.repeat(l, f)), _(h), b).map(function(P) {
+        return "".concat(P, "px");
+      }).join(", ");
+    }), A(n, "id", ft("recharts-line-")), A(n, "pathRef", function(a) {
+      n.mainCurve = a;
+    }), A(n, "handleAnimationEnd", function() {
+      n.setState({
+        isAnimationFinished: !0
+      }), n.props.onAnimationEnd && n.props.onAnimationEnd();
+    }), A(n, "handleAnimationStart", function() {
+      n.setState({
+        isAnimationFinished: !1
+      }), n.props.onAnimationStart && n.props.onAnimationStart();
+    }), n;
+  }
+  return jt(r, t), St(r, [{
+    key: "componentDidMount",
+    value: function() {
+      if (this.props.isAnimationActive) {
+        var e = this.getTotalLength();
+        this.setState({
+          totalLength: e
+        });
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function() {
+      if (this.props.isAnimationActive) {
+        var e = this.getTotalLength();
+        e !== this.state.totalLength && this.setState({
+          totalLength: e
+        });
+      }
+    }
+  }, {
+    key: "getTotalLength",
+    value: function() {
+      var e = this.mainCurve;
+      try {
+        return e && e.getTotalLength && e.getTotalLength() || 0;
+      } catch {
+        return 0;
+      }
+    }
+  }, {
+    key: "renderErrorBar",
+    value: function(e, i) {
+      if (this.props.isAnimationActive && !this.state.isAnimationFinished)
+        return null;
+      var o = this.props, a = o.points, s = o.xAxis, l = o.yAxis, c = o.layout, f = o.children, m = mt(f, pt);
+      if (!m)
+        return null;
+      var p = function(v, b) {
+        return {
+          x: v.x,
+          y: v.y,
+          value: v.value,
+          errorVal: Q(v.payload, b)
+        };
+      }, h = {
+        clipPath: e ? "url(#clipPath-".concat(i, ")") : null
+      };
+      return /* @__PURE__ */ y.createElement(z, h, m.map(function(u) {
+        return /* @__PURE__ */ y.cloneElement(u, {
+          key: "bar-".concat(u.props.dataKey),
+          data: a,
+          xAxis: s,
+          yAxis: l,
+          layout: c,
+          dataPointFormatter: p
+        });
+      }));
+    }
+  }, {
+    key: "renderDots",
+    value: function(e, i, o) {
+      var a = this.props.isAnimationActive;
+      if (a && !this.state.isAnimationFinished)
+        return null;
+      var s = this.props, l = s.dot, c = s.points, f = s.dataKey, m = W(this.props, !1), p = W(l, !0), h = c.map(function(v, b) {
+        var P = g(g(g({
+          key: "dot-".concat(b),
+          r: 3
+        }, m), p), {}, {
+          index: b,
+          cx: v.x,
+          cy: v.y,
+          value: v.value,
+          dataKey: f,
+          payload: v.payload,
+          points: c
+        });
+        return r.renderDotItem(l, P);
+      }), u = {
+        clipPath: e ? "url(#clipPath-".concat(i ? "" : "dots-").concat(o, ")") : null
+      };
+      return /* @__PURE__ */ y.createElement(z, B({
+        className: "recharts-line-dots",
+        key: "dots"
+      }, u), h);
+    }
+  }, {
+    key: "renderCurveStatically",
+    value: function(e, i, o, a) {
+      var s = this.props, l = s.type, c = s.layout, f = s.connectNulls;
+      s.ref;
+      var m = X(s, yt), p = g(g(g({}, W(m, !0)), {}, {
+        fill: "none",
+        className: "recharts-line-curve",
+        clipPath: i ? "url(#clipPath-".concat(o, ")") : null,
+        points: e
+      }, a), {}, {
+        type: l,
+        layout: c,
+        connectNulls: f
+      });
+      return /* @__PURE__ */ y.createElement(lt, B({}, p, {
+        pathRef: this.pathRef
+      }));
+    }
+  }, {
+    key: "renderCurveWithAnimation",
+    value: function(e, i) {
+      var o = this, a = this.props, s = a.points, l = a.strokeDasharray, c = a.isAnimationActive, f = a.animationBegin, m = a.animationDuration, p = a.animationEasing, h = a.animationId, u = a.animateNewValues, v = a.width, b = a.height, P = this.state, O = P.prevPoints, E = P.totalLength;
+      return /* @__PURE__ */ y.createElement(at, {
+        begin: f,
+        duration: m,
+        isActive: c,
+        easing: p,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "line-".concat(h),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function(w) {
+        var x = w.t;
+        if (O) {
+          var k = O.length / s.length, S = s.map(function(d, K) {
+            var T = Math.floor(K * k);
+            if (O[T]) {
+              var C = O[T], D = N(C.x, d.x), et = N(C.y, d.y);
+              return g(g({}, d), {}, {
+                x: D(x),
+                y: et(x)
+              });
+            }
+            if (u) {
+              var rt = N(v * 2, d.x), nt = N(b / 2, d.y);
+              return g(g({}, d), {}, {
+                x: rt(x),
+                y: nt(x)
+              });
+            }
+            return g(g({}, d), {}, {
+              x: d.x,
+              y: d.y
+            });
+          });
+          return o.renderCurveStatically(S, e, i);
+        }
+        var F = N(0, E), L = F(x), I;
+        if (l) {
+          var $ = "".concat(l).split(/[,\s]+/gim).map(function(d) {
+            return parseFloat(d);
+          });
+          I = o.getStrokeDasharray(L, E, $);
+        } else
+          I = o.generateSimpleStrokeDasharray(E, L);
+        return o.renderCurveStatically(s, e, i, {
+          strokeDasharray: I
+        });
+      });
+    }
+  }, {
+    key: "renderCurve",
+    value: function(e, i) {
+      var o = this.props, a = o.points, s = o.isAnimationActive, l = this.state, c = l.prevPoints, f = l.totalLength;
+      return s && a && a.length && (!c && f > 0 || !st(c, a)) ? this.renderCurveWithAnimation(e, i) : this.renderCurveStatically(a, e, i);
+    }
+  }, {
+    key: "render",
+    value: function() {
+      var e, i = this.props, o = i.hide, a = i.dot, s = i.points, l = i.className, c = i.xAxis, f = i.yAxis, m = i.top, p = i.left, h = i.width, u = i.height, v = i.isAnimationActive, b = i.id;
+      if (o || !s || !s.length)
+        return null;
+      var P = this.state.isAnimationFinished, O = s.length === 1, E = G("recharts-line", l), w = c && c.allowDataOverflow, x = f && f.allowDataOverflow, k = w || x, S = V(b) ? this.id : b, F = (e = W(a, !1)) !== null && e !== void 0 ? e : {
+        r: 3,
+        strokeWidth: 2
+      }, L = F.r, I = L === void 0 ? 3 : L, $ = F.strokeWidth, d = $ === void 0 ? 2 : $, K = ht(a) ? a : {}, T = K.clipDot, C = T === void 0 ? !0 : T, D = I * 2 + d;
+      return /* @__PURE__ */ y.createElement(z, {
+        className: E
+      }, w || x ? /* @__PURE__ */ y.createElement("defs", null, /* @__PURE__ */ y.createElement("clipPath", {
+        id: "clipPath-".concat(S)
+      }, /* @__PURE__ */ y.createElement("rect", {
+        x: w ? p : p - h / 2,
+        y: x ? m : m - u / 2,
+        width: w ? h : h * 2,
+        height: x ? u : u * 2
+      })), !C && /* @__PURE__ */ y.createElement("clipPath", {
+        id: "clipPath-dots-".concat(S)
+      }, /* @__PURE__ */ y.createElement("rect", {
+        x: p - D / 2,
+        y: m - D / 2,
+        width: h + D,
+        height: u + D
+      }))) : null, !O && this.renderCurve(k, S), this.renderErrorBar(k, S), (O || a) && this.renderDots(k, C, S), (!v || P) && ct.renderCallByParent(this.props, s));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function(e, i) {
+      return e.animationId !== i.prevAnimationId ? {
+        prevAnimationId: e.animationId,
+        curPoints: e.points,
+        prevPoints: i.curPoints
+      } : e.points !== i.curPoints ? {
+        curPoints: e.points
+      } : null;
+    }
+  }, {
+    key: "repeat",
+    value: function(e, i) {
+      for (var o = e.length % 2 !== 0 ? [].concat(_(e), [0]) : e, a = [], s = 0; s < i; ++s)
+        a = [].concat(_(a), _(o));
+      return a;
+    }
+  }, {
+    key: "renderDotItem",
+    value: function(e, i) {
+      var o;
+      if (/* @__PURE__ */ y.isValidElement(e))
+        o = /* @__PURE__ */ y.cloneElement(e, i);
+      else if (ot(e))
+        o = e(i);
+      else {
+        var a = i.key, s = X(i, dt), l = G("recharts-line-dot", typeof e != "boolean" ? e.className : "");
+        o = /* @__PURE__ */ y.createElement(ut, B({
+          key: a
+        }, s, {
+          className: l
+        }));
+      }
+      return o;
+    }
+  }]);
+})(it);
+A(q, "displayName", "Line");
+A(q, "defaultProps", {
+  xAxisId: 0,
+  yAxisId: 0,
+  connectNulls: !1,
+  activeDot: !0,
+  dot: !0,
+  legendType: "line",
+  stroke: "#3182bd",
+  strokeWidth: 1,
+  fill: "#fff",
+  points: [],
+  isAnimationActive: !vt.isSsr,
+  animateNewValues: !0,
+  animationBegin: 0,
+  animationDuration: 1500,
+  animationEasing: "ease",
+  hide: !1,
+  label: !1
+});
+A(q, "getComposedData", function(t) {
+  var r = t.props, n = t.xAxis, e = t.yAxis, i = t.xAxisTicks, o = t.yAxisTicks, a = t.dataKey, s = t.bandSize, l = t.displayedData, c = t.offset, f = r.layout, m = l.map(function(p, h) {
+    var u = Q(p, a);
+    return f === "horizontal" ? {
+      x: H({
+        axis: n,
+        ticks: i,
+        bandSize: s,
+        entry: p,
+        index: h
+      }),
+      y: V(u) ? null : e.scale(u),
+      value: u,
+      payload: p
+    } : {
+      x: V(u) ? null : n.scale(u),
+      y: H({
+        axis: e,
+        ticks: o,
+        bandSize: s,
+        entry: p,
+        index: h
+      }),
+      value: u,
+      payload: p
+    };
+  });
+  return g({
+    points: m,
+    layout: f
+  }, c);
+});
+export {
+  q as Line
+};

package/dist/node_modules/recharts/es6/cartesian/ReferenceArea.js

@@ -0,0 +1,187 @@
+import s from "react";
+import I from "../../../../_virtual/isFunction.js";
+import { clsx as D } from "../../../clsx/dist/clsx.js";
+import { Layer as T } from "../container/Layer.js";
+import { Label as M } from "../component/Label.js";
+import { createLabeledScales as V, rectWithPoints as B } from "../util/CartesianUtils.js";
+import { ifOverflowMatches as S } from "../util/IfOverflowMatches.js";
+import { isNumOrStr as y } from "../util/DataUtils.js";
+import { warn as L } from "../util/LogUtils.js";
+import { Rectangle as F } from "../shape/Rectangle.js";
+import { filterProps as K } from "../util/ReactUtils.js";
+function w() {
+  return w = Object.assign ? Object.assign.bind() : function(t) {
+    for (var e = 1; e < arguments.length; e++) {
+      var r = arguments[e];
+      for (var n in r)
+        Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]);
+    }
+    return t;
+  }, w.apply(this, arguments);
+}
+function c(t) {
+  "@babel/helpers - typeof";
+  return c = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+    return typeof e;
+  } : function(e) {
+    return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+  }, c(t);
+}
+function j(t, e) {
+  var r = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(t);
+    e && (n = n.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(t, a).enumerable;
+    })), r.push.apply(r, n);
+  }
+  return r;
+}
+function R(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? j(Object(r), !0).forEach(function(n) {
+      b(t, n, r[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : j(Object(r)).forEach(function(n) {
+      Object.defineProperty(t, n, Object.getOwnPropertyDescriptor(r, n));
+    });
+  }
+  return t;
+}
+function W(t, e) {
+  if (!(t instanceof e))
+    throw new TypeError("Cannot call a class as a function");
+}
+function X(t, e) {
+  for (var r = 0; r < e.length; r++) {
+    var n = e[r];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(t, A(n.key), n);
+  }
+}
+function Y(t, e, r) {
+  return e && X(t.prototype, e), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+}
+function z(t, e, r) {
+  return e = m(e), $(t, E() ? Reflect.construct(e, r || [], m(t).constructor) : e.apply(t, r));
+}
+function $(t, e) {
+  if (e && (c(e) === "object" || typeof e == "function"))
+    return e;
+  if (e !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return k(t);
+}
+function k(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function E() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (E = function() {
+    return !!t;
+  })();
+}
+function m(t) {
+  return m = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r) {
+    return r.__proto__ || Object.getPrototypeOf(r);
+  }, m(t);
+}
+function q(t, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && x(t, e);
+}
+function x(t, e) {
+  return x = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, a) {
+    return n.__proto__ = a, n;
+  }, x(t, e);
+}
+function b(t, e, r) {
+  return e = A(e), e in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+}
+function A(t) {
+  var e = G(t, "string");
+  return c(e) == "symbol" ? e : e + "";
+}
+function G(t, e) {
+  if (c(t) != "object" || !t) return t;
+  var r = t[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var n = r.call(t, e);
+    if (c(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var H = function(e, r, n, a, i) {
+  var h = i.x1, d = i.x2, v = i.y1, O = i.y2, p = i.xAxis, f = i.yAxis;
+  if (!p || !f) return null;
+  var o = V({
+    x: p.scale,
+    y: f.scale
+  }), u = {
+    x: e ? o.x.apply(h, {
+      position: "start"
+    }) : o.x.rangeMin,
+    y: n ? o.y.apply(v, {
+      position: "start"
+    }) : o.y.rangeMin
+  }, l = {
+    x: r ? o.x.apply(d, {
+      position: "end"
+    }) : o.x.rangeMax,
+    y: a ? o.y.apply(O, {
+      position: "end"
+    }) : o.y.rangeMax
+  };
+  return S(i, "discard") && (!o.isInRange(u) || !o.isInRange(l)) ? null : B(u, l);
+}, _ = /* @__PURE__ */ (function(t) {
+  function e() {
+    return W(this, e), z(this, e, arguments);
+  }
+  return q(e, t), Y(e, [{
+    key: "render",
+    value: function() {
+      var n = this.props, a = n.x1, i = n.x2, h = n.y1, d = n.y2, v = n.className, O = n.alwaysShow, p = n.clipPathId;
+      L(O === void 0, 'The alwaysShow prop is deprecated. Please use ifOverflow="extendDomain" instead.');
+      var f = y(a), o = y(i), u = y(h), l = y(d), P = this.props.shape;
+      if (!f && !o && !u && !l && !P)
+        return null;
+      var g = H(f, o, u, l, this.props);
+      if (!g && !P)
+        return null;
+      var N = S(this.props, "hidden") ? "url(#".concat(p, ")") : void 0;
+      return /* @__PURE__ */ s.createElement(T, {
+        className: D("recharts-reference-area", v)
+      }, e.renderRect(P, R(R({
+        clipPath: N
+      }, K(this.props, !0)), g)), M.renderCallByParent(this.props, g));
+    }
+  }]);
+})(s.Component);
+b(_, "displayName", "ReferenceArea");
+b(_, "defaultProps", {
+  isFront: !1,
+  ifOverflow: "discard",
+  xAxisId: 0,
+  yAxisId: 0,
+  r: 10,
+  fill: "#ccc",
+  fillOpacity: 0.5,
+  stroke: "none",
+  strokeWidth: 1
+});
+b(_, "renderRect", function(t, e) {
+  var r;
+  return /* @__PURE__ */ s.isValidElement(t) ? r = /* @__PURE__ */ s.cloneElement(t, e) : I(t) ? r = t(e) : r = /* @__PURE__ */ s.createElement(F, w({}, e, {
+    className: "recharts-reference-area-rect"
+  })), r;
+});
+export {
+  _ as ReferenceArea
+};