inital commit

node_modules/react-date-range/dist/accessibility/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ariaLabelsShape = void 0;
+var _propTypes = _interopRequireDefault(require("prop-types"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ariaLabelsShape = exports.ariaLabelsShape = _propTypes.default.shape({
+  dateInput: _propTypes.default.objectOf(_propTypes.default.shape({
+    startDate: _propTypes.default.string,
+    endDate: _propTypes.default.string
+  })),
+  monthPicker: _propTypes.default.string,
+  yearPicker: _propTypes.default.string,
+  prevButton: _propTypes.default.string,
+  nextButton: _propTypes.default.string
+});

node_modules/react-date-range/dist/components/Calendar/index.js

@@ -0,0 +1,621 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DayCell = require("../DayCell");
+var _Month = _interopRequireDefault(require("../Month"));
+var _DateInput = _interopRequireDefault(require("../DateInput"));
+var _utils = require("../../utils");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _reactList = _interopRequireDefault(require("react-list"));
+var _shallowEqual = require("shallow-equal");
+var _dateFns = require("date-fns");
+var _enUS = require("date-fns/locale/en-US");
+var _styles = _interopRequireDefault(require("../../styles"));
+var _accessibility = require("../../accessibility");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _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); }
+class Calendar extends _react.PureComponent {
+  constructor(_props, context) {
+    var _this;
+    super(_props, context);
+    _this = this;
+    _defineProperty(this, "focusToDate", function (date) {
+      let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.props;
+      let preventUnnecessary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      if (!props.scroll.enabled) {
+        if (preventUnnecessary && props.preventSnapRefocus) {
+          const focusedDateDiff = (0, _dateFns.differenceInCalendarMonths)(date, _this.state.focusedDate);
+          const isAllowedForward = props.calendarFocus === 'forwards' && focusedDateDiff >= 0;
+          const isAllowedBackward = props.calendarFocus === 'backwards' && focusedDateDiff <= 0;
+          if ((isAllowedForward || isAllowedBackward) && Math.abs(focusedDateDiff) < props.months) {
+            return;
+          }
+        }
+        _this.setState({
+          focusedDate: date
+        });
+        return;
+      }
+      const targetMonthIndex = (0, _dateFns.differenceInCalendarMonths)(date, props.minDate, _this.dateOptions);
+      const visibleMonths = _this.list.getVisibleRange();
+      if (preventUnnecessary && visibleMonths.includes(targetMonthIndex)) return;
+      _this.isFirstRender = true;
+      _this.list.scrollTo(targetMonthIndex);
+      _this.setState({
+        focusedDate: date
+      });
+    });
+    _defineProperty(this, "updateShownDate", function () {
+      let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props;
+      const newProps = props.scroll.enabled ? {
+        ...props,
+        months: _this.list.getVisibleRange().length
+      } : props;
+      const newFocus = (0, _utils.calcFocusDate)(_this.state.focusedDate, newProps);
+      _this.focusToDate(newFocus, newProps);
+    });
+    _defineProperty(this, "updatePreview", val => {
+      if (!val) {
+        this.setState({
+          preview: null
+        });
+        return;
+      }
+      const preview = {
+        startDate: val,
+        endDate: val,
+        color: this.props.color
+      };
+      this.setState({
+        preview
+      });
+    });
+    _defineProperty(this, "changeShownDate", function (value) {
+      let mode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'set';
+      const {
+        focusedDate
+      } = _this.state;
+      const {
+        onShownDateChange,
+        minDate,
+        maxDate
+      } = _this.props;
+      const modeMapper = {
+        monthOffset: () => (0, _dateFns.addMonths)(focusedDate, value),
+        setMonth: () => (0, _dateFns.setMonth)(focusedDate, value),
+        setYear: () => (0, _dateFns.setYear)(focusedDate, value),
+        set: () => value
+      };
+      const newDate = (0, _dateFns.min)([(0, _dateFns.max)([modeMapper[mode](), minDate]), maxDate]);
+      _this.focusToDate(newDate, _this.props, false);
+      onShownDateChange && onShownDateChange(newDate);
+    });
+    _defineProperty(this, "handleRangeFocusChange", (rangesIndex, rangeItemIndex) => {
+      this.props.onRangeFocusChange && this.props.onRangeFocusChange([rangesIndex, rangeItemIndex]);
+    });
+    _defineProperty(this, "handleScroll", () => {
+      const {
+        onShownDateChange,
+        minDate
+      } = this.props;
+      const {
+        focusedDate
+      } = this.state;
+      const {
+        isFirstRender
+      } = this;
+      const visibleMonths = this.list.getVisibleRange();
+      // prevent scroll jump with wrong visible value
+      if (visibleMonths[0] === undefined) return;
+      const visibleMonth = (0, _dateFns.addMonths)(minDate, visibleMonths[0] || 0);
+      const isFocusedToDifferent = !(0, _dateFns.isSameMonth)(visibleMonth, focusedDate);
+      if (isFocusedToDifferent && !isFirstRender) {
+        this.setState({
+          focusedDate: visibleMonth
+        });
+        onShownDateChange && onShownDateChange(visibleMonth);
+      }
+      this.isFirstRender = false;
+    });
+    _defineProperty(this, "renderMonthAndYear", (focusedDate, changeShownDate, props) => {
+      const {
+        showMonthArrow,
+        minDate,
+        maxDate,
+        showMonthAndYearPickers,
+        ariaLabels
+      } = props;
+      const upperYearLimit = (maxDate || Calendar.defaultProps.maxDate).getFullYear();
+      const lowerYearLimit = (minDate || Calendar.defaultProps.minDate).getFullYear();
+      const styles = this.styles;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        onMouseUp: e => e.stopPropagation(),
+        className: styles.monthAndYearWrapper
+      }, showMonthArrow ? /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        className: (0, _classnames.default)(styles.nextPrevButton, styles.prevButton),
+        onClick: () => changeShownDate(-1, 'monthOffset'),
+        "aria-label": ariaLabels.prevButton
+      }, /*#__PURE__*/_react.default.createElement("i", null)) : null, showMonthAndYearPickers ? /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthAndYearPickers
+      }, /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthPicker
+      }, /*#__PURE__*/_react.default.createElement("select", {
+        value: focusedDate.getMonth(),
+        onChange: e => changeShownDate(e.target.value, 'setMonth'),
+        "aria-label": ariaLabels.monthPicker
+      }, this.state.monthNames.map((monthName, i) => /*#__PURE__*/_react.default.createElement("option", {
+        key: i,
+        value: i
+      }, monthName)))), /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthAndYearDivider
+      }), /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.yearPicker
+      }, /*#__PURE__*/_react.default.createElement("select", {
+        value: focusedDate.getFullYear(),
+        onChange: e => changeShownDate(e.target.value, 'setYear'),
+        "aria-label": ariaLabels.yearPicker
+      }, new Array(upperYearLimit - lowerYearLimit + 1).fill(upperYearLimit).map((val, i) => {
+        const year = val - i;
+        return /*#__PURE__*/_react.default.createElement("option", {
+          key: year,
+          value: year
+        }, year);
+      })))) : /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthAndYearPickers
+      }, this.state.monthNames[focusedDate.getMonth()], " ", focusedDate.getFullYear()), showMonthArrow ? /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        className: (0, _classnames.default)(styles.nextPrevButton, styles.nextButton),
+        onClick: () => changeShownDate(+1, 'monthOffset'),
+        "aria-label": ariaLabels.nextButton
+      }, /*#__PURE__*/_react.default.createElement("i", null)) : null);
+    });
+    _defineProperty(this, "renderDateDisplay", () => {
+      const {
+        focusedRange,
+        color,
+        ranges,
+        rangeColors,
+        dateDisplayFormat,
+        editableDateInputs,
+        startDatePlaceholder,
+        endDatePlaceholder,
+        ariaLabels
+      } = this.props;
+      const defaultColor = rangeColors[focusedRange[0]] || color;
+      const styles = this.styles;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.dateDisplayWrapper
+      }, ranges.map((range, i) => {
+        if (range.showDateDisplay === false || range.disabled && !range.showDateDisplay) return null;
+        return /*#__PURE__*/_react.default.createElement("div", {
+          className: styles.dateDisplay,
+          key: i,
+          style: {
+            color: range.color || defaultColor
+          }
+        }, /*#__PURE__*/_react.default.createElement(_DateInput.default, {
+          className: (0, _classnames.default)(styles.dateDisplayItem, {
+            [styles.dateDisplayItemActive]: focusedRange[0] === i && focusedRange[1] === 0
+          }),
+          readOnly: !editableDateInputs,
+          disabled: range.disabled,
+          value: range.startDate,
+          placeholder: startDatePlaceholder,
+          dateOptions: this.dateOptions,
+          dateDisplayFormat: dateDisplayFormat,
+          ariaLabel: ariaLabels.dateInput && ariaLabels.dateInput[range.key] && ariaLabels.dateInput[range.key].startDate,
+          onChange: this.onDragSelectionEnd,
+          onFocus: () => this.handleRangeFocusChange(i, 0)
+        }), /*#__PURE__*/_react.default.createElement(_DateInput.default, {
+          className: (0, _classnames.default)(styles.dateDisplayItem, {
+            [styles.dateDisplayItemActive]: focusedRange[0] === i && focusedRange[1] === 1
+          }),
+          readOnly: !editableDateInputs,
+          disabled: range.disabled,
+          value: range.endDate,
+          placeholder: endDatePlaceholder,
+          dateOptions: this.dateOptions,
+          dateDisplayFormat: dateDisplayFormat,
+          ariaLabel: ariaLabels.dateInput && ariaLabels.dateInput[range.key] && ariaLabels.dateInput[range.key].endDate,
+          onChange: this.onDragSelectionEnd,
+          onFocus: () => this.handleRangeFocusChange(i, 1)
+        }));
+      }));
+    });
+    _defineProperty(this, "onDragSelectionStart", date => {
+      const {
+        onChange,
+        dragSelectionEnabled
+      } = this.props;
+      if (dragSelectionEnabled) {
+        this.setState({
+          drag: {
+            status: true,
+            range: {
+              startDate: date,
+              endDate: date
+            },
+            disablePreview: true
+          }
+        });
+      } else {
+        onChange && onChange(date);
+      }
+    });
+    _defineProperty(this, "onDragSelectionEnd", date => {
+      const {
+        updateRange,
+        displayMode,
+        onChange,
+        dragSelectionEnabled
+      } = this.props;
+      if (!dragSelectionEnabled) return;
+      if (displayMode === 'date' || !this.state.drag.status) {
+        onChange && onChange(date);
+        return;
+      }
+      const newRange = {
+        startDate: this.state.drag.range.startDate,
+        endDate: date
+      };
+      if (displayMode !== 'dateRange' || (0, _dateFns.isSameDay)(newRange.startDate, date)) {
+        this.setState({
+          drag: {
+            status: false,
+            range: {}
+          }
+        }, () => onChange && onChange(date));
+      } else {
+        this.setState({
+          drag: {
+            status: false,
+            range: {}
+          }
+        }, () => {
+          updateRange && updateRange(newRange);
+        });
+      }
+    });
+    _defineProperty(this, "onDragSelectionMove", date => {
+      const {
+        drag
+      } = this.state;
+      if (!drag.status || !this.props.dragSelectionEnabled) return;
+      this.setState({
+        drag: {
+          status: drag.status,
+          range: {
+            startDate: drag.range.startDate,
+            endDate: date
+          },
+          disablePreview: true
+        }
+      });
+    });
+    _defineProperty(this, "estimateMonthSize", (index, cache) => {
+      const {
+        direction,
+        minDate
+      } = this.props;
+      const {
+        scrollArea
+      } = this.state;
+      if (cache) {
+        this.listSizeCache = cache;
+        if (cache[index]) return cache[index];
+      }
+      if (direction === 'horizontal') return scrollArea.monthWidth;
+      const monthStep = (0, _dateFns.addMonths)(minDate, index);
+      const {
+        start,
+        end
+      } = (0, _utils.getMonthDisplayRange)(monthStep, this.dateOptions);
+      const isLongMonth = (0, _dateFns.differenceInDays)(end, start, this.dateOptions) + 1 > 7 * 5;
+      return isLongMonth ? scrollArea.longMonthHeight : scrollArea.monthHeight;
+    });
+    this.dateOptions = {
+      locale: _props.locale
+    };
+    if (_props.weekStartsOn !== undefined) this.dateOptions.weekStartsOn = _props.weekStartsOn;
+    this.styles = (0, _utils.generateStyles)([_styles.default, _props.classNames]);
+    this.listSizeCache = {};
+    this.isFirstRender = true;
+    this.state = {
+      monthNames: this.getMonthNames(),
+      focusedDate: (0, _utils.calcFocusDate)(null, _props),
+      drag: {
+        status: false,
+        range: {
+          startDate: null,
+          endDate: null
+        },
+        disablePreview: false
+      },
+      scrollArea: this.calcScrollArea(_props)
+    };
+  }
+  getMonthNames() {
+    return [...Array(12).keys()].map(i => this.props.locale.localize.month(i));
+  }
+  calcScrollArea(props) {
+    const {
+      direction,
+      months,
+      scroll
+    } = props;
+    if (!scroll.enabled) return {
+      enabled: false
+    };
+    const longMonthHeight = scroll.longMonthHeight || scroll.monthHeight;
+    if (direction === 'vertical') {
+      return {
+        enabled: true,
+        monthHeight: scroll.monthHeight || 220,
+        longMonthHeight: longMonthHeight || 260,
+        calendarWidth: 'auto',
+        calendarHeight: (scroll.calendarHeight || longMonthHeight || 240) * months
+      };
+    }
+    return {
+      enabled: true,
+      monthWidth: scroll.monthWidth || 332,
+      calendarWidth: (scroll.calendarWidth || scroll.monthWidth || 332) * months,
+      monthHeight: longMonthHeight || 300,
+      calendarHeight: longMonthHeight || 300
+    };
+  }
+  componentDidMount() {
+    if (this.props.scroll.enabled) {
+      // prevent react-list's initial render focus problem
+      setTimeout(() => this.focusToDate(this.state.focusedDate));
+    }
+  }
+  componentDidUpdate(prevProps) {
+    const propMapper = {
+      dateRange: 'ranges',
+      date: 'date'
+    };
+    const targetProp = propMapper[this.props.displayMode];
+    if (this.props[targetProp] !== prevProps[targetProp]) {
+      this.updateShownDate(this.props);
+    }
+    if (prevProps.locale !== this.props.locale || prevProps.weekStartsOn !== this.props.weekStartsOn) {
+      this.dateOptions = {
+        locale: this.props.locale
+      };
+      if (this.props.weekStartsOn !== undefined) this.dateOptions.weekStartsOn = this.props.weekStartsOn;
+      this.setState({
+        monthNames: this.getMonthNames()
+      });
+    }
+    if (!(0, _shallowEqual.shallowEqualObjects)(prevProps.scroll, this.props.scroll)) {
+      this.setState({
+        scrollArea: this.calcScrollArea(this.props)
+      });
+    }
+  }
+  renderWeekdays() {
+    const now = new Date();
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: this.styles.weekDays
+    }, (0, _dateFns.eachDayOfInterval)({
+      start: (0, _dateFns.startOfWeek)(now, this.dateOptions),
+      end: (0, _dateFns.endOfWeek)(now, this.dateOptions)
+    }).map((day, i) => /*#__PURE__*/_react.default.createElement("span", {
+      className: this.styles.weekDay,
+      key: i
+    }, (0, _dateFns.format)(day, this.props.weekdayDisplayFormat, this.dateOptions))));
+  }
+  render() {
+    const {
+      showDateDisplay,
+      onPreviewChange,
+      scroll,
+      direction,
+      disabledDates,
+      disabledDay,
+      maxDate,
+      minDate,
+      rangeColors,
+      color,
+      navigatorRenderer,
+      className,
+      preview
+    } = this.props;
+    const {
+      scrollArea,
+      focusedDate
+    } = this.state;
+    const isVertical = direction === 'vertical';
+    const monthAndYearRenderer = navigatorRenderer || this.renderMonthAndYear;
+    const ranges = this.props.ranges.map((range, i) => ({
+      ...range,
+      color: range.color || rangeColors[i] || color
+    }));
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.calendarWrapper, className),
+      onMouseUp: () => this.setState({
+        drag: {
+          status: false,
+          range: {}
+        }
+      }),
+      onMouseLeave: () => {
+        this.setState({
+          drag: {
+            status: false,
+            range: {}
+          }
+        });
+      }
+    }, showDateDisplay && this.renderDateDisplay(), monthAndYearRenderer(focusedDate, this.changeShownDate, this.props), scroll.enabled ? /*#__PURE__*/_react.default.createElement("div", null, isVertical && this.renderWeekdays(this.dateOptions), /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.infiniteMonths, isVertical ? this.styles.monthsVertical : this.styles.monthsHorizontal),
+      onMouseLeave: () => onPreviewChange && onPreviewChange(),
+      style: {
+        width: scrollArea.calendarWidth + 11,
+        height: scrollArea.calendarHeight + 11
+      },
+      onScroll: this.handleScroll
+    }, /*#__PURE__*/_react.default.createElement(_reactList.default, {
+      length: (0, _dateFns.differenceInCalendarMonths)((0, _dateFns.endOfMonth)(maxDate), (0, _dateFns.addDays)((0, _dateFns.startOfMonth)(minDate), -1), this.dateOptions),
+      treshold: 500,
+      type: "variable",
+      ref: target => this.list = target,
+      itemSizeEstimator: this.estimateMonthSize,
+      axis: isVertical ? 'y' : 'x',
+      itemRenderer: (index, key) => {
+        const monthStep = (0, _dateFns.addMonths)(minDate, index);
+        return /*#__PURE__*/_react.default.createElement(_Month.default, _extends({}, this.props, {
+          onPreviewChange: onPreviewChange || this.updatePreview,
+          preview: preview || this.state.preview,
+          ranges: ranges,
+          key: key,
+          drag: this.state.drag,
+          dateOptions: this.dateOptions,
+          disabledDates: disabledDates,
+          disabledDay: disabledDay,
+          month: monthStep,
+          onDragSelectionStart: this.onDragSelectionStart,
+          onDragSelectionEnd: this.onDragSelectionEnd,
+          onDragSelectionMove: this.onDragSelectionMove,
+          onMouseLeave: () => onPreviewChange && onPreviewChange(),
+          styles: this.styles,
+          style: isVertical ? {
+            height: this.estimateMonthSize(index)
+          } : {
+            height: scrollArea.monthHeight,
+            width: this.estimateMonthSize(index)
+          },
+          showMonthName: true,
+          showWeekDays: !isVertical
+        }));
+      }
+    }))) : /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.months, isVertical ? this.styles.monthsVertical : this.styles.monthsHorizontal)
+    }, new Array(this.props.months).fill(null).map((_, i) => {
+      let monthStep = (0, _dateFns.addMonths)(this.state.focusedDate, i);
+      if (this.props.calendarFocus === 'backwards') {
+        monthStep = (0, _dateFns.subMonths)(this.state.focusedDate, this.props.months - 1 - i);
+      }
+      return /*#__PURE__*/_react.default.createElement(_Month.default, _extends({}, this.props, {
+        onPreviewChange: onPreviewChange || this.updatePreview,
+        preview: preview || this.state.preview,
+        ranges: ranges,
+        key: i,
+        drag: this.state.drag,
+        dateOptions: this.dateOptions,
+        disabledDates: disabledDates,
+        disabledDay: disabledDay,
+        month: monthStep,
+        onDragSelectionStart: this.onDragSelectionStart,
+        onDragSelectionEnd: this.onDragSelectionEnd,
+        onDragSelectionMove: this.onDragSelectionMove,
+        onMouseLeave: () => onPreviewChange && onPreviewChange(),
+        styles: this.styles,
+        showWeekDays: !isVertical || i === 0,
+        showMonthName: !isVertical || i > 0
+      }));
+    })));
+  }
+}
+Calendar.defaultProps = {
+  showMonthArrow: true,
+  showMonthAndYearPickers: true,
+  disabledDates: [],
+  disabledDay: () => {},
+  classNames: {},
+  locale: _enUS.enUS,
+  ranges: [],
+  focusedRange: [0, 0],
+  dateDisplayFormat: 'MMM d, yyyy',
+  monthDisplayFormat: 'MMM yyyy',
+  weekdayDisplayFormat: 'E',
+  dayDisplayFormat: 'd',
+  showDateDisplay: true,
+  showPreview: true,
+  displayMode: 'date',
+  months: 1,
+  color: '#3d91ff',
+  scroll: {
+    enabled: false
+  },
+  direction: 'vertical',
+  maxDate: (0, _dateFns.addYears)(new Date(), 20),
+  minDate: (0, _dateFns.addYears)(new Date(), -100),
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  startDatePlaceholder: 'Early',
+  endDatePlaceholder: 'Continuous',
+  editableDateInputs: false,
+  dragSelectionEnabled: true,
+  fixedHeight: false,
+  calendarFocus: 'forwards',
+  preventSnapRefocus: false,
+  ariaLabels: {}
+};
+Calendar.propTypes = {
+  showMonthArrow: _propTypes.default.bool,
+  showMonthAndYearPickers: _propTypes.default.bool,
+  disabledDates: _propTypes.default.array,
+  disabledDay: _propTypes.default.func,
+  minDate: _propTypes.default.object,
+  maxDate: _propTypes.default.object,
+  date: _propTypes.default.object,
+  onChange: _propTypes.default.func,
+  onPreviewChange: _propTypes.default.func,
+  onRangeFocusChange: _propTypes.default.func,
+  classNames: _propTypes.default.object,
+  locale: _propTypes.default.object,
+  shownDate: _propTypes.default.object,
+  onShownDateChange: _propTypes.default.func,
+  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+  preview: _propTypes.default.shape({
+    startDate: _propTypes.default.object,
+    endDate: _propTypes.default.object,
+    color: _propTypes.default.string
+  }),
+  dateDisplayFormat: _propTypes.default.string,
+  monthDisplayFormat: _propTypes.default.string,
+  weekdayDisplayFormat: _propTypes.default.string,
+  weekStartsOn: _propTypes.default.number,
+  dayDisplayFormat: _propTypes.default.string,
+  focusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+  initialFocusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+  months: _propTypes.default.number,
+  className: _propTypes.default.string,
+  showDateDisplay: _propTypes.default.bool,
+  showPreview: _propTypes.default.bool,
+  displayMode: _propTypes.default.oneOf(['dateRange', 'date']),
+  color: _propTypes.default.string,
+  updateRange: _propTypes.default.func,
+  scroll: _propTypes.default.shape({
+    enabled: _propTypes.default.bool,
+    monthHeight: _propTypes.default.number,
+    longMonthHeight: _propTypes.default.number,
+    monthWidth: _propTypes.default.number,
+    calendarWidth: _propTypes.default.number,
+    calendarHeight: _propTypes.default.number
+  }),
+  direction: _propTypes.default.oneOf(['vertical', 'horizontal']),
+  startDatePlaceholder: _propTypes.default.string,
+  endDatePlaceholder: _propTypes.default.string,
+  navigatorRenderer: _propTypes.default.func,
+  rangeColors: _propTypes.default.arrayOf(_propTypes.default.string),
+  editableDateInputs: _propTypes.default.bool,
+  dragSelectionEnabled: _propTypes.default.bool,
+  fixedHeight: _propTypes.default.bool,
+  calendarFocus: _propTypes.default.string,
+  preventSnapRefocus: _propTypes.default.bool,
+  ariaLabels: _accessibility.ariaLabelsShape
+};
+var _default = exports.default = Calendar;

