main repo

node_modules/recharts/es6/cartesian/Area.js

@@ -0,0 +1,540 @@
+var _excluded = ["layout", "type", "stroke", "connectNulls", "isRange", "ref"];
+var _Area;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Area
+ */
+import React, { PureComponent } from 'react';
+import clsx from 'clsx';
+import Animate from 'react-smooth';
+import isFunction from 'lodash/isFunction';
+import max from 'lodash/max';
+import isNil from 'lodash/isNil';
+import isNan from 'lodash/isNaN';
+import isEqual from 'lodash/isEqual';
+import { Curve } from '../shape/Curve';
+import { Dot } from '../shape/Dot';
+import { Layer } from '../container/Layer';
+import { LabelList } from '../component/LabelList';
+import { Global } from '../util/Global';
+import { isNumber, uniqueId, interpolateNumber } from '../util/DataUtils';
+import { getCateCoordinateOfLine, getValueByDataKey } from '../util/ChartUtils';
+import { filterProps, isDotProps } from '../util/ReactUtils';
+export var Area = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Area, _PureComponent);
+  function Area() {
+    var _this;
+    _classCallCheck(this, Area);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, Area, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      isAnimationFinished: true
+    });
+    _defineProperty(_assertThisInitialized(_this), "id", uniqueId('recharts-area-'));
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationEnd", function () {
+      var onAnimationEnd = _this.props.onAnimationEnd;
+      _this.setState({
+        isAnimationFinished: true
+      });
+      if (isFunction(onAnimationEnd)) {
+        onAnimationEnd();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationStart", function () {
+      var onAnimationStart = _this.props.onAnimationStart;
+      _this.setState({
+        isAnimationFinished: false
+      });
+      if (isFunction(onAnimationStart)) {
+        onAnimationStart();
+      }
+    });
+    return _this;
+  }
+  _createClass(Area, [{
+    key: "renderDots",
+    value: function renderDots(needClip, clipDot, clipPathId) {
+      var isAnimationActive = this.props.isAnimationActive;
+      var isAnimationFinished = this.state.isAnimationFinished;
+      if (isAnimationActive && !isAnimationFinished) {
+        return null;
+      }
+      var _this$props = this.props,
+        dot = _this$props.dot,
+        points = _this$props.points,
+        dataKey = _this$props.dataKey;
+      var areaProps = filterProps(this.props, false);
+      var customDotProps = filterProps(dot, true);
+      var dots = points.map(function (entry, i) {
+        var dotProps = _objectSpread(_objectSpread(_objectSpread({
+          key: "dot-".concat(i),
+          r: 3
+        }, areaProps), customDotProps), {}, {
+          index: i,
+          cx: entry.x,
+          cy: entry.y,
+          dataKey: dataKey,
+          value: entry.value,
+          payload: entry.payload,
+          points: points
+        });
+        return Area.renderDotItem(dot, dotProps);
+      });
+      var dotsProps = {
+        clipPath: needClip ? "url(#clipPath-".concat(clipDot ? '' : 'dots-').concat(clipPathId, ")") : null
+      };
+      return /*#__PURE__*/React.createElement(Layer, _extends({
+        className: "recharts-area-dots"
+      }, dotsProps), dots);
+    }
+  }, {
+    key: "renderHorizontalRect",
+    value: function renderHorizontalRect(alpha) {
+      var _this$props2 = this.props,
+        baseLine = _this$props2.baseLine,
+        points = _this$props2.points,
+        strokeWidth = _this$props2.strokeWidth;
+      var startX = points[0].x;
+      var endX = points[points.length - 1].x;
+      var width = alpha * Math.abs(startX - endX);
+      var maxY = max(points.map(function (entry) {
+        return entry.y || 0;
+      }));
+      if (isNumber(baseLine) && typeof baseLine === 'number') {
+        maxY = Math.max(baseLine, maxY);
+      } else if (baseLine && Array.isArray(baseLine) && baseLine.length) {
+        maxY = Math.max(max(baseLine.map(function (entry) {
+          return entry.y || 0;
+        })), maxY);
+      }
+      if (isNumber(maxY)) {
+        return /*#__PURE__*/React.createElement("rect", {
+          x: startX < endX ? startX : startX - width,
+          y: 0,
+          width: width,
+          height: Math.floor(maxY + (strokeWidth ? parseInt("".concat(strokeWidth), 10) : 1))
+        });
+      }
+      return null;
+    }
+  }, {
+    key: "renderVerticalRect",
+    value: function renderVerticalRect(alpha) {
+      var _this$props3 = this.props,
+        baseLine = _this$props3.baseLine,
+        points = _this$props3.points,
+        strokeWidth = _this$props3.strokeWidth;
+      var startY = points[0].y;
+      var endY = points[points.length - 1].y;
+      var height = alpha * Math.abs(startY - endY);
+      var maxX = max(points.map(function (entry) {
+        return entry.x || 0;
+      }));
+      if (isNumber(baseLine) && typeof baseLine === 'number') {
+        maxX = Math.max(baseLine, maxX);
+      } else if (baseLine && Array.isArray(baseLine) && baseLine.length) {
+        maxX = Math.max(max(baseLine.map(function (entry) {
+          return entry.x || 0;
+        })), maxX);
+      }
+      if (isNumber(maxX)) {
+        return /*#__PURE__*/React.createElement("rect", {
+          x: 0,
+          y: startY < endY ? startY : startY - height,
+          width: maxX + (strokeWidth ? parseInt("".concat(strokeWidth), 10) : 1),
+          height: Math.floor(height)
+        });
+      }
+      return null;
+    }
+  }, {
+    key: "renderClipRect",
+    value: function renderClipRect(alpha) {
+      var layout = this.props.layout;
+      if (layout === 'vertical') {
+        return this.renderVerticalRect(alpha);
+      }
+      return this.renderHorizontalRect(alpha);
+    }
+  }, {
+    key: "renderAreaStatically",
+    value: function renderAreaStatically(points, baseLine, needClip, clipPathId) {
+      var _this$props4 = this.props,
+        layout = _this$props4.layout,
+        type = _this$props4.type,
+        stroke = _this$props4.stroke,
+        connectNulls = _this$props4.connectNulls,
+        isRange = _this$props4.isRange,
+        ref = _this$props4.ref,
+        others = _objectWithoutProperties(_this$props4, _excluded);
+      return /*#__PURE__*/React.createElement(Layer, {
+        clipPath: needClip ? "url(#clipPath-".concat(clipPathId, ")") : null
+      }, /*#__PURE__*/React.createElement(Curve, _extends({}, filterProps(others, true), {
+        points: points,
+        connectNulls: connectNulls,
+        type: type,
+        baseLine: baseLine,
+        layout: layout,
+        stroke: "none",
+        className: "recharts-area-area"
+      })), stroke !== 'none' && /*#__PURE__*/React.createElement(Curve, _extends({}, filterProps(this.props, false), {
+        className: "recharts-area-curve",
+        layout: layout,
+        type: type,
+        connectNulls: connectNulls,
+        fill: "none",
+        points: points
+      })), stroke !== 'none' && isRange && /*#__PURE__*/React.createElement(Curve, _extends({}, filterProps(this.props, false), {
+        className: "recharts-area-curve",
+        layout: layout,
+        type: type,
+        connectNulls: connectNulls,
+        fill: "none",
+        points: baseLine
+      })));
+    }
+  }, {
+    key: "renderAreaWithAnimation",
+    value: function renderAreaWithAnimation(needClip, clipPathId) {
+      var _this2 = this;
+      var _this$props5 = this.props,
+        points = _this$props5.points,
+        baseLine = _this$props5.baseLine,
+        isAnimationActive = _this$props5.isAnimationActive,
+        animationBegin = _this$props5.animationBegin,
+        animationDuration = _this$props5.animationDuration,
+        animationEasing = _this$props5.animationEasing,
+        animationId = _this$props5.animationId;
+      var _this$state = this.state,
+        prevPoints = _this$state.prevPoints,
+        prevBaseLine = _this$state.prevBaseLine;
+      // const clipPathId = isNil(id) ? this.id : id;
+
+      return /*#__PURE__*/React.createElement(Animate, {
+        begin: animationBegin,
+        duration: animationDuration,
+        isActive: isAnimationActive,
+        easing: animationEasing,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "area-".concat(animationId),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function (_ref) {
+        var t = _ref.t;
+        if (prevPoints) {
+          var prevPointsDiffFactor = prevPoints.length / points.length;
+          // update animtaion
+          var stepPoints = points.map(function (entry, index) {
+            var prevPointIndex = Math.floor(index * prevPointsDiffFactor);
+            if (prevPoints[prevPointIndex]) {
+              var prev = prevPoints[prevPointIndex];
+              var interpolatorX = interpolateNumber(prev.x, entry.x);
+              var interpolatorY = interpolateNumber(prev.y, entry.y);
+              return _objectSpread(_objectSpread({}, entry), {}, {
+                x: interpolatorX(t),
+                y: interpolatorY(t)
+              });
+            }
+            return entry;
+          });
+          var stepBaseLine;
+          if (isNumber(baseLine) && typeof baseLine === 'number') {
+            var interpolator = interpolateNumber(prevBaseLine, baseLine);
+            stepBaseLine = interpolator(t);
+          } else if (isNil(baseLine) || isNan(baseLine)) {
+            var _interpolator = interpolateNumber(prevBaseLine, 0);
+            stepBaseLine = _interpolator(t);
+          } else {
+            stepBaseLine = baseLine.map(function (entry, index) {
+              var prevPointIndex = Math.floor(index * prevPointsDiffFactor);
+              if (prevBaseLine[prevPointIndex]) {
+                var prev = prevBaseLine[prevPointIndex];
+                var interpolatorX = interpolateNumber(prev.x, entry.x);
+                var interpolatorY = interpolateNumber(prev.y, entry.y);
+                return _objectSpread(_objectSpread({}, entry), {}, {
+                  x: interpolatorX(t),
+                  y: interpolatorY(t)
+                });
+              }
+              return entry;
+            });
+          }
+          return _this2.renderAreaStatically(stepPoints, stepBaseLine, needClip, clipPathId);
+        }
+        return /*#__PURE__*/React.createElement(Layer, null, /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("clipPath", {
+          id: "animationClipPath-".concat(clipPathId)
+        }, _this2.renderClipRect(t))), /*#__PURE__*/React.createElement(Layer, {
+          clipPath: "url(#animationClipPath-".concat(clipPathId, ")")
+        }, _this2.renderAreaStatically(points, baseLine, needClip, clipPathId)));
+      });
+    }
+  }, {
+    key: "renderArea",
+    value: function renderArea(needClip, clipPathId) {
+      var _this$props6 = this.props,
+        points = _this$props6.points,
+        baseLine = _this$props6.baseLine,
+        isAnimationActive = _this$props6.isAnimationActive;
+      var _this$state2 = this.state,
+        prevPoints = _this$state2.prevPoints,
+        prevBaseLine = _this$state2.prevBaseLine,
+        totalLength = _this$state2.totalLength;
+      if (isAnimationActive && points && points.length && (!prevPoints && totalLength > 0 || !isEqual(prevPoints, points) || !isEqual(prevBaseLine, baseLine))) {
+        return this.renderAreaWithAnimation(needClip, clipPathId);
+      }
+      return this.renderAreaStatically(points, baseLine, needClip, clipPathId);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _filterProps;
+      var _this$props7 = this.props,
+        hide = _this$props7.hide,
+        dot = _this$props7.dot,
+        points = _this$props7.points,
+        className = _this$props7.className,
+        top = _this$props7.top,
+        left = _this$props7.left,
+        xAxis = _this$props7.xAxis,
+        yAxis = _this$props7.yAxis,
+        width = _this$props7.width,
+        height = _this$props7.height,
+        isAnimationActive = _this$props7.isAnimationActive,
+        id = _this$props7.id;
+      if (hide || !points || !points.length) {
+        return null;
+      }
+      var isAnimationFinished = this.state.isAnimationFinished;
+      var hasSinglePoint = points.length === 1;
+      var layerClass = clsx('recharts-area', className);
+      var needClipX = xAxis && xAxis.allowDataOverflow;
+      var needClipY = yAxis && yAxis.allowDataOverflow;
+      var needClip = needClipX || needClipY;
+      var clipPathId = isNil(id) ? this.id : id;
+      var _ref2 = (_filterProps = filterProps(dot, false)) !== null && _filterProps !== void 0 ? _filterProps : {
+          r: 3,
+          strokeWidth: 2
+        },
+        _ref2$r = _ref2.r,
+        r = _ref2$r === void 0 ? 3 : _ref2$r,
+        _ref2$strokeWidth = _ref2.strokeWidth,
+        strokeWidth = _ref2$strokeWidth === void 0 ? 2 : _ref2$strokeWidth;
+      var _ref3 = isDotProps(dot) ? dot : {},
+        _ref3$clipDot = _ref3.clipDot,
+        clipDot = _ref3$clipDot === void 0 ? true : _ref3$clipDot;
+      var dotSize = r * 2 + strokeWidth;
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: layerClass
+      }, needClipX || needClipY ? /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("clipPath", {
+        id: "clipPath-".concat(clipPathId)
+      }, /*#__PURE__*/React.createElement("rect", {
+        x: needClipX ? left : left - width / 2,
+        y: needClipY ? top : top - height / 2,
+        width: needClipX ? width : width * 2,
+        height: needClipY ? height : height * 2
+      })), !clipDot && /*#__PURE__*/React.createElement("clipPath", {
+        id: "clipPath-dots-".concat(clipPathId)
+      }, /*#__PURE__*/React.createElement("rect", {
+        x: left - dotSize / 2,
+        y: top - dotSize / 2,
+        width: width + dotSize,
+        height: height + dotSize
+      }))) : null, !hasSinglePoint ? this.renderArea(needClip, clipPathId) : null, (dot || hasSinglePoint) && this.renderDots(needClip, clipDot, clipPathId), (!isAnimationActive || isAnimationFinished) && LabelList.renderCallByParent(this.props, points));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      if (nextProps.animationId !== prevState.prevAnimationId) {
+        return {
+          prevAnimationId: nextProps.animationId,
+          curPoints: nextProps.points,
+          curBaseLine: nextProps.baseLine,
+          prevPoints: prevState.curPoints,
+          prevBaseLine: prevState.curBaseLine
+        };
+      }
+      if (nextProps.points !== prevState.curPoints || nextProps.baseLine !== prevState.curBaseLine) {
+        return {
+          curPoints: nextProps.points,
+          curBaseLine: nextProps.baseLine
+        };
+      }
+      return null;
+    }
+  }]);
+  return Area;
+}(PureComponent);
+_Area = Area;
+_defineProperty(Area, "displayName", 'Area');
+_defineProperty(Area, "defaultProps", {
+  stroke: '#3182bd',
+  fill: '#3182bd',
+  fillOpacity: 0.6,
+  xAxisId: 0,
+  yAxisId: 0,
+  legendType: 'line',
+  connectNulls: false,
+  // points of area
+  points: [],
+  dot: false,
+  activeDot: true,
+  hide: false,
+  isAnimationActive: !Global.isSsr,
+  animationBegin: 0,
+  animationDuration: 1500,
+  animationEasing: 'ease'
+});
+_defineProperty(Area, "getBaseValue", function (props, item, xAxis, yAxis) {
+  var layout = props.layout,
+    chartBaseValue = props.baseValue;
+  var itemBaseValue = item.props.baseValue;
+
+  // The baseValue can be defined both on the AreaChart as well as on the Area.
+  // The value for the item takes precedence.
+  var baseValue = itemBaseValue !== null && itemBaseValue !== void 0 ? itemBaseValue : chartBaseValue;
+  if (isNumber(baseValue) && typeof baseValue === 'number') {
+    return baseValue;
+  }
+  var numericAxis = layout === 'horizontal' ? yAxis : xAxis;
+  var domain = numericAxis.scale.domain();
+  if (numericAxis.type === 'number') {
+    var domainMax = Math.max(domain[0], domain[1]);
+    var domainMin = Math.min(domain[0], domain[1]);
+    if (baseValue === 'dataMin') {
+      return domainMin;
+    }
+    if (baseValue === 'dataMax') {
+      return domainMax;
+    }
+    return domainMax < 0 ? domainMax : Math.max(Math.min(domain[0], domain[1]), 0);
+  }
+  if (baseValue === 'dataMin') {
+    return domain[0];
+  }
+  if (baseValue === 'dataMax') {
+    return domain[1];
+  }
+  return domain[0];
+});
+_defineProperty(Area, "getComposedData", function (_ref4) {
+  var props = _ref4.props,
+    item = _ref4.item,
+    xAxis = _ref4.xAxis,
+    yAxis = _ref4.yAxis,
+    xAxisTicks = _ref4.xAxisTicks,
+    yAxisTicks = _ref4.yAxisTicks,
+    bandSize = _ref4.bandSize,
+    dataKey = _ref4.dataKey,
+    stackedData = _ref4.stackedData,
+    dataStartIndex = _ref4.dataStartIndex,
+    displayedData = _ref4.displayedData,
+    offset = _ref4.offset;
+  var layout = props.layout;
+  var hasStack = stackedData && stackedData.length;
+  var baseValue = _Area.getBaseValue(props, item, xAxis, yAxis);
+  var isHorizontalLayout = layout === 'horizontal';
+  var isRange = false;
+  var points = displayedData.map(function (entry, index) {
+    var value;
+    if (hasStack) {
+      value = stackedData[dataStartIndex + index];
+    } else {
+      value = getValueByDataKey(entry, dataKey);
+      if (!Array.isArray(value)) {
+        value = [baseValue, value];
+      } else {
+        isRange = true;
+      }
+    }
+    var isBreakPoint = value[1] == null || hasStack && getValueByDataKey(entry, dataKey) == null;
+    if (isHorizontalLayout) {
+      return {
+        x: getCateCoordinateOfLine({
+          axis: xAxis,
+          ticks: xAxisTicks,
+          bandSize: bandSize,
+          entry: entry,
+          index: index
+        }),
+        y: isBreakPoint ? null : yAxis.scale(value[1]),
+        value: value,
+        payload: entry
+      };
+    }
+    return {
+      x: isBreakPoint ? null : xAxis.scale(value[1]),
+      y: getCateCoordinateOfLine({
+        axis: yAxis,
+        ticks: yAxisTicks,
+        bandSize: bandSize,
+        entry: entry,
+        index: index
+      }),
+      value: value,
+      payload: entry
+    };
+  });
+  var baseLine;
+  if (hasStack || isRange) {
+    baseLine = points.map(function (entry) {
+      var x = Array.isArray(entry.value) ? entry.value[0] : null;
+      if (isHorizontalLayout) {
+        return {
+          x: entry.x,
+          y: x != null && entry.y != null ? yAxis.scale(x) : null
+        };
+      }
+      return {
+        x: x != null ? xAxis.scale(x) : null,
+        y: entry.y
+      };
+    });
+  } else {
+    baseLine = isHorizontalLayout ? yAxis.scale(baseValue) : xAxis.scale(baseValue);
+  }
+  return _objectSpread({
+    points: points,
+    baseLine: baseLine,
+    layout: layout,
+    isRange: isRange
+  }, offset);
+});
+_defineProperty(Area, "renderDotItem", function (option, props) {
+  var dotItem;
+  if ( /*#__PURE__*/React.isValidElement(option)) {
+    dotItem = /*#__PURE__*/React.cloneElement(option, props);
+  } else if (isFunction(option)) {
+    dotItem = option(props);
+  } else {
+    var className = clsx('recharts-area-dot', typeof option !== 'boolean' ? option.className : '');
+    dotItem = /*#__PURE__*/React.createElement(Dot, _extends({}, props, {
+      className: className
+    }));
+  }
+  return dotItem;
+});

