Index: node_modules/recharts/es6/util/scale/CartesianScaleHelper.js
===================================================================
--- node_modules/recharts/es6/util/scale/CartesianScaleHelper.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/CartesianScaleHelper.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,66 @@
+/**
+ * Groups X and Y scale functions together and provides helper methods.
+ */
+export class CartesianScaleHelperImpl {
+  constructor(_ref) {
+    var {
+      x,
+      y
+    } = _ref;
+    this.xAxisScale = x;
+    this.yAxisScale = y;
+  }
+  map(value, _ref2) {
+    var _this$xAxisScale$map, _this$yAxisScale$map;
+    var {
+      position
+    } = _ref2;
+    return {
+      x: (_this$xAxisScale$map = this.xAxisScale.map(value.x, {
+        position
+      })) !== null && _this$xAxisScale$map !== void 0 ? _this$xAxisScale$map : 0,
+      y: (_this$yAxisScale$map = this.yAxisScale.map(value.y, {
+        position
+      })) !== null && _this$yAxisScale$map !== void 0 ? _this$yAxisScale$map : 0
+    };
+  }
+  mapWithFallback(value, _ref3) {
+    var _this$xAxisScale$map2, _this$yAxisScale$map2;
+    var {
+      position,
+      fallback
+    } = _ref3;
+    var fallbackY, fallbackX;
+    if (fallback === 'rangeMin') {
+      fallbackY = this.yAxisScale.rangeMin();
+    } else if (fallback === 'rangeMax') {
+      fallbackY = this.yAxisScale.rangeMax();
+    } else {
+      fallbackY = 0;
+    }
+    if (fallback === 'rangeMin') {
+      fallbackX = this.xAxisScale.rangeMin();
+    } else if (fallback === 'rangeMax') {
+      fallbackX = this.xAxisScale.rangeMax();
+    } else {
+      fallbackX = 0;
+    }
+    return {
+      x: (_this$xAxisScale$map2 = this.xAxisScale.map(value.x, {
+        position
+      })) !== null && _this$xAxisScale$map2 !== void 0 ? _this$xAxisScale$map2 : fallbackX,
+      y: (_this$yAxisScale$map2 = this.yAxisScale.map(value.y, {
+        position
+      })) !== null && _this$yAxisScale$map2 !== void 0 ? _this$yAxisScale$map2 : fallbackY
+    };
+  }
+  isInRange(_ref4) {
+    var {
+      x,
+      y
+    } = _ref4;
+    var xInRange = x == null || this.xAxisScale.isInRange(x);
+    var yInRange = y == null || this.yAxisScale.isInRange(y);
+    return xInRange && yInRange;
+  }
+}
Index: node_modules/recharts/es6/util/scale/CustomScaleDefinition.js
===================================================================
--- node_modules/recharts/es6/util/scale/CustomScaleDefinition.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/CustomScaleDefinition.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,1 @@
+export {};
Index: node_modules/recharts/es6/util/scale/RechartsScale.js
===================================================================
--- node_modules/recharts/es6/util/scale/RechartsScale.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/RechartsScale.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,100 @@
+import * as d3Scales from 'victory-vendor/d3-scale';
+import { upperFirst } from '../DataUtils';
+
+/**
+ * This is internal representation of scale used in Recharts.
+ * Users will provide CustomScaleDefinition or a string, which we will parse into RechartsScale.
+ * Most importantly, RechartsScale is fully immutable - there are no setters that mutate the scale in place.
+ * This is important for React integration - if the scale changes, we want to trigger re-renders.
+ * Mutating the scale in place would not trigger re-renders, leading to stale UI.
+ */
+
+/**
+ * Position within a band for banded scales.
+ * In scales that are not banded, this parameter is ignored.
+ *
+ * @inline
+ */
+
+function getD3ScaleFromType(realScaleType) {
+  if (realScaleType in d3Scales) {
+    // @ts-expect-error we should do better type verification here
+    return d3Scales[realScaleType]();
+  }
+  var name = "scale".concat(upperFirst(realScaleType));
+  if (name in d3Scales) {
+    // @ts-expect-error we should do better type verification here
+    return d3Scales[name]();
+  }
+  return undefined;
+}
+export function d3ScaleToRechartsScale(d3Scale) {
+  var ticksFn = d3Scale.ticks;
+  var bandwidthFn = d3Scale.bandwidth;
+  var d3Range = d3Scale.range();
+  var range = [Math.min(...d3Range), Math.max(...d3Range)];
+  return {
+    domain: () => d3Scale.domain(),
+    range: function (_range) {
+      function range() {
+        return _range.apply(this, arguments);
+      }
+      range.toString = function () {
+        return _range.toString();
+      };
+      return range;
+    }(() => range),
+    rangeMin: () => range[0],
+    rangeMax: () => range[1],
+    isInRange(value) {
+      var first = range[0];
+      var last = range[1];
+      return first <= last ? value >= first && value <= last : value >= last && value <= first;
+    },
+    bandwidth: bandwidthFn ? () => bandwidthFn.call(d3Scale) : undefined,
+    ticks: ticksFn ? count => ticksFn.call(d3Scale, count) : undefined,
+    map: (input, options) => {
+      var baseValue = d3Scale(input);
+      if (baseValue == null) {
+        return undefined;
+      }
+      if (d3Scale.bandwidth && options !== null && options !== void 0 && options.position) {
+        var bandWidth = d3Scale.bandwidth();
+        switch (options.position) {
+          case 'middle':
+            baseValue += bandWidth / 2;
+            break;
+          case 'end':
+            baseValue += bandWidth;
+            break;
+          default:
+            // 'start' requires no adjustment
+            break;
+        }
+      }
+      return baseValue;
+    }
+  };
+}
+
+/**
+ * Converts external scale definition into internal RechartsScale definition.
+ * @param scale custom function scale - if you have the string, use `combineRealScaleType` first
+ * @param axisDomain
+ * @param axisRange
+ */
+
+export function rechartsScaleFactory(scale, axisDomain, axisRange) {
+  if (typeof scale === 'function') {
+    return d3ScaleToRechartsScale(scale.copy().domain(axisDomain).range(axisRange));
+  }
+  if (scale == null) {
+    return undefined;
+  }
+  var d3ScaleFunction = getD3ScaleFromType(scale);
+  if (d3ScaleFunction == null) {
+    return undefined;
+  }
+  d3ScaleFunction.domain(axisDomain).range(axisRange);
+  return d3ScaleToRechartsScale(d3ScaleFunction);
+}
Index: node_modules/recharts/es6/util/scale/getNiceTickValues.js
===================================================================
--- node_modules/recharts/es6/util/scale/getNiceTickValues.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/getNiceTickValues.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,208 @@
+/**
+ * @fileOverview calculate tick values of scale
+ * @author xile611, arcthur
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+import { getDigitCount, rangeStep } from './util/arithmetic';
+/**
+ * Calculate a interval of a minimum value and a maximum value
+ *
+ * @param  {Number} min       The minimum value
+ * @param  {Number} max       The maximum value
+ * @return {Array} An interval
+ */
+export var getValidInterval = _ref => {
+  var [min, max] = _ref;
+  var [validMin, validMax] = [min, max];
+
+  // exchange
+  if (min > max) {
+    [validMin, validMax] = [max, min];
+  }
+  return [validMin, validMax];
+};
+
+/**
+ * Calculate the step which is easy to understand between ticks, like 10, 20, 25
+ *
+ * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step which is easy to understand between two ticks
+ */
+export var getFormatStep = (roughStep, allowDecimals, correctionFactor) => {
+  if (roughStep.lte(0)) {
+    return new Decimal(0);
+  }
+  var digitCount = getDigitCount(roughStep.toNumber());
+  // The ratio between the rough step and the smallest number which has a bigger
+  // order of magnitudes than the rough step
+  var digitCountValue = new Decimal(10).pow(digitCount);
+  var stepRatio = roughStep.div(digitCountValue);
+  // When an integer and a float multiplied, the accuracy of result may be wrong
+  var stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;
+  var amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber())).add(correctionFactor).mul(stepRatioScale);
+  var formatStep = amendStepRatio.mul(digitCountValue);
+  return allowDecimals ? new Decimal(formatStep.toNumber()) : new Decimal(Math.ceil(formatStep.toNumber()));
+};
+
+/**
+ * calculate the ticks when the minimum value equals to the maximum value
+ *
+ * @param  value         The minimum value which is also the maximum value
+ * @param  tickCount     The count of ticks
+ * @param  allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export var getTickOfSingleValue = (value, tickCount, allowDecimals) => {
+  var step = new Decimal(1);
+  // calculate the middle value of ticks
+  var middle = new Decimal(value);
+  if (!middle.isint() && allowDecimals) {
+    var absVal = Math.abs(value);
+    if (absVal < 1) {
+      // The step should be a float number when the difference is smaller than 1
+      step = new Decimal(10).pow(getDigitCount(value) - 1);
+      middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);
+    } else if (absVal > 1) {
+      // Return the maximum integer which is smaller than 'value' when 'value' is greater than 1
+      middle = new Decimal(Math.floor(value));
+    }
+  } else if (value === 0) {
+    middle = new Decimal(Math.floor((tickCount - 1) / 2));
+  } else if (!allowDecimals) {
+    middle = new Decimal(Math.floor(value));
+  }
+  var middleIndex = Math.floor((tickCount - 1) / 2);
+  var ticks = [];
+  for (var i = 0; i < tickCount; i++) {
+    ticks.push(middle.add(new Decimal(i - middleIndex).mul(step)).toNumber());
+  }
+  return ticks;
+};
+
+/**
+ * Calculate the step
+ *
+ * @param  min              The minimum value of an interval
+ * @param  max              The maximum value of an interval
+ * @param  tickCount        The count of ticks
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step, minimum value of ticks, maximum value of ticks
+ */
+var _calculateStep = function calculateStep(min, max, tickCount, allowDecimals) {
+  var correctionFactor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  // dirty hack (for recharts' test)
+  if (!Number.isFinite((max - min) / (tickCount - 1))) {
+    return {
+      step: new Decimal(0),
+      tickMin: new Decimal(0),
+      tickMax: new Decimal(0)
+    };
+  }
+
+  // The step which is easy to understand between two ticks
+  var step = getFormatStep(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor);
+
+  // A medial value of ticks
+  var middle;
+
+  // When 0 is inside the interval, 0 should be a tick
+  if (min <= 0 && max >= 0) {
+    middle = new Decimal(0);
+  } else {
+    // calculate the middle value
+    middle = new Decimal(min).add(max).div(2);
+    // minus modulo value
+    middle = middle.sub(new Decimal(middle).mod(step));
+  }
+  var belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
+  var upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());
+  var scaleCount = belowCount + upCount + 1;
+  if (scaleCount > tickCount) {
+    // When more ticks need to cover the interval, step should be bigger.
+    return _calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1);
+  }
+  if (scaleCount < tickCount) {
+    // When less ticks can cover the interval, we should add some additional ticks
+    upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;
+    belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);
+  }
+  return {
+    step,
+    tickMin: middle.sub(new Decimal(belowCount).mul(step)),
+    tickMax: middle.add(new Decimal(upCount).mul(step))
+  };
+};
+
+/**
+ * Calculate the ticks of an interval. Ticks can appear outside the interval
+ * if it makes them more rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount     The count of ticks
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export { _calculateStep as calculateStep };
+export var getNiceTickValues = function getNiceTickValues(_ref2) {
+  var [min, max] = _ref2;
+  var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;
+  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  // More than two ticks should be return
+  var count = Math.max(tickCount, 2);
+  var [cormin, cormax] = getValidInterval([min, max]);
+  if (cormin === -Infinity || cormax === Infinity) {
+    var _values = cormax === Infinity ? [cormin, ...Array(tickCount - 1).fill(Infinity)] : [...Array(tickCount - 1).fill(-Infinity), cormax];
+    return min > max ? _values.reverse() : _values;
+  }
+  if (cormin === cormax) {
+    return getTickOfSingleValue(cormin, tickCount, allowDecimals);
+  }
+
+  // Get the step between two ticks
+  var {
+    step,
+    tickMin,
+    tickMax
+  } = _calculateStep(cormin, cormax, count, allowDecimals, 0);
+  var values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);
+  return min > max ? values.reverse() : values;
+};
+
+/**
+ * Calculate the ticks of an interval.
+ * Ticks will be constrained to the interval [min, max] even if it makes them less rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount     The count of ticks. This function may return less than tickCount ticks if the interval is too small.
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export var getTickValuesFixedDomain = function getTickValuesFixedDomain(_ref3, tickCount) {
+  var [min, max] = _ref3;
+  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  // More than two ticks should be return
+  var [cormin, cormax] = getValidInterval([min, max]);
+  if (cormin === -Infinity || cormax === Infinity) {
+    return [min, max];
+  }
+  if (cormin === cormax) {
+    return [cormin];
+  }
+  var count = Math.max(tickCount, 2);
+  var step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
+  var values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax];
+  if (allowDecimals === false) {
+    /*
+     * allowDecimals is false means that we want to have integer ticks.
+     * The step is guaranteed to be an integer in the code above which is great start
+     * but when the first step is not an integer, it will start stepping from a decimal value anyway.
+     * So we need to round all the values to integers after the fact.
+     */
+    values = values.map(value => Math.round(value));
+  }
+  return min > max ? values.reverse() : values;
+};
Index: node_modules/recharts/es6/util/scale/index.js
===================================================================
--- node_modules/recharts/es6/util/scale/index.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/index.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,1 @@
+export { getNiceTickValues, getTickValuesFixedDomain } from './getNiceTickValues';
Index: node_modules/recharts/es6/util/scale/util/arithmetic.js
===================================================================
--- node_modules/recharts/es6/util/scale/util/arithmetic.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/util/arithmetic.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,49 @@
+/**
+ * @fileOverview Some common arithmetic methods
+ * @author xile611
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+
+/**
+ * Get the digit count of a number.
+ * If the absolute value is in the interval [0.1, 1), the result is 0.
+ * If the absolute value is in the interval [0.01, 0.1), the digit count is -1.
+ * If the absolute value is in the interval [0.001, 0.01), the digit count is -2.
+ *
+ * @param  {Number} value The number
+ * @return {Integer}      Digit count
+ */
+function getDigitCount(value) {
+  var result;
+  if (value === 0) {
+    result = 1;
+  } else {
+    result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;
+  }
+  return result;
+}
+
+/**
+ * Get the data in the interval [start, end) with a fixed step.
+ * Also handles JS calculation precision issues.
+ *
+ * @param  {Decimal} start Start point
+ * @param  {Decimal} end   End point, not included
+ * @param  {Decimal} step  Step size
+ * @return {Array}         Array of numbers
+ */
+function rangeStep(start, end, step) {
+  var num = new Decimal(start);
+  var i = 0;
+  var result = [];
+
+  // magic number to prevent infinite loop
+  while (num.lt(end) && i < 100000) {
+    result.push(num.toNumber());
+    num = num.add(step);
+    i++;
+  }
+  return result;
+}
+export { rangeStep, getDigitCount };