node_modules/react-date-range/dist/components/Calendar/index.test.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _Calendar = _interopRequireDefault(require("../Calendar"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('Calendar', () => {
+  test('Should resolve', () => {
+    expect(_Calendar.default).toEqual(expect.anything());
+  });
+});

node_modules/react-date-range/dist/components/DateInput/index.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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); }
+class DateInput extends _react.PureComponent {
+  constructor(props, context) {
+    super(props, context);
+    _defineProperty(this, "onKeyDown", e => {
+      const {
+        value
+      } = this.state;
+      if (e.key === 'Enter') {
+        this.update(value);
+      }
+    });
+    _defineProperty(this, "onChange", e => {
+      this.setState({
+        value: e.target.value,
+        changed: true,
+        invalid: false
+      });
+    });
+    _defineProperty(this, "onBlur", () => {
+      const {
+        value
+      } = this.state;
+      this.update(value);
+    });
+    this.state = {
+      invalid: false,
+      changed: false,
+      value: this.formatDate(props)
+    };
+  }
+  componentDidUpdate(prevProps) {
+    const {
+      value
+    } = prevProps;
+    if (!(0, _dateFns.isEqual)(value, this.props.value)) {
+      this.setState({
+        value: this.formatDate(this.props)
+      });
+    }
+  }
+  formatDate(_ref) {
+    let {
+      value,
+      dateDisplayFormat,
+      dateOptions
+    } = _ref;
+    if (value && (0, _dateFns.isValid)(value)) {
+      return (0, _dateFns.format)(value, dateDisplayFormat, dateOptions);
+    }
+    return '';
+  }
+  update(value) {
+    const {
+      invalid,
+      changed
+    } = this.state;
+    if (invalid || !changed || !value) {
+      return;
+    }
+    const {
+      onChange,
+      dateDisplayFormat,
+      dateOptions
+    } = this.props;
+    const parsed = (0, _dateFns.parse)(value, dateDisplayFormat, new Date(), dateOptions);
+    if ((0, _dateFns.isValid)(parsed)) {
+      this.setState({
+        changed: false
+      }, () => onChange(parsed));
+    } else {
+      this.setState({
+        invalid: true
+      });
+    }
+  }
+  render() {
+    const {
+      className,
+      readOnly,
+      placeholder,
+      ariaLabel,
+      disabled,
+      onFocus
+    } = this.props;
+    const {
+      value,
+      invalid
+    } = this.state;
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: (0, _classnames.default)('rdrDateInput', className)
+    }, /*#__PURE__*/_react.default.createElement("input", {
+      readOnly: readOnly,
+      disabled: disabled,
+      value: value,
+      placeholder: placeholder,
+      "aria-label": ariaLabel,
+      onKeyDown: this.onKeyDown,
+      onChange: this.onChange,
+      onBlur: this.onBlur,
+      onFocus: onFocus
+    }), invalid && /*#__PURE__*/_react.default.createElement("span", {
+      className: "rdrWarning"
+    }, "\u26A0"));
+  }
+}
+DateInput.propTypes = {
+  value: _propTypes.default.object,
+  placeholder: _propTypes.default.string,
+  disabled: _propTypes.default.bool,
+  readOnly: _propTypes.default.bool,
+  dateOptions: _propTypes.default.object,
+  dateDisplayFormat: _propTypes.default.string,
+  ariaLabel: _propTypes.default.string,
+  className: _propTypes.default.string,
+  onFocus: _propTypes.default.func.isRequired,
+  onChange: _propTypes.default.func.isRequired
+};
+DateInput.defaultProps = {
+  readOnly: true,
+  disabled: false,
+  dateDisplayFormat: 'MMM D, YYYY'
+};
+var _default = exports.default = DateInput;