node_modules/recharts/es6/cartesian/Bar.js

@@ -0,0 +1,448 @@
+var _excluded = ["value", "background"];
+var _Bar;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Render a group of bar
+ */
+import React, { PureComponent } from 'react';
+import clsx from 'clsx';
+import Animate from 'react-smooth';
+import isEqual from 'lodash/isEqual';
+import isNil from 'lodash/isNil';
+import { Layer } from '../container/Layer';
+import { ErrorBar } from './ErrorBar';
+import { Cell } from '../component/Cell';
+import { LabelList } from '../component/LabelList';
+import { uniqueId, mathSign, interpolateNumber } from '../util/DataUtils';
+import { filterProps, findAllByType } from '../util/ReactUtils';
+import { Global } from '../util/Global';
+import { getCateCoordinateOfBar, getValueByDataKey, truncateByDomain, getBaseValueOfBar, findPositionOfBar, getTooltipItem } from '../util/ChartUtils';
+import { adaptEventsOfChild } from '../util/types';
+import { BarRectangle, minPointSizeCallback } from '../util/BarUtils';
+export var Bar = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Bar, _PureComponent);
+  function Bar() {
+    var _this;
+    _classCallCheck(this, Bar);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, Bar, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      isAnimationFinished: false
+    });
+    _defineProperty(_assertThisInitialized(_this), "id", uniqueId('recharts-bar-'));
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationEnd", function () {
+      var onAnimationEnd = _this.props.onAnimationEnd;
+      _this.setState({
+        isAnimationFinished: true
+      });
+      if (onAnimationEnd) {
+        onAnimationEnd();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationStart", function () {
+      var onAnimationStart = _this.props.onAnimationStart;
+      _this.setState({
+        isAnimationFinished: false
+      });
+      if (onAnimationStart) {
+        onAnimationStart();
+      }
+    });
+    return _this;
+  }
+  _createClass(Bar, [{
+    key: "renderRectanglesStatically",
+    value: function renderRectanglesStatically(data) {
+      var _this2 = this;
+      var _this$props = this.props,
+        shape = _this$props.shape,
+        dataKey = _this$props.dataKey,
+        activeIndex = _this$props.activeIndex,
+        activeBar = _this$props.activeBar;
+      var baseProps = filterProps(this.props, false);
+      return data && data.map(function (entry, i) {
+        var isActive = i === activeIndex;
+        var option = isActive ? activeBar : shape;
+        var props = _objectSpread(_objectSpread(_objectSpread({}, baseProps), entry), {}, {
+          isActive: isActive,
+          option: option,
+          index: i,
+          dataKey: dataKey,
+          onAnimationStart: _this2.handleAnimationStart,
+          onAnimationEnd: _this2.handleAnimationEnd
+        });
+        return /*#__PURE__*/React.createElement(Layer, _extends({
+          className: "recharts-bar-rectangle"
+        }, adaptEventsOfChild(_this2.props, entry, i), {
+          key: "rectangle-".concat(entry === null || entry === void 0 ? void 0 : entry.x, "-").concat(entry === null || entry === void 0 ? void 0 : entry.y, "-").concat(entry === null || entry === void 0 ? void 0 : entry.value)
+        }), /*#__PURE__*/React.createElement(BarRectangle, props));
+      });
+    }
+  }, {
+    key: "renderRectanglesWithAnimation",
+    value: function renderRectanglesWithAnimation() {
+      var _this3 = this;
+      var _this$props2 = this.props,
+        data = _this$props2.data,
+        layout = _this$props2.layout,
+        isAnimationActive = _this$props2.isAnimationActive,
+        animationBegin = _this$props2.animationBegin,
+        animationDuration = _this$props2.animationDuration,
+        animationEasing = _this$props2.animationEasing,
+        animationId = _this$props2.animationId;
+      var prevData = this.state.prevData;
+      return /*#__PURE__*/React.createElement(Animate, {
+        begin: animationBegin,
+        duration: animationDuration,
+        isActive: isAnimationActive,
+        easing: animationEasing,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "bar-".concat(animationId),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function (_ref) {
+        var t = _ref.t;
+        var stepData = data.map(function (entry, index) {
+          var prev = prevData && prevData[index];
+          if (prev) {
+            var interpolatorX = interpolateNumber(prev.x, entry.x);
+            var interpolatorY = interpolateNumber(prev.y, entry.y);
+            var interpolatorWidth = interpolateNumber(prev.width, entry.width);
+            var interpolatorHeight = interpolateNumber(prev.height, entry.height);
+            return _objectSpread(_objectSpread({}, entry), {}, {
+              x: interpolatorX(t),
+              y: interpolatorY(t),
+              width: interpolatorWidth(t),
+              height: interpolatorHeight(t)
+            });
+          }
+          if (layout === 'horizontal') {
+            var _interpolatorHeight = interpolateNumber(0, entry.height);
+            var h = _interpolatorHeight(t);
+            return _objectSpread(_objectSpread({}, entry), {}, {
+              y: entry.y + entry.height - h,
+              height: h
+            });
+          }
+          var interpolator = interpolateNumber(0, entry.width);
+          var w = interpolator(t);
+          return _objectSpread(_objectSpread({}, entry), {}, {
+            width: w
+          });
+        });
+        return /*#__PURE__*/React.createElement(Layer, null, _this3.renderRectanglesStatically(stepData));
+      });
+    }
+  }, {
+    key: "renderRectangles",
+    value: function renderRectangles() {
+      var _this$props3 = this.props,
+        data = _this$props3.data,
+        isAnimationActive = _this$props3.isAnimationActive;
+      var prevData = this.state.prevData;
+      if (isAnimationActive && data && data.length && (!prevData || !isEqual(prevData, data))) {
+        return this.renderRectanglesWithAnimation();
+      }
+      return this.renderRectanglesStatically(data);
+    }
+  }, {
+    key: "renderBackground",
+    value: function renderBackground() {
+      var _this4 = this;
+      var _this$props4 = this.props,
+        data = _this$props4.data,
+        dataKey = _this$props4.dataKey,
+        activeIndex = _this$props4.activeIndex;
+      var backgroundProps = filterProps(this.props.background, false);
+      return data.map(function (entry, i) {
+        var value = entry.value,
+          background = entry.background,
+          rest = _objectWithoutProperties(entry, _excluded);
+        if (!background) {
+          return null;
+        }
+        var props = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, rest), {}, {
+          fill: '#eee'
+        }, background), backgroundProps), adaptEventsOfChild(_this4.props, entry, i)), {}, {
+          onAnimationStart: _this4.handleAnimationStart,
+          onAnimationEnd: _this4.handleAnimationEnd,
+          dataKey: dataKey,
+          index: i,
+          key: "background-bar-".concat(i),
+          className: 'recharts-bar-background-rectangle'
+        });
+        return /*#__PURE__*/React.createElement(BarRectangle, _extends({
+          option: _this4.props.background,
+          isActive: i === activeIndex
+        }, props));
+      });
+    }
+  }, {
+    key: "renderErrorBar",
+    value: function renderErrorBar(needClip, clipPathId) {
+      if (this.props.isAnimationActive && !this.state.isAnimationFinished) {
+        return null;
+      }
+      var _this$props5 = this.props,
+        data = _this$props5.data,
+        xAxis = _this$props5.xAxis,
+        yAxis = _this$props5.yAxis,
+        layout = _this$props5.layout,
+        children = _this$props5.children;
+      var errorBarItems = findAllByType(children, ErrorBar);
+      if (!errorBarItems) {
+        return null;
+      }
+      var offset = layout === 'vertical' ? data[0].height / 2 : data[0].width / 2;
+      var dataPointFormatter = function dataPointFormatter(dataPoint, dataKey) {
+        /**
+         * if the value coming from `getComposedData` is an array then this is a stacked bar chart.
+         * arr[1] represents end value of the bar since the data is in the form of [startValue, endValue].
+         * */
+        var value = Array.isArray(dataPoint.value) ? dataPoint.value[1] : dataPoint.value;
+        return {
+          x: dataPoint.x,
+          y: dataPoint.y,
+          value: value,
+          errorVal: getValueByDataKey(dataPoint, dataKey)
+        };
+      };
+      var errorBarProps = {
+        clipPath: needClip ? "url(#clipPath-".concat(clipPathId, ")") : null
+      };
+      return /*#__PURE__*/React.createElement(Layer, errorBarProps, errorBarItems.map(function (item) {
+        return /*#__PURE__*/React.cloneElement(item, {
+          key: "error-bar-".concat(clipPathId, "-").concat(item.props.dataKey),
+          data: data,
+          xAxis: xAxis,
+          yAxis: yAxis,
+          layout: layout,
+          offset: offset,
+          dataPointFormatter: dataPointFormatter
+        });
+      }));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props6 = this.props,
+        hide = _this$props6.hide,
+        data = _this$props6.data,
+        className = _this$props6.className,
+        xAxis = _this$props6.xAxis,
+        yAxis = _this$props6.yAxis,
+        left = _this$props6.left,
+        top = _this$props6.top,
+        width = _this$props6.width,
+        height = _this$props6.height,
+        isAnimationActive = _this$props6.isAnimationActive,
+        background = _this$props6.background,
+        id = _this$props6.id;
+      if (hide || !data || !data.length) {
+        return null;
+      }
+      var isAnimationFinished = this.state.isAnimationFinished;
+      var layerClass = clsx('recharts-bar', className);
+      var needClipX = xAxis && xAxis.allowDataOverflow;
+      var needClipY = yAxis && yAxis.allowDataOverflow;
+      var needClip = needClipX || needClipY;
+      var clipPathId = isNil(id) ? this.id : id;
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: layerClass
+      }, needClipX || needClipY ? /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("clipPath", {
+        id: "clipPath-".concat(clipPathId)
+      }, /*#__PURE__*/React.createElement("rect", {
+        x: needClipX ? left : left - width / 2,
+        y: needClipY ? top : top - height / 2,
+        width: needClipX ? width : width * 2,
+        height: needClipY ? height : height * 2
+      }))) : null, /*#__PURE__*/React.createElement(Layer, {
+        className: "recharts-bar-rectangles",
+        clipPath: needClip ? "url(#clipPath-".concat(clipPathId, ")") : null
+      }, background ? this.renderBackground() : null, this.renderRectangles()), this.renderErrorBar(needClip, clipPathId), (!isAnimationActive || isAnimationFinished) && LabelList.renderCallByParent(this.props, data));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      if (nextProps.animationId !== prevState.prevAnimationId) {
+        return {
+          prevAnimationId: nextProps.animationId,
+          curData: nextProps.data,
+          prevData: prevState.curData
+        };
+      }
+      if (nextProps.data !== prevState.curData) {
+        return {
+          curData: nextProps.data
+        };
+      }
+      return null;
+    }
+  }]);
+  return Bar;
+}(PureComponent);
+_Bar = Bar;
+_defineProperty(Bar, "displayName", 'Bar');
+_defineProperty(Bar, "defaultProps", {
+  xAxisId: 0,
+  yAxisId: 0,
+  legendType: 'rect',
+  minPointSize: 0,
+  hide: false,
+  data: [],
+  layout: 'vertical',
+  activeBar: false,
+  isAnimationActive: !Global.isSsr,
+  animationBegin: 0,
+  animationDuration: 400,
+  animationEasing: 'ease'
+});
+/**
+ * Compose the data of each group
+ * @param {Object} props Props for the component
+ * @param {Object} item        An instance of Bar
+ * @param {Array} barPosition  The offset and size of each bar
+ * @param {Object} xAxis       The configuration of x-axis
+ * @param {Object} yAxis       The configuration of y-axis
+ * @param {Array} stackedData  The stacked data of a bar item
+ * @return{Array} Composed data
+ */
+_defineProperty(Bar, "getComposedData", function (_ref2) {
+  var props = _ref2.props,
+    item = _ref2.item,
+    barPosition = _ref2.barPosition,
+    bandSize = _ref2.bandSize,
+    xAxis = _ref2.xAxis,
+    yAxis = _ref2.yAxis,
+    xAxisTicks = _ref2.xAxisTicks,
+    yAxisTicks = _ref2.yAxisTicks,
+    stackedData = _ref2.stackedData,
+    dataStartIndex = _ref2.dataStartIndex,
+    displayedData = _ref2.displayedData,
+    offset = _ref2.offset;
+  var pos = findPositionOfBar(barPosition, item);
+  if (!pos) {
+    return null;
+  }
+  var layout = props.layout;
+  var _item$props = item.props,
+    dataKey = _item$props.dataKey,
+    children = _item$props.children,
+    minPointSizeProp = _item$props.minPointSize;
+  var numericAxis = layout === 'horizontal' ? yAxis : xAxis;
+  var stackedDomain = stackedData ? numericAxis.scale.domain() : null;
+  var baseValue = getBaseValueOfBar({
+    numericAxis: numericAxis
+  });
+  var cells = findAllByType(children, Cell);
+  var rects = displayedData.map(function (entry, index) {
+    var value, x, y, width, height, background;
+    if (stackedData) {
+      value = truncateByDomain(stackedData[dataStartIndex + index], stackedDomain);
+    } else {
+      value = getValueByDataKey(entry, dataKey);
+      if (!Array.isArray(value)) {
+        value = [baseValue, value];
+      }
+    }
+    var minPointSize = minPointSizeCallback(minPointSizeProp, _Bar.defaultProps.minPointSize)(value[1], index);
+    if (layout === 'horizontal') {
+      var _ref4;
+      var _ref3 = [yAxis.scale(value[0]), yAxis.scale(value[1])],
+        baseValueScale = _ref3[0],
+        currentValueScale = _ref3[1];
+      x = getCateCoordinateOfBar({
+        axis: xAxis,
+        ticks: xAxisTicks,
+        bandSize: bandSize,
+        offset: pos.offset,
+        entry: entry,
+        index: index
+      });
+      y = (_ref4 = currentValueScale !== null && currentValueScale !== void 0 ? currentValueScale : baseValueScale) !== null && _ref4 !== void 0 ? _ref4 : undefined;
+      width = pos.size;
+      var computedHeight = baseValueScale - currentValueScale;
+      height = Number.isNaN(computedHeight) ? 0 : computedHeight;
+      background = {
+        x: x,
+        y: yAxis.y,
+        width: width,
+        height: yAxis.height
+      };
+      if (Math.abs(minPointSize) > 0 && Math.abs(height) < Math.abs(minPointSize)) {
+        var delta = mathSign(height || minPointSize) * (Math.abs(minPointSize) - Math.abs(height));
+        y -= delta;
+        height += delta;
+      }
+    } else {
+      var _ref5 = [xAxis.scale(value[0]), xAxis.scale(value[1])],
+        _baseValueScale = _ref5[0],
+        _currentValueScale = _ref5[1];
+      x = _baseValueScale;
+      y = getCateCoordinateOfBar({
+        axis: yAxis,
+        ticks: yAxisTicks,
+        bandSize: bandSize,
+        offset: pos.offset,
+        entry: entry,
+        index: index
+      });
+      width = _currentValueScale - _baseValueScale;
+      height = pos.size;
+      background = {
+        x: xAxis.x,
+        y: y,
+        width: xAxis.width,
+        height: height
+      };
+      if (Math.abs(minPointSize) > 0 && Math.abs(width) < Math.abs(minPointSize)) {
+        var _delta = mathSign(width || minPointSize) * (Math.abs(minPointSize) - Math.abs(width));
+        width += _delta;
+      }
+    }
+    return _objectSpread(_objectSpread(_objectSpread({}, entry), {}, {
+      x: x,
+      y: y,
+      width: width,
+      height: height,
+      value: stackedData ? value : value[1],
+      payload: entry,
+      background: background
+    }, cells && cells[index] && cells[index].props), {}, {
+      tooltipPayload: [getTooltipItem(item, entry)],
+      tooltipPosition: {
+        x: x + width / 2,
+        y: y + height / 2
+      }
+    });
+  });
+  return _objectSpread({
+    data: rects,
+    layout: layout
+  }, offset);
+});

node_modules/recharts/es6/cartesian/Brush.js