node_modules/react-date-range/dist/components/DateRange/index.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _Calendar = _interopRequireDefault(require("../Calendar"));
+var _DayCell = require("../DayCell");
+var _utils = require("../../utils");
+var _dateFns = require("date-fns");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _styles = _interopRequireDefault(require("../../styles"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _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); }
+class DateRange extends _react.Component {
+  constructor(props, context) {
+    var _this;
+    super(props, context);
+    _this = this;
+    _defineProperty(this, "calcNewSelection", function (value) {
+      let isSingleValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      const focusedRange = _this.props.focusedRange || _this.state.focusedRange;
+      const {
+        ranges,
+        onChange,
+        maxDate,
+        moveRangeOnFirstSelection,
+        retainEndDateOnFirstSelection,
+        disabledDates
+      } = _this.props;
+      const focusedRangeIndex = focusedRange[0];
+      const selectedRange = ranges[focusedRangeIndex];
+      if (!selectedRange || !onChange) return {};
+      let {
+        startDate,
+        endDate
+      } = selectedRange;
+      const now = new Date();
+      let nextFocusRange;
+      if (!isSingleValue) {
+        startDate = value.startDate;
+        endDate = value.endDate;
+      } else if (focusedRange[1] === 0) {
+        // startDate selection
+        const dayOffset = (0, _dateFns.differenceInCalendarDays)(endDate || now, startDate);
+        const calculateEndDate = () => {
+          if (moveRangeOnFirstSelection) {
+            return (0, _dateFns.addDays)(value, dayOffset);
+          }
+          if (retainEndDateOnFirstSelection) {
+            if (!endDate || (0, _dateFns.isBefore)(value, endDate)) {
+              return endDate;
+            }
+            return value;
+          }
+          return value || now;
+        };
+        startDate = value;
+        endDate = calculateEndDate();
+        if (maxDate) endDate = (0, _dateFns.min)([endDate, maxDate]);
+        nextFocusRange = [focusedRange[0], 1];
+      } else {
+        endDate = value;
+      }
+
+      // reverse dates if startDate before endDate
+      let isStartDateSelected = focusedRange[1] === 0;
+      if ((0, _dateFns.isBefore)(endDate, startDate)) {
+        isStartDateSelected = !isStartDateSelected;
+        [startDate, endDate] = [endDate, startDate];
+      }
+      const inValidDatesWithinRange = disabledDates.filter(disabledDate => (0, _dateFns.isWithinInterval)(disabledDate, {
+        start: startDate,
+        end: endDate
+      }));
+      if (inValidDatesWithinRange.length > 0) {
+        if (isStartDateSelected) {
+          startDate = (0, _dateFns.addDays)((0, _dateFns.max)(inValidDatesWithinRange), 1);
+        } else {
+          endDate = (0, _dateFns.addDays)((0, _dateFns.min)(inValidDatesWithinRange), -1);
+        }
+      }
+      if (!nextFocusRange) {
+        const nextFocusRangeIndex = (0, _utils.findNextRangeIndex)(_this.props.ranges, focusedRange[0]);
+        nextFocusRange = [nextFocusRangeIndex, 0];
+      }
+      return {
+        wasValid: !(inValidDatesWithinRange.length > 0),
+        range: {
+          startDate,
+          endDate
+        },
+        nextFocusRange: nextFocusRange
+      };
+    });
+    _defineProperty(this, "setSelection", (value, isSingleValue) => {
+      const {
+        onChange,
+        ranges,
+        onRangeFocusChange
+      } = this.props;
+      const focusedRange = this.props.focusedRange || this.state.focusedRange;
+      const focusedRangeIndex = focusedRange[0];
+      const selectedRange = ranges[focusedRangeIndex];
+      if (!selectedRange) return;
+      const newSelection = this.calcNewSelection(value, isSingleValue);
+      onChange({
+        [selectedRange.key || `range${focusedRangeIndex + 1}`]: {
+          ...selectedRange,
+          ...newSelection.range
+        }
+      });
+      this.setState({
+        focusedRange: newSelection.nextFocusRange,
+        preview: null
+      });
+      onRangeFocusChange && onRangeFocusChange(newSelection.nextFocusRange);
+    });
+    _defineProperty(this, "handleRangeFocusChange", focusedRange => {
+      this.setState({
+        focusedRange
+      });
+      this.props.onRangeFocusChange && this.props.onRangeFocusChange(focusedRange);
+    });
+    _defineProperty(this, "updatePreview", val => {
+      if (!val) {
+        this.setState({
+          preview: null
+        });
+        return;
+      }
+      const {
+        rangeColors,
+        ranges
+      } = this.props;
+      const focusedRange = this.props.focusedRange || this.state.focusedRange;
+      const color = ranges[focusedRange[0]]?.color || rangeColors[focusedRange[0]] || color;
+      this.setState({
+        preview: {
+          ...val.range,
+          color
+        }
+      });
+    });
+    this.state = {
+      focusedRange: props.initialFocusedRange || [(0, _utils.findNextRangeIndex)(props.ranges), 0],
+      preview: null
+    };
+    this.styles = (0, _utils.generateStyles)([_styles.default, props.classNames]);
+  }
+  render() {
+    return /*#__PURE__*/_react.default.createElement(_Calendar.default, _extends({
+      focusedRange: this.state.focusedRange,
+      onRangeFocusChange: this.handleRangeFocusChange,
+      preview: this.state.preview,
+      onPreviewChange: value => {
+        this.updatePreview(value ? this.calcNewSelection(value) : null);
+      }
+    }, this.props, {
+      displayMode: "dateRange",
+      className: (0, _classnames.default)(this.styles.dateRangeWrapper, this.props.className),
+      onChange: this.setSelection,
+      updateRange: val => this.setSelection(val, false),
+      ref: target => {
+        this.calendar = target;
+      }
+    }));
+  }
+}
+DateRange.defaultProps = {
+  classNames: {},
+  ranges: [],
+  moveRangeOnFirstSelection: false,
+  retainEndDateOnFirstSelection: false,
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  disabledDates: []
+};
+DateRange.propTypes = {
+  ..._Calendar.default.propTypes,
+  onChange: _propTypes.default.func,
+  onRangeFocusChange: _propTypes.default.func,
+  className: _propTypes.default.string,
+  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+  moveRangeOnFirstSelection: _propTypes.default.bool,
+  retainEndDateOnFirstSelection: _propTypes.default.bool
+};
+var _default = exports.default = DateRange;

node_modules/react-date-range/dist/components/DateRange/index.test.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _dateFns = require("date-fns");
+var _DateRange = _interopRequireDefault(require("../DateRange"));
+var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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); }
+let testRenderer = null;
+let instance = null;
+const endDate = new Date();
+const startDate = (0, _dateFns.subDays)(endDate, 7);
+const commonProps = {
+  ranges: [{
+    startDate,
+    endDate,
+    key: 'selection'
+  }],
+  onChange: () => {},
+  moveRangeOnFirstSelection: false
+};
+const compareRanges = (newRange, assertionRange) => {
+  ['startDate', 'endDate'].forEach(key => {
+    if (!newRange[key] || !assertionRange[key]) {
+      return expect(newRange[key]).toEqual(assertionRange[key]);
+    }
+    return expect((0, _dateFns.isSameDay)(newRange[key], assertionRange[key])).toEqual(true);
+  });
+};
+beforeEach(() => {
+  testRenderer = _reactTestRenderer.default.create( /*#__PURE__*/_react.default.createElement(_DateRange.default, commonProps));
+  instance = testRenderer.getInstance();
+});
+describe('DateRange', () => {
+  test('Should resolve', () => {
+    expect(_DateRange.default).toEqual(expect.anything());
+  });
+  test('calculate new selection by resetting end date', () => {
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate: (0, _dateFns.subDays)(endDate, 10)
+    });
+  });
+  test('calculate new selection by resetting end date if start date is not before', () => {
+    const methodResult = instance.calcNewSelection((0, _dateFns.addDays)(endDate, 2), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.addDays)(endDate, 2),
+      endDate: (0, _dateFns.addDays)(endDate, 2)
+    });
+  });
+  test('calculate new selection based on moveRangeOnFirstSelection prop', () => {
+    testRenderer.update( /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({}, commonProps, {
+      moveRangeOnFirstSelection: true
+    })));
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate: (0, _dateFns.subDays)(endDate, 3)
+    });
+  });
+  test('calculate new selection by retaining end date, based on retainEndDateOnFirstSelection prop', () => {
+    testRenderer.update( /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({}, commonProps, {
+      retainEndDateOnFirstSelection: true
+    })));
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate
+    });
+  });
+  test('calculate new selection by retaining the unset end date, based on retainEndDateOnFirstSelection prop', () => {
+    testRenderer.update( /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({}, commonProps, {
+      ranges: [{
+        ...commonProps.ranges[0],
+        endDate: null
+      }],
+      retainEndDateOnFirstSelection: true
+    })));
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate: null
+    });
+  });
+});

node_modules/react-date-range/dist/components/DateRangePicker/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DateRange = _interopRequireDefault(require("../DateRange"));
+var _DefinedRange = _interopRequireDefault(require("../DefinedRange"));
+var _utils = require("../../utils");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _styles = _interopRequireDefault(require("../../styles"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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); }
+class DateRangePicker extends _react.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      focusedRange: [(0, _utils.findNextRangeIndex)(props.ranges), 0]
+    };
+    this.styles = (0, _utils.generateStyles)([_styles.default, props.classNames]);
+  }
+  render() {
+    const {
+      focusedRange
+    } = this.state;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.dateRangePickerWrapper, this.props.className)
+    }, /*#__PURE__*/_react.default.createElement(_DefinedRange.default, _extends({
+      focusedRange: focusedRange,
+      onPreviewChange: value => this.dateRange.updatePreview(value ? this.dateRange.calcNewSelection(value, typeof value === 'string') : null)
+    }, this.props, {
+      range: this.props.ranges[focusedRange[0]],
+      className: undefined
+    })), /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({
+      onRangeFocusChange: focusedRange => this.setState({
+        focusedRange
+      }),
+      focusedRange: focusedRange
+    }, this.props, {
+      ref: t => this.dateRange = t,
+      className: undefined
+    })));
+  }
+}
+DateRangePicker.defaultProps = {};
+DateRangePicker.propTypes = {
+  ..._DateRange.default.propTypes,
+  ..._DefinedRange.default.propTypes,
+  className: _propTypes.default.string
+};
+var _default = exports.default = DateRangePicker;

node_modules/react-date-range/dist/components/DayCell/index.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rangeShape = exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _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); } /* eslint-disable no-fallthrough */
+class DayCell extends _react.Component {
+  constructor(props, context) {
+    super(props, context);
+    _defineProperty(this, "handleKeyEvent", event => {
+      const {
+        day,
+        onMouseDown,
+        onMouseUp
+      } = this.props;
+      if ([13 /* space */, 32 /* enter */].includes(event.keyCode)) {
+        if (event.type === 'keydown') onMouseDown(day);else onMouseUp(day);
+      }
+    });
+    _defineProperty(this, "handleMouseEvent", event => {
+      const {
+        day,
+        disabled,
+        onPreviewChange,
+        onMouseEnter,
+        onMouseDown,
+        onMouseUp
+      } = this.props;
+      const stateChanges = {};
+      if (disabled) {
+        onPreviewChange();
+        return;
+      }
+      switch (event.type) {
+        case 'mouseenter':
+          onMouseEnter(day);
+          onPreviewChange(day);
+          stateChanges.hover = true;
+          break;
+        case 'blur':
+        case 'mouseleave':
+          stateChanges.hover = false;
+          break;
+        case 'mousedown':
+          stateChanges.active = true;
+          onMouseDown(day);
+          break;
+        case 'mouseup':
+          event.stopPropagation();
+          stateChanges.active = false;
+          onMouseUp(day);
+          break;
+        case 'focus':
+          onPreviewChange(day);
+          break;
+      }
+      if (Object.keys(stateChanges).length) {
+        this.setState(stateChanges);
+      }
+    });
+    _defineProperty(this, "getClassNames", () => {
+      const {
+        isPassive,
+        isToday,
+        isWeekend,
+        isStartOfWeek,
+        isEndOfWeek,
+        isStartOfMonth,
+        isEndOfMonth,
+        disabled,
+        styles
+      } = this.props;
+      return (0, _classnames.default)(styles.day, {
+        [styles.dayPassive]: isPassive,
+        [styles.dayDisabled]: disabled,
+        [styles.dayToday]: isToday,
+        [styles.dayWeekend]: isWeekend,
+        [styles.dayStartOfWeek]: isStartOfWeek,
+        [styles.dayEndOfWeek]: isEndOfWeek,
+        [styles.dayStartOfMonth]: isStartOfMonth,
+        [styles.dayEndOfMonth]: isEndOfMonth,
+        [styles.dayHovered]: this.state.hover,
+        [styles.dayActive]: this.state.active
+      });
+    });
+    _defineProperty(this, "renderPreviewPlaceholder", () => {
+      const {
+        preview,
+        day,
+        styles
+      } = this.props;
+      if (!preview) return null;
+      const startDate = preview.startDate ? (0, _dateFns.endOfDay)(preview.startDate) : null;
+      const endDate = preview.endDate ? (0, _dateFns.startOfDay)(preview.endDate) : null;
+      const isInRange = (!startDate || (0, _dateFns.isAfter)(day, startDate)) && (!endDate || (0, _dateFns.isBefore)(day, endDate));
+      const isStartEdge = !isInRange && (0, _dateFns.isSameDay)(day, startDate);
+      const isEndEdge = !isInRange && (0, _dateFns.isSameDay)(day, endDate);
+      return /*#__PURE__*/_react.default.createElement("span", {
+        className: (0, _classnames.default)({
+          [styles.dayStartPreview]: isStartEdge,
+          [styles.dayInPreview]: isInRange,
+          [styles.dayEndPreview]: isEndEdge
+        }),
+        style: {
+          color: preview.color
+        }
+      });
+    });
+    _defineProperty(this, "renderSelectionPlaceholders", () => {
+      const {
+        styles,
+        ranges,
+        day
+      } = this.props;
+      if (this.props.displayMode === 'date') {
+        let isSelected = (0, _dateFns.isSameDay)(this.props.day, this.props.date);
+        return isSelected ? /*#__PURE__*/_react.default.createElement("span", {
+          className: styles.selected,
+          style: {
+            color: this.props.color
+          }
+        }) : null;
+      }
+      const inRanges = ranges.reduce((result, range) => {
+        let startDate = range.startDate;
+        let endDate = range.endDate;
+        if (startDate && endDate && (0, _dateFns.isBefore)(endDate, startDate)) {
+          [startDate, endDate] = [endDate, startDate];
+        }
+        startDate = startDate ? (0, _dateFns.endOfDay)(startDate) : null;
+        endDate = endDate ? (0, _dateFns.startOfDay)(endDate) : null;
+        const isInRange = (!startDate || (0, _dateFns.isAfter)(day, startDate)) && (!endDate || (0, _dateFns.isBefore)(day, endDate));
+        const isStartEdge = !isInRange && (0, _dateFns.isSameDay)(day, startDate);
+        const isEndEdge = !isInRange && (0, _dateFns.isSameDay)(day, endDate);
+        if (isInRange || isStartEdge || isEndEdge) {
+          return [...result, {
+            isStartEdge,
+            isEndEdge: isEndEdge,
+            isInRange,
+            ...range
+          }];
+        }
+        return result;
+      }, []);
+      return inRanges.map((range, i) => /*#__PURE__*/_react.default.createElement("span", {
+        key: i,
+        className: (0, _classnames.default)({
+          [styles.startEdge]: range.isStartEdge,
+          [styles.endEdge]: range.isEndEdge,
+          [styles.inRange]: range.isInRange
+        }),
+        style: {
+          color: range.color || this.props.color
+        }
+      }));
+    });
+    this.state = {
+      hover: false,
+      active: false
+    };
+  }
+  render() {
+    const {
+      dayContentRenderer
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement("button", _extends({
+      type: "button",
+      onMouseEnter: this.handleMouseEvent,
+      onMouseLeave: this.handleMouseEvent,
+      onFocus: this.handleMouseEvent,
+      onMouseDown: this.handleMouseEvent,
+      onMouseUp: this.handleMouseEvent,
+      onBlur: this.handleMouseEvent,
+      onPauseCapture: this.handleMouseEvent,
+      onKeyDown: this.handleKeyEvent,
+      onKeyUp: this.handleKeyEvent,
+      className: this.getClassNames(this.props.styles)
+    }, this.props.disabled || this.props.isPassive ? {
+      tabIndex: -1
+    } : {}, {
+      style: {
+        color: this.props.color
+      }
+    }), this.renderSelectionPlaceholders(), this.renderPreviewPlaceholder(), /*#__PURE__*/_react.default.createElement("span", {
+      className: this.props.styles.dayNumber
+    }, dayContentRenderer?.(this.props.day) || /*#__PURE__*/_react.default.createElement("span", null, (0, _dateFns.format)(this.props.day, this.props.dayDisplayFormat))));
+  }
+}
+DayCell.defaultProps = {};
+const rangeShape = exports.rangeShape = _propTypes.default.shape({
+  startDate: _propTypes.default.object,
+  endDate: _propTypes.default.object,
+  color: _propTypes.default.string,
+  key: _propTypes.default.string,
+  autoFocus: _propTypes.default.bool,
+  disabled: _propTypes.default.bool,
+  showDateDisplay: _propTypes.default.bool
+});
+DayCell.propTypes = {
+  day: _propTypes.default.object.isRequired,
+  dayDisplayFormat: _propTypes.default.string,
+  date: _propTypes.default.object,
+  ranges: _propTypes.default.arrayOf(rangeShape),
+  preview: _propTypes.default.shape({
+    startDate: _propTypes.default.object,
+    endDate: _propTypes.default.object,
+    color: _propTypes.default.string
+  }),
+  onPreviewChange: _propTypes.default.func,
+  previewColor: _propTypes.default.string,
+  disabled: _propTypes.default.bool,
+  isPassive: _propTypes.default.bool,
+  isToday: _propTypes.default.bool,
+  isWeekend: _propTypes.default.bool,
+  isStartOfWeek: _propTypes.default.bool,
+  isEndOfWeek: _propTypes.default.bool,
+  isStartOfMonth: _propTypes.default.bool,
+  isEndOfMonth: _propTypes.default.bool,
+  color: _propTypes.default.string,
+  displayMode: _propTypes.default.oneOf(['dateRange', 'date']),
+  styles: _propTypes.default.object,
+  onMouseDown: _propTypes.default.func,
+  onMouseUp: _propTypes.default.func,
+  onMouseEnter: _propTypes.default.func,
+  dayContentRenderer: _propTypes.default.func
+};
+var _default = exports.default = DayCell;

node_modules/react-date-range/dist/components/DefinedRange/index.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _styles = _interopRequireDefault(require("../../styles"));
+var _defaultRanges = require("../../defaultRanges");
+var _DayCell = require("../DayCell");
+var _InputRangeField = _interopRequireDefault(require("../InputRangeField"));
+var _classnames = _interopRequireDefault(require("classnames"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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); }
+class DefinedRange extends _react.Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "handleRangeChange", range => {
+      const {
+        onChange,
+        ranges,
+        focusedRange
+      } = this.props;
+      const selectedRange = ranges[focusedRange[0]];
+      if (!onChange || !selectedRange) return;
+      onChange({
+        [selectedRange.key || `range${focusedRange[0] + 1}`]: {
+          ...selectedRange,
+          ...range
+        }
+      });
+    });
+    this.state = {
+      rangeOffset: 0,
+      focusedInput: -1
+    };
+  }
+  getRangeOptionValue(option) {
+    const {
+      ranges = [],
+      focusedRange = []
+    } = this.props;
+    if (typeof option.getCurrentValue !== 'function') {
+      return '';
+    }
+    const selectedRange = ranges[focusedRange[0]] || {};
+    return option.getCurrentValue(selectedRange) || '';
+  }
+  getSelectedRange(ranges, staticRange) {
+    const focusedRangeIndex = ranges.findIndex(range => {
+      if (!range.startDate || !range.endDate || range.disabled) return false;
+      return staticRange.isSelected(range);
+    });
+    const selectedRange = ranges[focusedRangeIndex];
+    return {
+      selectedRange,
+      focusedRangeIndex
+    };
+  }
+  render() {
+    const {
+      headerContent,
+      footerContent,
+      onPreviewChange,
+      inputRanges,
+      staticRanges,
+      ranges,
+      renderStaticRangeLabel,
+      rangeColors,
+      className
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(_styles.default.definedRangesWrapper, className)
+    }, headerContent, /*#__PURE__*/_react.default.createElement("div", {
+      className: _styles.default.staticRanges
+    }, staticRanges.map((staticRange, i) => {
+      const {
+        selectedRange,
+        focusedRangeIndex
+      } = this.getSelectedRange(ranges, staticRange);
+      let labelContent;
+      if (staticRange.hasCustomRendering) {
+        labelContent = renderStaticRangeLabel(staticRange);
+      } else {
+        labelContent = staticRange.label;
+      }
+      return /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        className: (0, _classnames.default)(_styles.default.staticRange, {
+          [_styles.default.staticRangeSelected]: Boolean(selectedRange)
+        }),
+        style: {
+          color: selectedRange ? selectedRange.color || rangeColors[focusedRangeIndex] : null
+        },
+        key: i,
+        onClick: () => this.handleRangeChange(staticRange.range(this.props)),
+        onFocus: () => onPreviewChange && onPreviewChange(staticRange.range(this.props)),
+        onMouseOver: () => onPreviewChange && onPreviewChange(staticRange.range(this.props)),
+        onMouseLeave: () => {
+          onPreviewChange && onPreviewChange();
+        }
+      }, /*#__PURE__*/_react.default.createElement("span", {
+        tabIndex: -1,
+        className: _styles.default.staticRangeLabel
+      }, labelContent));
+    })), /*#__PURE__*/_react.default.createElement("div", {
+      className: _styles.default.inputRanges
+    }, inputRanges.map((rangeOption, i) => /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      key: i,
+      styles: _styles.default,
+      label: rangeOption.label,
+      onFocus: () => this.setState({
+        focusedInput: i,
+        rangeOffset: 0
+      }),
+      onBlur: () => this.setState({
+        rangeOffset: 0
+      }),
+      onChange: value => this.handleRangeChange(rangeOption.range(value, this.props)),
+      value: this.getRangeOptionValue(rangeOption)
+    }))), footerContent);
+  }
+}
+DefinedRange.propTypes = {
+  inputRanges: _propTypes.default.array,
+  staticRanges: _propTypes.default.array,
+  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+  focusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+  onPreviewChange: _propTypes.default.func,
+  onChange: _propTypes.default.func,
+  footerContent: _propTypes.default.any,
+  headerContent: _propTypes.default.any,
+  rangeColors: _propTypes.default.arrayOf(_propTypes.default.string),
+  className: _propTypes.default.string,
+  renderStaticRangeLabel: _propTypes.default.func
+};
+DefinedRange.defaultProps = {
+  inputRanges: _defaultRanges.defaultInputRanges,
+  staticRanges: _defaultRanges.defaultStaticRanges,
+  ranges: [],
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  focusedRange: [0, 0]
+};
+var _default = exports.default = DefinedRange;

node_modules/react-date-range/dist/components/DefinedRange/index.test.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _enzyme = require("enzyme");
+var _DefinedRange = _interopRequireDefault(require("../DefinedRange"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('DefinedRange tests', () => {
+  test('Should call "renderStaticRangeLabel" callback correct amount of times according to the "hasCustomRendering" option', () => {
+    const renderStaticRangeLabel = jest.fn();
+    (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_DefinedRange.default, {
+      staticRanges: [{
+        label: 'Dynamic Label',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }, {
+        label: 'Static Label',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        }
+      }, {
+        label: 'Hede',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }],
+      renderStaticRangeLabel: renderStaticRangeLabel
+    }));
+    expect(renderStaticRangeLabel).toHaveBeenCalledTimes(2);
+  });
+  test('Should render dynamic static label contents correctly', () => {
+    const renderItalicLabelContent = () => /*#__PURE__*/_react.default.createElement("i", {
+      className: 'italic-label-content'
+    }, 'Italic Content');
+    const renderBoldLabelContent = () => /*#__PURE__*/_react.default.createElement("b", {
+      className: 'bold-label-content'
+    }, 'Bold Content');
+    const renderSomethingElse = () => /*#__PURE__*/_react.default.createElement("img", {
+      className: 'random-image'
+    });
+    const renderStaticRangeLabel = function (staticRange) {
+      let result;
+      if (staticRange.id === 'italic') {
+        result = renderItalicLabelContent();
+      } else if (staticRange.id === 'bold') {
+        result = renderBoldLabelContent();
+      } else {
+        result = renderSomethingElse();
+      }
+      return result;
+    };
+    const wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react.default.createElement(_DefinedRange.default, {
+      staticRanges: [{
+        id: 'italic',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }, {
+        label: 'Static Label',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        }
+      }, {
+        id: 'whatever',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }, {
+        id: 'bold',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }],
+      renderStaticRangeLabel: renderStaticRangeLabel
+    }));
+    expect(wrapper).toMatchSnapshot();
+  });
+});