@@ -0,0 +1,622 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Brush
+ */
+import React, { PureComponent, Children } from 'react';
+import clsx from 'clsx';
+import { scalePoint } from 'victory-vendor/d3-scale';
+import isFunction from 'lodash/isFunction';
+import range from 'lodash/range';
+import { Layer } from '../container/Layer';
+import { Text } from '../component/Text';
+import { getValueByDataKey } from '../util/ChartUtils';
+import { isNumber } from '../util/DataUtils';
+import { generatePrefixStyle } from '../util/CssPrefixUtils';
+import { filterProps } from '../util/ReactUtils';
+var createScale = function createScale(_ref) {
+  var data = _ref.data,
+    startIndex = _ref.startIndex,
+    endIndex = _ref.endIndex,
+    x = _ref.x,
+    width = _ref.width,
+    travellerWidth = _ref.travellerWidth;
+  if (!data || !data.length) {
+    return {};
+  }
+  var len = data.length;
+  var scale = scalePoint().domain(range(0, len)).range([x, x + width - travellerWidth]);
+  var scaleValues = scale.domain().map(function (entry) {
+    return scale(entry);
+  });
+  return {
+    isTextActive: false,
+    isSlideMoving: false,
+    isTravellerMoving: false,
+    isTravellerFocused: false,
+    startX: scale(startIndex),
+    endX: scale(endIndex),
+    scale: scale,
+    scaleValues: scaleValues
+  };
+};
+var isTouch = function isTouch(e) {
+  return e.changedTouches && !!e.changedTouches.length;
+};
+export var Brush = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Brush, _PureComponent);
+  function Brush(props) {
+    var _this;
+    _classCallCheck(this, Brush);
+    _this = _callSuper(this, Brush, [props]);
+    _defineProperty(_assertThisInitialized(_this), "handleDrag", function (e) {
+      if (_this.leaveTimer) {
+        clearTimeout(_this.leaveTimer);
+        _this.leaveTimer = null;
+      }
+      if (_this.state.isTravellerMoving) {
+        _this.handleTravellerMove(e);
+      } else if (_this.state.isSlideMoving) {
+        _this.handleSlideDrag(e);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleTouchMove", function (e) {
+      if (e.changedTouches != null && e.changedTouches.length > 0) {
+        _this.handleDrag(e.changedTouches[0]);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleDragEnd", function () {
+      _this.setState({
+        isTravellerMoving: false,
+        isSlideMoving: false
+      }, function () {
+        var _this$props = _this.props,
+          endIndex = _this$props.endIndex,
+          onDragEnd = _this$props.onDragEnd,
+          startIndex = _this$props.startIndex;
+        onDragEnd === null || onDragEnd === void 0 || onDragEnd({
+          endIndex: endIndex,
+          startIndex: startIndex
+        });
+      });
+      _this.detachDragEndListener();
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleLeaveWrapper", function () {
+      if (_this.state.isTravellerMoving || _this.state.isSlideMoving) {
+        _this.leaveTimer = window.setTimeout(_this.handleDragEnd, _this.props.leaveTimeOut);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleEnterSlideOrTraveller", function () {
+      _this.setState({
+        isTextActive: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleLeaveSlideOrTraveller", function () {
+      _this.setState({
+        isTextActive: false
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleSlideDragStart", function (e) {
+      var event = isTouch(e) ? e.changedTouches[0] : e;
+      _this.setState({
+        isTravellerMoving: false,
+        isSlideMoving: true,
+        slideMoveStartX: event.pageX
+      });
+      _this.attachDragEndListener();
+    });
+    _this.travellerDragStartHandlers = {
+      startX: _this.handleTravellerDragStart.bind(_assertThisInitialized(_this), 'startX'),
+      endX: _this.handleTravellerDragStart.bind(_assertThisInitialized(_this), 'endX')
+    };
+    _this.state = {};
+    return _this;
+  }
+  _createClass(Brush, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.leaveTimer) {
+        clearTimeout(this.leaveTimer);
+        this.leaveTimer = null;
+      }
+      this.detachDragEndListener();
+    }
+  }, {
+    key: "getIndex",
+    value: function getIndex(_ref2) {
+      var startX = _ref2.startX,
+        endX = _ref2.endX;
+      var scaleValues = this.state.scaleValues;
+      var _this$props2 = this.props,
+        gap = _this$props2.gap,
+        data = _this$props2.data;
+      var lastIndex = data.length - 1;
+      var min = Math.min(startX, endX);
+      var max = Math.max(startX, endX);
+      var minIndex = Brush.getIndexInRange(scaleValues, min);
+      var maxIndex = Brush.getIndexInRange(scaleValues, max);
+      return {
+        startIndex: minIndex - minIndex % gap,
+        endIndex: maxIndex === lastIndex ? lastIndex : maxIndex - maxIndex % gap
+      };
+    }
+  }, {
+    key: "getTextOfTick",
+    value: function getTextOfTick(index) {
+      var _this$props3 = this.props,
+        data = _this$props3.data,
+        tickFormatter = _this$props3.tickFormatter,
+        dataKey = _this$props3.dataKey;
+      var text = getValueByDataKey(data[index], dataKey, index);
+      return isFunction(tickFormatter) ? tickFormatter(text, index) : text;
+    }
+  }, {
+    key: "attachDragEndListener",
+    value: function attachDragEndListener() {
+      window.addEventListener('mouseup', this.handleDragEnd, true);
+      window.addEventListener('touchend', this.handleDragEnd, true);
+      window.addEventListener('mousemove', this.handleDrag, true);
+    }
+  }, {
+    key: "detachDragEndListener",
+    value: function detachDragEndListener() {
+      window.removeEventListener('mouseup', this.handleDragEnd, true);
+      window.removeEventListener('touchend', this.handleDragEnd, true);
+      window.removeEventListener('mousemove', this.handleDrag, true);
+    }
+  }, {
+    key: "handleSlideDrag",
+    value: function handleSlideDrag(e) {
+      var _this$state = this.state,
+        slideMoveStartX = _this$state.slideMoveStartX,
+        startX = _this$state.startX,
+        endX = _this$state.endX;
+      var _this$props4 = this.props,
+        x = _this$props4.x,
+        width = _this$props4.width,
+        travellerWidth = _this$props4.travellerWidth,
+        startIndex = _this$props4.startIndex,
+        endIndex = _this$props4.endIndex,
+        onChange = _this$props4.onChange;
+      var delta = e.pageX - slideMoveStartX;
+      if (delta > 0) {
+        delta = Math.min(delta, x + width - travellerWidth - endX, x + width - travellerWidth - startX);
+      } else if (delta < 0) {
+        delta = Math.max(delta, x - startX, x - endX);
+      }
+      var newIndex = this.getIndex({
+        startX: startX + delta,
+        endX: endX + delta
+      });
+      if ((newIndex.startIndex !== startIndex || newIndex.endIndex !== endIndex) && onChange) {
+        onChange(newIndex);
+      }
+      this.setState({
+        startX: startX + delta,
+        endX: endX + delta,
+        slideMoveStartX: e.pageX
+      });
+    }
+  }, {
+    key: "handleTravellerDragStart",
+    value: function handleTravellerDragStart(id, e) {
+      var event = isTouch(e) ? e.changedTouches[0] : e;
+      this.setState({
+        isSlideMoving: false,
+        isTravellerMoving: true,
+        movingTravellerId: id,
+        brushMoveStartX: event.pageX
+      });
+      this.attachDragEndListener();
+    }
+  }, {
+    key: "handleTravellerMove",
+    value: function handleTravellerMove(e) {
+      var _this$state2 = this.state,
+        brushMoveStartX = _this$state2.brushMoveStartX,
+        movingTravellerId = _this$state2.movingTravellerId,
+        endX = _this$state2.endX,
+        startX = _this$state2.startX;
+      var prevValue = this.state[movingTravellerId];
+      var _this$props5 = this.props,
+        x = _this$props5.x,
+        width = _this$props5.width,
+        travellerWidth = _this$props5.travellerWidth,
+        onChange = _this$props5.onChange,
+        gap = _this$props5.gap,
+        data = _this$props5.data;
+      var params = {
+        startX: this.state.startX,
+        endX: this.state.endX
+      };
+      var delta = e.pageX - brushMoveStartX;
+      if (delta > 0) {
+        delta = Math.min(delta, x + width - travellerWidth - prevValue);
+      } else if (delta < 0) {
+        delta = Math.max(delta, x - prevValue);
+      }
+      params[movingTravellerId] = prevValue + delta;
+      var newIndex = this.getIndex(params);
+      var startIndex = newIndex.startIndex,
+        endIndex = newIndex.endIndex;
+      var isFullGap = function isFullGap() {
+        var lastIndex = data.length - 1;
+        if (movingTravellerId === 'startX' && (endX > startX ? startIndex % gap === 0 : endIndex % gap === 0) || endX < startX && endIndex === lastIndex || movingTravellerId === 'endX' && (endX > startX ? endIndex % gap === 0 : startIndex % gap === 0) || endX > startX && endIndex === lastIndex) {
+          return true;
+        }
+        return false;
+      };
+      this.setState(_defineProperty(_defineProperty({}, movingTravellerId, prevValue + delta), "brushMoveStartX", e.pageX), function () {
+        if (onChange) {
+          if (isFullGap()) {
+            onChange(newIndex);
+          }
+        }
+      });
+    }
+  }, {
+    key: "handleTravellerMoveKeyboard",
+    value: function handleTravellerMoveKeyboard(direction, id) {
+      var _this2 = this;
+      // scaleValues are a list of coordinates. For example: [65, 250, 435, 620, 805, 990].
+      var _this$state3 = this.state,
+        scaleValues = _this$state3.scaleValues,
+        startX = _this$state3.startX,
+        endX = _this$state3.endX;
+      // currentScaleValue refers to which coordinate the current traveller should be placed at.
+      var currentScaleValue = this.state[id];
+      var currentIndex = scaleValues.indexOf(currentScaleValue);
+      if (currentIndex === -1) {
+        return;
+      }
+      var newIndex = currentIndex + direction;
+      if (newIndex === -1 || newIndex >= scaleValues.length) {
+        return;
+      }
+      var newScaleValue = scaleValues[newIndex];
+
+      // Prevent travellers from being on top of each other or overlapping
+      if (id === 'startX' && newScaleValue >= endX || id === 'endX' && newScaleValue <= startX) {
+        return;
+      }
+      this.setState(_defineProperty({}, id, newScaleValue), function () {
+        _this2.props.onChange(_this2.getIndex({
+          startX: _this2.state.startX,
+          endX: _this2.state.endX
+        }));
+      });
+    }
+  }, {
+    key: "renderBackground",
+    value: function renderBackground() {
+      var _this$props6 = this.props,
+        x = _this$props6.x,
+        y = _this$props6.y,
+        width = _this$props6.width,
+        height = _this$props6.height,
+        fill = _this$props6.fill,
+        stroke = _this$props6.stroke;
+      return /*#__PURE__*/React.createElement("rect", {
+        stroke: stroke,
+        fill: fill,
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      });
+    }
+  }, {
+    key: "renderPanorama",
+    value: function renderPanorama() {
+      var _this$props7 = this.props,
+        x = _this$props7.x,
+        y = _this$props7.y,
+        width = _this$props7.width,
+        height = _this$props7.height,
+        data = _this$props7.data,
+        children = _this$props7.children,
+        padding = _this$props7.padding;
+      var chartElement = Children.only(children);
+      if (!chartElement) {
+        return null;
+      }
+      return /*#__PURE__*/React.cloneElement(chartElement, {
+        x: x,
+        y: y,
+        width: width,
+        height: height,
+        margin: padding,
+        compact: true,
+        data: data
+      });
+    }
+  }, {
+    key: "renderTravellerLayer",
+    value: function renderTravellerLayer(travellerX, id) {
+      var _data$startIndex,
+        _data$endIndex,
+        _this3 = this;
+      var _this$props8 = this.props,
+        y = _this$props8.y,
+        travellerWidth = _this$props8.travellerWidth,
+        height = _this$props8.height,
+        traveller = _this$props8.traveller,
+        ariaLabel = _this$props8.ariaLabel,
+        data = _this$props8.data,
+        startIndex = _this$props8.startIndex,
+        endIndex = _this$props8.endIndex;
+      var x = Math.max(travellerX, this.props.x);
+      var travellerProps = _objectSpread(_objectSpread({}, filterProps(this.props, false)), {}, {
+        x: x,
+        y: y,
+        width: travellerWidth,
+        height: height
+      });
+      var ariaLabelBrush = ariaLabel || "Min value: ".concat((_data$startIndex = data[startIndex]) === null || _data$startIndex === void 0 ? void 0 : _data$startIndex.name, ", Max value: ").concat((_data$endIndex = data[endIndex]) === null || _data$endIndex === void 0 ? void 0 : _data$endIndex.name);
+      return /*#__PURE__*/React.createElement(Layer, {
+        tabIndex: 0,
+        role: "slider",
+        "aria-label": ariaLabelBrush,
+        "aria-valuenow": travellerX,
+        className: "recharts-brush-traveller",
+        onMouseEnter: this.handleEnterSlideOrTraveller,
+        onMouseLeave: this.handleLeaveSlideOrTraveller,
+        onMouseDown: this.travellerDragStartHandlers[id],
+        onTouchStart: this.travellerDragStartHandlers[id],
+        onKeyDown: function onKeyDown(e) {
+          if (!['ArrowLeft', 'ArrowRight'].includes(e.key)) {
+            return;
+          }
+          e.preventDefault();
+          e.stopPropagation();
+          _this3.handleTravellerMoveKeyboard(e.key === 'ArrowRight' ? 1 : -1, id);
+        },
+        onFocus: function onFocus() {
+          _this3.setState({
+            isTravellerFocused: true
+          });
+        },
+        onBlur: function onBlur() {
+          _this3.setState({
+            isTravellerFocused: false
+          });
+        },
+        style: {
+          cursor: 'col-resize'
+        }
+      }, Brush.renderTraveller(traveller, travellerProps));
+    }
+  }, {
+    key: "renderSlide",
+    value: function renderSlide(startX, endX) {
+      var _this$props9 = this.props,
+        y = _this$props9.y,
+        height = _this$props9.height,
+        stroke = _this$props9.stroke,
+        travellerWidth = _this$props9.travellerWidth;
+      var x = Math.min(startX, endX) + travellerWidth;
+      var width = Math.max(Math.abs(endX - startX) - travellerWidth, 0);
+      return /*#__PURE__*/React.createElement("rect", {
+        className: "recharts-brush-slide",
+        onMouseEnter: this.handleEnterSlideOrTraveller,
+        onMouseLeave: this.handleLeaveSlideOrTraveller,
+        onMouseDown: this.handleSlideDragStart,
+        onTouchStart: this.handleSlideDragStart,
+        style: {
+          cursor: 'move'
+        },
+        stroke: "none",
+        fill: stroke,
+        fillOpacity: 0.2,
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      });
+    }
+  }, {
+    key: "renderText",
+    value: function renderText() {
+      var _this$props10 = this.props,
+        startIndex = _this$props10.startIndex,
+        endIndex = _this$props10.endIndex,
+        y = _this$props10.y,
+        height = _this$props10.height,
+        travellerWidth = _this$props10.travellerWidth,
+        stroke = _this$props10.stroke;
+      var _this$state4 = this.state,
+        startX = _this$state4.startX,
+        endX = _this$state4.endX;
+      var offset = 5;
+      var attrs = {
+        pointerEvents: 'none',
+        fill: stroke
+      };
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: "recharts-brush-texts"
+      }, /*#__PURE__*/React.createElement(Text, _extends({
+        textAnchor: "end",
+        verticalAnchor: "middle",
+        x: Math.min(startX, endX) - offset,
+        y: y + height / 2
+      }, attrs), this.getTextOfTick(startIndex)), /*#__PURE__*/React.createElement(Text, _extends({
+        textAnchor: "start",
+        verticalAnchor: "middle",
+        x: Math.max(startX, endX) + travellerWidth + offset,
+        y: y + height / 2
+      }, attrs), this.getTextOfTick(endIndex)));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props11 = this.props,
+        data = _this$props11.data,
+        className = _this$props11.className,
+        children = _this$props11.children,
+        x = _this$props11.x,
+        y = _this$props11.y,
+        width = _this$props11.width,
+        height = _this$props11.height,
+        alwaysShowText = _this$props11.alwaysShowText;
+      var _this$state5 = this.state,
+        startX = _this$state5.startX,
+        endX = _this$state5.endX,
+        isTextActive = _this$state5.isTextActive,
+        isSlideMoving = _this$state5.isSlideMoving,
+        isTravellerMoving = _this$state5.isTravellerMoving,
+        isTravellerFocused = _this$state5.isTravellerFocused;
+      if (!data || !data.length || !isNumber(x) || !isNumber(y) || !isNumber(width) || !isNumber(height) || width <= 0 || height <= 0) {
+        return null;
+      }
+      var layerClass = clsx('recharts-brush', className);
+      var isPanoramic = React.Children.count(children) === 1;
+      var style = generatePrefixStyle('userSelect', 'none');
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: layerClass,
+        onMouseLeave: this.handleLeaveWrapper,
+        onTouchMove: this.handleTouchMove,
+        style: style
+      }, this.renderBackground(), isPanoramic && this.renderPanorama(), this.renderSlide(startX, endX), this.renderTravellerLayer(startX, 'startX'), this.renderTravellerLayer(endX, 'endX'), (isTextActive || isSlideMoving || isTravellerMoving || isTravellerFocused || alwaysShowText) && this.renderText());
+    }
+  }], [{
+    key: "renderDefaultTraveller",
+    value: function renderDefaultTraveller(props) {
+      var x = props.x,
+        y = props.y,
+        width = props.width,
+        height = props.height,
+        stroke = props.stroke;
+      var lineY = Math.floor(y + height / 2) - 1;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("rect", {
+        x: x,
+        y: y,
+        width: width,
+        height: height,
+        fill: stroke,
+        stroke: "none"
+      }), /*#__PURE__*/React.createElement("line", {
+        x1: x + 1,
+        y1: lineY,
+        x2: x + width - 1,
+        y2: lineY,
+        fill: "none",
+        stroke: "#fff"
+      }), /*#__PURE__*/React.createElement("line", {
+        x1: x + 1,
+        y1: lineY + 2,
+        x2: x + width - 1,
+        y2: lineY + 2,
+        fill: "none",
+        stroke: "#fff"
+      }));
+    }
+  }, {
+    key: "renderTraveller",
+    value: function renderTraveller(option, props) {
+      var rectangle;
+      if ( /*#__PURE__*/React.isValidElement(option)) {
+        rectangle = /*#__PURE__*/React.cloneElement(option, props);
+      } else if (isFunction(option)) {
+        rectangle = option(props);
+      } else {
+        rectangle = Brush.renderDefaultTraveller(props);
+      }
+      return rectangle;
+    }
+  }, {
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      var data = nextProps.data,
+        width = nextProps.width,
+        x = nextProps.x,
+        travellerWidth = nextProps.travellerWidth,
+        updateId = nextProps.updateId,
+        startIndex = nextProps.startIndex,
+        endIndex = nextProps.endIndex;
+      if (data !== prevState.prevData || updateId !== prevState.prevUpdateId) {
+        return _objectSpread({
+          prevData: data,
+          prevTravellerWidth: travellerWidth,
+          prevUpdateId: updateId,
+          prevX: x,
+          prevWidth: width
+        }, data && data.length ? createScale({
+          data: data,
+          width: width,
+          x: x,
+          travellerWidth: travellerWidth,
+          startIndex: startIndex,
+          endIndex: endIndex
+        }) : {
+          scale: null,
+          scaleValues: null
+        });
+      }
+      if (prevState.scale && (width !== prevState.prevWidth || x !== prevState.prevX || travellerWidth !== prevState.prevTravellerWidth)) {
+        prevState.scale.range([x, x + width - travellerWidth]);
+        var scaleValues = prevState.scale.domain().map(function (entry) {
+          return prevState.scale(entry);
+        });
+        return {
+          prevData: data,
+          prevTravellerWidth: travellerWidth,
+          prevUpdateId: updateId,
+          prevX: x,
+          prevWidth: width,
+          startX: prevState.scale(nextProps.startIndex),
+          endX: prevState.scale(nextProps.endIndex),
+          scaleValues: scaleValues
+        };
+      }
+      return null;
+    }
+  }, {
+    key: "getIndexInRange",
+    value: function getIndexInRange(valueRange, x) {
+      var len = valueRange.length;
+      var start = 0;
+      var end = len - 1;
+      while (end - start > 1) {
+        var middle = Math.floor((start + end) / 2);
+        if (valueRange[middle] > x) {
+          end = middle;
+        } else {
+          start = middle;
+        }
+      }
+      return x >= valueRange[end] ? end : start;
+    }
+  }]);
+  return Brush;
+}(PureComponent);
+_defineProperty(Brush, "displayName", 'Brush');
+_defineProperty(Brush, "defaultProps", {
+  height: 40,
+  travellerWidth: 5,
+  gap: 1,
+  fill: '#fff',
+  stroke: '#666',
+  padding: {
+    top: 1,
+    right: 1,
+    bottom: 1,
+    left: 1
+  },
+  leaveTimeOut: 1000,
+  alwaysShowText: false
+});