node_modules/react-date-range/dist/components/InputRangeField/index.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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); }
+const MIN = 0;
+const MAX = 99999;
+class InputRangeField extends _react.Component {
+  constructor(props, context) {
+    super(props, context);
+    _defineProperty(this, "onChange", e => {
+      const {
+        onChange
+      } = this.props;
+      let value = parseInt(e.target.value, 10);
+      value = isNaN(value) ? 0 : Math.max(Math.min(MAX, value), MIN);
+      onChange(value);
+    });
+  }
+  shouldComponentUpdate(nextProps) {
+    const {
+      value,
+      label,
+      placeholder
+    } = this.props;
+    return value !== nextProps.value || label !== nextProps.label || placeholder !== nextProps.placeholder;
+  }
+  render() {
+    const {
+      label,
+      placeholder,
+      value,
+      styles,
+      onBlur,
+      onFocus
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: styles.inputRange
+    }, /*#__PURE__*/_react.default.createElement("input", {
+      className: styles.inputRangeInput,
+      placeholder: placeholder,
+      value: value,
+      min: MIN,
+      max: MAX,
+      onChange: this.onChange,
+      onFocus: onFocus,
+      onBlur: onBlur
+    }), /*#__PURE__*/_react.default.createElement("span", {
+      className: styles.inputRangeLabel
+    }, label));
+  }
+}
+InputRangeField.propTypes = {
+  value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  label: _propTypes.default.oneOfType([_propTypes.default.element, _propTypes.default.node]).isRequired,
+  placeholder: _propTypes.default.string,
+  styles: _propTypes.default.shape({
+    inputRange: _propTypes.default.string,
+    inputRangeInput: _propTypes.default.string,
+    inputRangeLabel: _propTypes.default.string
+  }).isRequired,
+  onBlur: _propTypes.default.func.isRequired,
+  onFocus: _propTypes.default.func.isRequired,
+  onChange: _propTypes.default.func.isRequired
+};
+InputRangeField.defaultProps = {
+  value: '',
+  placeholder: '-'
+};
+var _default = exports.default = InputRangeField;

node_modules/react-date-range/dist/components/InputRangeField/index.test.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _enzyme = require("enzyme");
+var _InputRangeField = _interopRequireDefault(require("../InputRangeField"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const styles = {
+  inputRange: 'range',
+  inputRangeInput: 'input',
+  inputRangeLabel: 'label'
+};
+const toChangeEvent = value => ({
+  target: {
+    value
+  }
+});
+describe('InputRangeField tests', () => {
+  test('Should parse input value to number', () => {
+    const onChange = jest.fn();
+    const wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      label: "Input label",
+      styles: styles,
+      onChange: onChange,
+      onFocus: jest.fn(),
+      onBlur: jest.fn()
+    }));
+    wrapper.find('input').simulate('change', toChangeEvent('3'));
+    expect(onChange).lastCalledWith(3);
+    wrapper.find('input').simulate('change', toChangeEvent(12));
+    expect(onChange).lastCalledWith(12);
+    wrapper.find('input').simulate('change', toChangeEvent(''));
+    expect(onChange).lastCalledWith(0);
+    wrapper.find('input').simulate('change', toChangeEvent('invalid number'));
+    expect(onChange).lastCalledWith(0);
+    wrapper.find('input').simulate('change', toChangeEvent(-12));
+    expect(onChange).lastCalledWith(0);
+    wrapper.find('input').simulate('change', toChangeEvent(99999999));
+    expect(onChange).lastCalledWith(99999);
+    expect(onChange).toHaveBeenCalledTimes(6);
+    expect(wrapper).toMatchSnapshot();
+  });
+  test('Should rerender when props change', () => {
+    const wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      value: 12,
+      placeholder: "Placeholder",
+      label: "Input label",
+      styles: styles,
+      onChange: jest.fn(),
+      onFocus: jest.fn(),
+      onBlur: jest.fn()
+    }));
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual(12);
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      value: '32'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      placeholder: '-'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      label: 'Label'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Label');
+  });
+  test('Should render the label as a Component', () => {
+    const Label = () => /*#__PURE__*/_react.default.createElement("span", {
+      className: "input-range-field-label"
+    }, "Input label");
+    const wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      value: 12,
+      placeholder: "Placeholder",
+      label: /*#__PURE__*/_react.default.createElement(Label, null),
+      styles: styles,
+      onChange: jest.fn(),
+      onFocus: jest.fn(),
+      onBlur: jest.fn()
+    }));
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual(12);
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    expect(wrapper.find(`.input-range-field-label`).text()).toEqual('Input label');
+    wrapper.setProps({
+      value: '32'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      placeholder: '-'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      label: 'Label'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Label');
+  });
+});

node_modules/react-date-range/dist/components/Month/index.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DayCell = _interopRequireWildcard(require("../DayCell"));
+var _dateFns = require("date-fns");
+var _utils = require("../../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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); } /* eslint-disable no-fallthrough */
+function renderWeekdays(styles, dateOptions, weekdayDisplayFormat) {
+  const now = new Date();
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: styles.weekDays
+  }, (0, _dateFns.eachDayOfInterval)({
+    start: (0, _dateFns.startOfWeek)(now, dateOptions),
+    end: (0, _dateFns.endOfWeek)(now, dateOptions)
+  }).map((day, i) => /*#__PURE__*/_react.default.createElement("span", {
+    className: styles.weekDay,
+    key: i
+  }, (0, _dateFns.format)(day, weekdayDisplayFormat, dateOptions))));
+}
+class Month extends _react.PureComponent {
+  render() {
+    const now = new Date();
+    const {
+      displayMode,
+      focusedRange,
+      drag,
+      styles,
+      disabledDates,
+      disabledDay
+    } = this.props;
+    const minDate = this.props.minDate && (0, _dateFns.startOfDay)(this.props.minDate);
+    const maxDate = this.props.maxDate && (0, _dateFns.endOfDay)(this.props.maxDate);
+    const monthDisplay = (0, _utils.getMonthDisplayRange)(this.props.month, this.props.dateOptions, this.props.fixedHeight);
+    let ranges = this.props.ranges;
+    if (displayMode === 'dateRange' && drag.status) {
+      let {
+        startDate,
+        endDate
+      } = drag.range;
+      ranges = ranges.map((range, i) => {
+        if (i !== focusedRange[0]) return range;
+        return {
+          ...range,
+          startDate,
+          endDate
+        };
+      });
+    }
+    const showPreview = this.props.showPreview && !drag.disablePreview;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: styles.month,
+      style: this.props.style
+    }, this.props.showMonthName ? /*#__PURE__*/_react.default.createElement("div", {
+      className: styles.monthName
+    }, (0, _dateFns.format)(this.props.month, this.props.monthDisplayFormat, this.props.dateOptions)) : null, this.props.showWeekDays && renderWeekdays(styles, this.props.dateOptions, this.props.weekdayDisplayFormat), /*#__PURE__*/_react.default.createElement("div", {
+      className: styles.days,
+      onMouseLeave: this.props.onMouseLeave
+    }, (0, _dateFns.eachDayOfInterval)({
+      start: monthDisplay.start,
+      end: monthDisplay.end
+    }).map((day, index) => {
+      const isStartOfMonth = (0, _dateFns.isSameDay)(day, monthDisplay.startDateOfMonth);
+      const isEndOfMonth = (0, _dateFns.isSameDay)(day, monthDisplay.endDateOfMonth);
+      const isOutsideMinMax = minDate && (0, _dateFns.isBefore)(day, minDate) || maxDate && (0, _dateFns.isAfter)(day, maxDate);
+      const isDisabledSpecifically = disabledDates.some(disabledDate => (0, _dateFns.isSameDay)(disabledDate, day));
+      const isDisabledDay = disabledDay(day);
+      return /*#__PURE__*/_react.default.createElement(_DayCell.default, _extends({}, this.props, {
+        ranges: ranges,
+        day: day,
+        preview: showPreview ? this.props.preview : null,
+        isWeekend: (0, _dateFns.isWeekend)(day, this.props.dateOptions),
+        isToday: (0, _dateFns.isSameDay)(day, now),
+        isStartOfWeek: (0, _dateFns.isSameDay)(day, (0, _dateFns.startOfWeek)(day, this.props.dateOptions)),
+        isEndOfWeek: (0, _dateFns.isSameDay)(day, (0, _dateFns.endOfWeek)(day, this.props.dateOptions)),
+        isStartOfMonth: isStartOfMonth,
+        isEndOfMonth: isEndOfMonth,
+        key: index,
+        disabled: isOutsideMinMax || isDisabledSpecifically || isDisabledDay,
+        isPassive: !(0, _dateFns.isWithinInterval)(day, {
+          start: monthDisplay.startDateOfMonth,
+          end: monthDisplay.endDateOfMonth
+        }),
+        styles: styles,
+        onMouseDown: this.props.onDragSelectionStart,
+        onMouseUp: this.props.onDragSelectionEnd,
+        onMouseEnter: this.props.onDragSelectionMove,
+        dragRange: drag.range,
+        drag: drag.status
+      }));
+    })));
+  }
+}
+Month.defaultProps = {};
+Month.propTypes = {
+  style: _propTypes.default.object,
+  styles: _propTypes.default.object,
+  month: _propTypes.default.object,
+  drag: _propTypes.default.object,
+  dateOptions: _propTypes.default.object,
+  disabledDates: _propTypes.default.array,
+  disabledDay: _propTypes.default.func,
+  preview: _propTypes.default.shape({
+    startDate: _propTypes.default.object,
+    endDate: _propTypes.default.object
+  }),
+  showPreview: _propTypes.default.bool,
+  displayMode: _propTypes.default.oneOf(['dateRange', 'date']),
+  minDate: _propTypes.default.object,
+  maxDate: _propTypes.default.object,
+  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+  focusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+  onDragSelectionStart: _propTypes.default.func,
+  onDragSelectionEnd: _propTypes.default.func,
+  onDragSelectionMove: _propTypes.default.func,
+  onMouseLeave: _propTypes.default.func,
+  monthDisplayFormat: _propTypes.default.string,
+  weekdayDisplayFormat: _propTypes.default.string,
+  dayDisplayFormat: _propTypes.default.string,
+  showWeekDays: _propTypes.default.bool,
+  showMonthName: _propTypes.default.bool,
+  fixedHeight: _propTypes.default.bool
+};
+var _default = exports.default = Month;

node_modules/react-date-range/dist/defaultRanges.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStaticRanges = createStaticRanges;
+exports.defaultStaticRanges = exports.defaultInputRanges = void 0;
+var _dateFns = require("date-fns");
+const defineds = {
+  startOfWeek: (0, _dateFns.startOfWeek)(new Date()),
+  endOfWeek: (0, _dateFns.endOfWeek)(new Date()),
+  startOfLastWeek: (0, _dateFns.startOfWeek)((0, _dateFns.addDays)(new Date(), -7)),
+  endOfLastWeek: (0, _dateFns.endOfWeek)((0, _dateFns.addDays)(new Date(), -7)),
+  startOfToday: (0, _dateFns.startOfDay)(new Date()),
+  endOfToday: (0, _dateFns.endOfDay)(new Date()),
+  startOfYesterday: (0, _dateFns.startOfDay)((0, _dateFns.addDays)(new Date(), -1)),
+  endOfYesterday: (0, _dateFns.endOfDay)((0, _dateFns.addDays)(new Date(), -1)),
+  startOfMonth: (0, _dateFns.startOfMonth)(new Date()),
+  endOfMonth: (0, _dateFns.endOfMonth)(new Date()),
+  startOfLastMonth: (0, _dateFns.startOfMonth)((0, _dateFns.addMonths)(new Date(), -1)),
+  endOfLastMonth: (0, _dateFns.endOfMonth)((0, _dateFns.addMonths)(new Date(), -1))
+};
+const staticRangeHandler = {
+  range: {},
+  isSelected(range) {
+    const definedRange = this.range();
+    return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+  }
+};
+function createStaticRanges(ranges) {
+  return ranges.map(range => ({
+    ...staticRangeHandler,
+    ...range
+  }));
+}
+const defaultStaticRanges = exports.defaultStaticRanges = createStaticRanges([{
+  label: 'Today',
+  range: () => ({
+    startDate: defineds.startOfToday,
+    endDate: defineds.endOfToday
+  })
+}, {
+  label: 'Yesterday',
+  range: () => ({
+    startDate: defineds.startOfYesterday,
+    endDate: defineds.endOfYesterday
+  })
+}, {
+  label: 'This Week',
+  range: () => ({
+    startDate: defineds.startOfWeek,
+    endDate: defineds.endOfWeek
+  })
+}, {
+  label: 'Last Week',
+  range: () => ({
+    startDate: defineds.startOfLastWeek,
+    endDate: defineds.endOfLastWeek
+  })
+}, {
+  label: 'This Month',
+  range: () => ({
+    startDate: defineds.startOfMonth,
+    endDate: defineds.endOfMonth
+  })
+}, {
+  label: 'Last Month',
+  range: () => ({
+    startDate: defineds.startOfLastMonth,
+    endDate: defineds.endOfLastMonth
+  })
+}]);
+const defaultInputRanges = exports.defaultInputRanges = [{
+  label: 'days up to today',
+  range(value) {
+    return {
+      startDate: (0, _dateFns.addDays)(defineds.startOfToday, (Math.max(Number(value), 1) - 1) * -1),
+      endDate: defineds.endOfToday
+    };
+  },
+  getCurrentValue(range) {
+    if (!(0, _dateFns.isSameDay)(range.endDate, defineds.endOfToday)) return '-';
+    if (!range.startDate) return '∞';
+    return (0, _dateFns.differenceInCalendarDays)(defineds.endOfToday, range.startDate) + 1;
+  }
+}, {
+  label: 'days starting today',
+  range(value) {
+    const today = new Date();
+    return {
+      startDate: today,
+      endDate: (0, _dateFns.addDays)(today, Math.max(Number(value), 1) - 1)
+    };
+  },
+  getCurrentValue(range) {
+    if (!(0, _dateFns.isSameDay)(range.startDate, defineds.startOfToday)) return '-';
+    if (!range.endDate) return '∞';
+    return (0, _dateFns.differenceInCalendarDays)(range.endDate, defineds.startOfToday) + 1;
+  }
+}];

node_modules/react-date-range/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Calendar", {
+  enumerable: true,
+  get: function () {
+    return _Calendar.default;
+  }
+});
+Object.defineProperty(exports, "DateRange", {
+  enumerable: true,
+  get: function () {
+    return _DateRange.default;
+  }
+});
+Object.defineProperty(exports, "DateRangePicker", {
+  enumerable: true,
+  get: function () {
+    return _DateRangePicker.default;
+  }
+});
+Object.defineProperty(exports, "DefinedRange", {
+  enumerable: true,
+  get: function () {
+    return _DefinedRange.default;
+  }
+});
+Object.defineProperty(exports, "createStaticRanges", {
+  enumerable: true,
+  get: function () {
+    return _defaultRanges.createStaticRanges;
+  }
+});
+Object.defineProperty(exports, "defaultInputRanges", {
+  enumerable: true,
+  get: function () {
+    return _defaultRanges.defaultInputRanges;
+  }
+});
+Object.defineProperty(exports, "defaultStaticRanges", {
+  enumerable: true,
+  get: function () {
+    return _defaultRanges.defaultStaticRanges;
+  }
+});
+var _DateRange = _interopRequireDefault(require("./components/DateRange"));
+var _Calendar = _interopRequireDefault(require("./components/Calendar"));
+var _DateRangePicker = _interopRequireDefault(require("./components/DateRangePicker"));
+var _DefinedRange = _interopRequireDefault(require("./components/DefinedRange"));
+var _defaultRanges = require("./defaultRanges");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

node_modules/react-date-range/dist/locale/index.js