node_modules/recharts/es6/cartesian/CartesianAxis.js

@@ -0,0 +1,354 @@
+var _excluded = ["viewBox"],
+  _excluded2 = ["viewBox"],
+  _excluded3 = ["ticks"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Cartesian Axis
+ */
+import React, { Component } from 'react';
+import isFunction from 'lodash/isFunction';
+import get from 'lodash/get';
+import clsx from 'clsx';
+import { shallowEqual } from '../util/ShallowEqual';
+import { Layer } from '../container/Layer';
+import { Text } from '../component/Text';
+import { Label } from '../component/Label';
+import { isNumber } from '../util/DataUtils';
+import { adaptEventsOfChild } from '../util/types';
+import { filterProps } from '../util/ReactUtils';
+import { getTicks } from './getTicks';
+
+/** The orientation of the axis in correspondence to the chart */
+
+/** A unit to be appended to a value */
+
+/** The formatter function of tick */
+
+export var CartesianAxis = /*#__PURE__*/function (_Component) {
+  _inherits(CartesianAxis, _Component);
+  function CartesianAxis(props) {
+    var _this;
+    _classCallCheck(this, CartesianAxis);
+    _this = _callSuper(this, CartesianAxis, [props]);
+    _this.state = {
+      fontSize: '',
+      letterSpacing: ''
+    };
+    return _this;
+  }
+  _createClass(CartesianAxis, [{
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(_ref, nextState) {
+      var viewBox = _ref.viewBox,
+        restProps = _objectWithoutProperties(_ref, _excluded);
+      // props.viewBox is sometimes generated every time -
+      // check that specially as object equality is likely to fail
+      var _this$props = this.props,
+        viewBoxOld = _this$props.viewBox,
+        restPropsOld = _objectWithoutProperties(_this$props, _excluded2);
+      return !shallowEqual(viewBox, viewBoxOld) || !shallowEqual(restProps, restPropsOld) || !shallowEqual(nextState, this.state);
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var htmlLayer = this.layerReference;
+      if (!htmlLayer) return;
+      var tick = htmlLayer.getElementsByClassName('recharts-cartesian-axis-tick-value')[0];
+      if (tick) {
+        this.setState({
+          fontSize: window.getComputedStyle(tick).fontSize,
+          letterSpacing: window.getComputedStyle(tick).letterSpacing
+        });
+      }
+    }
+
+    /**
+     * Calculate the coordinates of endpoints in ticks
+     * @param  {Object} data The data of a simple tick
+     * @return {Object} (x1, y1): The coordinate of endpoint close to tick text
+     *  (x2, y2): The coordinate of endpoint close to axis
+     */
+  }, {
+    key: "getTickLineCoord",
+    value: function getTickLineCoord(data) {
+      var _this$props2 = this.props,
+        x = _this$props2.x,
+        y = _this$props2.y,
+        width = _this$props2.width,
+        height = _this$props2.height,
+        orientation = _this$props2.orientation,
+        tickSize = _this$props2.tickSize,
+        mirror = _this$props2.mirror,
+        tickMargin = _this$props2.tickMargin;
+      var x1, x2, y1, y2, tx, ty;
+      var sign = mirror ? -1 : 1;
+      var finalTickSize = data.tickSize || tickSize;
+      var tickCoord = isNumber(data.tickCoord) ? data.tickCoord : data.coordinate;
+      switch (orientation) {
+        case 'top':
+          x1 = x2 = data.coordinate;
+          y2 = y + +!mirror * height;
+          y1 = y2 - sign * finalTickSize;
+          ty = y1 - sign * tickMargin;
+          tx = tickCoord;
+          break;
+        case 'left':
+          y1 = y2 = data.coordinate;
+          x2 = x + +!mirror * width;
+          x1 = x2 - sign * finalTickSize;
+          tx = x1 - sign * tickMargin;
+          ty = tickCoord;
+          break;
+        case 'right':
+          y1 = y2 = data.coordinate;
+          x2 = x + +mirror * width;
+          x1 = x2 + sign * finalTickSize;
+          tx = x1 + sign * tickMargin;
+          ty = tickCoord;
+          break;
+        default:
+          x1 = x2 = data.coordinate;
+          y2 = y + +mirror * height;
+          y1 = y2 + sign * finalTickSize;
+          ty = y1 + sign * tickMargin;
+          tx = tickCoord;
+          break;
+      }
+      return {
+        line: {
+          x1: x1,
+          y1: y1,
+          x2: x2,
+          y2: y2
+        },
+        tick: {
+          x: tx,
+          y: ty
+        }
+      };
+    }
+  }, {
+    key: "getTickTextAnchor",
+    value: function getTickTextAnchor() {
+      var _this$props3 = this.props,
+        orientation = _this$props3.orientation,
+        mirror = _this$props3.mirror;
+      var textAnchor;
+      switch (orientation) {
+        case 'left':
+          textAnchor = mirror ? 'start' : 'end';
+          break;
+        case 'right':
+          textAnchor = mirror ? 'end' : 'start';
+          break;
+        default:
+          textAnchor = 'middle';
+          break;
+      }
+      return textAnchor;
+    }
+  }, {
+    key: "getTickVerticalAnchor",
+    value: function getTickVerticalAnchor() {
+      var _this$props4 = this.props,
+        orientation = _this$props4.orientation,
+        mirror = _this$props4.mirror;
+      var verticalAnchor = 'end';
+      switch (orientation) {
+        case 'left':
+        case 'right':
+          verticalAnchor = 'middle';
+          break;
+        case 'top':
+          verticalAnchor = mirror ? 'start' : 'end';
+          break;
+        default:
+          verticalAnchor = mirror ? 'end' : 'start';
+          break;
+      }
+      return verticalAnchor;
+    }
+  }, {
+    key: "renderAxisLine",
+    value: function renderAxisLine() {
+      var _this$props5 = this.props,
+        x = _this$props5.x,
+        y = _this$props5.y,
+        width = _this$props5.width,
+        height = _this$props5.height,
+        orientation = _this$props5.orientation,
+        mirror = _this$props5.mirror,
+        axisLine = _this$props5.axisLine;
+      var props = _objectSpread(_objectSpread(_objectSpread({}, filterProps(this.props, false)), filterProps(axisLine, false)), {}, {
+        fill: 'none'
+      });
+      if (orientation === 'top' || orientation === 'bottom') {
+        var needHeight = +(orientation === 'top' && !mirror || orientation === 'bottom' && mirror);
+        props = _objectSpread(_objectSpread({}, props), {}, {
+          x1: x,
+          y1: y + needHeight * height,
+          x2: x + width,
+          y2: y + needHeight * height
+        });
+      } else {
+        var needWidth = +(orientation === 'left' && !mirror || orientation === 'right' && mirror);
+        props = _objectSpread(_objectSpread({}, props), {}, {
+          x1: x + needWidth * width,
+          y1: y,
+          x2: x + needWidth * width,
+          y2: y + height
+        });
+      }
+      return /*#__PURE__*/React.createElement("line", _extends({}, props, {
+        className: clsx('recharts-cartesian-axis-line', get(axisLine, 'className'))
+      }));
+    }
+  }, {
+    key: "renderTicks",
+    value:
+    /**
+     * render the ticks
+     * @param {Array} ticks The ticks to actually render (overrides what was passed in props)
+     * @param {string} fontSize Fontsize to consider for tick spacing
+     * @param {string} letterSpacing Letterspacing to consider for tick spacing
+     * @return {ReactComponent} renderedTicks
+     */
+    function renderTicks(ticks, fontSize, letterSpacing) {
+      var _this2 = this;
+      var _this$props6 = this.props,
+        tickLine = _this$props6.tickLine,
+        stroke = _this$props6.stroke,
+        tick = _this$props6.tick,
+        tickFormatter = _this$props6.tickFormatter,
+        unit = _this$props6.unit;
+      var finalTicks = getTicks(_objectSpread(_objectSpread({}, this.props), {}, {
+        ticks: ticks
+      }), fontSize, letterSpacing);
+      var textAnchor = this.getTickTextAnchor();
+      var verticalAnchor = this.getTickVerticalAnchor();
+      var axisProps = filterProps(this.props, false);
+      var customTickProps = filterProps(tick, false);
+      var tickLineProps = _objectSpread(_objectSpread({}, axisProps), {}, {
+        fill: 'none'
+      }, filterProps(tickLine, false));
+      var items = finalTicks.map(function (entry, i) {
+        var _this2$getTickLineCoo = _this2.getTickLineCoord(entry),
+          lineCoord = _this2$getTickLineCoo.line,
+          tickCoord = _this2$getTickLineCoo.tick;
+        var tickProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+          textAnchor: textAnchor,
+          verticalAnchor: verticalAnchor
+        }, axisProps), {}, {
+          stroke: 'none',
+          fill: stroke
+        }, customTickProps), tickCoord), {}, {
+          index: i,
+          payload: entry,
+          visibleTicksCount: finalTicks.length,
+          tickFormatter: tickFormatter
+        });
+        return /*#__PURE__*/React.createElement(Layer, _extends({
+          className: "recharts-cartesian-axis-tick",
+          key: "tick-".concat(entry.value, "-").concat(entry.coordinate, "-").concat(entry.tickCoord)
+        }, adaptEventsOfChild(_this2.props, entry, i)), tickLine && /*#__PURE__*/React.createElement("line", _extends({}, tickLineProps, lineCoord, {
+          className: clsx('recharts-cartesian-axis-tick-line', get(tickLine, 'className'))
+        })), tick && CartesianAxis.renderTickItem(tick, tickProps, "".concat(isFunction(tickFormatter) ? tickFormatter(entry.value, i) : entry.value).concat(unit || '')));
+      });
+      return /*#__PURE__*/React.createElement("g", {
+        className: "recharts-cartesian-axis-ticks"
+      }, items);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      var _this$props7 = this.props,
+        axisLine = _this$props7.axisLine,
+        width = _this$props7.width,
+        height = _this$props7.height,
+        ticksGenerator = _this$props7.ticksGenerator,
+        className = _this$props7.className,
+        hide = _this$props7.hide;
+      if (hide) {
+        return null;
+      }
+      var _this$props8 = this.props,
+        ticks = _this$props8.ticks,
+        noTicksProps = _objectWithoutProperties(_this$props8, _excluded3);
+      var finalTicks = ticks;
+      if (isFunction(ticksGenerator)) {
+        finalTicks = ticks && ticks.length > 0 ? ticksGenerator(this.props) : ticksGenerator(noTicksProps);
+      }
+      if (width <= 0 || height <= 0 || !finalTicks || !finalTicks.length) {
+        return null;
+      }
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: clsx('recharts-cartesian-axis', className),
+        ref: function ref(_ref2) {
+          _this3.layerReference = _ref2;
+        }
+      }, axisLine && this.renderAxisLine(), this.renderTicks(finalTicks, this.state.fontSize, this.state.letterSpacing), Label.renderCallByParent(this.props));
+    }
+  }], [{
+    key: "renderTickItem",
+    value: function renderTickItem(option, props, value) {
+      var tickItem;
+      if ( /*#__PURE__*/React.isValidElement(option)) {
+        tickItem = /*#__PURE__*/React.cloneElement(option, props);
+      } else if (isFunction(option)) {
+        tickItem = option(props);
+      } else {
+        tickItem = /*#__PURE__*/React.createElement(Text, _extends({}, props, {
+          className: "recharts-cartesian-axis-tick-value"
+        }), value);
+      }
+      return tickItem;
+    }
+  }]);
+  return CartesianAxis;
+}(Component);
+_defineProperty(CartesianAxis, "displayName", 'CartesianAxis');
+_defineProperty(CartesianAxis, "defaultProps", {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  viewBox: {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // The orientation of axis
+  orientation: 'bottom',
+  // The ticks
+  ticks: [],
+  stroke: '#666',
+  tickLine: true,
+  axisLine: true,
+  tick: true,
+  mirror: false,
+  minTickGap: 5,
+  // The width or height of tick
+  tickSize: 6,
+  tickMargin: 2,
+  interval: 'preserveEnd'
+});

node_modules/recharts/es6/cartesian/CartesianGrid.js

@@ -0,0 +1,366 @@
+var _excluded = ["x1", "y1", "x2", "y2", "key"],
+  _excluded2 = ["offset"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+/**
+ * @fileOverview Cartesian Grid
+ */
+import React from 'react';
+import isFunction from 'lodash/isFunction';
+import { warn } from '../util/LogUtils';
+import { isNumber } from '../util/DataUtils';
+import { filterProps } from '../util/ReactUtils';
+import { getCoordinatesOfGrid, getTicksOfAxis } from '../util/ChartUtils';
+import { getTicks } from './getTicks';
+import { CartesianAxis } from './CartesianAxis';
+import { useArbitraryXAxis, useChartHeight, useChartWidth, useOffset, useYAxisWithFiniteDomainOrRandom } from '../context/chartLayoutContext';
+
+/**
+ * The <CartesianGrid horizontal
+ */
+
+var Background = function Background(props) {
+  var fill = props.fill;
+  if (!fill || fill === 'none') {
+    return null;
+  }
+  var fillOpacity = props.fillOpacity,
+    x = props.x,
+    y = props.y,
+    width = props.width,
+    height = props.height;
+  return /*#__PURE__*/React.createElement("rect", {
+    x: x,
+    y: y,
+    width: width,
+    height: height,
+    stroke: "none",
+    fill: fill,
+    fillOpacity: fillOpacity,
+    className: "recharts-cartesian-grid-bg"
+  });
+};
+function renderLineItem(option, props) {
+  var lineItem;
+  if ( /*#__PURE__*/React.isValidElement(option)) {
+    // @ts-expect-error typescript does not see the props type when cloning an element
+    lineItem = /*#__PURE__*/React.cloneElement(option, props);
+  } else if (isFunction(option)) {
+    lineItem = option(props);
+  } else {
+    var x1 = props.x1,
+      y1 = props.y1,
+      x2 = props.x2,
+      y2 = props.y2,
+      key = props.key,
+      others = _objectWithoutProperties(props, _excluded);
+    var _filterProps = filterProps(others, false),
+      __ = _filterProps.offset,
+      restOfFilteredProps = _objectWithoutProperties(_filterProps, _excluded2);
+    lineItem = /*#__PURE__*/React.createElement("line", _extends({}, restOfFilteredProps, {
+      x1: x1,
+      y1: y1,
+      x2: x2,
+      y2: y2,
+      fill: "none",
+      key: key
+    }));
+  }
+  return lineItem;
+}
+function HorizontalGridLines(props) {
+  var x = props.x,
+    width = props.width,
+    _props$horizontal = props.horizontal,
+    horizontal = _props$horizontal === void 0 ? true : _props$horizontal,
+    horizontalPoints = props.horizontalPoints;
+  if (!horizontal || !horizontalPoints || !horizontalPoints.length) {
+    return null;
+  }
+  var items = horizontalPoints.map(function (entry, i) {
+    var lineItemProps = _objectSpread(_objectSpread({}, props), {}, {
+      x1: x,
+      y1: entry,
+      x2: x + width,
+      y2: entry,
+      key: "line-".concat(i),
+      index: i
+    });
+    return renderLineItem(horizontal, lineItemProps);
+  });
+  return /*#__PURE__*/React.createElement("g", {
+    className: "recharts-cartesian-grid-horizontal"
+  }, items);
+}
+function VerticalGridLines(props) {
+  var y = props.y,
+    height = props.height,
+    _props$vertical = props.vertical,
+    vertical = _props$vertical === void 0 ? true : _props$vertical,
+    verticalPoints = props.verticalPoints;
+  if (!vertical || !verticalPoints || !verticalPoints.length) {
+    return null;
+  }
+  var items = verticalPoints.map(function (entry, i) {
+    var lineItemProps = _objectSpread(_objectSpread({}, props), {}, {
+      x1: entry,
+      y1: y,
+      x2: entry,
+      y2: y + height,
+      key: "line-".concat(i),
+      index: i
+    });
+    return renderLineItem(vertical, lineItemProps);
+  });
+  return /*#__PURE__*/React.createElement("g", {
+    className: "recharts-cartesian-grid-vertical"
+  }, items);
+}
+function HorizontalStripes(props) {
+  var horizontalFill = props.horizontalFill,
+    fillOpacity = props.fillOpacity,
+    x = props.x,
+    y = props.y,
+    width = props.width,
+    height = props.height,
+    horizontalPoints = props.horizontalPoints,
+    _props$horizontal2 = props.horizontal,
+    horizontal = _props$horizontal2 === void 0 ? true : _props$horizontal2;
+  if (!horizontal || !horizontalFill || !horizontalFill.length) {
+    return null;
+  }
+
+  // Why =y -y? I was trying to find any difference that this makes, with floating point numbers and edge cases but ... nothing.
+  var roundedSortedHorizontalPoints = horizontalPoints.map(function (e) {
+    return Math.round(e + y - y);
+  }).sort(function (a, b) {
+    return a - b;
+  });
+  // Why is this condition `!==` instead of `<=` ?
+  if (y !== roundedSortedHorizontalPoints[0]) {
+    roundedSortedHorizontalPoints.unshift(0);
+  }
+  var items = roundedSortedHorizontalPoints.map(function (entry, i) {
+    // Why do we strip only the last stripe if it is invisible, and not all invisible stripes?
+    var lastStripe = !roundedSortedHorizontalPoints[i + 1];
+    var lineHeight = lastStripe ? y + height - entry : roundedSortedHorizontalPoints[i + 1] - entry;
+    if (lineHeight <= 0) {
+      return null;
+    }
+    var colorIndex = i % horizontalFill.length;
+    return /*#__PURE__*/React.createElement("rect", {
+      key: "react-".concat(i) // eslint-disable-line react/no-array-index-key
+      ,
+      y: entry,
+      x: x,
+      height: lineHeight,
+      width: width,
+      stroke: "none",
+      fill: horizontalFill[colorIndex],
+      fillOpacity: fillOpacity,
+      className: "recharts-cartesian-grid-bg"
+    });
+  });
+  return /*#__PURE__*/React.createElement("g", {
+    className: "recharts-cartesian-gridstripes-horizontal"
+  }, items);
+}
+function VerticalStripes(props) {
+  var _props$vertical2 = props.vertical,
+    vertical = _props$vertical2 === void 0 ? true : _props$vertical2,
+    verticalFill = props.verticalFill,
+    fillOpacity = props.fillOpacity,
+    x = props.x,
+    y = props.y,
+    width = props.width,
+    height = props.height,
+    verticalPoints = props.verticalPoints;
+  if (!vertical || !verticalFill || !verticalFill.length) {
+    return null;
+  }
+  var roundedSortedVerticalPoints = verticalPoints.map(function (e) {
+    return Math.round(e + x - x);
+  }).sort(function (a, b) {
+    return a - b;
+  });
+  if (x !== roundedSortedVerticalPoints[0]) {
+    roundedSortedVerticalPoints.unshift(0);
+  }
+  var items = roundedSortedVerticalPoints.map(function (entry, i) {
+    var lastStripe = !roundedSortedVerticalPoints[i + 1];
+    var lineWidth = lastStripe ? x + width - entry : roundedSortedVerticalPoints[i + 1] - entry;
+    if (lineWidth <= 0) {
+      return null;
+    }
+    var colorIndex = i % verticalFill.length;
+    return /*#__PURE__*/React.createElement("rect", {
+      key: "react-".concat(i) // eslint-disable-line react/no-array-index-key
+      ,
+      x: entry,
+      y: y,
+      width: lineWidth,
+      height: height,
+      stroke: "none",
+      fill: verticalFill[colorIndex],
+      fillOpacity: fillOpacity,
+      className: "recharts-cartesian-grid-bg"
+    });
+  });
+  return /*#__PURE__*/React.createElement("g", {
+    className: "recharts-cartesian-gridstripes-vertical"
+  }, items);
+}
+var defaultVerticalCoordinatesGenerator = function defaultVerticalCoordinatesGenerator(_ref, syncWithTicks) {
+  var xAxis = _ref.xAxis,
+    width = _ref.width,
+    height = _ref.height,
+    offset = _ref.offset;
+  return getCoordinatesOfGrid(getTicks(_objectSpread(_objectSpread(_objectSpread({}, CartesianAxis.defaultProps), xAxis), {}, {
+    ticks: getTicksOfAxis(xAxis, true),
+    viewBox: {
+      x: 0,
+      y: 0,
+      width: width,
+      height: height
+    }
+  })), offset.left, offset.left + offset.width, syncWithTicks);
+};
+var defaultHorizontalCoordinatesGenerator = function defaultHorizontalCoordinatesGenerator(_ref2, syncWithTicks) {
+  var yAxis = _ref2.yAxis,
+    width = _ref2.width,
+    height = _ref2.height,
+    offset = _ref2.offset;
+  return getCoordinatesOfGrid(getTicks(_objectSpread(_objectSpread(_objectSpread({}, CartesianAxis.defaultProps), yAxis), {}, {
+    ticks: getTicksOfAxis(yAxis, true),
+    viewBox: {
+      x: 0,
+      y: 0,
+      width: width,
+      height: height
+    }
+  })), offset.top, offset.top + offset.height, syncWithTicks);
+};
+var defaultProps = {
+  horizontal: true,
+  vertical: true,
+  // The ordinates of horizontal grid lines
+  horizontalPoints: [],
+  // The abscissas of vertical grid lines
+  verticalPoints: [],
+  stroke: '#ccc',
+  fill: 'none',
+  // The fill of colors of grid lines
+  verticalFill: [],
+  horizontalFill: []
+};
+export function CartesianGrid(props) {
+  var _props$stroke, _props$fill, _props$horizontal3, _props$horizontalFill, _props$vertical3, _props$verticalFill;
+  var chartWidth = useChartWidth();
+  var chartHeight = useChartHeight();
+  var offset = useOffset();
+  var propsIncludingDefaults = _objectSpread(_objectSpread({}, props), {}, {
+    stroke: (_props$stroke = props.stroke) !== null && _props$stroke !== void 0 ? _props$stroke : defaultProps.stroke,
+    fill: (_props$fill = props.fill) !== null && _props$fill !== void 0 ? _props$fill : defaultProps.fill,
+    horizontal: (_props$horizontal3 = props.horizontal) !== null && _props$horizontal3 !== void 0 ? _props$horizontal3 : defaultProps.horizontal,
+    horizontalFill: (_props$horizontalFill = props.horizontalFill) !== null && _props$horizontalFill !== void 0 ? _props$horizontalFill : defaultProps.horizontalFill,
+    vertical: (_props$vertical3 = props.vertical) !== null && _props$vertical3 !== void 0 ? _props$vertical3 : defaultProps.vertical,
+    verticalFill: (_props$verticalFill = props.verticalFill) !== null && _props$verticalFill !== void 0 ? _props$verticalFill : defaultProps.verticalFill,
+    x: isNumber(props.x) ? props.x : offset.left,
+    y: isNumber(props.y) ? props.y : offset.top,
+    width: isNumber(props.width) ? props.width : offset.width,
+    height: isNumber(props.height) ? props.height : offset.height
+  });
+  var x = propsIncludingDefaults.x,
+    y = propsIncludingDefaults.y,
+    width = propsIncludingDefaults.width,
+    height = propsIncludingDefaults.height,
+    syncWithTicks = propsIncludingDefaults.syncWithTicks,
+    horizontalValues = propsIncludingDefaults.horizontalValues,
+    verticalValues = propsIncludingDefaults.verticalValues;
+
+  // @ts-expect-error the scale prop is mixed up - we need to untagle this at some point
+  var xAxis = useArbitraryXAxis();
+  // @ts-expect-error the scale prop is mixed up - we need to untagle this at some point
+  var yAxis = useYAxisWithFiniteDomainOrRandom();
+  if (!isNumber(width) || width <= 0 || !isNumber(height) || height <= 0 || !isNumber(x) || x !== +x || !isNumber(y) || y !== +y) {
+    return null;
+  }
+
+  /*
+   * verticalCoordinatesGenerator and horizontalCoordinatesGenerator are defined
+   * outside of the propsIncludingDefaults because they were never part of the original props
+   * and they were never passed as a prop down to horizontal/vertical custom elements.
+   * If we add these two to propsIncludingDefaults then we are changing public API.
+   * Not a bad thing per se but also not necessary.
+   */
+  var verticalCoordinatesGenerator = propsIncludingDefaults.verticalCoordinatesGenerator || defaultVerticalCoordinatesGenerator;
+  var horizontalCoordinatesGenerator = propsIncludingDefaults.horizontalCoordinatesGenerator || defaultHorizontalCoordinatesGenerator;
+  var horizontalPoints = propsIncludingDefaults.horizontalPoints,
+    verticalPoints = propsIncludingDefaults.verticalPoints;
+
+  // No horizontal points are specified
+  if ((!horizontalPoints || !horizontalPoints.length) && isFunction(horizontalCoordinatesGenerator)) {
+    var isHorizontalValues = horizontalValues && horizontalValues.length;
+    var generatorResult = horizontalCoordinatesGenerator({
+      yAxis: yAxis ? _objectSpread(_objectSpread({}, yAxis), {}, {
+        ticks: isHorizontalValues ? horizontalValues : yAxis.ticks
+      }) : undefined,
+      width: chartWidth,
+      height: chartHeight,
+      offset: offset
+    }, isHorizontalValues ? true : syncWithTicks);
+    warn(Array.isArray(generatorResult), "horizontalCoordinatesGenerator should return Array but instead it returned [".concat(_typeof(generatorResult), "]"));
+    if (Array.isArray(generatorResult)) {
+      horizontalPoints = generatorResult;
+    }
+  }
+
+  // No vertical points are specified
+  if ((!verticalPoints || !verticalPoints.length) && isFunction(verticalCoordinatesGenerator)) {
+    var isVerticalValues = verticalValues && verticalValues.length;
+    var _generatorResult = verticalCoordinatesGenerator({
+      xAxis: xAxis ? _objectSpread(_objectSpread({}, xAxis), {}, {
+        ticks: isVerticalValues ? verticalValues : xAxis.ticks
+      }) : undefined,
+      width: chartWidth,
+      height: chartHeight,
+      offset: offset
+    }, isVerticalValues ? true : syncWithTicks);
+    warn(Array.isArray(_generatorResult), "verticalCoordinatesGenerator should return Array but instead it returned [".concat(_typeof(_generatorResult), "]"));
+    if (Array.isArray(_generatorResult)) {
+      verticalPoints = _generatorResult;
+    }
+  }
+  return /*#__PURE__*/React.createElement("g", {
+    className: "recharts-cartesian-grid"
+  }, /*#__PURE__*/React.createElement(Background, {
+    fill: propsIncludingDefaults.fill,
+    fillOpacity: propsIncludingDefaults.fillOpacity,
+    x: propsIncludingDefaults.x,
+    y: propsIncludingDefaults.y,
+    width: propsIncludingDefaults.width,
+    height: propsIncludingDefaults.height
+  }), /*#__PURE__*/React.createElement(HorizontalGridLines, _extends({}, propsIncludingDefaults, {
+    offset: offset,
+    horizontalPoints: horizontalPoints,
+    xAxis: xAxis,
+    yAxis: yAxis
+  })), /*#__PURE__*/React.createElement(VerticalGridLines, _extends({}, propsIncludingDefaults, {
+    offset: offset,
+    verticalPoints: verticalPoints,
+    xAxis: xAxis,
+    yAxis: yAxis
+  })), /*#__PURE__*/React.createElement(HorizontalStripes, _extends({}, propsIncludingDefaults, {
+    horizontalPoints: horizontalPoints
+  })), /*#__PURE__*/React.createElement(VerticalStripes, _extends({}, propsIncludingDefaults, {
+    verticalPoints: verticalPoints
+  })));
+}
+CartesianGrid.displayName = 'CartesianGrid';

node_modules/recharts/es6/cartesian/ErrorBar.js

@@ -0,0 +1,131 @@
+var _excluded = ["offset", "layout", "width", "dataKey", "data", "dataPointFormatter", "xAxis", "yAxis"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+/**
+ * @fileOverview Render a group of error bar
+ */
+import React from 'react';
+import invariant from 'tiny-invariant';
+import { Layer } from '../container/Layer';
+import { filterProps } from '../util/ReactUtils';
+export function ErrorBar(props) {
+  var offset = props.offset,
+    layout = props.layout,
+    width = props.width,
+    dataKey = props.dataKey,
+    data = props.data,
+    dataPointFormatter = props.dataPointFormatter,
+    xAxis = props.xAxis,
+    yAxis = props.yAxis,
+    others = _objectWithoutProperties(props, _excluded);
+  var svgProps = filterProps(others, false);
+  !!(props.direction === 'x' && xAxis.type !== 'number') ? process.env.NODE_ENV !== "production" ? invariant(false, 'ErrorBar requires Axis type property to be "number".') : invariant(false) : void 0;
+  var errorBars = data.map(function (entry) {
+    var _dataPointFormatter = dataPointFormatter(entry, dataKey),
+      x = _dataPointFormatter.x,
+      y = _dataPointFormatter.y,
+      value = _dataPointFormatter.value,
+      errorVal = _dataPointFormatter.errorVal;
+    if (!errorVal) {
+      return null;
+    }
+    var lineCoordinates = [];
+    var lowBound, highBound;
+    if (Array.isArray(errorVal)) {
+      var _errorVal = _slicedToArray(errorVal, 2);
+      lowBound = _errorVal[0];
+      highBound = _errorVal[1];
+    } else {
+      lowBound = highBound = errorVal;
+    }
+    if (layout === 'vertical') {
+      // error bar for horizontal charts, the y is fixed, x is a range value
+      var scale = xAxis.scale;
+      var yMid = y + offset;
+      var yMin = yMid + width;
+      var yMax = yMid - width;
+      var xMin = scale(value - lowBound);
+      var xMax = scale(value + highBound);
+
+      // the right line of |--|
+      lineCoordinates.push({
+        x1: xMax,
+        y1: yMin,
+        x2: xMax,
+        y2: yMax
+      });
+      // the middle line of |--|
+      lineCoordinates.push({
+        x1: xMin,
+        y1: yMid,
+        x2: xMax,
+        y2: yMid
+      });
+      // the left line of |--|
+      lineCoordinates.push({
+        x1: xMin,
+        y1: yMin,
+        x2: xMin,
+        y2: yMax
+      });
+    } else if (layout === 'horizontal') {
+      // error bar for horizontal charts, the x is fixed, y is a range value
+      var _scale = yAxis.scale;
+      var xMid = x + offset;
+      var _xMin = xMid - width;
+      var _xMax = xMid + width;
+      var _yMin = _scale(value - lowBound);
+      var _yMax = _scale(value + highBound);
+
+      // the top line
+      lineCoordinates.push({
+        x1: _xMin,
+        y1: _yMax,
+        x2: _xMax,
+        y2: _yMax
+      });
+      // the middle line
+      lineCoordinates.push({
+        x1: xMid,
+        y1: _yMin,
+        x2: xMid,
+        y2: _yMax
+      });
+      // the bottom line
+      lineCoordinates.push({
+        x1: _xMin,
+        y1: _yMin,
+        x2: _xMax,
+        y2: _yMin
+      });
+    }
+    return /*#__PURE__*/React.createElement(Layer, _extends({
+      className: "recharts-errorBar",
+      key: "bar-".concat(lineCoordinates.map(function (c) {
+        return "".concat(c.x1, "-").concat(c.x2, "-").concat(c.y1, "-").concat(c.y2);
+      }))
+    }, svgProps), lineCoordinates.map(function (coordinates) {
+      return /*#__PURE__*/React.createElement("line", _extends({}, coordinates, {
+        key: "line-".concat(coordinates.x1, "-").concat(coordinates.x2, "-").concat(coordinates.y1, "-").concat(coordinates.y2)
+      }));
+    }));
+  });
+  return /*#__PURE__*/React.createElement(Layer, {
+    className: "recharts-errorBars"
+  }, errorBars);
+}
+ErrorBar.defaultProps = {
+  stroke: 'black',
+  strokeWidth: 1.5,
+  width: 5,
+  offset: 0,
+  layout: 'horizontal'
+};
+ErrorBar.displayName = 'ErrorBar';

node_modules/recharts/es6/cartesian/Line.js

@@ -0,0 +1,506 @@
+var _excluded = ["type", "layout", "connectNulls", "ref"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Line
+ */
+import React, { PureComponent } from 'react';
+import Animate from 'react-smooth';
+import isFunction from 'lodash/isFunction';
+import isNil from 'lodash/isNil';
+import isEqual from 'lodash/isEqual';
+import clsx from 'clsx';
+import { Curve } from '../shape/Curve';
+import { Dot } from '../shape/Dot';
+import { Layer } from '../container/Layer';
+import { LabelList } from '../component/LabelList';
+import { ErrorBar } from './ErrorBar';
+import { uniqueId, interpolateNumber } from '../util/DataUtils';
+import { findAllByType, filterProps, isDotProps } from '../util/ReactUtils';
+import { Global } from '../util/Global';
+import { getCateCoordinateOfLine, getValueByDataKey } from '../util/ChartUtils';
+export var Line = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Line, _PureComponent);
+  function Line() {
+    var _this;
+    _classCallCheck(this, Line);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, Line, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      isAnimationFinished: true,
+      totalLength: 0
+    });
+    _defineProperty(_assertThisInitialized(_this), "generateSimpleStrokeDasharray", function (totalLength, length) {
+      return "".concat(length, "px ").concat(totalLength - length, "px");
+    });
+    _defineProperty(_assertThisInitialized(_this), "getStrokeDasharray", function (length, totalLength, lines) {
+      var lineLength = lines.reduce(function (pre, next) {
+        return pre + next;
+      });
+
+      // if lineLength is 0 return the default when no strokeDasharray is provided
+      if (!lineLength) {
+        return _this.generateSimpleStrokeDasharray(totalLength, length);
+      }
+      var count = Math.floor(length / lineLength);
+      var remainLength = length % lineLength;
+      var restLength = totalLength - length;
+      var remainLines = [];
+      for (var i = 0, sum = 0; i < lines.length; sum += lines[i], ++i) {
+        if (sum + lines[i] > remainLength) {
+          remainLines = [].concat(_toConsumableArray(lines.slice(0, i)), [remainLength - sum]);
+          break;
+        }
+      }
+      var emptyLines = remainLines.length % 2 === 0 ? [0, restLength] : [restLength];
+      return [].concat(_toConsumableArray(Line.repeat(lines, count)), _toConsumableArray(remainLines), emptyLines).map(function (line) {
+        return "".concat(line, "px");
+      }).join(', ');
+    });
+    _defineProperty(_assertThisInitialized(_this), "id", uniqueId('recharts-line-'));
+    _defineProperty(_assertThisInitialized(_this), "pathRef", function (node) {
+      _this.mainCurve = node;
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationEnd", function () {
+      _this.setState({
+        isAnimationFinished: true
+      });
+      if (_this.props.onAnimationEnd) {
+        _this.props.onAnimationEnd();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationStart", function () {
+      _this.setState({
+        isAnimationFinished: false
+      });
+      if (_this.props.onAnimationStart) {
+        _this.props.onAnimationStart();
+      }
+    });
+    return _this;
+  }
+  _createClass(Line, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (!this.props.isAnimationActive) {
+        return;
+      }
+      var totalLength = this.getTotalLength();
+      this.setState({
+        totalLength: totalLength
+      });
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      if (!this.props.isAnimationActive) {
+        return;
+      }
+      var totalLength = this.getTotalLength();
+      if (totalLength !== this.state.totalLength) {
+        this.setState({
+          totalLength: totalLength
+        });
+      }
+    }
+  }, {
+    key: "getTotalLength",
+    value: function getTotalLength() {
+      var curveDom = this.mainCurve;
+      try {
+        return curveDom && curveDom.getTotalLength && curveDom.getTotalLength() || 0;
+      } catch (err) {
+        return 0;
+      }
+    }
+  }, {
+    key: "renderErrorBar",
+    value: function renderErrorBar(needClip, clipPathId) {
+      if (this.props.isAnimationActive && !this.state.isAnimationFinished) {
+        return null;
+      }
+      var _this$props = this.props,
+        points = _this$props.points,
+        xAxis = _this$props.xAxis,
+        yAxis = _this$props.yAxis,
+        layout = _this$props.layout,
+        children = _this$props.children;
+      var errorBarItems = findAllByType(children, ErrorBar);
+      if (!errorBarItems) {
+        return null;
+      }
+      var dataPointFormatter = function dataPointFormatter(dataPoint, dataKey) {
+        return {
+          x: dataPoint.x,
+          y: dataPoint.y,
+          value: dataPoint.value,
+          errorVal: getValueByDataKey(dataPoint.payload, dataKey)
+        };
+      };
+      var errorBarProps = {
+        clipPath: needClip ? "url(#clipPath-".concat(clipPathId, ")") : null
+      };
+      return /*#__PURE__*/React.createElement(Layer, errorBarProps, errorBarItems.map(function (item) {
+        return /*#__PURE__*/React.cloneElement(item, {
+          key: "bar-".concat(item.props.dataKey),
+          data: points,
+          xAxis: xAxis,
+          yAxis: yAxis,
+          layout: layout,
+          dataPointFormatter: dataPointFormatter
+        });
+      }));
+    }
+  }, {
+    key: "renderDots",
+    value: function renderDots(needClip, clipDot, clipPathId) {
+      var isAnimationActive = this.props.isAnimationActive;
+      if (isAnimationActive && !this.state.isAnimationFinished) {
+        return null;
+      }
+      var _this$props2 = this.props,
+        dot = _this$props2.dot,
+        points = _this$props2.points,
+        dataKey = _this$props2.dataKey;
+      var lineProps = filterProps(this.props, false);
+      var customDotProps = filterProps(dot, true);
+      var dots = points.map(function (entry, i) {
+        var dotProps = _objectSpread(_objectSpread(_objectSpread({
+          key: "dot-".concat(i),
+          r: 3
+        }, lineProps), customDotProps), {}, {
+          value: entry.value,
+          dataKey: dataKey,
+          cx: entry.x,
+          cy: entry.y,
+          index: i,
+          payload: entry.payload
+        });
+        return Line.renderDotItem(dot, dotProps);
+      });
+      var dotsProps = {
+        clipPath: needClip ? "url(#clipPath-".concat(clipDot ? '' : 'dots-').concat(clipPathId, ")") : null
+      };
+      return /*#__PURE__*/React.createElement(Layer, _extends({
+        className: "recharts-line-dots",
+        key: "dots"
+      }, dotsProps), dots);
+    }
+  }, {
+    key: "renderCurveStatically",
+    value: function renderCurveStatically(points, needClip, clipPathId, props) {
+      var _this$props3 = this.props,
+        type = _this$props3.type,
+        layout = _this$props3.layout,
+        connectNulls = _this$props3.connectNulls,
+        ref = _this$props3.ref,
+        others = _objectWithoutProperties(_this$props3, _excluded);
+      var curveProps = _objectSpread(_objectSpread(_objectSpread({}, filterProps(others, true)), {}, {
+        fill: 'none',
+        className: 'recharts-line-curve',
+        clipPath: needClip ? "url(#clipPath-".concat(clipPathId, ")") : null,
+        points: points
+      }, props), {}, {
+        type: type,
+        layout: layout,
+        connectNulls: connectNulls
+      });
+      return /*#__PURE__*/React.createElement(Curve, _extends({}, curveProps, {
+        pathRef: this.pathRef
+      }));
+    }
+  }, {
+    key: "renderCurveWithAnimation",
+    value: function renderCurveWithAnimation(needClip, clipPathId) {
+      var _this2 = this;
+      var _this$props4 = this.props,
+        points = _this$props4.points,
+        strokeDasharray = _this$props4.strokeDasharray,
+        isAnimationActive = _this$props4.isAnimationActive,
+        animationBegin = _this$props4.animationBegin,
+        animationDuration = _this$props4.animationDuration,
+        animationEasing = _this$props4.animationEasing,
+        animationId = _this$props4.animationId,
+        animateNewValues = _this$props4.animateNewValues,
+        width = _this$props4.width,
+        height = _this$props4.height;
+      var _this$state = this.state,
+        prevPoints = _this$state.prevPoints,
+        totalLength = _this$state.totalLength;
+      return /*#__PURE__*/React.createElement(Animate, {
+        begin: animationBegin,
+        duration: animationDuration,
+        isActive: isAnimationActive,
+        easing: animationEasing,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "line-".concat(animationId),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function (_ref) {
+        var t = _ref.t;
+        if (prevPoints) {
+          var prevPointsDiffFactor = prevPoints.length / points.length;
+          var stepData = points.map(function (entry, index) {
+            var prevPointIndex = Math.floor(index * prevPointsDiffFactor);
+            if (prevPoints[prevPointIndex]) {
+              var prev = prevPoints[prevPointIndex];
+              var interpolatorX = interpolateNumber(prev.x, entry.x);
+              var interpolatorY = interpolateNumber(prev.y, entry.y);
+              return _objectSpread(_objectSpread({}, entry), {}, {
+                x: interpolatorX(t),
+                y: interpolatorY(t)
+              });
+            }
+
+            // magic number of faking previous x and y location
+            if (animateNewValues) {
+              var _interpolatorX = interpolateNumber(width * 2, entry.x);
+              var _interpolatorY = interpolateNumber(height / 2, entry.y);
+              return _objectSpread(_objectSpread({}, entry), {}, {
+                x: _interpolatorX(t),
+                y: _interpolatorY(t)
+              });
+            }
+            return _objectSpread(_objectSpread({}, entry), {}, {
+              x: entry.x,
+              y: entry.y
+            });
+          });
+          return _this2.renderCurveStatically(stepData, needClip, clipPathId);
+        }
+        var interpolator = interpolateNumber(0, totalLength);
+        var curLength = interpolator(t);
+        var currentStrokeDasharray;
+        if (strokeDasharray) {
+          var lines = "".concat(strokeDasharray).split(/[,\s]+/gim).map(function (num) {
+            return parseFloat(num);
+          });
+          currentStrokeDasharray = _this2.getStrokeDasharray(curLength, totalLength, lines);
+        } else {
+          currentStrokeDasharray = _this2.generateSimpleStrokeDasharray(totalLength, curLength);
+        }
+        return _this2.renderCurveStatically(points, needClip, clipPathId, {
+          strokeDasharray: currentStrokeDasharray
+        });
+      });
+    }
+  }, {
+    key: "renderCurve",
+    value: function renderCurve(needClip, clipPathId) {
+      var _this$props5 = this.props,
+        points = _this$props5.points,
+        isAnimationActive = _this$props5.isAnimationActive;
+      var _this$state2 = this.state,
+        prevPoints = _this$state2.prevPoints,
+        totalLength = _this$state2.totalLength;
+      if (isAnimationActive && points && points.length && (!prevPoints && totalLength > 0 || !isEqual(prevPoints, points))) {
+        return this.renderCurveWithAnimation(needClip, clipPathId);
+      }
+      return this.renderCurveStatically(points, needClip, clipPathId);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _filterProps;
+      var _this$props6 = this.props,
+        hide = _this$props6.hide,
+        dot = _this$props6.dot,
+        points = _this$props6.points,
+        className = _this$props6.className,
+        xAxis = _this$props6.xAxis,
+        yAxis = _this$props6.yAxis,
+        top = _this$props6.top,
+        left = _this$props6.left,
+        width = _this$props6.width,
+        height = _this$props6.height,
+        isAnimationActive = _this$props6.isAnimationActive,
+        id = _this$props6.id;
+      if (hide || !points || !points.length) {
+        return null;
+      }
+      var isAnimationFinished = this.state.isAnimationFinished;
+      var hasSinglePoint = points.length === 1;
+      var layerClass = clsx('recharts-line', className);
+      var needClipX = xAxis && xAxis.allowDataOverflow;
+      var needClipY = yAxis && yAxis.allowDataOverflow;
+      var needClip = needClipX || needClipY;
+      var clipPathId = isNil(id) ? this.id : id;
+      var _ref2 = (_filterProps = filterProps(dot, false)) !== null && _filterProps !== void 0 ? _filterProps : {
+          r: 3,
+          strokeWidth: 2
+        },
+        _ref2$r = _ref2.r,
+        r = _ref2$r === void 0 ? 3 : _ref2$r,
+        _ref2$strokeWidth = _ref2.strokeWidth,
+        strokeWidth = _ref2$strokeWidth === void 0 ? 2 : _ref2$strokeWidth;
+      var _ref3 = isDotProps(dot) ? dot : {},
+        _ref3$clipDot = _ref3.clipDot,
+        clipDot = _ref3$clipDot === void 0 ? true : _ref3$clipDot;
+      var dotSize = r * 2 + strokeWidth;
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: layerClass
+      }, needClipX || needClipY ? /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("clipPath", {
+        id: "clipPath-".concat(clipPathId)
+      }, /*#__PURE__*/React.createElement("rect", {
+        x: needClipX ? left : left - width / 2,
+        y: needClipY ? top : top - height / 2,
+        width: needClipX ? width : width * 2,
+        height: needClipY ? height : height * 2
+      })), !clipDot && /*#__PURE__*/React.createElement("clipPath", {
+        id: "clipPath-dots-".concat(clipPathId)
+      }, /*#__PURE__*/React.createElement("rect", {
+        x: left - dotSize / 2,
+        y: top - dotSize / 2,
+        width: width + dotSize,
+        height: height + dotSize
+      }))) : null, !hasSinglePoint && this.renderCurve(needClip, clipPathId), this.renderErrorBar(needClip, clipPathId), (hasSinglePoint || dot) && this.renderDots(needClip, clipDot, clipPathId), (!isAnimationActive || isAnimationFinished) && LabelList.renderCallByParent(this.props, points));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      if (nextProps.animationId !== prevState.prevAnimationId) {
+        return {
+          prevAnimationId: nextProps.animationId,
+          curPoints: nextProps.points,
+          prevPoints: prevState.curPoints
+        };
+      }
+      if (nextProps.points !== prevState.curPoints) {
+        return {
+          curPoints: nextProps.points
+        };
+      }
+      return null;
+    }
+  }, {
+    key: "repeat",
+    value: function repeat(lines, count) {
+      var linesUnit = lines.length % 2 !== 0 ? [].concat(_toConsumableArray(lines), [0]) : lines;
+      var result = [];
+      for (var i = 0; i < count; ++i) {
+        result = [].concat(_toConsumableArray(result), _toConsumableArray(linesUnit));
+      }
+      return result;
+    }
+  }, {
+    key: "renderDotItem",
+    value: function renderDotItem(option, props) {
+      var dotItem;
+      if ( /*#__PURE__*/React.isValidElement(option)) {
+        dotItem = /*#__PURE__*/React.cloneElement(option, props);
+      } else if (isFunction(option)) {
+        dotItem = option(props);
+      } else {
+        var className = clsx('recharts-line-dot', typeof option !== 'boolean' ? option.className : '');
+        dotItem = /*#__PURE__*/React.createElement(Dot, _extends({}, props, {
+          className: className
+        }));
+      }
+      return dotItem;
+    }
+  }]);
+  return Line;
+}(PureComponent);
+_defineProperty(Line, "displayName", 'Line');
+_defineProperty(Line, "defaultProps", {
+  xAxisId: 0,
+  yAxisId: 0,
+  connectNulls: false,
+  activeDot: true,
+  dot: true,
+  legendType: 'line',
+  stroke: '#3182bd',
+  strokeWidth: 1,
+  fill: '#fff',
+  points: [],
+  isAnimationActive: !Global.isSsr,
+  animateNewValues: true,
+  animationBegin: 0,
+  animationDuration: 1500,
+  animationEasing: 'ease',
+  hide: false,
+  label: false
+});
+/**
+ * Compose the data of each group
+ * @param {Object} props The props from the component
+ * @param  {Object} xAxis   The configuration of x-axis
+ * @param  {Object} yAxis   The configuration of y-axis
+ * @param  {String} dataKey The unique key of a group
+ * @return {Array}  Composed data
+ */
+_defineProperty(Line, "getComposedData", function (_ref4) {
+  var props = _ref4.props,
+    xAxis = _ref4.xAxis,
+    yAxis = _ref4.yAxis,
+    xAxisTicks = _ref4.xAxisTicks,
+    yAxisTicks = _ref4.yAxisTicks,
+    dataKey = _ref4.dataKey,
+    bandSize = _ref4.bandSize,
+    displayedData = _ref4.displayedData,
+    offset = _ref4.offset;
+  var layout = props.layout;
+  var points = displayedData.map(function (entry, index) {
+    var value = getValueByDataKey(entry, dataKey);
+    if (layout === 'horizontal') {
+      return {
+        x: getCateCoordinateOfLine({
+          axis: xAxis,
+          ticks: xAxisTicks,
+          bandSize: bandSize,
+          entry: entry,
+          index: index
+        }),
+        y: isNil(value) ? null : yAxis.scale(value),
+        value: value,
+        payload: entry
+      };
+    }
+    return {
+      x: isNil(value) ? null : xAxis.scale(value),
+      y: getCateCoordinateOfLine({
+        axis: yAxis,
+        ticks: yAxisTicks,
+        bandSize: bandSize,
+        entry: entry,
+        index: index
+      }),
+      value: value,
+      payload: entry
+    };
+  });
+  return _objectSpread({
+    points: points,
+    layout: layout
+  }, offset);
+});