@@ -0,0 +1,440 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "af", {
+  enumerable: true,
+  get: function () {
+    return _af.default;
+  }
+});
+Object.defineProperty(exports, "arDZ", {
+  enumerable: true,
+  get: function () {
+    return _arDZ.default;
+  }
+});
+Object.defineProperty(exports, "arSA", {
+  enumerable: true,
+  get: function () {
+    return _arSA.default;
+  }
+});
+Object.defineProperty(exports, "be", {
+  enumerable: true,
+  get: function () {
+    return _be.default;
+  }
+});
+Object.defineProperty(exports, "bg", {
+  enumerable: true,
+  get: function () {
+    return _bg.default;
+  }
+});
+Object.defineProperty(exports, "bn", {
+  enumerable: true,
+  get: function () {
+    return _bn.default;
+  }
+});
+Object.defineProperty(exports, "ca", {
+  enumerable: true,
+  get: function () {
+    return _ca.default;
+  }
+});
+Object.defineProperty(exports, "cs", {
+  enumerable: true,
+  get: function () {
+    return _cs.default;
+  }
+});
+Object.defineProperty(exports, "cy", {
+  enumerable: true,
+  get: function () {
+    return _cy.default;
+  }
+});
+Object.defineProperty(exports, "da", {
+  enumerable: true,
+  get: function () {
+    return _da.default;
+  }
+});
+Object.defineProperty(exports, "de", {
+  enumerable: true,
+  get: function () {
+    return _de.default;
+  }
+});
+Object.defineProperty(exports, "el", {
+  enumerable: true,
+  get: function () {
+    return _el.default;
+  }
+});
+Object.defineProperty(exports, "enAU", {
+  enumerable: true,
+  get: function () {
+    return _enAU.default;
+  }
+});
+Object.defineProperty(exports, "enCA", {
+  enumerable: true,
+  get: function () {
+    return _enCA.default;
+  }
+});
+Object.defineProperty(exports, "enGB", {
+  enumerable: true,
+  get: function () {
+    return _enGB.default;
+  }
+});
+Object.defineProperty(exports, "enUS", {
+  enumerable: true,
+  get: function () {
+    return _enUS.default;
+  }
+});
+Object.defineProperty(exports, "eo", {
+  enumerable: true,
+  get: function () {
+    return _eo.default;
+  }
+});
+Object.defineProperty(exports, "es", {
+  enumerable: true,
+  get: function () {
+    return _es.default;
+  }
+});
+Object.defineProperty(exports, "et", {
+  enumerable: true,
+  get: function () {
+    return _et.default;
+  }
+});
+Object.defineProperty(exports, "faIR", {
+  enumerable: true,
+  get: function () {
+    return _faIR.default;
+  }
+});
+Object.defineProperty(exports, "fi", {
+  enumerable: true,
+  get: function () {
+    return _fi.default;
+  }
+});
+Object.defineProperty(exports, "fr", {
+  enumerable: true,
+  get: function () {
+    return _fr.default;
+  }
+});
+Object.defineProperty(exports, "frCA", {
+  enumerable: true,
+  get: function () {
+    return _frCA.default;
+  }
+});
+Object.defineProperty(exports, "gl", {
+  enumerable: true,
+  get: function () {
+    return _gl.default;
+  }
+});
+Object.defineProperty(exports, "gu", {
+  enumerable: true,
+  get: function () {
+    return _gu.default;
+  }
+});
+Object.defineProperty(exports, "he", {
+  enumerable: true,
+  get: function () {
+    return _he.default;
+  }
+});
+Object.defineProperty(exports, "hi", {
+  enumerable: true,
+  get: function () {
+    return _hi.default;
+  }
+});
+Object.defineProperty(exports, "hr", {
+  enumerable: true,
+  get: function () {
+    return _hr.default;
+  }
+});
+Object.defineProperty(exports, "hu", {
+  enumerable: true,
+  get: function () {
+    return _hu.default;
+  }
+});
+Object.defineProperty(exports, "hy", {
+  enumerable: true,
+  get: function () {
+    return _hy.default;
+  }
+});
+Object.defineProperty(exports, "id", {
+  enumerable: true,
+  get: function () {
+    return _id.default;
+  }
+});
+Object.defineProperty(exports, "is", {
+  enumerable: true,
+  get: function () {
+    return _is.default;
+  }
+});
+Object.defineProperty(exports, "it", {
+  enumerable: true,
+  get: function () {
+    return _it.default;
+  }
+});
+Object.defineProperty(exports, "ja", {
+  enumerable: true,
+  get: function () {
+    return _ja.default;
+  }
+});
+Object.defineProperty(exports, "ka", {
+  enumerable: true,
+  get: function () {
+    return _ka.default;
+  }
+});
+Object.defineProperty(exports, "kk", {
+  enumerable: true,
+  get: function () {
+    return _kk.default;
+  }
+});
+Object.defineProperty(exports, "ko", {
+  enumerable: true,
+  get: function () {
+    return _ko.default;
+  }
+});
+Object.defineProperty(exports, "lt", {
+  enumerable: true,
+  get: function () {
+    return _lt.default;
+  }
+});
+Object.defineProperty(exports, "lv", {
+  enumerable: true,
+  get: function () {
+    return _lv.default;
+  }
+});
+Object.defineProperty(exports, "ms", {
+  enumerable: true,
+  get: function () {
+    return _ms.default;
+  }
+});
+Object.defineProperty(exports, "nb", {
+  enumerable: true,
+  get: function () {
+    return _nb.default;
+  }
+});
+Object.defineProperty(exports, "nl", {
+  enumerable: true,
+  get: function () {
+    return _nl.default;
+  }
+});
+Object.defineProperty(exports, "nn", {
+  enumerable: true,
+  get: function () {
+    return _nn.default;
+  }
+});
+Object.defineProperty(exports, "pl", {
+  enumerable: true,
+  get: function () {
+    return _pl.default;
+  }
+});
+Object.defineProperty(exports, "pt", {
+  enumerable: true,
+  get: function () {
+    return _pt.default;
+  }
+});
+Object.defineProperty(exports, "ptBR", {
+  enumerable: true,
+  get: function () {
+    return _ptBR.default;
+  }
+});
+Object.defineProperty(exports, "ro", {
+  enumerable: true,
+  get: function () {
+    return _ro.default;
+  }
+});
+Object.defineProperty(exports, "ru", {
+  enumerable: true,
+  get: function () {
+    return _ru.default;
+  }
+});
+Object.defineProperty(exports, "sk", {
+  enumerable: true,
+  get: function () {
+    return _sk.default;
+  }
+});
+Object.defineProperty(exports, "sl", {
+  enumerable: true,
+  get: function () {
+    return _sl.default;
+  }
+});
+Object.defineProperty(exports, "sr", {
+  enumerable: true,
+  get: function () {
+    return _sr.default;
+  }
+});
+Object.defineProperty(exports, "srLatn", {
+  enumerable: true,
+  get: function () {
+    return _srLatn.default;
+  }
+});
+Object.defineProperty(exports, "sv", {
+  enumerable: true,
+  get: function () {
+    return _sv.default;
+  }
+});
+Object.defineProperty(exports, "ta", {
+  enumerable: true,
+  get: function () {
+    return _ta.default;
+  }
+});
+Object.defineProperty(exports, "te", {
+  enumerable: true,
+  get: function () {
+    return _te.default;
+  }
+});
+Object.defineProperty(exports, "th", {
+  enumerable: true,
+  get: function () {
+    return _th.default;
+  }
+});
+Object.defineProperty(exports, "tr", {
+  enumerable: true,
+  get: function () {
+    return _tr.default;
+  }
+});
+Object.defineProperty(exports, "ug", {
+  enumerable: true,
+  get: function () {
+    return _ug.default;
+  }
+});
+Object.defineProperty(exports, "uk", {
+  enumerable: true,
+  get: function () {
+    return _uk.default;
+  }
+});
+Object.defineProperty(exports, "vi", {
+  enumerable: true,
+  get: function () {
+    return _vi.default;
+  }
+});
+Object.defineProperty(exports, "zhCN", {
+  enumerable: true,
+  get: function () {
+    return _zhCN.default;
+  }
+});
+Object.defineProperty(exports, "zhTW", {
+  enumerable: true,
+  get: function () {
+    return _zhTW.default;
+  }
+});
+var _af = _interopRequireDefault(require("date-fns/locale/af"));
+var _arDZ = _interopRequireDefault(require("date-fns/locale/ar-DZ"));
+var _arSA = _interopRequireDefault(require("date-fns/locale/ar-SA"));
+var _be = _interopRequireDefault(require("date-fns/locale/be"));
+var _bg = _interopRequireDefault(require("date-fns/locale/bg"));
+var _bn = _interopRequireDefault(require("date-fns/locale/bn"));
+var _ca = _interopRequireDefault(require("date-fns/locale/ca"));
+var _cs = _interopRequireDefault(require("date-fns/locale/cs"));
+var _cy = _interopRequireDefault(require("date-fns/locale/cy"));
+var _da = _interopRequireDefault(require("date-fns/locale/da"));
+var _de = _interopRequireDefault(require("date-fns/locale/de"));
+var _el = _interopRequireDefault(require("date-fns/locale/el"));
+var _enAU = _interopRequireDefault(require("date-fns/locale/en-AU"));
+var _enCA = _interopRequireDefault(require("date-fns/locale/en-CA"));
+var _enGB = _interopRequireDefault(require("date-fns/locale/en-GB"));
+var _enUS = _interopRequireDefault(require("date-fns/locale/en-US"));
+var _eo = _interopRequireDefault(require("date-fns/locale/eo"));
+var _es = _interopRequireDefault(require("date-fns/locale/es"));
+var _et = _interopRequireDefault(require("date-fns/locale/et"));
+var _faIR = _interopRequireDefault(require("date-fns/locale/fa-IR"));
+var _fi = _interopRequireDefault(require("date-fns/locale/fi"));
+var _fr = _interopRequireDefault(require("date-fns/locale/fr"));
+var _frCA = _interopRequireDefault(require("date-fns/locale/fr-CA"));
+var _gl = _interopRequireDefault(require("date-fns/locale/gl"));
+var _gu = _interopRequireDefault(require("date-fns/locale/gu"));
+var _he = _interopRequireDefault(require("date-fns/locale/he"));
+var _hi = _interopRequireDefault(require("date-fns/locale/hi"));
+var _hr = _interopRequireDefault(require("date-fns/locale/hr"));
+var _hu = _interopRequireDefault(require("date-fns/locale/hu"));
+var _hy = _interopRequireDefault(require("date-fns/locale/hy"));
+var _id = _interopRequireDefault(require("date-fns/locale/id"));
+var _is = _interopRequireDefault(require("date-fns/locale/is"));
+var _it = _interopRequireDefault(require("date-fns/locale/it"));
+var _ja = _interopRequireDefault(require("date-fns/locale/ja"));
+var _ka = _interopRequireDefault(require("date-fns/locale/ka"));
+var _kk = _interopRequireDefault(require("date-fns/locale/kk"));
+var _ko = _interopRequireDefault(require("date-fns/locale/ko"));
+var _lt = _interopRequireDefault(require("date-fns/locale/lt"));
+var _lv = _interopRequireDefault(require("date-fns/locale/lv"));
+var _ms = _interopRequireDefault(require("date-fns/locale/ms"));
+var _nb = _interopRequireDefault(require("date-fns/locale/nb"));
+var _nl = _interopRequireDefault(require("date-fns/locale/nl"));
+var _nn = _interopRequireDefault(require("date-fns/locale/nn"));
+var _pl = _interopRequireDefault(require("date-fns/locale/pl"));
+var _pt = _interopRequireDefault(require("date-fns/locale/pt"));
+var _ptBR = _interopRequireDefault(require("date-fns/locale/pt-BR"));
+var _ro = _interopRequireDefault(require("date-fns/locale/ro"));
+var _ru = _interopRequireDefault(require("date-fns/locale/ru"));
+var _sk = _interopRequireDefault(require("date-fns/locale/sk"));
+var _sl = _interopRequireDefault(require("date-fns/locale/sl"));
+var _sr = _interopRequireDefault(require("date-fns/locale/sr"));
+var _srLatn = _interopRequireDefault(require("date-fns/locale/sr-Latn"));
+var _sv = _interopRequireDefault(require("date-fns/locale/sv"));
+var _ta = _interopRequireDefault(require("date-fns/locale/ta"));
+var _te = _interopRequireDefault(require("date-fns/locale/te"));
+var _th = _interopRequireDefault(require("date-fns/locale/th"));
+var _tr = _interopRequireDefault(require("date-fns/locale/tr"));
+var _ug = _interopRequireDefault(require("date-fns/locale/ug"));
+var _uk = _interopRequireDefault(require("date-fns/locale/uk"));
+var _vi = _interopRequireDefault(require("date-fns/locale/vi"));
+var _zhCN = _interopRequireDefault(require("date-fns/locale/zh-CN"));
+var _zhTW = _interopRequireDefault(require("date-fns/locale/zh-TW"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

node_modules/react-date-range/dist/styles.css

@@ -0,0 +1,194 @@
+.rdrCalendarWrapper {
+  box-sizing: border-box;
+  background: #ffffff;
+  display: inline-flex;
+  flex-direction: column;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+}
+
+.rdrDateDisplay{
+  display: flex;
+  justify-content: space-between;
+}
+
+.rdrDateDisplayItem{
+  flex: 1 1;
+  width: 0;
+  text-align: center;
+  color: inherit;
+}
+
+.rdrDateDisplayItem + .rdrDateDisplayItem{
+    margin-left: 0.833em;
+  }
+
+.rdrDateDisplayItem input{
+    text-align: inherit
+  }
+
+.rdrDateDisplayItem input:disabled{
+      cursor: default;
+    }
+
+.rdrDateDisplayItemActive{}
+
+.rdrMonthAndYearWrapper {
+  box-sizing: inherit;
+  display: flex;
+  justify-content: space-between;
+}
+
+.rdrMonthAndYearPickers{
+  flex: 1 1 auto;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.rdrMonthPicker{}
+
+.rdrYearPicker{}
+
+.rdrNextPrevButton {
+  box-sizing: inherit;
+  cursor: pointer;
+  outline: none;
+}
+
+.rdrPprevButton {}
+
+.rdrNextButton {}
+
+.rdrMonths{
+  display: flex;
+}
+
+.rdrMonthsVertical{
+  flex-direction: column;
+}
+
+.rdrMonthsHorizontal > div > div > div{
+  display: flex;
+  flex-direction: row;
+}
+
+.rdrMonth{
+  width: 27.667em;
+}
+
+.rdrWeekDays{
+  display: flex;
+}
+
+.rdrWeekDay {
+  flex-basis: calc(100% / 7);
+  box-sizing: inherit;
+  text-align: center;
+}
+
+.rdrDays{
+  display: flex;
+  flex-wrap: wrap;
+}
+
+.rdrDateDisplayWrapper{}
+
+.rdrMonthName{}
+
+.rdrInfiniteMonths{
+  overflow: auto;
+}
+
+.rdrDateRangeWrapper{
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+}
+
+.rdrDateInput {
+  position: relative;
+}
+
+.rdrDateInput input {
+    outline: none;
+  }
+
+.rdrDateInput .rdrWarning {
+    position: absolute;
+    font-size: 1.6em;
+    line-height: 1.6em;
+    top: 0;
+    right: .25em;
+    color: #FF0000;
+  }
+
+.rdrDay {
+  box-sizing: inherit;
+  width: calc(100% / 7);
+  position: relative;
+  font: inherit;
+  cursor: pointer;
+}
+
+.rdrDayNumber {
+  display: block;
+  position: relative;
+}
+
+.rdrDayNumber span{
+    color: #1d2429;
+  }
+
+.rdrDayDisabled {
+  cursor: not-allowed;
+}
+
+@supports (-ms-ime-align: auto) {
+  .rdrDay {
+    flex-basis: 14.285% !important;
+  }
+}
+
+.rdrSelected, .rdrInRange, .rdrStartEdge, .rdrEndEdge{
+  pointer-events: none;
+}
+
+.rdrInRange{}
+
+.rdrDayStartPreview, .rdrDayInPreview, .rdrDayEndPreview{
+  pointer-events: none;
+}
+
+.rdrDayHovered{}
+
+.rdrDayActive{}
+
+.rdrDateRangePickerWrapper{
+  display: inline-flex;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+}
+
+.rdrDefinedRangesWrapper{}
+
+.rdrStaticRanges{
+  display: flex;
+  flex-direction: column;
+}
+
+.rdrStaticRange{
+  font-size: inherit;
+}
+
+.rdrStaticRangeLabel{}
+
+.rdrInputRanges{}
+
+.rdrInputRange{
+  display: flex;
+}
+
+.rdrInputRangeInput{}

node_modules/react-date-range/dist/styles.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  dateRangeWrapper: 'rdrDateRangeWrapper',
+  calendarWrapper: 'rdrCalendarWrapper',
+  dateDisplay: 'rdrDateDisplay',
+  dateDisplayItem: 'rdrDateDisplayItem',
+  dateDisplayItemActive: 'rdrDateDisplayItemActive',
+  monthAndYearWrapper: 'rdrMonthAndYearWrapper',
+  monthAndYearPickers: 'rdrMonthAndYearPickers',
+  nextPrevButton: 'rdrNextPrevButton',
+  month: 'rdrMonth',
+  weekDays: 'rdrWeekDays',
+  weekDay: 'rdrWeekDay',
+  days: 'rdrDays',
+  day: 'rdrDay',
+  dayNumber: 'rdrDayNumber',
+  dayPassive: 'rdrDayPassive',
+  dayToday: 'rdrDayToday',
+  dayStartOfWeek: 'rdrDayStartOfWeek',
+  dayEndOfWeek: 'rdrDayEndOfWeek',
+  daySelected: 'rdrDaySelected',
+  dayDisabled: 'rdrDayDisabled',
+  dayStartOfMonth: 'rdrDayStartOfMonth',
+  dayEndOfMonth: 'rdrDayEndOfMonth',
+  dayWeekend: 'rdrDayWeekend',
+  dayStartPreview: 'rdrDayStartPreview',
+  dayInPreview: 'rdrDayInPreview',
+  dayEndPreview: 'rdrDayEndPreview',
+  dayHovered: 'rdrDayHovered',
+  dayActive: 'rdrDayActive',
+  inRange: 'rdrInRange',
+  endEdge: 'rdrEndEdge',
+  startEdge: 'rdrStartEdge',
+  prevButton: 'rdrPprevButton',
+  nextButton: 'rdrNextButton',
+  selected: 'rdrSelected',
+  months: 'rdrMonths',
+  monthPicker: 'rdrMonthPicker',
+  yearPicker: 'rdrYearPicker',
+  dateDisplayWrapper: 'rdrDateDisplayWrapper',
+  definedRangesWrapper: 'rdrDefinedRangesWrapper',
+  staticRanges: 'rdrStaticRanges',
+  staticRange: 'rdrStaticRange',
+  inputRanges: 'rdrInputRanges',
+  inputRange: 'rdrInputRange',
+  inputRangeInput: 'rdrInputRangeInput',
+  dateRangePickerWrapper: 'rdrDateRangePickerWrapper',
+  staticRangeLabel: 'rdrStaticRangeLabel',
+  staticRangeSelected: 'rdrStaticRangeSelected',
+  monthName: 'rdrMonthName',
+  infiniteMonths: 'rdrInfiniteMonths',
+  monthsVertical: 'rdrMonthsVertical',
+  monthsHorizontal: 'rdrMonthsHorizontal'
+};

node_modules/react-date-range/dist/theme/default.css

@@ -0,0 +1,385 @@
+.rdrCalendarWrapper{
+  color: #000000;
+  font-size: 12px;
+}
+
+.rdrDateDisplayWrapper{
+  background-color: rgb(239, 242, 247);
+}
+
+.rdrDateDisplay{
+  margin: 0.833em;
+}
+
+.rdrDateDisplayItem{
+  border-radius: 4px;
+  background-color: rgb(255, 255, 255);
+  box-shadow: 0 1px 2px 0 rgba(35, 57, 66, 0.21);
+  border: 1px solid transparent;
+}
+
+.rdrDateDisplayItem input{
+    cursor: pointer;
+    height: 2.5em;
+    line-height: 2.5em;
+    border: 0px;
+    background: transparent;
+    width: 100%;
+    color: #849095;
+  }
+
+.rdrDateDisplayItemActive{
+  border-color: currentColor;
+}
+
+.rdrDateDisplayItemActive input{
+    color: #7d888d
+  }
+
+.rdrMonthAndYearWrapper {
+  align-items: center;
+  height: 60px;
+  padding-top: 10px;
+}
+
+.rdrMonthAndYearPickers{
+  font-weight: 600;
+}
+
+.rdrMonthAndYearPickers select{
+    -moz-appearance: none;
+         appearance: none;
+    -webkit-appearance: none;
+    border: 0;
+    background: transparent;
+    padding: 10px 30px 10px 10px;
+    border-radius: 4px;
+    outline: 0;
+    color: #3e484f;
+    background: url("data:image/svg+xml;utf8,<svg width='9px' height='6px' viewBox='0 0 9 6' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'><g id='Artboard' stroke='none' stroke-width='1' fill='none' fill-rule='evenodd' transform='translate(-636.000000, -171.000000)' fill-opacity='0.368716033'><g id='input' transform='translate(172.000000, 37.000000)' fill='%230E242F' fill-rule='nonzero'><g id='Group-9' transform='translate(323.000000, 127.000000)'><path d='M142.280245,7.23952813 C141.987305,6.92353472 141.512432,6.92361662 141.219585,7.23971106 C140.926739,7.5558055 140.926815,8.06821394 141.219755,8.38420735 L145.498801,13 L149.780245,8.38162071 C150.073185,8.0656273 150.073261,7.55321886 149.780415,7.23712442 C149.487568,6.92102998 149.012695,6.92094808 148.719755,7.23694149 L145.498801,10.7113732 L142.280245,7.23952813 Z' id='arrow'></path></g></g></g></svg>") no-repeat;
+    background-position: right 8px center;
+    cursor: pointer;
+    text-align: center
+  }
+
+.rdrMonthAndYearPickers select:hover{
+      background-color: rgba(0,0,0,0.07);
+    }
+
+.rdrMonthPicker, .rdrYearPicker{
+  margin: 0 5px
+}
+
+.rdrNextPrevButton {
+  display: block;
+  width: 24px;
+  height: 24px;
+  margin: 0 0.833em;
+  padding: 0;
+  border: 0;
+  border-radius: 5px;
+  background: #EFF2F7
+}
+
+.rdrNextPrevButton:hover{
+    background: #E1E7F0;
+  }
+
+.rdrNextPrevButton i {
+    display: block;
+    width: 0;
+    height: 0;
+    padding: 0;
+    text-align: center;
+    border-style: solid;
+    margin: auto;
+    transform: translate(-3px, 0px);
+  }
+
+.rdrPprevButton i {
+    border-width: 4px 6px 4px 4px;
+    border-color: transparent rgb(52, 73, 94) transparent transparent;
+    transform: translate(-3px, 0px);
+  }
+
+.rdrNextButton i {
+    margin: 0 0 0 7px;
+    border-width: 4px 4px 4px 6px;
+    border-color: transparent transparent transparent rgb(52, 73, 94);
+    transform: translate(3px, 0px);
+  }
+
+.rdrWeekDays {
+  padding: 0 0.833em;
+}
+
+.rdrMonth{
+  padding: 0 0.833em 1.666em 0.833em;
+}
+
+.rdrMonth .rdrWeekDays {
+    padding: 0;
+  }
+
+.rdrMonths.rdrMonthsVertical .rdrMonth:first-child .rdrMonthName{
+  display: none;
+}
+
+.rdrWeekDay {
+  font-weight: 400;
+  line-height: 2.667em;
+  color: rgb(132, 144, 149);
+}
+
+.rdrDay {
+  background: transparent;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+  border: 0;
+  padding: 0;
+  line-height: 3.000em;
+  height: 3.000em;
+  text-align: center;
+  color: #1d2429
+}
+
+.rdrDay:focus {
+    outline: 0;
+  }
+
+.rdrDayNumber {
+  outline: 0;
+  font-weight: 300;
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  top: 5px;
+  bottom: 5px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.rdrDayToday .rdrDayNumber span{
+  font-weight: 500
+}
+
+.rdrDayToday .rdrDayNumber span:after{
+    content: '';
+    position: absolute;
+    bottom: 4px;
+    left: 50%;
+    transform: translate(-50%, 0);
+    width: 18px;
+    height: 2px;
+    border-radius: 2px;
+    background: #3d91ff;
+  }
+
+.rdrDayToday:not(.rdrDayPassive) .rdrInRange ~ .rdrDayNumber span:after,.rdrDayToday:not(.rdrDayPassive) .rdrStartEdge ~ .rdrDayNumber span:after,.rdrDayToday:not(.rdrDayPassive) .rdrEndEdge ~ .rdrDayNumber span:after,.rdrDayToday:not(.rdrDayPassive) .rdrSelected ~ .rdrDayNumber span:after{
+      background: #fff;
+    }
+
+.rdrDay:not(.rdrDayPassive) .rdrInRange ~ .rdrDayNumber span,.rdrDay:not(.rdrDayPassive) .rdrStartEdge ~ .rdrDayNumber span,.rdrDay:not(.rdrDayPassive) .rdrEndEdge ~ .rdrDayNumber span,.rdrDay:not(.rdrDayPassive) .rdrSelected ~ .rdrDayNumber span{
+          color: rgba(255, 255, 255, 0.85);
+        }
+
+.rdrSelected, .rdrInRange, .rdrStartEdge, .rdrEndEdge{
+  background: currentColor;
+  position: absolute;
+  top: 5px;
+  left: 0;
+  right: 0;
+  bottom: 5px;
+}
+
+.rdrSelected{
+  left: 2px;
+  right: 2px;
+}
+
+.rdrInRange{}
+
+.rdrStartEdge{
+  border-top-left-radius: 1.042em;
+  border-bottom-left-radius: 1.042em;
+  left: 2px;
+}
+
+.rdrEndEdge{
+  border-top-right-radius: 1.042em;
+  border-bottom-right-radius: 1.042em;
+  right: 2px;
+}
+
+.rdrSelected{
+  border-radius: 1.042em;
+}
+
+.rdrDayStartOfMonth .rdrInRange, .rdrDayStartOfMonth .rdrEndEdge, .rdrDayStartOfWeek .rdrInRange, .rdrDayStartOfWeek .rdrEndEdge{
+    border-top-left-radius: 1.042em;
+    border-bottom-left-radius: 1.042em;
+    left: 2px;
+  }
+
+.rdrDayEndOfMonth .rdrInRange,  .rdrDayEndOfMonth .rdrStartEdge,  .rdrDayEndOfWeek .rdrInRange,  .rdrDayEndOfWeek .rdrStartEdge{
+    border-top-right-radius: 1.042em;
+    border-bottom-right-radius: 1.042em;
+    right: 2px;
+  }
+
+.rdrDayStartOfMonth .rdrDayInPreview, .rdrDayStartOfMonth .rdrDayEndPreview, .rdrDayStartOfWeek .rdrDayInPreview, .rdrDayStartOfWeek .rdrDayEndPreview{
+    border-top-left-radius: 1.333em;
+    border-bottom-left-radius: 1.333em;
+    border-left-width: 1px;
+    left: 0px;
+  }
+
+.rdrDayEndOfMonth .rdrDayInPreview, .rdrDayEndOfMonth .rdrDayStartPreview, .rdrDayEndOfWeek .rdrDayInPreview, .rdrDayEndOfWeek .rdrDayStartPreview{
+   border-top-right-radius: 1.333em;
+   border-bottom-right-radius: 1.333em;
+   border-right-width: 1px;
+   right: 0px;
+ }
+
+.rdrDayStartPreview, .rdrDayInPreview, .rdrDayEndPreview{
+  background: rgba(255, 255, 255, 0.09);
+  position: absolute;
+  top: 3px;
+  left: 0px;
+  right: 0px;
+  bottom: 3px;
+  pointer-events: none;
+  border: 0px solid currentColor;
+  z-index: 1;
+}
+
+.rdrDayStartPreview{
+  border-top-width: 1px;
+  border-left-width: 1px;
+  border-bottom-width: 1px;
+  border-top-left-radius: 1.333em;
+  border-bottom-left-radius: 1.333em;
+  left: 0px;
+}
+
+.rdrDayInPreview{
+  border-top-width: 1px;
+  border-bottom-width: 1px;
+}
+
+.rdrDayEndPreview{
+  border-top-width: 1px;
+  border-right-width: 1px;
+  border-bottom-width: 1px;
+  border-top-right-radius: 1.333em;
+  border-bottom-right-radius: 1.333em;
+  right: 2px;
+  right: 0px;
+}
+
+.rdrDefinedRangesWrapper{
+  font-size: 12px;
+  width: 226px;
+  border-right: solid 1px #eff2f7;
+  background: #fff;
+}
+
+.rdrDefinedRangesWrapper .rdrStaticRangeSelected{
+    color: currentColor;
+    font-weight: 600;
+  }
+
+.rdrStaticRange{
+  border: 0;
+  cursor: pointer;
+  display: block;
+  outline: 0;
+  border-bottom: 1px solid #eff2f7;
+  padding: 0;
+  background: #fff
+}
+
+.rdrStaticRange:hover .rdrStaticRangeLabel,.rdrStaticRange:focus .rdrStaticRangeLabel{
+      background: #eff2f7;
+    }
+
+.rdrStaticRangeLabel{
+  display: block;
+  outline: 0;
+  line-height: 18px;
+  padding: 10px 20px;
+  text-align: left;
+}
+
+.rdrInputRanges{
+  padding: 10px 0;
+}
+
+.rdrInputRange{
+  align-items: center;
+  padding: 5px 20px;
+}
+
+.rdrInputRangeInput{
+  width: 30px;
+  height: 30px;
+  line-height: 30px;
+  border-radius: 4px;
+  text-align: center;
+  border: solid 1px rgb(222, 231, 235);
+  margin-right: 10px;
+  color: rgb(108, 118, 122)
+}
+
+.rdrInputRangeInput:focus, .rdrInputRangeInput:hover{
+    border-color: rgb(180, 191, 196);
+    outline: 0;
+    color: #333;
+  }
+
+.rdrCalendarWrapper:not(.rdrDateRangeWrapper) .rdrDayHovered .rdrDayNumber:after{
+  content: '';
+  border: 1px solid currentColor;
+  border-radius: 1.333em;
+  position: absolute;
+  top: -2px;
+  bottom: -2px;
+  left: 0px;
+  right: 0px;
+  background: transparent;
+}
+
+.rdrDayPassive{
+  pointer-events: none;
+}
+
+.rdrDayPassive .rdrDayNumber span{
+    color: #d5dce0;
+  }
+
+.rdrDayPassive .rdrInRange, .rdrDayPassive .rdrStartEdge, .rdrDayPassive .rdrEndEdge, .rdrDayPassive .rdrSelected, .rdrDayPassive .rdrDayStartPreview, .rdrDayPassive .rdrDayInPreview, .rdrDayPassive .rdrDayEndPreview{
+    display: none;
+  }
+
+.rdrDayDisabled {
+  background-color: rgb(248, 248, 248);
+}
+
+.rdrDayDisabled .rdrDayNumber span{
+    color: #aeb9bf;
+  }
+
+.rdrDayDisabled .rdrInRange, .rdrDayDisabled .rdrStartEdge, .rdrDayDisabled .rdrEndEdge, .rdrDayDisabled .rdrSelected, .rdrDayDisabled .rdrDayStartPreview, .rdrDayDisabled .rdrDayInPreview, .rdrDayDisabled .rdrDayEndPreview{
+    filter: grayscale(100%) opacity(60%);
+  }
+
+.rdrMonthName{
+  text-align: left;
+  font-weight: 600;
+  color: #849095;
+  padding: 0.833em;
+}

node_modules/react-date-range/dist/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcFocusDate = calcFocusDate;
+exports.findNextRangeIndex = findNextRangeIndex;
+exports.generateStyles = generateStyles;
+exports.getMonthDisplayRange = getMonthDisplayRange;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function calcFocusDate(currentFocusedDate, props) {
+  const {
+    shownDate,
+    date,
+    months,
+    ranges,
+    focusedRange,
+    displayMode
+  } = props;
+  // find primary date according the props
+  let targetInterval;
+  if (displayMode === 'dateRange') {
+    const range = ranges[focusedRange[0]] || {};
+    targetInterval = {
+      start: range.startDate,
+      end: range.endDate
+    };
+  } else {
+    targetInterval = {
+      start: date,
+      end: date
+    };
+  }
+  targetInterval.start = (0, _dateFns.startOfMonth)(targetInterval.start || new Date());
+  targetInterval.end = (0, _dateFns.endOfMonth)(targetInterval.end || targetInterval.start);
+  const targetDate = targetInterval.start || targetInterval.end || shownDate || new Date();
+
+  // initial focus
+  if (!currentFocusedDate) return shownDate || targetDate;
+
+  // // just return targetDate for native scrolled calendars
+  // if (props.scroll.enabled) return targetDate;
+  if ((0, _dateFns.differenceInCalendarMonths)(targetInterval.start, targetInterval.end) > months) {
+    // don't change focused if new selection in view area
+    return currentFocusedDate;
+  }
+  return targetDate;
+}
+function findNextRangeIndex(ranges) {
+  let currentRangeIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+  const nextIndex = ranges.findIndex((range, i) => i > currentRangeIndex && range.autoFocus !== false && !range.disabled);
+  if (nextIndex !== -1) return nextIndex;
+  return ranges.findIndex(range => range.autoFocus !== false && !range.disabled);
+}
+function getMonthDisplayRange(date, dateOptions, fixedHeight) {
+  const startDateOfMonth = (0, _dateFns.startOfMonth)(date, dateOptions);
+  const endDateOfMonth = (0, _dateFns.endOfMonth)(date, dateOptions);
+  const startDateOfCalendar = (0, _dateFns.startOfWeek)(startDateOfMonth, dateOptions);
+  let endDateOfCalendar = (0, _dateFns.endOfWeek)(endDateOfMonth, dateOptions);
+  if (fixedHeight && (0, _dateFns.differenceInCalendarDays)(endDateOfCalendar, startDateOfCalendar) <= 34) {
+    endDateOfCalendar = (0, _dateFns.addDays)(endDateOfCalendar, 7);
+  }
+  return {
+    start: startDateOfCalendar,
+    end: endDateOfCalendar,
+    startDateOfMonth,
+    endDateOfMonth
+  };
+}
+function generateStyles(sources) {
+  if (!sources.length) return {};
+  const generatedStyles = sources.filter(source => Boolean(source)).reduce((styles, styleSource) => {
+    Object.keys(styleSource).forEach(key => {
+      styles[key] = (0, _classnames.default)(styles[key], styleSource[key]);
+    });
+    return styles;
+  }, {});
+  return generatedStyles;
+}