node_modules/recharts/es6/cartesian/ReferenceArea.js

@@ -0,0 +1,107 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Reference Line
+ */
+import React from 'react';
+import isFunction from 'lodash/isFunction';
+import clsx from 'clsx';
+import { Layer } from '../container/Layer';
+import { Label } from '../component/Label';
+import { createLabeledScales, rectWithPoints } from '../util/CartesianUtils';
+import { ifOverflowMatches } from '../util/IfOverflowMatches';
+import { isNumOrStr } from '../util/DataUtils';
+import { warn } from '../util/LogUtils';
+import { Rectangle } from '../shape/Rectangle';
+import { filterProps } from '../util/ReactUtils';
+var getRect = function getRect(hasX1, hasX2, hasY1, hasY2, props) {
+  var xValue1 = props.x1,
+    xValue2 = props.x2,
+    yValue1 = props.y1,
+    yValue2 = props.y2,
+    xAxis = props.xAxis,
+    yAxis = props.yAxis;
+  if (!xAxis || !yAxis) return null;
+  var scales = createLabeledScales({
+    x: xAxis.scale,
+    y: yAxis.scale
+  });
+  var p1 = {
+    x: hasX1 ? scales.x.apply(xValue1, {
+      position: 'start'
+    }) : scales.x.rangeMin,
+    y: hasY1 ? scales.y.apply(yValue1, {
+      position: 'start'
+    }) : scales.y.rangeMin
+  };
+  var p2 = {
+    x: hasX2 ? scales.x.apply(xValue2, {
+      position: 'end'
+    }) : scales.x.rangeMax,
+    y: hasY2 ? scales.y.apply(yValue2, {
+      position: 'end'
+    }) : scales.y.rangeMax
+  };
+  if (ifOverflowMatches(props, 'discard') && (!scales.isInRange(p1) || !scales.isInRange(p2))) {
+    return null;
+  }
+  return rectWithPoints(p1, p2);
+};
+export function ReferenceArea(props) {
+  var x1 = props.x1,
+    x2 = props.x2,
+    y1 = props.y1,
+    y2 = props.y2,
+    className = props.className,
+    alwaysShow = props.alwaysShow,
+    clipPathId = props.clipPathId;
+  warn(alwaysShow === undefined, 'The alwaysShow prop is deprecated. Please use ifOverflow="extendDomain" instead.');
+  var hasX1 = isNumOrStr(x1);
+  var hasX2 = isNumOrStr(x2);
+  var hasY1 = isNumOrStr(y1);
+  var hasY2 = isNumOrStr(y2);
+  var shape = props.shape;
+  if (!hasX1 && !hasX2 && !hasY1 && !hasY2 && !shape) {
+    return null;
+  }
+  var rect = getRect(hasX1, hasX2, hasY1, hasY2, props);
+  if (!rect && !shape) {
+    return null;
+  }
+  var clipPath = ifOverflowMatches(props, 'hidden') ? "url(#".concat(clipPathId, ")") : undefined;
+  return /*#__PURE__*/React.createElement(Layer, {
+    className: clsx('recharts-reference-area', className)
+  }, ReferenceArea.renderRect(shape, _objectSpread(_objectSpread({
+    clipPath: clipPath
+  }, filterProps(props, true)), rect)), Label.renderCallByParent(props, rect));
+}
+ReferenceArea.displayName = 'ReferenceArea';
+ReferenceArea.defaultProps = {
+  isFront: false,
+  ifOverflow: 'discard',
+  xAxisId: 0,
+  yAxisId: 0,
+  r: 10,
+  fill: '#ccc',
+  fillOpacity: 0.5,
+  stroke: 'none',
+  strokeWidth: 1
+};
+ReferenceArea.renderRect = function (option, props) {
+  var rect;
+  if ( /*#__PURE__*/React.isValidElement(option)) {
+    rect = /*#__PURE__*/React.cloneElement(option, props);
+  } else if (isFunction(option)) {
+    rect = option(props);
+  } else {
+    rect = /*#__PURE__*/React.createElement(Rectangle, _extends({}, props, {
+      className: "recharts-reference-area-rect"
+    }));
+  }
+  return rect;
+};

node_modules/recharts/es6/cartesian/ReferenceDot.js

@@ -0,0 +1,104 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Reference Dot
+ */
+import React from 'react';
+import isFunction from 'lodash/isFunction';
+import clsx from 'clsx';
+import { Layer } from '../container/Layer';
+import { Dot } from '../shape/Dot';
+import { Label } from '../component/Label';
+import { isNumOrStr } from '../util/DataUtils';
+import { ifOverflowMatches } from '../util/IfOverflowMatches';
+import { createLabeledScales } from '../util/CartesianUtils';
+import { warn } from '../util/LogUtils';
+import { filterProps } from '../util/ReactUtils';
+var getCoordinate = function getCoordinate(props) {
+  var x = props.x,
+    y = props.y,
+    xAxis = props.xAxis,
+    yAxis = props.yAxis;
+  var scales = createLabeledScales({
+    x: xAxis.scale,
+    y: yAxis.scale
+  });
+  var result = scales.apply({
+    x: x,
+    y: y
+  }, {
+    bandAware: true
+  });
+  if (ifOverflowMatches(props, 'discard') && !scales.isInRange(result)) {
+    return null;
+  }
+  return result;
+};
+export function ReferenceDot(props) {
+  var x = props.x,
+    y = props.y,
+    r = props.r,
+    alwaysShow = props.alwaysShow,
+    clipPathId = props.clipPathId;
+  var isX = isNumOrStr(x);
+  var isY = isNumOrStr(y);
+  warn(alwaysShow === undefined, 'The alwaysShow prop is deprecated. Please use ifOverflow="extendDomain" instead.');
+  if (!isX || !isY) {
+    return null;
+  }
+  var coordinate = getCoordinate(props);
+  if (!coordinate) {
+    return null;
+  }
+  var cx = coordinate.x,
+    cy = coordinate.y;
+  var shape = props.shape,
+    className = props.className;
+  var clipPath = ifOverflowMatches(props, 'hidden') ? "url(#".concat(clipPathId, ")") : undefined;
+  var dotProps = _objectSpread(_objectSpread({
+    clipPath: clipPath
+  }, filterProps(props, true)), {}, {
+    cx: cx,
+    cy: cy
+  });
+  return /*#__PURE__*/React.createElement(Layer, {
+    className: clsx('recharts-reference-dot', className)
+  }, ReferenceDot.renderDot(shape, dotProps), Label.renderCallByParent(props, {
+    x: cx - r,
+    y: cy - r,
+    width: 2 * r,
+    height: 2 * r
+  }));
+}
+ReferenceDot.displayName = 'ReferenceDot';
+ReferenceDot.defaultProps = {
+  isFront: false,
+  ifOverflow: 'discard',
+  xAxisId: 0,
+  yAxisId: 0,
+  r: 10,
+  fill: '#fff',
+  stroke: '#ccc',
+  fillOpacity: 1,
+  strokeWidth: 1
+};
+ReferenceDot.renderDot = function (option, props) {
+  var dot;
+  if ( /*#__PURE__*/React.isValidElement(option)) {
+    dot = /*#__PURE__*/React.cloneElement(option, props);
+  } else if (isFunction(option)) {
+    dot = option(props);
+  } else {
+    dot = /*#__PURE__*/React.createElement(Dot, _extends({}, props, {
+      cx: props.cx,
+      cy: props.cy,
+      className: "recharts-reference-dot-dot"
+    }));
+  }
+  return dot;
+};

node_modules/recharts/es6/cartesian/ReferenceLine.js

@@ -0,0 +1,170 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+/**
+ * @fileOverview Reference Line
+ */
+import React from 'react';
+import isFunction from 'lodash/isFunction';
+import some from 'lodash/some';
+import clsx from 'clsx';
+import { Layer } from '../container/Layer';
+import { Label } from '../component/Label';
+import { ifOverflowMatches } from '../util/IfOverflowMatches';
+import { isNumOrStr } from '../util/DataUtils';
+import { createLabeledScales, rectWithCoords } from '../util/CartesianUtils';
+import { warn } from '../util/LogUtils';
+import { filterProps } from '../util/ReactUtils';
+import { useClipPathId, useViewBox, useXAxisOrThrow, useYAxisOrThrow } from '../context/chartLayoutContext';
+
+/**
+ * This excludes `viewBox` prop from svg for two reasons:
+ * 1. The components wants viewBox of object type, and svg wants string
+ *    - so there's a conflict, and the component will throw if it gets string
+ * 2. Internally the component calls `filterProps` which filters the viewBox away anyway
+ */
+
+var renderLine = function renderLine(option, props) {
+  var line;
+  if ( /*#__PURE__*/React.isValidElement(option)) {
+    line = /*#__PURE__*/React.cloneElement(option, props);
+  } else if (isFunction(option)) {
+    line = option(props);
+  } else {
+    line = /*#__PURE__*/React.createElement("line", _extends({}, props, {
+      className: "recharts-reference-line-line"
+    }));
+  }
+  return line;
+};
+// TODO: ScaleHelper
+export var getEndPoints = function getEndPoints(scales, isFixedX, isFixedY, isSegment, viewBox, position, xAxisOrientation, yAxisOrientation, props) {
+  var x = viewBox.x,
+    y = viewBox.y,
+    width = viewBox.width,
+    height = viewBox.height;
+  if (isFixedY) {
+    var yCoord = props.y;
+    var coord = scales.y.apply(yCoord, {
+      position: position
+    });
+    if (ifOverflowMatches(props, 'discard') && !scales.y.isInRange(coord)) {
+      return null;
+    }
+    var points = [{
+      x: x + width,
+      y: coord
+    }, {
+      x: x,
+      y: coord
+    }];
+    return yAxisOrientation === 'left' ? points.reverse() : points;
+  }
+  if (isFixedX) {
+    var xCoord = props.x;
+    var _coord = scales.x.apply(xCoord, {
+      position: position
+    });
+    if (ifOverflowMatches(props, 'discard') && !scales.x.isInRange(_coord)) {
+      return null;
+    }
+    var _points = [{
+      x: _coord,
+      y: y + height
+    }, {
+      x: _coord,
+      y: y
+    }];
+    return xAxisOrientation === 'top' ? _points.reverse() : _points;
+  }
+  if (isSegment) {
+    var segment = props.segment;
+    var _points2 = segment.map(function (p) {
+      return scales.apply(p, {
+        position: position
+      });
+    });
+    if (ifOverflowMatches(props, 'discard') && some(_points2, function (p) {
+      return !scales.isInRange(p);
+    })) {
+      return null;
+    }
+    return _points2;
+  }
+  return null;
+};
+export function ReferenceLine(props) {
+  var fixedX = props.x,
+    fixedY = props.y,
+    segment = props.segment,
+    xAxisId = props.xAxisId,
+    yAxisId = props.yAxisId,
+    shape = props.shape,
+    className = props.className,
+    alwaysShow = props.alwaysShow;
+  var clipPathId = useClipPathId();
+  var xAxis = useXAxisOrThrow(xAxisId);
+  var yAxis = useYAxisOrThrow(yAxisId);
+  var viewBox = useViewBox();
+  if (!clipPathId || !viewBox) {
+    return null;
+  }
+  warn(alwaysShow === undefined, 'The alwaysShow prop is deprecated. Please use ifOverflow="extendDomain" instead.');
+  var scales = createLabeledScales({
+    x: xAxis.scale,
+    y: yAxis.scale
+  });
+  var isX = isNumOrStr(fixedX);
+  var isY = isNumOrStr(fixedY);
+  var isSegment = segment && segment.length === 2;
+  var endPoints = getEndPoints(scales, isX, isY, isSegment, viewBox, props.position, xAxis.orientation, yAxis.orientation, props);
+  if (!endPoints) {
+    return null;
+  }
+  var _endPoints = _slicedToArray(endPoints, 2),
+    _endPoints$ = _endPoints[0],
+    x1 = _endPoints$.x,
+    y1 = _endPoints$.y,
+    _endPoints$2 = _endPoints[1],
+    x2 = _endPoints$2.x,
+    y2 = _endPoints$2.y;
+  var clipPath = ifOverflowMatches(props, 'hidden') ? "url(#".concat(clipPathId, ")") : undefined;
+  var lineProps = _objectSpread(_objectSpread({
+    clipPath: clipPath
+  }, filterProps(props, true)), {}, {
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2
+  });
+  return /*#__PURE__*/React.createElement(Layer, {
+    className: clsx('recharts-reference-line', className)
+  }, renderLine(shape, lineProps), Label.renderCallByParent(props, rectWithCoords({
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2
+  })));
+}
+ReferenceLine.displayName = 'ReferenceLine';
+ReferenceLine.defaultProps = {
+  isFront: false,
+  ifOverflow: 'discard',
+  xAxisId: 0,
+  yAxisId: 0,
+  fill: 'none',
+  stroke: '#ccc',
+  fillOpacity: 1,
+  strokeWidth: 1,
+  position: 'middle'
+};

node_modules/recharts/es6/cartesian/Scatter.js

@@ -0,0 +1,419 @@
+var _Scatter;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * @fileOverview Render a group of scatters
+ */
+import React, { PureComponent } from 'react';
+import Animate from 'react-smooth';
+import isNil from 'lodash/isNil';
+import isEqual from 'lodash/isEqual';
+import isFunction from 'lodash/isFunction';
+import clsx from 'clsx';
+import { Layer } from '../container/Layer';
+import { LabelList } from '../component/LabelList';
+import { findAllByType, filterProps } from '../util/ReactUtils';
+import { Global } from '../util/Global';
+import { ZAxis } from './ZAxis';
+import { Curve } from '../shape/Curve';
+import { ErrorBar } from './ErrorBar';
+import { Cell } from '../component/Cell';
+import { uniqueId, interpolateNumber, getLinearRegression } from '../util/DataUtils';
+import { getValueByDataKey, getCateCoordinateOfLine } from '../util/ChartUtils';
+import { adaptEventsOfChild } from '../util/types';
+import { ScatterSymbol } from '../util/ScatterUtils';
+export var Scatter = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Scatter, _PureComponent);
+  function Scatter() {
+    var _this;
+    _classCallCheck(this, Scatter);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, Scatter, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      isAnimationFinished: false
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationEnd", function () {
+      _this.setState({
+        isAnimationFinished: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleAnimationStart", function () {
+      _this.setState({
+        isAnimationFinished: false
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "id", uniqueId('recharts-scatter-'));
+    return _this;
+  }
+  _createClass(Scatter, [{
+    key: "renderSymbolsStatically",
+    value: function renderSymbolsStatically(points) {
+      var _this2 = this;
+      var _this$props = this.props,
+        shape = _this$props.shape,
+        activeShape = _this$props.activeShape,
+        activeIndex = _this$props.activeIndex;
+      var baseProps = filterProps(this.props, false);
+      return points.map(function (entry, i) {
+        var isActive = activeIndex === i;
+        var option = isActive ? activeShape : shape;
+        var props = _objectSpread(_objectSpread({
+          key: "symbol-".concat(i)
+        }, baseProps), entry);
+        return /*#__PURE__*/React.createElement(Layer, _extends({
+          className: "recharts-scatter-symbol"
+        }, adaptEventsOfChild(_this2.props, entry, i), {
+          // eslint-disable-next-line react/no-array-index-key
+          key: "symbol-".concat(entry === null || entry === void 0 ? void 0 : entry.cx, "-").concat(entry === null || entry === void 0 ? void 0 : entry.cy, "-").concat(entry === null || entry === void 0 ? void 0 : entry.size, "-").concat(i),
+          role: "img"
+        }), /*#__PURE__*/React.createElement(ScatterSymbol, _extends({
+          option: option,
+          isActive: isActive
+        }, props)));
+      });
+    }
+  }, {
+    key: "renderSymbolsWithAnimation",
+    value: function renderSymbolsWithAnimation() {
+      var _this3 = this;
+      var _this$props2 = this.props,
+        points = _this$props2.points,
+        isAnimationActive = _this$props2.isAnimationActive,
+        animationBegin = _this$props2.animationBegin,
+        animationDuration = _this$props2.animationDuration,
+        animationEasing = _this$props2.animationEasing,
+        animationId = _this$props2.animationId;
+      var prevPoints = this.state.prevPoints;
+      return /*#__PURE__*/React.createElement(Animate, {
+        begin: animationBegin,
+        duration: animationDuration,
+        isActive: isAnimationActive,
+        easing: animationEasing,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "pie-".concat(animationId),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function (_ref) {
+        var t = _ref.t;
+        var stepData = points.map(function (entry, index) {
+          var prev = prevPoints && prevPoints[index];
+          if (prev) {
+            var interpolatorCx = interpolateNumber(prev.cx, entry.cx);
+            var interpolatorCy = interpolateNumber(prev.cy, entry.cy);
+            var interpolatorSize = interpolateNumber(prev.size, entry.size);
+            return _objectSpread(_objectSpread({}, entry), {}, {
+              cx: interpolatorCx(t),
+              cy: interpolatorCy(t),
+              size: interpolatorSize(t)
+            });
+          }
+          var interpolator = interpolateNumber(0, entry.size);
+          return _objectSpread(_objectSpread({}, entry), {}, {
+            size: interpolator(t)
+          });
+        });
+        return /*#__PURE__*/React.createElement(Layer, null, _this3.renderSymbolsStatically(stepData));
+      });
+    }
+  }, {
+    key: "renderSymbols",
+    value: function renderSymbols() {
+      var _this$props3 = this.props,
+        points = _this$props3.points,
+        isAnimationActive = _this$props3.isAnimationActive;
+      var prevPoints = this.state.prevPoints;
+      if (isAnimationActive && points && points.length && (!prevPoints || !isEqual(prevPoints, points))) {
+        return this.renderSymbolsWithAnimation();
+      }
+      return this.renderSymbolsStatically(points);
+    }
+  }, {
+    key: "renderErrorBar",
+    value: function renderErrorBar() {
+      var isAnimationActive = this.props.isAnimationActive;
+      if (isAnimationActive && !this.state.isAnimationFinished) {
+        return null;
+      }
+      var _this$props4 = this.props,
+        points = _this$props4.points,
+        xAxis = _this$props4.xAxis,
+        yAxis = _this$props4.yAxis,
+        children = _this$props4.children;
+      var errorBarItems = findAllByType(children, ErrorBar);
+      if (!errorBarItems) {
+        return null;
+      }
+      return errorBarItems.map(function (item, i) {
+        var _item$props = item.props,
+          direction = _item$props.direction,
+          errorDataKey = _item$props.dataKey;
+        return /*#__PURE__*/React.cloneElement(item, {
+          key: "".concat(direction, "-").concat(errorDataKey, "-").concat(points[i]),
+          data: points,
+          xAxis: xAxis,
+          yAxis: yAxis,
+          layout: direction === 'x' ? 'vertical' : 'horizontal',
+          dataPointFormatter: function dataPointFormatter(dataPoint, dataKey) {
+            return {
+              x: dataPoint.cx,
+              y: dataPoint.cy,
+              value: direction === 'x' ? +dataPoint.node.x : +dataPoint.node.y,
+              errorVal: getValueByDataKey(dataPoint, dataKey)
+            };
+          }
+        });
+      });
+    }
+  }, {
+    key: "renderLine",
+    value: function renderLine() {
+      var _this$props5 = this.props,
+        points = _this$props5.points,
+        line = _this$props5.line,
+        lineType = _this$props5.lineType,
+        lineJointType = _this$props5.lineJointType;
+      var scatterProps = filterProps(this.props, false);
+      var customLineProps = filterProps(line, false);
+      var linePoints, lineItem;
+      if (lineType === 'joint') {
+        linePoints = points.map(function (entry) {
+          return {
+            x: entry.cx,
+            y: entry.cy
+          };
+        });
+      } else if (lineType === 'fitting') {
+        var _getLinearRegression = getLinearRegression(points),
+          xmin = _getLinearRegression.xmin,
+          xmax = _getLinearRegression.xmax,
+          a = _getLinearRegression.a,
+          b = _getLinearRegression.b;
+        var linearExp = function linearExp(x) {
+          return a * x + b;
+        };
+        linePoints = [{
+          x: xmin,
+          y: linearExp(xmin)
+        }, {
+          x: xmax,
+          y: linearExp(xmax)
+        }];
+      }
+      var lineProps = _objectSpread(_objectSpread(_objectSpread({}, scatterProps), {}, {
+        fill: 'none',
+        stroke: scatterProps && scatterProps.fill
+      }, customLineProps), {}, {
+        points: linePoints
+      });
+      if ( /*#__PURE__*/React.isValidElement(line)) {
+        lineItem = /*#__PURE__*/React.cloneElement(line, lineProps);
+      } else if (isFunction(line)) {
+        lineItem = line(lineProps);
+      } else {
+        lineItem = /*#__PURE__*/React.createElement(Curve, _extends({}, lineProps, {
+          type: lineJointType
+        }));
+      }
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: "recharts-scatter-line",
+        key: "recharts-scatter-line"
+      }, lineItem);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props6 = this.props,
+        hide = _this$props6.hide,
+        points = _this$props6.points,
+        line = _this$props6.line,
+        className = _this$props6.className,
+        xAxis = _this$props6.xAxis,
+        yAxis = _this$props6.yAxis,
+        left = _this$props6.left,
+        top = _this$props6.top,
+        width = _this$props6.width,
+        height = _this$props6.height,
+        id = _this$props6.id,
+        isAnimationActive = _this$props6.isAnimationActive;
+      if (hide || !points || !points.length) {
+        return null;
+      }
+      var isAnimationFinished = this.state.isAnimationFinished;
+      var layerClass = clsx('recharts-scatter', className);
+      var needClipX = xAxis && xAxis.allowDataOverflow;
+      var needClipY = yAxis && yAxis.allowDataOverflow;
+      var needClip = needClipX || needClipY;
+      var clipPathId = isNil(id) ? this.id : id;
+      return /*#__PURE__*/React.createElement(Layer, {
+        className: layerClass,
+        clipPath: needClip ? "url(#clipPath-".concat(clipPathId, ")") : null
+      }, needClipX || needClipY ? /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("clipPath", {
+        id: "clipPath-".concat(clipPathId)
+      }, /*#__PURE__*/React.createElement("rect", {
+        x: needClipX ? left : left - width / 2,
+        y: needClipY ? top : top - height / 2,
+        width: needClipX ? width : width * 2,
+        height: needClipY ? height : height * 2
+      }))) : null, line && this.renderLine(), this.renderErrorBar(), /*#__PURE__*/React.createElement(Layer, {
+        key: "recharts-scatter-symbols"
+      }, this.renderSymbols()), (!isAnimationActive || isAnimationFinished) && LabelList.renderCallByParent(this.props, points));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      if (nextProps.animationId !== prevState.prevAnimationId) {
+        return {
+          prevAnimationId: nextProps.animationId,
+          curPoints: nextProps.points,
+          prevPoints: prevState.curPoints
+        };
+      }
+      if (nextProps.points !== prevState.curPoints) {
+        return {
+          curPoints: nextProps.points
+        };
+      }
+      return null;
+    }
+  }]);
+  return Scatter;
+}(PureComponent);
+_Scatter = Scatter;
+_defineProperty(Scatter, "displayName", 'Scatter');
+_defineProperty(Scatter, "defaultProps", {
+  xAxisId: 0,
+  yAxisId: 0,
+  zAxisId: 0,
+  legendType: 'circle',
+  lineType: 'joint',
+  lineJointType: 'linear',
+  data: [],
+  shape: 'circle',
+  hide: false,
+  isAnimationActive: !Global.isSsr,
+  animationBegin: 0,
+  animationDuration: 400,
+  animationEasing: 'linear'
+});
+/**
+ * Compose the data of each group
+ * @param  {Object} xAxis   The configuration of x-axis
+ * @param  {Object} yAxis   The configuration of y-axis
+ * @param  {String} dataKey The unique key of a group
+ * @return {Array}  Composed data
+ */
+_defineProperty(Scatter, "getComposedData", function (_ref2) {
+  var xAxis = _ref2.xAxis,
+    yAxis = _ref2.yAxis,
+    zAxis = _ref2.zAxis,
+    item = _ref2.item,
+    displayedData = _ref2.displayedData,
+    xAxisTicks = _ref2.xAxisTicks,
+    yAxisTicks = _ref2.yAxisTicks,
+    offset = _ref2.offset;
+  var tooltipType = item.props.tooltipType;
+  var cells = findAllByType(item.props.children, Cell);
+  var xAxisDataKey = isNil(xAxis.dataKey) ? item.props.dataKey : xAxis.dataKey;
+  var yAxisDataKey = isNil(yAxis.dataKey) ? item.props.dataKey : yAxis.dataKey;
+  var zAxisDataKey = zAxis && zAxis.dataKey;
+  var defaultRangeZ = zAxis ? zAxis.range : ZAxis.defaultProps.range;
+  var defaultZ = defaultRangeZ && defaultRangeZ[0];
+  var xBandSize = xAxis.scale.bandwidth ? xAxis.scale.bandwidth() : 0;
+  var yBandSize = yAxis.scale.bandwidth ? yAxis.scale.bandwidth() : 0;
+  var points = displayedData.map(function (entry, index) {
+    var x = getValueByDataKey(entry, xAxisDataKey);
+    var y = getValueByDataKey(entry, yAxisDataKey);
+    var z = !isNil(zAxisDataKey) && getValueByDataKey(entry, zAxisDataKey) || '-';
+    var tooltipPayload = [{
+      name: isNil(xAxis.dataKey) ? item.props.name : xAxis.name || xAxis.dataKey,
+      unit: xAxis.unit || '',
+      value: x,
+      payload: entry,
+      dataKey: xAxisDataKey,
+      type: tooltipType
+    }, {
+      name: isNil(yAxis.dataKey) ? item.props.name : yAxis.name || yAxis.dataKey,
+      unit: yAxis.unit || '',
+      value: y,
+      payload: entry,
+      dataKey: yAxisDataKey,
+      type: tooltipType
+    }];
+    if (z !== '-') {
+      tooltipPayload.push({
+        name: zAxis.name || zAxis.dataKey,
+        unit: zAxis.unit || '',
+        value: z,
+        payload: entry,
+        dataKey: zAxisDataKey,
+        type: tooltipType
+      });
+    }
+    var cx = getCateCoordinateOfLine({
+      axis: xAxis,
+      ticks: xAxisTicks,
+      bandSize: xBandSize,
+      entry: entry,
+      index: index,
+      dataKey: xAxisDataKey
+    });
+    var cy = getCateCoordinateOfLine({
+      axis: yAxis,
+      ticks: yAxisTicks,
+      bandSize: yBandSize,
+      entry: entry,
+      index: index,
+      dataKey: yAxisDataKey
+    });
+    var size = z !== '-' ? zAxis.scale(z) : defaultZ;
+    var radius = Math.sqrt(Math.max(size, 0) / Math.PI);
+    return _objectSpread(_objectSpread({}, entry), {}, {
+      cx: cx,
+      cy: cy,
+      x: cx - radius,
+      y: cy - radius,
+      xAxis: xAxis,
+      yAxis: yAxis,
+      zAxis: zAxis,
+      width: 2 * radius,
+      height: 2 * radius,
+      size: size,
+      node: {
+        x: x,
+        y: y,
+        z: z
+      },
+      tooltipPayload: tooltipPayload,
+      tooltipPosition: {
+        x: cx,
+        y: cy
+      },
+      payload: entry
+    }, cells && cells[index] && cells[index].props);
+  });
+  return _objectSpread({
+    points: points
+  }, offset);
+});

node_modules/recharts/es6/cartesian/XAxis.js

@@ -0,0 +1,58 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+/**
+ * @fileOverview X Axis
+ */
+
+import React from 'react';
+import clsx from 'clsx';
+import { useChartHeight, useChartWidth, useXAxisOrThrow } from '../context/chartLayoutContext';
+import { CartesianAxis } from './CartesianAxis';
+import { getTicksOfAxis } from '../util/ChartUtils';
+
+/** Define of XAxis props */
+
+export var XAxis = function XAxis(_ref) {
+  var xAxisId = _ref.xAxisId;
+  var width = useChartWidth();
+  var height = useChartHeight();
+  var axisOptions = useXAxisOrThrow(xAxisId);
+  if (axisOptions == null) {
+    return null;
+  }
+  return (
+    /*#__PURE__*/
+    // @ts-expect-error the axisOptions type is not exactly what CartesianAxis is expecting.
+    React.createElement(CartesianAxis, _extends({}, axisOptions, {
+      className: clsx("recharts-".concat(axisOptions.axisType, " ").concat(axisOptions.axisType), axisOptions.className),
+      viewBox: {
+        x: 0,
+        y: 0,
+        width: width,
+        height: height
+      },
+      ticksGenerator: function ticksGenerator(axis) {
+        return getTicksOfAxis(axis, true);
+      }
+    }))
+  );
+};
+XAxis.displayName = 'XAxis';
+XAxis.defaultProps = {
+  allowDecimals: true,
+  hide: false,
+  orientation: 'bottom',
+  width: 0,
+  height: 30,
+  mirror: false,
+  xAxisId: 0,
+  tickCount: 5,
+  type: 'category',
+  padding: {
+    left: 0,
+    right: 0
+  },
+  allowDataOverflow: false,
+  scale: 'auto',
+  reversed: false,
+  allowDuplicatedCategory: true
+};

node_modules/recharts/es6/cartesian/YAxis.js

@@ -0,0 +1,54 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+/**
+ * @fileOverview Y Axis
+ */
+import React from 'react';
+import clsx from 'clsx';
+import { useChartHeight, useChartWidth, useYAxisOrThrow } from '../context/chartLayoutContext';
+import { CartesianAxis } from './CartesianAxis';
+import { getTicksOfAxis } from '../util/ChartUtils';
+export var YAxis = function YAxis(_ref) {
+  var yAxisId = _ref.yAxisId;
+  var width = useChartWidth();
+  var height = useChartHeight();
+  var axisOptions = useYAxisOrThrow(yAxisId);
+  if (axisOptions == null) {
+    return null;
+  }
+  return (
+    /*#__PURE__*/
+    // @ts-expect-error the axisOptions type is not exactly what CartesianAxis is expecting.
+    React.createElement(CartesianAxis, _extends({}, axisOptions, {
+      className: clsx("recharts-".concat(axisOptions.axisType, " ").concat(axisOptions.axisType), axisOptions.className),
+      viewBox: {
+        x: 0,
+        y: 0,
+        width: width,
+        height: height
+      },
+      ticksGenerator: function ticksGenerator(axis) {
+        return getTicksOfAxis(axis, true);
+      }
+    }))
+  );
+};
+YAxis.displayName = 'YAxis';
+YAxis.defaultProps = {
+  allowDuplicatedCategory: true,
+  allowDecimals: true,
+  hide: false,
+  orientation: 'left',
+  width: 60,
+  height: 0,
+  mirror: false,
+  yAxisId: 0,
+  tickCount: 5,
+  type: 'number',
+  padding: {
+    top: 0,
+    bottom: 0
+  },
+  allowDataOverflow: false,
+  scale: 'auto',
+  reversed: false
+};

node_modules/recharts/es6/cartesian/ZAxis.js

@@ -0,0 +1,14 @@
+/**
+ * @fileOverview Z Axis
+ */
+
+export var ZAxis = function ZAxis() {
+  return null;
+};
+ZAxis.displayName = 'ZAxis';
+ZAxis.defaultProps = {
+  zAxisId: 0,
+  range: [64, 64],
+  scale: 'auto',
+  type: 'number'
+};

node_modules/recharts/es6/cartesian/getEquidistantTicks.js

@@ -0,0 +1,55 @@
+import { isVisible } from '../util/TickUtils';
+import { getEveryNthWithCondition } from '../util/getEveryNthWithCondition';
+export function getEquidistantTicks(sign, boundaries, getTickSize, ticks, minTickGap) {
+  var result = (ticks || []).slice();
+  var initialStart = boundaries.start,
+    end = boundaries.end;
+  var index = 0;
+  // Premature optimisation idea 1: Estimate a lower bound, and start from there.
+  // For now, start from every tick
+  var stepsize = 1;
+  var start = initialStart;
+  var _loop = function _loop() {
+      // Given stepsize, evaluate whether every stepsize-th tick can be shown.
+      // If it can not, then increase the stepsize by 1, and try again.
+
+      var entry = ticks === null || ticks === void 0 ? void 0 : ticks[index];
+
+      // Break condition - If we have evaluate all the ticks, then we are done.
+      if (entry === undefined) {
+        return {
+          v: getEveryNthWithCondition(ticks, stepsize)
+        };
+      }
+
+      // Check if the element collides with the next element
+      var i = index;
+      var size;
+      var getSize = function getSize() {
+        if (size === undefined) {
+          size = getTickSize(entry, i);
+        }
+        return size;
+      };
+      var tickCoord = entry.coordinate;
+      // We will always show the first tick.
+      var isShow = index === 0 || isVisible(sign, tickCoord, getSize, start, end);
+      if (!isShow) {
+        // Start all over with a larger stepsize
+        index = 0;
+        start = initialStart;
+        stepsize += 1;
+      }
+      if (isShow) {
+        // If it can be shown, update the start
+        start = tickCoord + sign * (getSize() / 2 + minTickGap);
+        index += stepsize;
+      }
+    },
+    _ret;
+  while (stepsize <= result.length) {
+    _ret = _loop();
+    if (_ret) return _ret.v;
+  }
+  return [];
+}

node_modules/recharts/es6/cartesian/getTicks.js

@@ -0,0 +1,155 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import isFunction from 'lodash/isFunction';
+import { mathSign, isNumber } from '../util/DataUtils';
+import { getStringSize } from '../util/DOMUtils';
+import { Global } from '../util/Global';
+import { isVisible, getTickBoundaries, getNumberIntervalTicks, getAngledTickWidth } from '../util/TickUtils';
+import { getEquidistantTicks } from './getEquidistantTicks';
+function getTicksEnd(sign, boundaries, getTickSize, ticks, minTickGap) {
+  var result = (ticks || []).slice();
+  var len = result.length;
+  var start = boundaries.start;
+  var end = boundaries.end;
+  var _loop = function _loop(i) {
+    var entry = result[i];
+    var size;
+    var getSize = function getSize() {
+      if (size === undefined) {
+        size = getTickSize(entry, i);
+      }
+      return size;
+    };
+    if (i === len - 1) {
+      var gap = sign * (entry.coordinate + sign * getSize() / 2 - end);
+      result[i] = entry = _objectSpread(_objectSpread({}, entry), {}, {
+        tickCoord: gap > 0 ? entry.coordinate - gap * sign : entry.coordinate
+      });
+    } else {
+      result[i] = entry = _objectSpread(_objectSpread({}, entry), {}, {
+        tickCoord: entry.coordinate
+      });
+    }
+    var isShow = isVisible(sign, entry.tickCoord, getSize, start, end);
+    if (isShow) {
+      end = entry.tickCoord - sign * (getSize() / 2 + minTickGap);
+      result[i] = _objectSpread(_objectSpread({}, entry), {}, {
+        isShow: true
+      });
+    }
+  };
+  for (var i = len - 1; i >= 0; i--) {
+    _loop(i);
+  }
+  return result;
+}
+function getTicksStart(sign, boundaries, getTickSize, ticks, minTickGap, preserveEnd) {
+  var result = (ticks || []).slice();
+  var len = result.length;
+  var start = boundaries.start,
+    end = boundaries.end;
+  if (preserveEnd) {
+    // Try to guarantee the tail to be displayed
+    var tail = ticks[len - 1];
+    var tailSize = getTickSize(tail, len - 1);
+    var tailGap = sign * (tail.coordinate + sign * tailSize / 2 - end);
+    result[len - 1] = tail = _objectSpread(_objectSpread({}, tail), {}, {
+      tickCoord: tailGap > 0 ? tail.coordinate - tailGap * sign : tail.coordinate
+    });
+    var isTailShow = isVisible(sign, tail.tickCoord, function () {
+      return tailSize;
+    }, start, end);
+    if (isTailShow) {
+      end = tail.tickCoord - sign * (tailSize / 2 + minTickGap);
+      result[len - 1] = _objectSpread(_objectSpread({}, tail), {}, {
+        isShow: true
+      });
+    }
+  }
+  var count = preserveEnd ? len - 1 : len;
+  var _loop2 = function _loop2(i) {
+    var entry = result[i];
+    var size;
+    var getSize = function getSize() {
+      if (size === undefined) {
+        size = getTickSize(entry, i);
+      }
+      return size;
+    };
+    if (i === 0) {
+      var gap = sign * (entry.coordinate - sign * getSize() / 2 - start);
+      result[i] = entry = _objectSpread(_objectSpread({}, entry), {}, {
+        tickCoord: gap < 0 ? entry.coordinate - gap * sign : entry.coordinate
+      });
+    } else {
+      result[i] = entry = _objectSpread(_objectSpread({}, entry), {}, {
+        tickCoord: entry.coordinate
+      });
+    }
+    var isShow = isVisible(sign, entry.tickCoord, getSize, start, end);
+    if (isShow) {
+      start = entry.tickCoord + sign * (getSize() / 2 + minTickGap);
+      result[i] = _objectSpread(_objectSpread({}, entry), {}, {
+        isShow: true
+      });
+    }
+  };
+  for (var i = 0; i < count; i++) {
+    _loop2(i);
+  }
+  return result;
+}
+export function getTicks(props, fontSize, letterSpacing) {
+  var tick = props.tick,
+    ticks = props.ticks,
+    viewBox = props.viewBox,
+    minTickGap = props.minTickGap,
+    orientation = props.orientation,
+    interval = props.interval,
+    tickFormatter = props.tickFormatter,
+    unit = props.unit,
+    angle = props.angle;
+  if (!ticks || !ticks.length || !tick) {
+    return [];
+  }
+  if (isNumber(interval) || Global.isSsr) {
+    return getNumberIntervalTicks(ticks, typeof interval === 'number' && isNumber(interval) ? interval : 0);
+  }
+  var candidates = [];
+  var sizeKey = orientation === 'top' || orientation === 'bottom' ? 'width' : 'height';
+  var unitSize = unit && sizeKey === 'width' ? getStringSize(unit, {
+    fontSize: fontSize,
+    letterSpacing: letterSpacing
+  }) : {
+    width: 0,
+    height: 0
+  };
+  var getTickSize = function getTickSize(content, index) {
+    var value = isFunction(tickFormatter) ? tickFormatter(content.value, index) : content.value;
+    // Recharts only supports angles when sizeKey === 'width'
+    return sizeKey === 'width' ? getAngledTickWidth(getStringSize(value, {
+      fontSize: fontSize,
+      letterSpacing: letterSpacing
+    }), unitSize, angle) : getStringSize(value, {
+      fontSize: fontSize,
+      letterSpacing: letterSpacing
+    })[sizeKey];
+  };
+  var sign = ticks.length >= 2 ? mathSign(ticks[1].coordinate - ticks[0].coordinate) : 1;
+  var boundaries = getTickBoundaries(viewBox, sign, sizeKey);
+  if (interval === 'equidistantPreserveStart') {
+    return getEquidistantTicks(sign, boundaries, getTickSize, ticks, minTickGap);
+  }
+  if (interval === 'preserveStart' || interval === 'preserveStartEnd') {
+    candidates = getTicksStart(sign, boundaries, getTickSize, ticks, minTickGap, interval === 'preserveStartEnd');
+  } else {
+    candidates = getTicksEnd(sign, boundaries, getTickSize, ticks, minTickGap);
+  }
+  return candidates.filter(function (entry) {
+    return entry.isShow;
+  });
+}