inital commit

node_modules/react-date-range/. eslintignore

@@ -0,0 +1,4 @@
+/node_modules/*
+/lib/*
+/dist/*
+**/*.snap

node_modules/react-date-range/.prettierrc

@@ -0,0 +1,11 @@
+{
+    "printWidth": 110,
+    "tabWidth": 2,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "none",
+    "bracketSpacing": true,
+    "jsxBracketSameLine": false,
+    "fluid": false
+  }

node_modules/react-date-range/CHANGELOG.md

@@ -0,0 +1,197 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## 1.4.0
+
+### Added
+- `calendarFocus` prop: Whether calendar focus month should be forward-driven or backwards-driven. can be `forwards` or `backwards` (Default: `forwards`)
+- `preventSnapRefocus` prop: prevents unneceessary refocus of shown range on selection. (Default: `false`)
+
+## 1.3.0
+
+### Added
+- `retainEndDateOnFirstSelection` prop: You can prevent the endDate from changing for selections when the startDate is updated. Default behaviour is for endDate to reset which is preserved. This prop makes this configurable.
+
+
+## 1.2.0
+
+### Added
+- `dayContentRenderer` prop: You can control how each date cell is rendered be passing this function that excepts a date and returns what need to be rendered (#242, #384, #476)
+
+
+## 1.1.4
+
+### Fixed
+- #356: Use babel-plugin-date-fns to reduce bundle size
+- #373, #415, #416: Add missing aria labels
+
+
+## 1.0.0
+### Changed
+- BREAKING: `date-fns` is now loaded as a peerDependency. You can use this plugin with your own project's `date-fns` version. However if you want to keep using date-fns versions older than 2.0.0, (minimum version is 2.0.0-alpha.1) you need to pass the following props to your component. ([See the reason here](https://blog.date-fns.org/post/unicode-tokens-in-date-fns-v2-sreatyki91jg/), also see [this table](https://date-fns.org/docs/format))
+
+```jsx
+<Calendar
+  dateDisplayFormat='MMM D, YYYY'
+  monthDisplayFormat='MMM YYYY'
+  weekdayDisplayFormat='ddd'
+  dayDisplayFormat='D'
+/>
+```
+
+### Added
+- `weekStartsOn` prop: You can set the week start day. (Number, 0 - Sunday, 1 - Monday etc.) If not specified, gets the week start day from your locale.
+
+- `weekdayDisplayFormat`, `dayDisplayFormat` and `monthDisplayFormat` props: For being able to use different versions of date-fns
+
+- `startDatePlaceholder` and `endDatePlaceholder` props: You can set different placeholders for Date inputs. If not set, falls back to 'Early' and 'Continuous'.
+
+- `fixedHeight` prop: Set this to `true` to prevent height change while selecting different months. Since some months require less than 6 lines to show, by setting this prop, you can force 6 lines for all months.
+
+- `editableDateInputs` prop: Set this to `true` to make the inputs editable. Falls back to false.
+
+- `DateInput` and `InputRangeField` are exported as dedicated components.
+
+
+### Fixed
+- Works with React 16, without warnings (Deprecated methods are removed: componentWillReceiveProps )
+- IE11 Bug where the last day of each week is not shown.
+- Now infinite scroll mode works as expected.
+
+## 1.0.0 beta
+
+### Changed
+- BREAKING: `Calendar` and `DateRange` are now totally controlled components with stateless date management.
+
+- BREAKING: React-date-range is no longer use moment out of the box. Input and output values are native Date object. Until v2 version you don't depent on momentjs. You can keep continue to use moment if you want like below
+
+OLD
+```js
+// this.state.eventDate: momentjs object
+<Calendar
+  date={this.state.eventDate}
+  onChange={date => this.setState({eventDate: date})}
+/>
+```
+
+NEW
+```js
+<Calendar
+  date={this.state.eventDate} // js object
+  onChange={date => this.setState({ eventDate: date })} //
+/>
+```
+
+NEW with moment (or any other date libraries)
+```js
+<Calendar
+  date={this.state.eventDate.toDate()} // convert moment object to js Date
+  onChange={date => this.setState({ eventDate: moment(date) })} //
+/>
+```
+- BREAKING: Theming and style approach complately changed. `react-date-range` don't use inline styles any more. At the new version you should import **skeleton styles** and **theme styles**
+
+```js
+// main style file
+import 'react-date-range/dist/styles.css';
+// theme css file
+import 'react-date-range/dist/theme/default.css';
+```
+
+- BREAKING: `Calendar` and `DateRange` Components, no longer support string typed `lang` prop.
+
+ OLD
+ ```js
+  <Calendar lang="tr" />
+```
+
+ NEW
+ ```js
+  import turkish from 'react-date-range/locale/tr';
+  // you can view full list in https://github.com/hypeserver/react-date-range/tree/next/src/locale/index.js
+  <Calendar locale={turkish} />
+```
+
+- BREAKING: `DateRange` handle range data with `ranges:Array` prop instead of `startDate` and `endDate` props.
+
+OLD
+```js
+  <DateRange
+    startDate={new Date()}
+    endDate={new Date(2048, 6, 6)}
+    onChange={ change => {
+      console.log(change);
+      /* prints:
+      {
+        startDate: Moment,
+        endDate: Moment
+      }
+      /*
+    } }
+  />
+```
+
+NEW
+```js
+  <DateRange
+    ranges={[{
+      startDate: new Date(),
+      endDate: new Date(2048, 06, 06),
+      key: 'selection',
+    }]}
+    onChange={changes => {
+      console.log(changes);
+      /* prints
+      {
+        selection: {
+          startDate: Date,
+          endDate: Date
+        }
+      }
+      */
+    }}
+  />
+```
+- `calendars` prop renamed as `months`. And `Calendar` component is accepting `months` prop just like `DateRange`. Default value changed to `1` from `2`.
+### Removed
+
+- `format` prop removed. No longer accepts string input for `Calendar` or `DateRange`. You should parse dates like below:
+Native js: `new Date(dateString)`
+Date-fns: `fns.parse(dateString)`
+Momentjs: `moment(dateString).toDate()`
+
+- `disableDaysBeforeToday` prop removed. use `minDate={new Date()}` instead.
+- `firstDayOfWeek` prop removed. It is auto detecting from locale prop.
+- `init` prop removed.
+- `specialDays` prop removed.
+
+### Added
+- `disabledDates` prop: It's a set of disabled dates.
+- `DefinedRanges` component: It's a set of date presets. Receives `inputRanges`, `staticRanges` for setting date ranges.
+- `DateRangePicker` component. It's combined version of `DateRange` with `DefinedRanges` component.
+- Date range selection by drag.
+- Infinite scroll feature. Sample usage:
+```js
+  const horizontalScroll={enabled: true, monthHeight: 300, monthWidth: 300 };
+  const verticalScroll={enabled: true, monthHeight: 220, longMonthHeight: 240 };
+  <DateRangePicker scroll={horizontalScroll} />
+  <DateRangePicker scroll={verticalScroll} months={2} />
+```
+- `showPreview` prop added to control visibility of preview. Default value is `true`.
+- `preview` prop added: It displays a preview range and overwrite DateRange's default preview. You can set a controlled preview with below shape of object.
+```js
+{
+  startDate: [Date Object] || null,
+  endDate: [Date Object] || null,
+  color: '#fed14c',
+}
+```
+- `onPreviewChange(date)` prop added: Callback function for preview changes. You can set controlled custom previews with `preview` prop.
+- `focusedRange` prop added: It defines which range and step are focused. Common initial value is `[0, 0]`; first value is index of ranges, second value is which step on date range(startDate or endDate).
+- `initialFocusedRange` prop added: Initial value for focused range. See `focusedRange` for usage.
+- `onRangeFocusChange` prop added: Callback function for focus changes by user.
+- `dragSelectionEnabled` prop added
+- `showMonthAndYearPickers` prop added

node_modules/react-date-range/CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Contributing Guide
+
+Make sure your issue or feature doesn't have any related issue at [react-date-range repo](https://github.com/hypeserver/react-date-range/issues). If it didn't exist already, create an issue.
+
+## Getting Started
+
+1. First install [Node.js](https://nodejs.org/en/download) and [Yarn](https://yarnpkg.com/lang/en/).
+
+2. Fork the project, clone your local and create a new branch which named like `fix/{bug-description}` or `feature/{feature-description}`.
+
+3. Run `yarn` to install the dependencies.
+
+4. Run `yarn run dev` to start development server.
+
+## Building
+
+. Run `yarn run test` and `yarn run lint` for make sure tests passes and linter doesn't throw any error.
+
+. Run `yarn run build` compile the library and demo source.
+
+. Push your changes and create a PR and apply code review decisions.
+

node_modules/react-date-range/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+Copyright (c) 2015-2020 Adphorus
+Copyright (c) 2020-     Hypeserver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/react-date-range/README.md

@@ -0,0 +1,211 @@
+# react-date-range
+[![npm](https://img.shields.io/npm/v/react-date-range)](https://www.npmjs.com/package/react-date-range)
+[![npm](https://img.shields.io/npm/l/react-date-range)]()
+[![npm](https://img.shields.io/npm/dw/react-date-range)](https://www.npmjs.com/package/react-date-range)
+[![sponsors](https://img.shields.io/github/sponsors/hypeserver)](https://github.com/sponsors/hypeserver)
+
+
+A date library agnostic React component for choosing dates and date ranges. Uses [date-fns](http://date-fns.org/) for date operations.
+
+# Notice ⚠️
+This project is currently unmaintained because the original maintainers are busy with other things. It should be pretty stable in it's current state but we won't be updating it in the foreseeable future. **If you are willing to maintain it, please fork and open a pr adding your fork's link to this readme.**
+
+### Why should you use `react-date-range`?
+
+- Stateless date operations
+- Highly configurable
+- Multiple range selection
+- Based on native js dates
+- Drag n Drop selection
+- Keyboard friendly
+
+**Live Demo :** [http://hypeserver.github.io/react-date-range](http://hypeserver.github.io/react-date-range)
+
+![](https://raw.githubusercontent.com/hypeserver/react-date-range/master/demo/ss.png)
+
+
+## Getting Started
+### Installation
+
+```
+npm install --save react-date-range
+```
+This plugin expects `react` and `date-fns` as peerDependencies, It means that you need to install them in your project folder.
+
+```
+npm install --save react date-fns
+```
+
+## Usage
+
+You need to import skeleton and theme styles first.
+
+```javascript
+import 'react-date-range/dist/styles.css'; // main style file
+import 'react-date-range/dist/theme/default.css'; // theme css file
+```
+
+### `DatePicker`
+```javascript
+import { Calendar } from 'react-date-range';
+
+class MyComponent extends Component {
+  handleSelect(date){
+    console.log(date); // native Date object
+  }
+  render(){
+    return (
+      <Calendar
+        date={new Date()}
+        onChange={this.handleSelect}
+      />
+    )
+  }
+}
+
+```
+
+### `DateRangePicker / DateRange`
+```javascript
+import { DateRangePicker } from 'react-date-range';
+
+class MyComponent extends Component {
+  handleSelect(ranges){
+    console.log(ranges);
+    // {
+    //   selection: {
+    //     startDate: [native Date Object],
+    //     endDate: [native Date Object],
+    //   }
+    // }
+  }
+  render(){
+    const selectionRange = {
+      startDate: new Date(),
+      endDate: new Date(),
+      key: 'selection',
+    }
+    return (
+      <DateRangePicker
+        ranges={[selectionRange]}
+        onChange={this.handleSelect}
+      />
+    )
+  }
+}
+
+```
+
+### Options
+
+Property                             | type      | Default Value    | Description
+-------------------------------------|-----------|------------------|-----------------------------------------------------------------
+locale                               | Object    | enUS from locale | you can view full list from [here](https://github.com/hypeserver/react-date-range/tree/next/src/locale/index.js). Locales directly exported from [`date-fns/locales`](https://date-fns.org/docs/I18n#supported-languages).
+className                            | String    |                  | wrapper classname
+months                               | Number    | 1                | rendered month count
+showSelectionPreview                 | Boolean   | true             | show preview on focused/hovered dates
+showMonthAndYearPickers              | Boolean   | true             | show select tags for month and year on calendar top, if false it will just display the month and year
+rangeColors                          | String[]  |                  | defines color for selection preview.
+shownDate                            | Date      |                  | initial focus date
+minDate                              | Date      |                  | defines minimum date. Disabled earlier dates
+maxDate                              | Date      |                  | defines maximum date. Disabled later dates
+direction                            | String    | 'vertical'       | direction of calendar months. can be `vertical` or `horizontal`
+disabledDates                        | Date[]    | []               | dates that are disabled
+disabledDay                          | Func      |                  | predicate function that disable day fn(date: Date)
+scroll                               | Object    | { enabled: false }| infinite scroll behaviour configuration. Check out [Infinite Scroll](#infinite-scrolled-mode) section
+showMonthArrow                       | Boolean   | true             | show/hide month arrow button
+navigatorRenderer                    | Func      |                  | renderer for focused date navigation area. fn(currentFocusedDate: Date, changeShownDate: func, props: object)
+ranges                               | *Object[] | []               | Defines ranges. array of range object
+moveRangeOnFirstSelection(DateRange) | Boolean   | false            | move range on startDate selection. Otherwise endDate will replace with startDate unless `retainEndDateOnFirstSelection` is set to true.
+retainEndDateOnFirstSelection(DateRange) | Boolean   | false            | Retain end date when the start date is changed, unless start date is later than end date. Ignored if `moveRangeOnFirstSelection` is set to true.
+onChange(Calendar)                   | Func      |                  | callback function for date changes. fn(date: Date)
+onChange(DateRange)                  | Func      |                  | callback function for range changes. fn(changes). changes contains changed ranges with new `startDate`/`endDate` properties.
+color(Calendar)                      | String    | `#3d91ff`        | defines color for selected date in Calendar
+date(Calendar)                       | Date      |                  | date value for Calendar
+showDateDisplay(DateRange)           | Boolean   | true             | show/hide selection display row. Uses `dateDisplayFormat` for formatter
+onShownDateChange(DateRange,Calendar)| Function  |                  | Callback function that is called when the shown date changes
+initialFocusedRange(DateRange)       | Object    |                  | Initial value for focused range. See `focusedRange` for usage.
+focusedRange(DateRange)              | Object    |                  | It defines which range and step are focused. Common initial value is `[0, 0]`; first value is index of ranges, second one is which step on date range(startDate or endDate).
+onRangeFocusChange(DateRange)        | Object    |                  | Callback function for focus changes
+preview(DateRange)                   | Object    |                  | displays a preview range and overwrite DateRange's default preview. Expected shape: `{ startDate: Date, endDate: Date, color: String }`
+showPreview(DateRange)               | bool      | true             | visibility of preview
+editableDateInputs(Calendar)         | bool      | false            | whether dates can be edited in the Calendar's input fields
+dragSelectionEnabled(Calendar)       | bool      | true             | whether dates can be selected via drag n drop
+calendarFocus(Calendar)              | String    | 'forwards'       | Whether calendar focus month should be forward-driven or backwards-driven. can be 'forwards' or 'backwards'
+preventSnapRefocus(Calendar)  | bool      | false            | prevents unneceessary refocus of shown range on selection
+onPreviewChange(DateRange)           | Object    |                  | Callback function for preview changes
+dateDisplayFormat                    | String    | `MMM d, yyyy`    | selected range preview formatter. Check out [date-fns's format option](https://date-fns.org/docs/format)
+dayDisplayFormat                     | String    | `d`              | selected range preview formatter. Check out [date-fns's format option](https://date-fns.org/docs/format)
+weekdayDisplayFormat                 | String    | `E`              | selected range preview formatter. Check out [date-fns's format option](https://date-fns.org/docs/format)
+monthDisplayFormat                   | String    | `MMM yyyy`       | selected range preview formatter. Check out [date-fns's format option](https://date-fns.org/docs/format)
+weekStartsOn                         | Number    |                  | Whether the week start day that comes from the locale will be overriden. Default value comes from your locale, if no local is specified, note that default locale is enUS
+startDatePlaceholder                 | String    | `Early`          | Start Date Placeholder
+endDatePlaceholder                   | String    | `Continuous`     | End Date Placeholder
+fixedHeight                          | Boolean   | false            | Since some months require less than 6 lines to show, by setting this prop, you can force 6 lines for all months.
+renderStaticRangeLabel(`DefinedRange`)| Function |                  | Callback function to be triggered for the static range configurations that have `hasCustomRendering: true` on them. Instead of rendering `staticRange.label`, return value of this callback will be rendered.
+staticRanges(`DefinedRange`, `DateRangePicker`)  | Array            | [default preDefined ranges](https://github.com/hypeserver/react-date-range/blob/master/src/defaultRanges.js)             | -
+inputRanges(`DefinedRange`, `DateRangePicker`)   | Array            | [default input ranges](https://github.com/hypeserver/react-date-range/blob/master/src/defaultRanges.js)             | -
+ariaLabels                           | Object    | {}               | inserts aria-label to inner elements
+dayContentRenderer                   | Function  | null             | Function to customize the rendering of Calendar Day. given a date is supposed to return what to render.
+
+ *shape of range:
+ ```js
+  {
+    startDate: PropTypes.object,
+    endDate: PropTypes.object,
+    color: PropTypes.string,
+    key: PropTypes.string,
+    autoFocus: PropTypes.bool,
+    disabled: PropTypes.bool,
+    showDateDisplay: PropTypes.bool,
+  }
+```
+
+ **shape of ariaLabels:
+ ```js
+  {
+    // The key of dateInput should be same as key in range.
+    dateInput: PropTypes.objectOf(
+      PropTypes.shape({
+        startDate: PropTypes.string,
+        endDate: PropTypes.string
+      })
+    ),
+    monthPicker: PropTypes.string,
+    yearPicker: PropTypes.string,
+    prevButton: PropTypes.string,
+    nextButton: PropTypes.string,
+  }
+```
+#### Infinite Scrolled Mode
+
+To enable infinite scroll set `scroll={{enabled: true}}` basically. Infinite scroll feature is affected by `direction`(rendering direction for months) and `months`(for rendered months count) props directly.
+If you prefer, you can overwrite calendar sizes with `calendarWidth`/`calendarHeight` or each month's height/width with `monthWidth`/`monthHeight`/`longMonthHeight` at `scroll` prop.
+
+```js
+  // shape of scroll prop
+  scroll: {
+    enabled: PropTypes.bool,
+    monthHeight: PropTypes.number,
+    longMonthHeight: PropTypes.number, // some months has 1 more row than others
+    monthWidth: PropTypes.number, // just used when direction="horizontal"
+    calendarWidth: PropTypes.number, // defaults monthWidth * months
+    calendarHeight: PropTypes.number, // defaults monthHeight * months
+  }),
+```
+
+
+### Release workflow
+- Merge everything that needs to be in the release to master
+- Open a new release PR than:
+  - bumps version to appropriate one <new_version>
+  - Update CHANGELOG.md
+- Make sure the demo and important features are working as expected
+- After merging, tag the master commit with `release/<new_version>` and let Github Action handle publishing
+- = Profit 🙈
+
+### TODOs
+
+- Make mobile friendly (integrate tap and swipe actions)
+- Add tests
+- Improve documentation

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;
+}

node_modules/react-date-range/jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+  verbose: true,
+  testURL: 'http://localhost/',
+  setupFiles: ['<rootDir>/setupTests.js'],
+  testPathIgnorePatterns: ['/node_modules/', '/dist/', '/demo/dist/'],
+  snapshotSerializers: ['enzyme-to-json/serializer'],
+};

node_modules/react-date-range/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "react-date-range",
+  "version": "2.0.1",
+  "description": "A React component for choosing dates and date ranges.",
+  "main": "dist/index.js",
+  "scripts": {
+    "start": "yarn build:css & styleguidist server",
+    "build": "yarn build:css & yarn build:js & styleguidist build",
+    "build:css": "postcss 'src/styles.scss' -d dist --ext css & postcss 'src/theme/*.scss' -d 'dist/theme' --ext css",
+    "build:js": "babel ./src --out-dir ./dist --ignore test.js",
+    "lint": "eslint 'src/**/*.js'",
+    "test": "jest",
+    "preversion": "yarn clear & yarn build"
+  },
+  "keywords": [
+    "react",
+    "date",
+    "range",
+    "datepicker",
+    "rangepicker"
+  ],
+  "contributors": [
+    "Burak Can <neoberg@gmail.com> (https://github.com/burakcan)",
+    "Mehmet Kamil Morcay <mehmetmorcay@gmail.com> (https://github.com/mkg0)",
+    "Kamyar Ghasemlou <github@kamy.me> (https://github.com/kamyar)",
+    "Engin Semih Basmacı <semih.basmaci@gmail.com> (https://github.com/mortargrind)",
+    "Onur Kerimov <onurkerimov@gmail.com> (https://github.com/onurkerimov)"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/hypeserver/react-date-range"
+  },
+  "bugs": {
+    "url": "http://github.com/hypeserver/react-date-range/issues"
+  },
+  "browserslist": [
+    "defaults"
+  ],
+  "dependencies": {
+    "classnames": "^2.2.6",
+    "prop-types": "^15.7.2",
+    "react-list": "^0.8.13",
+    "shallow-equal": "^1.2.1"
+  },
+  "peerDependencies": {
+    "date-fns": "3.0.6 || >=3.0.0",
+    "react": "^0.14 || ^15.0.0-rc || >=15.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.4",
+    "@babel/core": "^7.4.4",
+    "@babel/plugin-proposal-export-default-from": "^7.7.4",
+    "@babel/plugin-transform-class-properties": "^7.23.3",
+    "@babel/preset-env": "^7.4.4",
+    "@babel/preset-react": "^7.7.4",
+    "autoprefixer": "^9.7.3",
+    "babel-eslint": "^10.0.3",
+    "babel-loader": "^9.1.3",
+    "css-loader": "^3.6.0",
+    "date-fns": "^3.0.6",
+    "enzyme": "^3.11.0",
+    "enzyme-adapter-react-16": "^1.15.2",
+    "enzyme-to-json": "^3.4.3",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.7.0",
+    "eslint-plugin-import": "^2.19.1",
+    "eslint-plugin-jsx-a11y": "^6.2.3",
+    "eslint-plugin-prettier": "^3.1.2",
+    "eslint-plugin-react": "^7.17.0",
+    "jest": "^24.9.0",
+    "normalize.css": "^8.0.1",
+    "postcss": "^8.2.13",
+    "postcss-cli": "^10.1.0",
+    "postcss-import": "^12.0.1",
+    "postcss-loader": "^3.0.0",
+    "precss": "^4.0.0",
+    "prettier": "^1.19.1",
+    "react": "^16.12.0",
+    "react-dom": "^16.12.0",
+    "react-styleguidist": "^12.0.1",
+    "style-loader": "^1.3.0",
+    "url-loader": "^3.0.0",
+    "webpack": "^5.89.0"
+  }
+}

node_modules/react-date-range/setupTests.js

@@ -0,0 +1,4 @@
+import { configure } from 'enzyme';
+import Adapter from 'enzyme-adapter-react-16';
+
+configure({ adapter: new Adapter() });

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

@@ -0,0 +1,11 @@
+import PropTypes from 'prop-types';
+
+export const ariaLabelsShape = PropTypes.shape({
+  dateInput: PropTypes.objectOf(
+    PropTypes.shape({ startDate: PropTypes.string, endDate: PropTypes.string })
+  ),
+  monthPicker: PropTypes.string,
+  yearPicker: PropTypes.string,
+  prevButton: PropTypes.string,
+  nextButton: PropTypes.string,
+});

node_modules/react-date-range/src/components/Calendar/README.md

@@ -0,0 +1,82 @@
+#### Example: Internationalization
+
+```jsx inside Markdown
+import * as locales from 'react-date-range/dist/locale';
+import {useState} from 'react'
+
+const nameMapper = {
+  ar: 'Arabic',
+  bg: 'Bulgarian',
+  ca: 'Catalan',
+  cs: 'Czech',
+  cy: 'Welsh',
+  da: 'Danish',
+  de: 'German',
+  el: 'Greek',
+  enGB: 'English (United Kingdom)',
+  enUS: 'English (United States)',
+  eo: 'Esperanto',
+  es: 'Spanish',
+  et: 'Estonian',
+  faIR: 'Persian',
+  fi: 'Finnish',
+  fil: 'Filipino',
+  fr: 'French',
+  hi: 'Hindi',
+  hr: 'Croatian',
+  hu: 'Hungarian',
+  hy: 'Armenian',
+  id: 'Indonesian',
+  is: 'Icelandic',
+  it: 'Italian',
+  ja: 'Japanese',
+  ka: 'Georgian',
+  ko: 'Korean',
+  lt: 'Lithuanian',
+  lv: 'Latvian',
+  mk: 'Macedonian',
+  nb: 'Norwegian Bokmål',
+  nl: 'Dutch',
+  pl: 'Polish',
+  pt: 'Portuguese',
+  ro: 'Romanian',
+  ru: 'Russian',
+  sk: 'Slovak',
+  sl: 'Slovenian',
+  sr: 'Serbian',
+  sv: 'Swedish',
+  th: 'Thai',
+  tr: 'Turkish',
+  uk: 'Ukrainian',
+  vi: 'Vietnamese',
+  zhCN: 'Chinese Simplified',
+  zhTW: 'Chinese Traditional'
+};
+
+const localeOptions = Object.keys(locales)
+  .map(key => ({
+    value: key,
+    label: `${key} - ${nameMapper[key] || ''}`
+  }))
+  .filter(item => nameMapper[item.value]);
+
+const [locale, setLocale] = React.useState('ja');
+const [date, setDate] = useState(null);
+
+
+<div style={{ display: 'flex', flexFlow: 'column nowrap' }}>
+  <select
+    style={{ margin: '20px auto' }}
+    onChange={e => setLocale(e.target.value)}
+    value={locale}
+  >
+    {localeOptions.map((option, i) => (
+      <option value={option.value} key={i}>
+        {option.label}
+      </option>
+    ))}
+  </select>
+  <Calendar onChange={item => setDate(item)}
+ locale={locales[locale]} date={date} />
+</div>;
+```

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

@@ -0,0 +1,620 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import { rangeShape } from '../DayCell';
+import Month from '../Month';
+import DateInput from '../DateInput';
+import { calcFocusDate, generateStyles, getMonthDisplayRange } from '../../utils';
+import classnames from 'classnames';
+import ReactList from 'react-list';
+import { shallowEqualObjects } from 'shallow-equal';
+import {
+  addMonths,
+  subMonths,
+  format,
+  eachDayOfInterval,
+  startOfWeek,
+  endOfWeek,
+  isSameDay,
+  addYears,
+  setYear,
+  setMonth,
+  differenceInCalendarMonths,
+  startOfMonth,
+  endOfMonth,
+  addDays,
+  isSameMonth,
+  differenceInDays,
+  min,
+  max,
+} from 'date-fns';
+import { enUS as defaultLocale } from 'date-fns/locale/en-US';
+import coreStyles from '../../styles';
+import { ariaLabelsShape } from '../../accessibility';
+
+class Calendar extends PureComponent {
+  constructor(props, context) {
+    super(props, context);
+    this.dateOptions = { locale: props.locale };
+    if (props.weekStartsOn !== undefined) this.dateOptions.weekStartsOn = props.weekStartsOn;
+    this.styles = generateStyles([coreStyles, props.classNames]);
+    this.listSizeCache = {};
+    this.isFirstRender = true;
+    this.state = {
+      monthNames: this.getMonthNames(),
+      focusedDate: 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,
+    };
+  }
+  focusToDate = (date, props = this.props, preventUnnecessary = true) => {
+    if (!props.scroll.enabled) {
+      if (preventUnnecessary && props.preventSnapRefocus) {
+        const focusedDateDiff = 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 = 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 });
+  };
+  updateShownDate = (props = this.props) => {
+    const newProps = props.scroll.enabled
+      ? {
+        ...props,
+        months: this.list.getVisibleRange().length,
+      }
+      : props;
+    const newFocus = calcFocusDate(this.state.focusedDate, newProps);
+    this.focusToDate(newFocus, newProps);
+  };
+  updatePreview = val => {
+    if (!val) {
+      this.setState({ preview: null });
+      return;
+    }
+    const preview = {
+      startDate: val,
+      endDate: val,
+      color: this.props.color,
+    };
+    this.setState({ preview });
+  };
+  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 (!shallowEqualObjects(prevProps.scroll, this.props.scroll)) {
+      this.setState({ scrollArea: this.calcScrollArea(this.props) });
+    }
+  }
+
+  changeShownDate = (value, mode = 'set') => {
+    const { focusedDate } = this.state;
+    const { onShownDateChange, minDate, maxDate } = this.props;
+    const modeMapper = {
+      monthOffset: () => addMonths(focusedDate, value),
+      setMonth: () => setMonth(focusedDate, value),
+      setYear: () => setYear(focusedDate, value),
+      set: () => value,
+    };
+
+    const newDate = min([max([modeMapper[mode](), minDate]), maxDate]);
+    this.focusToDate(newDate, this.props, false);
+    onShownDateChange && onShownDateChange(newDate);
+  };
+  handleRangeFocusChange = (rangesIndex, rangeItemIndex) => {
+    this.props.onRangeFocusChange && this.props.onRangeFocusChange([rangesIndex, rangeItemIndex]);
+  };
+  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 = addMonths(minDate, visibleMonths[0] || 0);
+    const isFocusedToDifferent = !isSameMonth(visibleMonth, focusedDate);
+    if (isFocusedToDifferent && !isFirstRender) {
+      this.setState({ focusedDate: visibleMonth });
+      onShownDateChange && onShownDateChange(visibleMonth);
+    }
+    this.isFirstRender = false;
+  };
+  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 (
+      <div onMouseUp={e => e.stopPropagation()} className={styles.monthAndYearWrapper}>
+        {showMonthArrow ? (
+          <button
+            type="button"
+            className={classnames(styles.nextPrevButton, styles.prevButton)}
+            onClick={() => changeShownDate(-1, 'monthOffset')}
+            aria-label={ariaLabels.prevButton}>
+            <i />
+          </button>
+        ) : null}
+        {showMonthAndYearPickers ? (
+          <span className={styles.monthAndYearPickers}>
+            <span className={styles.monthPicker}>
+              <select
+                value={focusedDate.getMonth()}
+                onChange={e => changeShownDate(e.target.value, 'setMonth')}
+                aria-label={ariaLabels.monthPicker}>
+                {this.state.monthNames.map((monthName, i) => (
+                  <option key={i} value={i}>
+                    {monthName}
+                  </option>
+                ))}
+              </select>
+            </span>
+            <span className={styles.monthAndYearDivider} />
+            <span className={styles.yearPicker}>
+              <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 (
+                      <option key={year} value={year}>
+                        {year}
+                      </option>
+                    );
+                  })}
+              </select>
+            </span>
+          </span>
+        ) : (
+          <span className={styles.monthAndYearPickers}>
+            {this.state.monthNames[focusedDate.getMonth()]} {focusedDate.getFullYear()}
+          </span>
+        )}
+        {showMonthArrow ? (
+          <button
+            type="button"
+            className={classnames(styles.nextPrevButton, styles.nextButton)}
+            onClick={() => changeShownDate(+1, 'monthOffset')}
+            aria-label={ariaLabels.nextButton}>
+            <i />
+          </button>
+        ) : null}
+      </div>
+    );
+  };
+  renderWeekdays() {
+    const now = new Date();
+    return (
+      <div className={this.styles.weekDays}>
+        {eachDayOfInterval({
+          start: startOfWeek(now, this.dateOptions),
+          end: endOfWeek(now, this.dateOptions),
+        }).map((day, i) => (
+          <span className={this.styles.weekDay} key={i}>
+            {format(day, this.props.weekdayDisplayFormat, this.dateOptions)}
+          </span>
+        ))}
+      </div>
+    );
+  }
+  renderDateDisplay = () => {
+    const {
+      focusedRange,
+      color,
+      ranges,
+      rangeColors,
+      dateDisplayFormat,
+      editableDateInputs,
+      startDatePlaceholder,
+      endDatePlaceholder,
+      ariaLabels,
+    } = this.props;
+
+    const defaultColor = rangeColors[focusedRange[0]] || color;
+    const styles = this.styles;
+
+    return (
+      <div className={styles.dateDisplayWrapper}>
+        {ranges.map((range, i) => {
+          if (range.showDateDisplay === false || (range.disabled && !range.showDateDisplay))
+            return null;
+          return (
+            <div
+              className={styles.dateDisplay}
+              key={i}
+              style={{ color: range.color || defaultColor }}>
+              <DateInput
+                className={classnames(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)}
+              />
+              <DateInput
+                className={classnames(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)}
+              />
+            </div>
+          );
+        })}
+      </div>
+    );
+  };
+  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);
+    }
+  };
+
+  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' || isSameDay(newRange.startDate, date)) {
+      this.setState({ drag: { status: false, range: {} } }, () => onChange && onChange(date));
+    } else {
+      this.setState({ drag: { status: false, range: {} } }, () => {
+        updateRange && updateRange(newRange);
+      });
+    }
+  };
+  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,
+      },
+    });
+  };
+
+  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 = addMonths(minDate, index);
+    const { start, end } = getMonthDisplayRange(monthStep, this.dateOptions);
+    const isLongMonth = differenceInDays(end, start, this.dateOptions) + 1 > 7 * 5;
+    return isLongMonth ? scrollArea.longMonthHeight : scrollArea.monthHeight;
+  };
+  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 (
+      <div
+        className={classnames(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 ? (
+          <div>
+            {isVertical && this.renderWeekdays(this.dateOptions)}
+            <div
+              className={classnames(
+                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}>
+              <ReactList
+                length={differenceInCalendarMonths(
+                  endOfMonth(maxDate),
+                  addDays(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 = addMonths(minDate, index);
+                  return (
+                    <Month
+                      {...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
+                      showWeekDays={!isVertical}
+                    />
+                  );
+                }}
+              />
+            </div>
+          </div>
+        ) : (
+          <div
+            className={classnames(
+              this.styles.months,
+              isVertical ? this.styles.monthsVertical : this.styles.monthsHorizontal
+            )}>
+            {new Array(this.props.months).fill(null).map((_, i) => {
+              let monthStep = addMonths(this.state.focusedDate, i);
+              if (this.props.calendarFocus === 'backwards') {
+                monthStep = subMonths(this.state.focusedDate, this.props.months - 1 - i);
+              }
+              return (
+                <Month
+                  {...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}
+                />
+              );
+            })}
+          </div>
+        )}
+      </div>
+    );
+  }
+}
+
+Calendar.defaultProps = {
+  showMonthArrow: true,
+  showMonthAndYearPickers: true,
+  disabledDates: [],
+  disabledDay: () => { },
+  classNames: {},
+  locale: defaultLocale,
+  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: addYears(new Date(), 20),
+  minDate: 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.bool,
+  showMonthAndYearPickers: PropTypes.bool,
+  disabledDates: PropTypes.array,
+  disabledDay: PropTypes.func,
+  minDate: PropTypes.object,
+  maxDate: PropTypes.object,
+  date: PropTypes.object,
+  onChange: PropTypes.func,
+  onPreviewChange: PropTypes.func,
+  onRangeFocusChange: PropTypes.func,
+  classNames: PropTypes.object,
+  locale: PropTypes.object,
+  shownDate: PropTypes.object,
+  onShownDateChange: PropTypes.func,
+  ranges: PropTypes.arrayOf(rangeShape),
+  preview: PropTypes.shape({
+    startDate: PropTypes.object,
+    endDate: PropTypes.object,
+    color: PropTypes.string,
+  }),
+  dateDisplayFormat: PropTypes.string,
+  monthDisplayFormat: PropTypes.string,
+  weekdayDisplayFormat: PropTypes.string,
+  weekStartsOn: PropTypes.number,
+  dayDisplayFormat: PropTypes.string,
+  focusedRange: PropTypes.arrayOf(PropTypes.number),
+  initialFocusedRange: PropTypes.arrayOf(PropTypes.number),
+  months: PropTypes.number,
+  className: PropTypes.string,
+  showDateDisplay: PropTypes.bool,
+  showPreview: PropTypes.bool,
+  displayMode: PropTypes.oneOf(['dateRange', 'date']),
+  color: PropTypes.string,
+  updateRange: PropTypes.func,
+  scroll: PropTypes.shape({
+    enabled: PropTypes.bool,
+    monthHeight: PropTypes.number,
+    longMonthHeight: PropTypes.number,
+    monthWidth: PropTypes.number,
+    calendarWidth: PropTypes.number,
+    calendarHeight: PropTypes.number,
+  }),
+  direction: PropTypes.oneOf(['vertical', 'horizontal']),
+  startDatePlaceholder: PropTypes.string,
+  endDatePlaceholder: PropTypes.string,
+  navigatorRenderer: PropTypes.func,
+  rangeColors: PropTypes.arrayOf(PropTypes.string),
+  editableDateInputs: PropTypes.bool,
+  dragSelectionEnabled: PropTypes.bool,
+  fixedHeight: PropTypes.bool,
+  calendarFocus: PropTypes.string,
+  preventSnapRefocus: PropTypes.bool,
+  ariaLabels: ariaLabelsShape,
+};
+
+export default Calendar;

node_modules/react-date-range/src/components/Calendar/index.scss

@@ -0,0 +1,97 @@
+.rdrCalendarWrapper {
+  box-sizing: border-box;
+  background: #ffffff;
+  display: inline-flex;
+  flex-direction: column;
+  user-select: none;
+}
+
+.rdrDateDisplay{
+  display: flex;
+  justify-content: space-between;
+}
+
+.rdrDateDisplayItem{
+  flex: 1 1;
+  width: 0;
+  text-align: center;
+  color: inherit;
+  & + &{
+    margin-left: 0.833em;
+  }
+  input{
+    text-align: inherit;
+    &: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;
+}

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

@@ -0,0 +1,7 @@
+import Calendar from '../Calendar';
+
+describe('Calendar', () => {
+  test('Should resolve', () => {
+    expect(Calendar).toEqual(expect.anything());
+  });
+});

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

@@ -0,0 +1,108 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { format, parse, isValid, isEqual } from 'date-fns';
+
+class DateInput extends PureComponent {
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      invalid: false,
+      changed: false,
+      value: this.formatDate(props),
+    };
+  }
+
+  componentDidUpdate(prevProps) {
+    const { value } = prevProps;
+
+    if (!isEqual(value, this.props.value)) {
+      this.setState({ value: this.formatDate(this.props) });
+    }
+  }
+
+  formatDate({ value, dateDisplayFormat, dateOptions }) {
+    if (value && isValid(value)) {
+      return 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 = parse(value, dateDisplayFormat, new Date(), dateOptions);
+
+    if (isValid(parsed)) {
+      this.setState({ changed: false }, () => onChange(parsed));
+    } else {
+      this.setState({ invalid: true });
+    }
+  }
+
+  onKeyDown = e => {
+    const { value } = this.state;
+
+    if (e.key === 'Enter') {
+      this.update(value);
+    }
+  };
+
+  onChange = e => {
+    this.setState({ value: e.target.value, changed: true, invalid: false });
+  };
+
+  onBlur = () => {
+    const { value } = this.state;
+    this.update(value);
+  };
+
+  render() {
+    const { className, readOnly, placeholder, ariaLabel, disabled, onFocus } = this.props;
+    const { value, invalid } = this.state;
+
+    return (
+      <span className={classnames('rdrDateInput', className)}>
+        <input
+          readOnly={readOnly}
+          disabled={disabled}
+          value={value}
+          placeholder={placeholder}
+          aria-label={ariaLabel}
+          onKeyDown={this.onKeyDown}
+          onChange={this.onChange}
+          onBlur={this.onBlur}
+          onFocus={onFocus}
+        />
+        {invalid && <span className="rdrWarning">&#9888;</span>}
+      </span>
+    );
+  }
+}
+
+DateInput.propTypes = {
+  value: PropTypes.object,
+  placeholder: PropTypes.string,
+  disabled: PropTypes.bool,
+  readOnly: PropTypes.bool,
+  dateOptions: PropTypes.object,
+  dateDisplayFormat: PropTypes.string,
+  ariaLabel: PropTypes.string,
+  className: PropTypes.string,
+  onFocus: PropTypes.func.isRequired,
+  onChange: PropTypes.func.isRequired,
+};
+
+DateInput.defaultProps = {
+  readOnly: true,
+  disabled: false,
+  dateDisplayFormat: 'MMM D, YYYY',
+};
+
+export default DateInput;

node_modules/react-date-range/src/components/DateInput/index.scss

@@ -0,0 +1,16 @@
+.rdrDateInput {
+  position: relative;
+
+  input {
+    outline: none;
+  }
+
+  .rdrWarning {
+    position: absolute;
+    font-size: 1.6em;
+    line-height: 1.6em;
+    top: 0;
+    right: .25em;
+    color: #FF0000;
+  }
+}

node_modules/react-date-range/src/components/DateRange/README.md

@@ -0,0 +1,29 @@
+This component extends all the props of **[Calendar](#calendar)** component. In addition to those props, it has the following props: 
+
+| Prop Name  |  Type |
+|---|---|
+|  **moveRangeOnFirstSelection** |  boolean |
+|  **retainEndDateOnFirstSelection** |  boolean |
+|  **onRangeFocusChange** |  function |
+|  **rangeColors**  |  array |
+|  **ranges**  |  array |
+
+
+#### Example: Editable Date Inputs
+```jsx inside Markdown
+import {useState} from 'react'
+const [state, setState] = useState([
+    {
+      startDate: new Date(),
+      endDate: null,
+      key: 'selection'
+    }
+  ]);
+  
+<DateRange
+  editableDateInputs={true}
+  onChange={item => setState([item.selection])}
+  moveRangeOnFirstSelection={false}
+  ranges={state}
+/>
+```

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

@@ -0,0 +1,167 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import Calendar from '../Calendar';
+import { rangeShape } from '../DayCell';
+import { findNextRangeIndex, generateStyles } from '../../utils';
+import { isBefore, differenceInCalendarDays, addDays, min, isWithinInterval, max } from 'date-fns';
+import classnames from 'classnames';
+import coreStyles from '../../styles';
+
+class DateRange extends Component {
+  constructor(props, context) {
+    super(props, context);
+    this.state = {
+      focusedRange: props.initialFocusedRange || [findNextRangeIndex(props.ranges), 0],
+      preview: null,
+    };
+    this.styles = generateStyles([coreStyles, props.classNames]);
+  }
+  calcNewSelection = (value, isSingleValue = 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 = differenceInCalendarDays(endDate || now, startDate);
+      const calculateEndDate = () => {
+        if (moveRangeOnFirstSelection) {
+          return addDays(value, dayOffset);
+        }
+        if (retainEndDateOnFirstSelection) {
+          if (!endDate || isBefore(value, endDate)) {
+            return endDate;
+          }
+          return value;
+        }
+        return value || now;
+      };
+      startDate = value;
+      endDate = calculateEndDate();
+      if (maxDate) endDate = min([endDate, maxDate]);
+      nextFocusRange = [focusedRange[0], 1];
+    } else {
+      endDate = value;
+    }
+
+    // reverse dates if startDate before endDate
+    let isStartDateSelected = focusedRange[1] === 0;
+    if (isBefore(endDate, startDate)) {
+      isStartDateSelected = !isStartDateSelected;
+      [startDate, endDate] = [endDate, startDate];
+    }
+
+    const inValidDatesWithinRange = disabledDates.filter(disabledDate =>
+      isWithinInterval(disabledDate, {
+        start: startDate,
+        end: endDate,
+      })
+    );
+
+    if (inValidDatesWithinRange.length > 0) {
+      if (isStartDateSelected) {
+        startDate = addDays(max(inValidDatesWithinRange), 1);
+      } else {
+        endDate = addDays(min(inValidDatesWithinRange), -1);
+      }
+    }
+
+    if (!nextFocusRange) {
+      const nextFocusRangeIndex = findNextRangeIndex(this.props.ranges, focusedRange[0]);
+      nextFocusRange = [nextFocusRangeIndex, 0];
+    }
+    return {
+      wasValid: !(inValidDatesWithinRange.length > 0),
+      range: { startDate, endDate },
+      nextFocusRange: nextFocusRange,
+    };
+  };
+  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);
+  };
+  handleRangeFocusChange = focusedRange => {
+    this.setState({ focusedRange });
+    this.props.onRangeFocusChange && this.props.onRangeFocusChange(focusedRange);
+  };
+  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 } });
+  };
+  render() {
+    return (
+      <Calendar
+        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={classnames(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.propTypes,
+  onChange: PropTypes.func,
+  onRangeFocusChange: PropTypes.func,
+  className: PropTypes.string,
+  ranges: PropTypes.arrayOf(rangeShape),
+  moveRangeOnFirstSelection: PropTypes.bool,
+  retainEndDateOnFirstSelection: PropTypes.bool,
+};
+
+export default DateRange;

node_modules/react-date-range/src/components/DateRange/index.scss

@@ -0,0 +1,3 @@
+.rdrDateRangeWrapper{
+  user-select: none;
+}

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

@@ -0,0 +1,84 @@
+import React from 'react';
+import { subDays, addDays, isSameDay } from 'date-fns';
+import DateRange from '../DateRange';
+import renderer from 'react-test-renderer';
+
+let testRenderer = null;
+let instance = null;
+const endDate = new Date();
+const startDate = 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(isSameDay(newRange[key], assertionRange[key])).toEqual(true);
+  });
+};
+
+beforeEach(() => {
+  testRenderer = renderer.create(<DateRange {...commonProps} />);
+  instance = testRenderer.getInstance();
+});
+
+describe('DateRange', () => {
+  test('Should resolve', () => {
+    expect(DateRange).toEqual(expect.anything());
+  });
+
+  test('calculate new selection by resetting end date', () => {
+    const methodResult = instance.calcNewSelection(subDays(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: subDays(endDate, 10),
+      endDate: subDays(endDate, 10),
+    });
+  });
+
+  test('calculate new selection by resetting end date if start date is not before', () => {
+    const methodResult = instance.calcNewSelection(addDays(endDate, 2), true);
+    compareRanges(methodResult.range, {
+      startDate: addDays(endDate, 2),
+      endDate: addDays(endDate, 2),
+    });
+  });
+
+  test('calculate new selection based on moveRangeOnFirstSelection prop', () => {
+    testRenderer.update(<DateRange {...commonProps} moveRangeOnFirstSelection />);
+    const methodResult = instance.calcNewSelection(subDays(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: subDays(endDate, 10),
+      endDate: subDays(endDate, 3),
+    });
+  });
+
+  test('calculate new selection by retaining end date, based on retainEndDateOnFirstSelection prop', () => {
+    testRenderer.update(<DateRange {...commonProps} retainEndDateOnFirstSelection />);
+    const methodResult = instance.calcNewSelection(subDays(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: subDays(endDate, 10),
+      endDate,
+    });
+  });
+
+  test('calculate new selection by retaining the unset end date, based on retainEndDateOnFirstSelection prop', () => {
+    testRenderer.update(
+      <DateRange
+        {...commonProps}
+        ranges={[{ ...commonProps.ranges[0], endDate: null }]}
+        retainEndDateOnFirstSelection
+      />
+    );
+    const methodResult = instance.calcNewSelection(subDays(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: subDays(endDate, 10),
+      endDate: null,
+    });
+  });
+});

node_modules/react-date-range/src/components/DateRangePicker/README.md

@@ -0,0 +1,248 @@
+This component wraps **[DefinedRange](#definedrange)** and **[Calendar](#calendar)** components together, and extends all the props of them.
+
+#### Example: 2 Month View
+
+```jsx inside Markdown
+import { addDays } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState([
+  {
+    startDate: new Date(),
+    endDate: addDays(new Date(), 7),
+    key: 'selection'
+  }
+]);
+
+<DateRangePicker
+  onChange={item => setState([item.selection])}
+  showSelectionPreview={true}
+  moveRangeOnFirstSelection={false}
+  months={2}
+  ranges={state}
+  direction="horizontal"
+/>;
+```
+
+#### Example: Backwards 2 Month View with preventSnapRefocus
+
+```jsx inside Markdown
+import { addDays } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState([
+  {
+    startDate: new Date(),
+    endDate: addDays(new Date(), 7),
+    key: 'selection'
+  }
+]);
+
+<DateRangePicker
+  onChange={item => setState([item.selection])}
+  showSelectionPreview={true}
+  moveRangeOnFirstSelection={false}
+  months={2}
+  ranges={state}
+  direction="horizontal"
+  preventSnapRefocus={true}
+  calendarFocus="backwards"
+/>;
+```
+
+#### Example: Vertical Infinite
+
+```jsx inside Markdown
+import { addDays } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState({
+  selection: {
+    startDate: new Date(),
+    endDate: null,
+    key: 'selection'
+  },
+  compare: {
+    startDate: new Date(),
+    endDate: addDays(new Date(), 3),
+    key: 'compare'
+  }
+});
+
+<DateRangePicker
+  onChange={item => setState({ ...state, ...item })}
+  months={1}
+  minDate={addDays(new Date(), -300)}
+  maxDate={addDays(new Date(), 900)}
+  direction="vertical"
+  scroll={{ enabled: true }}
+  ranges={[state.selection, state.compare]}
+/>;
+```
+
+#### Example: Multiple Range
+
+```jsx inside Markdown
+import { addDays } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState({
+  selection1: {
+    startDate: addDays(new Date(), 1),
+    endDate: null,
+    key: 'selection1'
+  },
+  selection2: {
+    startDate: addDays(new Date(), 4),
+    endDate: addDays(new Date(), 8),
+    key: 'selection2'
+  },
+  selection3: {
+    startDate: addDays(new Date(), 8),
+    endDate: addDays(new Date(), 10),
+    key: 'selection3',
+    autoFocus: false
+  }
+});
+
+<DateRangePicker
+  onChange={item => setState({ ...state, ...item })}
+  ranges={[state.selection1, state.selection2, state.selection3]}
+/>;
+```
+
+#### Example: Insert Aria-label
+
+```jsx inside Markdown
+import { addDays } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState({
+  selection1: {
+    startDate: addDays(new Date(), -6),
+    endDate: new Date(),
+    key: 'selection1'
+  },
+  selection2: {
+    startDate: addDays(new Date(), 1),
+    endDate: addDays(new Date(), 7),
+    key: 'selection2'
+  }
+});
+
+<DateRangePicker
+  onChange={item => setState({ ...state, ...item })}
+  showSelectionPreview={true}
+  moveRangeOnFirstSelection={false}
+  months={2}
+  ranges={[state.selection1, state.selection2]}
+  direction="horizontal"
+  ariaLabels={{
+    dateInput: {
+      selection1: { startDate: "start date input of selction 1", endDate: "end date input of selction 1" },
+      selection2: { startDate: "start date input of selction 2", endDate: "end date input of selction 2" }
+    },
+    monthPicker: "month picker",
+    yearPicker: "year picker",
+    prevButton: "previous month button",
+    nextButton: "next month button",
+  }}
+/>;
+```
+
+#### Example: Custom Day Cell Content
+Show orange dot only for weekend
+
+```jsx inside Markdown
+import { addDays, format, isWeekend } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState({
+  selection1: {
+    startDate: addDays(new Date(), -6),
+    endDate: new Date(),
+    key: 'selection1'
+  },
+  selection2: {
+    startDate: addDays(new Date(), 1),
+    endDate: addDays(new Date(), 7),
+    key: 'selection2'
+  }
+});
+
+function customDayContent(day) {
+  extraDot = null;
+  if (isWeekend(day)) {
+    extraDot = (
+      <div
+        style={{
+          height: "5px",
+          width: "5px",
+          borderRadius: "100%",
+          background: "orange",
+          position: "absolute",
+          top: 2,
+          right: 2,
+        }}
+      />
+    )
+  }
+  return (
+    <div>
+      {extraDot}
+      <span>{format(day, "d")}</span>
+    </div>
+  )
+}
+
+<DateRangePicker
+  onChange={item => setState({ ...state, ...item })}
+  showSelectionPreview={true}
+  moveRangeOnFirstSelection={false}
+  months={2}
+  ranges={[state.selection1, state.selection2]}
+  direction="horizontal"
+  dayContentRenderer={customDayContent}
+  ariaLabels={{
+    dateInput: {
+      selection1: { startDate: "start date input of selction 1", endDate: "end date input of selction 1" },
+      selection2: { startDate: "start date input of selction 2", endDate: "end date input of selction 2" }
+    },
+    monthPicker: "month picker",
+    yearPicker: "year picker",
+    prevButton: "previous month button",
+    nextButton: "next month button",
+  }}
+/>;
+```
+
+
+#### Example: Restrict Date Selection
+Restricts access for range selection to (-30, +30) days of current date.
+```jsx inside Markdown
+import { addDays } from 'date-fns';
+import { useState } from 'react';
+
+const [state, setState] = useState({
+  selection: {
+    startDate: new Date(),
+    endDate: null,
+    key: 'selection'
+  },
+  compare: {
+    startDate: new Date(),
+    endDate: addDays(new Date(), 3),
+    key: 'compare'
+  }
+});
+
+<DateRangePicker
+  onChange={item => setState({ ...state, ...item })}
+  months={1}
+  minDate={addDays(new Date(), -30)}
+  maxDate={addDays(new Date(), 30)}
+  direction="vertical"
+  scroll={{ enabled: true }}
+  ranges={[state.selection, state.compare]}
+/>;
+```

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

@@ -0,0 +1,52 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import DateRange from '../DateRange';
+import DefinedRange from '../DefinedRange';
+import { findNextRangeIndex, generateStyles } from '../../utils';
+import classnames from 'classnames';
+import coreStyles from '../../styles';
+
+class DateRangePicker extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      focusedRange: [findNextRangeIndex(props.ranges), 0],
+    };
+    this.styles = generateStyles([coreStyles, props.classNames]);
+  }
+  render() {
+    const { focusedRange } = this.state;
+    return (
+      <div className={classnames(this.styles.dateRangePickerWrapper, this.props.className)}>
+        <DefinedRange
+          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}
+        />
+        <DateRange
+          onRangeFocusChange={focusedRange => this.setState({ focusedRange })}
+          focusedRange={focusedRange}
+          {...this.props}
+          ref={t => (this.dateRange = t)}
+          className={undefined}
+        />
+      </div>
+    );
+  }
+}
+
+DateRangePicker.defaultProps = {};
+
+DateRangePicker.propTypes = {
+  ...DateRange.propTypes,
+  ...DefinedRange.propTypes,
+  className: PropTypes.string,
+};
+
+export default DateRangePicker;

node_modules/react-date-range/src/components/DateRangePicker/index.scss

@@ -0,0 +1,4 @@
+.rdrDateRangePickerWrapper{
+  display: inline-flex;
+  user-select: none;
+}

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

@@ -0,0 +1,224 @@
+/* eslint-disable no-fallthrough */
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { startOfDay, format, isSameDay, isAfter, isBefore, endOfDay } from 'date-fns';
+
+class DayCell extends Component {
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      hover: false,
+      active: false,
+    };
+  }
+
+  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);
+    }
+  };
+  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);
+    }
+  };
+  getClassNames = () => {
+    const {
+      isPassive,
+      isToday,
+      isWeekend,
+      isStartOfWeek,
+      isEndOfWeek,
+      isStartOfMonth,
+      isEndOfMonth,
+      disabled,
+      styles,
+    } = this.props;
+
+    return classnames(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,
+    });
+  };
+  renderPreviewPlaceholder = () => {
+    const { preview, day, styles } = this.props;
+    if (!preview) return null;
+    const startDate = preview.startDate ? endOfDay(preview.startDate) : null;
+    const endDate = preview.endDate ? startOfDay(preview.endDate) : null;
+    const isInRange =
+      (!startDate || isAfter(day, startDate)) && (!endDate || isBefore(day, endDate));
+    const isStartEdge = !isInRange && isSameDay(day, startDate);
+    const isEndEdge = !isInRange && isSameDay(day, endDate);
+    return (
+      <span
+        className={classnames({
+          [styles.dayStartPreview]: isStartEdge,
+          [styles.dayInPreview]: isInRange,
+          [styles.dayEndPreview]: isEndEdge,
+        })}
+        style={{ color: preview.color }}
+      />
+    );
+  };
+  renderSelectionPlaceholders = () => {
+    const { styles, ranges, day } = this.props;
+    if (this.props.displayMode === 'date') {
+      let isSelected = isSameDay(this.props.day, this.props.date);
+      return isSelected ? (
+        <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 && isBefore(endDate, startDate)) {
+        [startDate, endDate] = [endDate, startDate];
+      }
+      startDate = startDate ? endOfDay(startDate) : null;
+      endDate = endDate ? startOfDay(endDate) : null;
+      const isInRange =
+        (!startDate || isAfter(day, startDate)) && (!endDate || isBefore(day, endDate));
+      const isStartEdge = !isInRange && isSameDay(day, startDate);
+      const isEndEdge = !isInRange && isSameDay(day, endDate);
+      if (isInRange || isStartEdge || isEndEdge) {
+        return [
+          ...result,
+          {
+            isStartEdge,
+            isEndEdge: isEndEdge,
+            isInRange,
+            ...range,
+          },
+        ];
+      }
+      return result;
+    }, []);
+
+    return inRanges.map((range, i) => (
+      <span
+        key={i}
+        className={classnames({
+          [styles.startEdge]: range.isStartEdge,
+          [styles.endEdge]: range.isEndEdge,
+          [styles.inRange]: range.isInRange,
+        })}
+        style={{ color: range.color || this.props.color }}
+      />
+    ));
+  };
+
+  render() {
+    const { dayContentRenderer } = this.props;
+    return (
+      <button
+        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()}
+        <span className={this.props.styles.dayNumber}>
+          {
+            dayContentRenderer?.(this.props.day) ||
+            <span>{format(this.props.day, this.props.dayDisplayFormat)}</span>
+          }
+        </span>
+      </button>
+    );
+  }
+}
+
+DayCell.defaultProps = {};
+
+export const rangeShape = PropTypes.shape({
+  startDate: PropTypes.object,
+  endDate: PropTypes.object,
+  color: PropTypes.string,
+  key: PropTypes.string,
+  autoFocus: PropTypes.bool,
+  disabled: PropTypes.bool,
+  showDateDisplay: PropTypes.bool,
+});
+
+DayCell.propTypes = {
+  day: PropTypes.object.isRequired,
+  dayDisplayFormat: PropTypes.string,
+  date: PropTypes.object,
+  ranges: PropTypes.arrayOf(rangeShape),
+  preview: PropTypes.shape({
+    startDate: PropTypes.object,
+    endDate: PropTypes.object,
+    color: PropTypes.string,
+  }),
+  onPreviewChange: PropTypes.func,
+  previewColor: PropTypes.string,
+  disabled: PropTypes.bool,
+  isPassive: PropTypes.bool,
+  isToday: PropTypes.bool,
+  isWeekend: PropTypes.bool,
+  isStartOfWeek: PropTypes.bool,
+  isEndOfWeek: PropTypes.bool,
+  isStartOfMonth: PropTypes.bool,
+  isEndOfMonth: PropTypes.bool,
+  color: PropTypes.string,
+  displayMode: PropTypes.oneOf(['dateRange', 'date']),
+  styles: PropTypes.object,
+  onMouseDown: PropTypes.func,
+  onMouseUp: PropTypes.func,
+  onMouseEnter: PropTypes.func,
+  dayContentRenderer: PropTypes.func,
+};
+
+export default DayCell;

node_modules/react-date-range/src/components/DayCell/index.scss

@@ -0,0 +1,39 @@
+.rdrDay {
+  box-sizing: inherit;
+  width: calc(100% / 7);
+  position: relative;
+  font: inherit;
+  cursor: pointer;
+}
+
+.rdrDayNumber {
+  display: block;
+  position: relative;
+  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{}

node_modules/react-date-range/src/components/DefinedRange/README.md

@@ -0,0 +1,90 @@
+#### Example: Default Labels
+
+```jsx inside Markdown
+import { useState } from 'react';
+
+const [state, setState] = useState([
+  {
+    startDate: new Date(),
+    endDate: null,
+    key: 'selection'
+  }
+]);
+
+<DefinedRange
+  onChange={item => setState([item.selection])}
+  ranges={state}
+/>;
+```
+#### Example: Custom range labels
+
+```jsx inside Markdown
+import { useState } from 'react';
+
+const renderStaticRangeLabel = () => (
+  <CustomStaticRangeLabelContent text={'This is a custom label content: '} />
+);
+
+class CustomStaticRangeLabelContent extends React.Component {
+  constructor(props) {
+    super(props);
+
+    this.state = {
+      currentDateString: Date(),
+    };
+
+    this.intervalId = setInterval(() => {
+      this.setState({
+        currentDateString: Date(),
+      });
+    }, 1000);
+  }
+
+  componentWillUnmount() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+  }
+
+  render() {
+    const { currentDateString } = this.state;
+    const { text } = this.props;
+
+    return (
+      <span>
+        <i>{text}</i>
+        <span className={'random-date-string'}>
+          <b>{currentDateString}</b>
+        </span>
+      </span>
+    );
+  }
+}
+
+const [state, setState] = useState([
+  {
+    startDate: new Date(),
+    endDate: null,
+    key: 'selection'
+  }
+]);
+
+<DefinedRange
+  onChange={item => setState([item.selection])}
+  ranges={state}
+  renderStaticRangeLabel={renderStaticRangeLabel}
+  staticRanges={[
+    {
+      label: 'Hoy',
+      hasCustomRendering: true,
+      range: () => ({
+        startDate: new Date(),
+        endDate: new Date()
+      }),
+      isSelected() {
+        return true;
+      }
+    }
+  ]}
+/>;
+```

node_modules/react-date-range/src/components/DefinedRange/__snapshots__/index.test.js.snap

@@ -0,0 +1,238 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`DefinedRange tests Should render dynamic static label contents correctly 1`] = `
+<div
+  className="rdrDefinedRangesWrapper"
+>
+  <div
+    className="rdrStaticRanges"
+  >
+    <button
+      className="rdrStaticRange"
+      key="0"
+      onClick={[Function]}
+      onFocus={[Function]}
+      onMouseLeave={[Function]}
+      onMouseOver={[Function]}
+      style={
+        Object {
+          "color": null,
+        }
+      }
+      type="button"
+    >
+      <span
+        className="rdrStaticRangeLabel"
+        tabIndex={-1}
+      >
+        <i
+          className="italic-label-content"
+        >
+          Italic Content
+        </i>
+      </span>
+    </button>
+    <button
+      className="rdrStaticRange"
+      key="1"
+      onClick={[Function]}
+      onFocus={[Function]}
+      onMouseLeave={[Function]}
+      onMouseOver={[Function]}
+      style={
+        Object {
+          "color": null,
+        }
+      }
+      type="button"
+    >
+      <span
+        className="rdrStaticRangeLabel"
+        tabIndex={-1}
+      >
+        Static Label
+      </span>
+    </button>
+    <button
+      className="rdrStaticRange"
+      key="2"
+      onClick={[Function]}
+      onFocus={[Function]}
+      onMouseLeave={[Function]}
+      onMouseOver={[Function]}
+      style={
+        Object {
+          "color": null,
+        }
+      }
+      type="button"
+    >
+      <span
+        className="rdrStaticRangeLabel"
+        tabIndex={-1}
+      >
+        <img
+          className="random-image"
+        />
+      </span>
+    </button>
+    <button
+      className="rdrStaticRange"
+      key="3"
+      onClick={[Function]}
+      onFocus={[Function]}
+      onMouseLeave={[Function]}
+      onMouseOver={[Function]}
+      style={
+        Object {
+          "color": null,
+        }
+      }
+      type="button"
+    >
+      <span
+        className="rdrStaticRangeLabel"
+        tabIndex={-1}
+      >
+        <b
+          className="bold-label-content"
+        >
+          Bold Content
+        </b>
+      </span>
+    </button>
+  </div>
+  <div
+    className="rdrInputRanges"
+  >
+    <InputRangeField
+      key="0"
+      label="days up to today"
+      onBlur={[Function]}
+      onChange={[Function]}
+      onFocus={[Function]}
+      placeholder="-"
+      styles={
+        Object {
+          "calendarWrapper": "rdrCalendarWrapper",
+          "dateDisplay": "rdrDateDisplay",
+          "dateDisplayItem": "rdrDateDisplayItem",
+          "dateDisplayItemActive": "rdrDateDisplayItemActive",
+          "dateDisplayWrapper": "rdrDateDisplayWrapper",
+          "dateRangePickerWrapper": "rdrDateRangePickerWrapper",
+          "dateRangeWrapper": "rdrDateRangeWrapper",
+          "day": "rdrDay",
+          "dayActive": "rdrDayActive",
+          "dayDisabled": "rdrDayDisabled",
+          "dayEndOfMonth": "rdrDayEndOfMonth",
+          "dayEndOfWeek": "rdrDayEndOfWeek",
+          "dayEndPreview": "rdrDayEndPreview",
+          "dayHovered": "rdrDayHovered",
+          "dayInPreview": "rdrDayInPreview",
+          "dayNumber": "rdrDayNumber",
+          "dayPassive": "rdrDayPassive",
+          "daySelected": "rdrDaySelected",
+          "dayStartOfMonth": "rdrDayStartOfMonth",
+          "dayStartOfWeek": "rdrDayStartOfWeek",
+          "dayStartPreview": "rdrDayStartPreview",
+          "dayToday": "rdrDayToday",
+          "dayWeekend": "rdrDayWeekend",
+          "days": "rdrDays",
+          "definedRangesWrapper": "rdrDefinedRangesWrapper",
+          "endEdge": "rdrEndEdge",
+          "inRange": "rdrInRange",
+          "infiniteMonths": "rdrInfiniteMonths",
+          "inputRange": "rdrInputRange",
+          "inputRangeInput": "rdrInputRangeInput",
+          "inputRanges": "rdrInputRanges",
+          "month": "rdrMonth",
+          "monthAndYearPickers": "rdrMonthAndYearPickers",
+          "monthAndYearWrapper": "rdrMonthAndYearWrapper",
+          "monthName": "rdrMonthName",
+          "monthPicker": "rdrMonthPicker",
+          "months": "rdrMonths",
+          "monthsHorizontal": "rdrMonthsHorizontal",
+          "monthsVertical": "rdrMonthsVertical",
+          "nextButton": "rdrNextButton",
+          "nextPrevButton": "rdrNextPrevButton",
+          "prevButton": "rdrPprevButton",
+          "selected": "rdrSelected",
+          "startEdge": "rdrStartEdge",
+          "staticRange": "rdrStaticRange",
+          "staticRangeLabel": "rdrStaticRangeLabel",
+          "staticRangeSelected": "rdrStaticRangeSelected",
+          "staticRanges": "rdrStaticRanges",
+          "weekDay": "rdrWeekDay",
+          "weekDays": "rdrWeekDays",
+          "yearPicker": "rdrYearPicker",
+        }
+      }
+      value="-"
+    />
+    <InputRangeField
+      key="1"
+      label="days starting today"
+      onBlur={[Function]}
+      onChange={[Function]}
+      onFocus={[Function]}
+      placeholder="-"
+      styles={
+        Object {
+          "calendarWrapper": "rdrCalendarWrapper",
+          "dateDisplay": "rdrDateDisplay",
+          "dateDisplayItem": "rdrDateDisplayItem",
+          "dateDisplayItemActive": "rdrDateDisplayItemActive",
+          "dateDisplayWrapper": "rdrDateDisplayWrapper",
+          "dateRangePickerWrapper": "rdrDateRangePickerWrapper",
+          "dateRangeWrapper": "rdrDateRangeWrapper",
+          "day": "rdrDay",
+          "dayActive": "rdrDayActive",
+          "dayDisabled": "rdrDayDisabled",
+          "dayEndOfMonth": "rdrDayEndOfMonth",
+          "dayEndOfWeek": "rdrDayEndOfWeek",
+          "dayEndPreview": "rdrDayEndPreview",
+          "dayHovered": "rdrDayHovered",
+          "dayInPreview": "rdrDayInPreview",
+          "dayNumber": "rdrDayNumber",
+          "dayPassive": "rdrDayPassive",
+          "daySelected": "rdrDaySelected",
+          "dayStartOfMonth": "rdrDayStartOfMonth",
+          "dayStartOfWeek": "rdrDayStartOfWeek",
+          "dayStartPreview": "rdrDayStartPreview",
+          "dayToday": "rdrDayToday",
+          "dayWeekend": "rdrDayWeekend",
+          "days": "rdrDays",
+          "definedRangesWrapper": "rdrDefinedRangesWrapper",
+          "endEdge": "rdrEndEdge",
+          "inRange": "rdrInRange",
+          "infiniteMonths": "rdrInfiniteMonths",
+          "inputRange": "rdrInputRange",
+          "inputRangeInput": "rdrInputRangeInput",
+          "inputRanges": "rdrInputRanges",
+          "month": "rdrMonth",
+          "monthAndYearPickers": "rdrMonthAndYearPickers",
+          "monthAndYearWrapper": "rdrMonthAndYearWrapper",
+          "monthName": "rdrMonthName",
+          "monthPicker": "rdrMonthPicker",
+          "months": "rdrMonths",
+          "monthsHorizontal": "rdrMonthsHorizontal",
+          "monthsVertical": "rdrMonthsVertical",
+          "nextButton": "rdrNextButton",
+          "nextPrevButton": "rdrNextPrevButton",
+          "prevButton": "rdrPprevButton",
+          "selected": "rdrSelected",
+          "startEdge": "rdrStartEdge",
+          "staticRange": "rdrStaticRange",
+          "staticRangeLabel": "rdrStaticRangeLabel",
+          "staticRangeSelected": "rdrStaticRangeSelected",
+          "staticRanges": "rdrStaticRanges",
+          "weekDay": "rdrWeekDay",
+          "weekDays": "rdrWeekDays",
+          "yearPicker": "rdrYearPicker",
+        }
+      }
+      value="-"
+    />
+  </div>
+</div>
+`;

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

@@ -0,0 +1,142 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import styles from '../../styles';
+import { defaultInputRanges, defaultStaticRanges } from '../../defaultRanges';
+import { rangeShape } from '../DayCell';
+import InputRangeField from '../InputRangeField';
+import cx from 'classnames';
+
+class DefinedRange extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      rangeOffset: 0,
+      focusedInput: -1,
+    };
+  }
+
+  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 },
+    });
+  };
+
+  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 (
+      <div className={cx(styles.definedRangesWrapper, className)}>
+        {headerContent}
+        <div className={styles.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 (
+              <button
+                type="button"
+                className={cx(styles.staticRange, {
+                  [styles.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();
+                }}>
+                <span tabIndex={-1} className={styles.staticRangeLabel}>
+                  {labelContent}
+                </span>
+              </button>
+            );
+          })}
+        </div>
+        <div className={styles.inputRanges}>
+          {inputRanges.map((rangeOption, i) => (
+            <InputRangeField
+              key={i}
+              styles={styles}
+              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)}
+            />
+          ))}
+        </div>
+        {footerContent}
+      </div>
+    );
+  }
+}
+
+DefinedRange.propTypes = {
+  inputRanges: PropTypes.array,
+  staticRanges: PropTypes.array,
+  ranges: PropTypes.arrayOf(rangeShape),
+  focusedRange: PropTypes.arrayOf(PropTypes.number),
+  onPreviewChange: PropTypes.func,
+  onChange: PropTypes.func,
+  footerContent: PropTypes.any,
+  headerContent: PropTypes.any,
+  rangeColors: PropTypes.arrayOf(PropTypes.string),
+  className: PropTypes.string,
+  renderStaticRangeLabel: PropTypes.func,
+};
+
+DefinedRange.defaultProps = {
+  inputRanges: defaultInputRanges,
+  staticRanges: defaultStaticRanges,
+  ranges: [],
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  focusedRange: [0, 0],
+};
+
+export default DefinedRange;

node_modules/react-date-range/src/components/DefinedRange/index.scss

@@ -0,0 +1,20 @@
+.rdrDefinedRangesWrapper{}
+
+.rdrStaticRanges{
+  display: flex;
+  flex-direction: column;
+}
+
+.rdrStaticRange{
+  font-size: inherit;
+}
+
+.rdrStaticRangeLabel{}
+
+.rdrInputRanges{}
+
+.rdrInputRange{
+  display: flex;
+}
+
+.rdrInputRangeInput{}

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

@@ -0,0 +1,135 @@
+import React from 'react';
+import { mount, shallow } from 'enzyme';
+
+import DefinedRange from '../DefinedRange';
+import { isSameDay } from 'date-fns';
+
+describe('DefinedRange tests', () => {
+  test('Should call "renderStaticRangeLabel" callback correct amount of times according to the "hasCustomRendering" option', () => {
+    const renderStaticRangeLabel = jest.fn();
+
+    mount(
+      <DefinedRange
+        staticRanges={[
+          {
+            label: 'Dynamic Label',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+            hasCustomRendering: true,
+          },
+          {
+            label: 'Static Label',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+          },
+          {
+            label: 'Hede',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+            hasCustomRendering: true,
+          },
+        ]}
+        renderStaticRangeLabel={renderStaticRangeLabel}
+      />
+    );
+
+    expect(renderStaticRangeLabel).toHaveBeenCalledTimes(2);
+  });
+
+  test('Should render dynamic static label contents correctly', () => {
+    const renderItalicLabelContent = () => (
+      <i className={'italic-label-content'}>{'Italic Content'}</i>
+    );
+    const renderBoldLabelContent = () => <b className={'bold-label-content'}>{'Bold Content'}</b>;
+    const renderSomethingElse = () => <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 = shallow(
+      <DefinedRange
+        staticRanges={[
+          {
+            id: 'italic',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+            hasCustomRendering: true,
+          },
+          {
+            label: 'Static Label',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+          },
+          {
+            id: 'whatever',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+            hasCustomRendering: true,
+          },
+          {
+            id: 'bold',
+            range: {},
+            isSelected(range) {
+              const definedRange = this.range();
+              return (
+                isSameDay(range.startDate, definedRange.startDate) &&
+                isSameDay(range.endDate, definedRange.endDate)
+              );
+            },
+            hasCustomRendering: true,
+          },
+        ]}
+        renderStaticRangeLabel={renderStaticRangeLabel}
+      />
+    );
+
+    expect(wrapper).toMatchSnapshot();
+  });
+});

node_modules/react-date-range/src/components/InputRangeField/__snapshots__/index.test.js.snap

@@ -0,0 +1,88 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`InputRangeField tests Should parse input value to number 1`] = `
+<InputRangeField
+  label="Input label"
+  onBlur={[MockFunction]}
+  onChange={
+    [MockFunction] {
+      "calls": Array [
+        Array [
+          3,
+        ],
+        Array [
+          12,
+        ],
+        Array [
+          0,
+        ],
+        Array [
+          0,
+        ],
+        Array [
+          0,
+        ],
+        Array [
+          99999,
+        ],
+      ],
+      "results": Array [
+        Object {
+          "type": "return",
+          "value": undefined,
+        },
+        Object {
+          "type": "return",
+          "value": undefined,
+        },
+        Object {
+          "type": "return",
+          "value": undefined,
+        },
+        Object {
+          "type": "return",
+          "value": undefined,
+        },
+        Object {
+          "type": "return",
+          "value": undefined,
+        },
+        Object {
+          "type": "return",
+          "value": undefined,
+        },
+      ],
+    }
+  }
+  onFocus={[MockFunction]}
+  placeholder="-"
+  styles={
+    Object {
+      "inputRange": "range",
+      "inputRangeInput": "input",
+      "inputRangeLabel": "label",
+    }
+  }
+  value=""
+>
+  <div
+    className="range"
+  >
+    <input
+      className="input"
+      max={99999}
+      min={0}
+      onBlur={[MockFunction]}
+      onChange={[Function]}
+      onFocus={[MockFunction]}
+      placeholder="-"
+      value=""
+    />
+    <span
+      className="label"
+    >
+      Input label
+    </span>
+  </div>
+</InputRangeField>
+`;

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

@@ -0,0 +1,71 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+
+const MIN = 0;
+const MAX = 99999;
+
+class InputRangeField extends Component {
+  constructor(props, context) {
+    super(props, context);
+  }
+
+  shouldComponentUpdate(nextProps) {
+    const { value, label, placeholder } = this.props;
+
+    return (
+      value !== nextProps.value ||
+      label !== nextProps.label ||
+      placeholder !== nextProps.placeholder
+    );
+  }
+
+  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);
+  };
+
+  render() {
+    const { label, placeholder, value, styles, onBlur, onFocus } = this.props;
+
+    return (
+      <div className={styles.inputRange}>
+        <input
+          className={styles.inputRangeInput}
+          placeholder={placeholder}
+          value={value}
+          min={MIN}
+          max={MAX}
+          onChange={this.onChange}
+          onFocus={onFocus}
+          onBlur={onBlur}
+        />
+        <span className={styles.inputRangeLabel}>{label}</span>
+      </div>
+    );
+  }
+}
+
+InputRangeField.propTypes = {
+  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  label: PropTypes.oneOfType([PropTypes.element, PropTypes.node]).isRequired,
+  placeholder: PropTypes.string,
+  styles: PropTypes.shape({
+    inputRange: PropTypes.string,
+    inputRangeInput: PropTypes.string,
+    inputRangeLabel: PropTypes.string,
+  }).isRequired,
+  onBlur: PropTypes.func.isRequired,
+  onFocus: PropTypes.func.isRequired,
+  onChange: PropTypes.func.isRequired,
+};
+
+InputRangeField.defaultProps = {
+  value: '',
+  placeholder: '-',
+};
+
+export default InputRangeField;

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

@@ -0,0 +1,111 @@
+import React from 'react';
+import { mount } from 'enzyme';
+
+import InputRangeField from '../InputRangeField';
+
+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 = mount(
+      <InputRangeField
+        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 = mount(
+      <InputRangeField
+        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 = () => <span className="input-range-field-label">Input label</span>;
+    const wrapper = mount(
+      <InputRangeField
+        value={12}
+        placeholder="Placeholder"
+        label={<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');
+    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/src/components/Month/index.js

@@ -0,0 +1,148 @@
+/* eslint-disable no-fallthrough */
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import DayCell, { rangeShape } from '../DayCell';
+import {
+  format,
+  startOfDay,
+  endOfDay,
+  startOfWeek,
+  endOfWeek,
+  isBefore,
+  isSameDay,
+  isAfter,
+  isWeekend,
+  isWithinInterval,
+  eachDayOfInterval,
+} from 'date-fns';
+import { getMonthDisplayRange } from '../../utils';
+
+function renderWeekdays(styles, dateOptions, weekdayDisplayFormat) {
+  const now = new Date();
+  return (
+    <div className={styles.weekDays}>
+      {eachDayOfInterval({
+        start: startOfWeek(now, dateOptions),
+        end: endOfWeek(now, dateOptions),
+      }).map((day, i) => (
+        <span className={styles.weekDay} key={i}>
+          {format(day, weekdayDisplayFormat, dateOptions)}
+        </span>
+      ))}
+    </div>
+  );
+}
+
+class Month extends PureComponent {
+  render() {
+    const now = new Date();
+    const { displayMode, focusedRange, drag, styles, disabledDates, disabledDay } = this.props;
+    const minDate = this.props.minDate && startOfDay(this.props.minDate);
+    const maxDate = this.props.maxDate && endOfDay(this.props.maxDate);
+    const monthDisplay = 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 (
+      <div className={styles.month} style={this.props.style}>
+        {this.props.showMonthName ? (
+          <div className={styles.monthName}>
+            {format(this.props.month, this.props.monthDisplayFormat, this.props.dateOptions)}
+          </div>
+        ) : null}
+        {this.props.showWeekDays &&
+          renderWeekdays(styles, this.props.dateOptions, this.props.weekdayDisplayFormat)}
+        <div className={styles.days} onMouseLeave={this.props.onMouseLeave}>
+          {eachDayOfInterval({ start: monthDisplay.start, end: monthDisplay.end }).map(
+            (day, index) => {
+              const isStartOfMonth = isSameDay(day, monthDisplay.startDateOfMonth);
+              const isEndOfMonth = isSameDay(day, monthDisplay.endDateOfMonth);
+              const isOutsideMinMax =
+                (minDate && isBefore(day, minDate)) || (maxDate && isAfter(day, maxDate));
+              const isDisabledSpecifically = disabledDates.some(disabledDate =>
+                isSameDay(disabledDate, day)
+              );
+              const isDisabledDay = disabledDay(day);
+              return (
+                <DayCell
+                  {...this.props}
+                  ranges={ranges}
+                  day={day}
+                  preview={showPreview ? this.props.preview : null}
+                  isWeekend={isWeekend(day, this.props.dateOptions)}
+                  isToday={isSameDay(day, now)}
+                  isStartOfWeek={isSameDay(day, startOfWeek(day, this.props.dateOptions))}
+                  isEndOfWeek={isSameDay(day, endOfWeek(day, this.props.dateOptions))}
+                  isStartOfMonth={isStartOfMonth}
+                  isEndOfMonth={isEndOfMonth}
+                  key={index}
+                  disabled={isOutsideMinMax || isDisabledSpecifically || isDisabledDay}
+                  isPassive={
+                    !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}
+                />
+              );
+            }
+          )}
+        </div>
+      </div>
+    );
+  }
+}
+
+Month.defaultProps = {};
+
+Month.propTypes = {
+  style: PropTypes.object,
+  styles: PropTypes.object,
+  month: PropTypes.object,
+  drag: PropTypes.object,
+  dateOptions: PropTypes.object,
+  disabledDates: PropTypes.array,
+  disabledDay: PropTypes.func,
+  preview: PropTypes.shape({
+    startDate: PropTypes.object,
+    endDate: PropTypes.object,
+  }),
+  showPreview: PropTypes.bool,
+  displayMode: PropTypes.oneOf(['dateRange', 'date']),
+  minDate: PropTypes.object,
+  maxDate: PropTypes.object,
+  ranges: PropTypes.arrayOf(rangeShape),
+  focusedRange: PropTypes.arrayOf(PropTypes.number),
+  onDragSelectionStart: PropTypes.func,
+  onDragSelectionEnd: PropTypes.func,
+  onDragSelectionMove: PropTypes.func,
+  onMouseLeave: PropTypes.func,
+  monthDisplayFormat: PropTypes.string,
+  weekdayDisplayFormat: PropTypes.string,
+  dayDisplayFormat: PropTypes.string,
+  showWeekDays: PropTypes.bool,
+  showMonthName: PropTypes.bool,
+  fixedHeight: PropTypes.bool,
+};
+
+export default Month;

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

@@ -0,0 +1,120 @@
+import {
+  addDays,
+  endOfDay,
+  startOfDay,
+  startOfMonth,
+  endOfMonth,
+  addMonths,
+  startOfWeek,
+  endOfWeek,
+  isSameDay,
+  differenceInCalendarDays,
+} from 'date-fns';
+
+const defineds = {
+  startOfWeek: startOfWeek(new Date()),
+  endOfWeek: endOfWeek(new Date()),
+  startOfLastWeek: startOfWeek(addDays(new Date(), -7)),
+  endOfLastWeek: endOfWeek(addDays(new Date(), -7)),
+  startOfToday: startOfDay(new Date()),
+  endOfToday: endOfDay(new Date()),
+  startOfYesterday: startOfDay(addDays(new Date(), -1)),
+  endOfYesterday: endOfDay(addDays(new Date(), -1)),
+  startOfMonth: startOfMonth(new Date()),
+  endOfMonth: endOfMonth(new Date()),
+  startOfLastMonth: startOfMonth(addMonths(new Date(), -1)),
+  endOfLastMonth: endOfMonth(addMonths(new Date(), -1)),
+};
+
+const staticRangeHandler = {
+  range: {},
+  isSelected(range) {
+    const definedRange = this.range();
+    return (
+      isSameDay(range.startDate, definedRange.startDate) &&
+      isSameDay(range.endDate, definedRange.endDate)
+    );
+  },
+};
+
+export function createStaticRanges(ranges) {
+  return ranges.map(range => ({ ...staticRangeHandler, ...range }));
+}
+
+export const 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,
+    }),
+  },
+]);
+
+export const defaultInputRanges = [
+  {
+    label: 'days up to today',
+    range(value) {
+      return {
+        startDate: addDays(defineds.startOfToday, (Math.max(Number(value), 1) - 1) * -1),
+        endDate: defineds.endOfToday,
+      };
+    },
+    getCurrentValue(range) {
+      if (!isSameDay(range.endDate, defineds.endOfToday)) return '-';
+      if (!range.startDate) return '∞';
+      return differenceInCalendarDays(defineds.endOfToday, range.startDate) + 1;
+    },
+  },
+  {
+    label: 'days starting today',
+    range(value) {
+      const today = new Date();
+      return {
+        startDate: today,
+        endDate: addDays(today, Math.max(Number(value), 1) - 1),
+      };
+    },
+    getCurrentValue(range) {
+      if (!isSameDay(range.startDate, defineds.startOfToday)) return '-';
+      if (!range.endDate) return '∞';
+      return differenceInCalendarDays(range.endDate, defineds.startOfToday) + 1;
+    },
+  },
+];

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

@@ -0,0 +1,5 @@
+export { default as DateRange } from './components/DateRange';
+export { default as Calendar } from './components/Calendar';
+export { default as DateRangePicker } from './components/DateRangePicker';
+export { default as DefinedRange } from './components/DefinedRange';
+export { defaultInputRanges, defaultStaticRanges, createStaticRanges } from './defaultRanges';

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

@@ -0,0 +1,62 @@
+export { default as af } from 'date-fns/locale/af';
+export { default as arDZ } from 'date-fns/locale/ar-DZ';
+export { default as arSA } from 'date-fns/locale/ar-SA';
+export { default as be } from 'date-fns/locale/be';
+export { default as bg } from 'date-fns/locale/bg';
+export { default as bn } from 'date-fns/locale/bn';
+export { default as ca } from 'date-fns/locale/ca';
+export { default as cs } from 'date-fns/locale/cs';
+export { default as cy } from 'date-fns/locale/cy';
+export { default as da } from 'date-fns/locale/da';
+export { default as de } from 'date-fns/locale/de';
+export { default as el } from 'date-fns/locale/el';
+export { default as enAU } from 'date-fns/locale/en-AU';
+export { default as enCA } from 'date-fns/locale/en-CA';
+export { default as enGB } from 'date-fns/locale/en-GB';
+export { default as enUS } from 'date-fns/locale/en-US';
+export { default as eo } from 'date-fns/locale/eo';
+export { default as es } from 'date-fns/locale/es';
+export { default as et } from 'date-fns/locale/et';
+export { default as faIR } from 'date-fns/locale/fa-IR';
+export { default as fi } from 'date-fns/locale/fi';
+export { default as fr } from 'date-fns/locale/fr';
+export { default as frCA } from 'date-fns/locale/fr-CA';
+export { default as gl } from 'date-fns/locale/gl';
+export { default as gu } from 'date-fns/locale/gu';
+export { default as he } from 'date-fns/locale/he';
+export { default as hi } from 'date-fns/locale/hi';
+export { default as hr } from 'date-fns/locale/hr';
+export { default as hu } from 'date-fns/locale/hu';
+export { default as hy } from 'date-fns/locale/hy';
+export { default as id } from 'date-fns/locale/id';
+export { default as is } from 'date-fns/locale/is';
+export { default as it } from 'date-fns/locale/it';
+export { default as ja } from 'date-fns/locale/ja';
+export { default as ka } from 'date-fns/locale/ka';
+export { default as kk } from 'date-fns/locale/kk';
+export { default as ko } from 'date-fns/locale/ko';
+export { default as lt } from 'date-fns/locale/lt';
+export { default as lv } from 'date-fns/locale/lv';
+export { default as ms } from 'date-fns/locale/ms';
+export { default as nb } from 'date-fns/locale/nb';
+export { default as nl } from 'date-fns/locale/nl';
+export { default as nn } from 'date-fns/locale/nn';
+export { default as pl } from 'date-fns/locale/pl';
+export { default as pt } from 'date-fns/locale/pt';
+export { default as ptBR } from 'date-fns/locale/pt-BR';
+export { default as ro } from 'date-fns/locale/ro';
+export { default as ru } from 'date-fns/locale/ru';
+export { default as sk } from 'date-fns/locale/sk';
+export { default as sl } from 'date-fns/locale/sl';
+export { default as sr } from 'date-fns/locale/sr';
+export { default as srLatn } from 'date-fns/locale/sr-Latn';
+export { default as sv } from 'date-fns/locale/sv';
+export { default as ta } from 'date-fns/locale/ta';
+export { default as te } from 'date-fns/locale/te';
+export { default as th } from 'date-fns/locale/th';
+export { default as tr } from 'date-fns/locale/tr';
+export { default as ug } from 'date-fns/locale/ug';
+export { default as uk } from 'date-fns/locale/uk';
+export { default as vi } from 'date-fns/locale/vi';
+export { default as zhCN } from 'date-fns/locale/zh-CN';
+export { default as zhTW } from 'date-fns/locale/zh-TW';

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

@@ -0,0 +1,53 @@
+export 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/src/styles.scss

@@ -0,0 +1,6 @@
+@import 'components/Calendar/index.scss';
+@import 'components/DateRange/index.scss';
+@import 'components/DateInput/index.scss';
+@import 'components/DayCell/index.scss';
+@import 'components/DateRangePicker/index.scss';
+@import 'components/DefinedRange/index.scss';

node_modules/react-date-range/src/theme/default.scss

@@ -0,0 +1,396 @@
+.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;
+  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;
+  select{
+    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;
+    &: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;
+  &:hover{
+    background: #E1E7F0;
+  }
+  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;
+  .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;
+  user-select: none;
+  border: 0;
+  padding: 0;
+  line-height: 3.000em;
+  height: 3.000em;
+  text-align: center;
+  color: #1d2429;
+  &: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;
+  &: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, .rdrStartEdge, .rdrEndEdge, .rdrSelected{
+    & ~ .rdrDayNumber span:after{
+      background: #fff;
+    }
+  }
+}
+
+.rdrDay:not(.rdrDayPassive){
+  .rdrInRange, .rdrStartEdge, .rdrEndEdge, .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, .rdrDayStartOfWeek{
+  .rdrInRange, .rdrEndEdge{
+    border-top-left-radius: 1.042em;
+    border-bottom-left-radius: 1.042em;
+    left: 2px;
+  }
+}
+
+.rdrDayEndOfMonth, .rdrDayEndOfWeek{
+  .rdrInRange,  .rdrStartEdge{
+    border-top-right-radius: 1.042em;
+    border-bottom-right-radius: 1.042em;
+    right: 2px;
+  }
+}
+
+.rdrDayStartOfMonth, .rdrDayStartOfWeek{
+  .rdrDayInPreview, .rdrDayEndPreview{
+    border-top-left-radius: 1.333em;
+    border-bottom-left-radius: 1.333em;
+    border-left-width: 1px;
+    left: 0px;
+  }
+}
+
+.rdrDayEndOfMonth, .rdrDayEndOfWeek{
+  .rdrDayInPreview, .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;
+  .rdrStaticRangeSelected{
+    color: currentColor;
+    font-weight: 600;
+  }
+}
+
+.rdrStaticRange{
+  border: 0;
+  cursor: pointer;
+  display: block;
+  outline: 0;
+  border-bottom: 1px solid #eff2f7;
+  padding: 0;
+  background: #fff;
+  &:hover, &: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);
+  &:focus, &: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;
+  .rdrDayNumber span{
+    color: #d5dce0;
+  }
+  .rdrInRange, .rdrStartEdge, .rdrEndEdge, .rdrSelected, .rdrDayStartPreview, .rdrDayInPreview, .rdrDayEndPreview{
+    display: none;
+  }
+}
+
+.rdrDayDisabled {
+  background-color: rgb(248, 248, 248);
+  .rdrDayNumber span{
+    color: #aeb9bf;
+  }
+  .rdrInRange, .rdrStartEdge, .rdrEndEdge, .rdrSelected, .rdrDayStartPreview, .rdrDayInPreview, .rdrDayEndPreview{
+    filter: grayscale(100%) opacity(60%);
+  }
+}
+
+.rdrMonthName{
+  text-align: left;
+  font-weight: 600;
+  color: #849095;
+  padding: 0.833em;
+}

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

@@ -0,0 +1,79 @@
+import classnames from 'classnames';
+import {
+  startOfMonth,
+  endOfMonth,
+  startOfWeek,
+  endOfWeek,
+  differenceInCalendarDays,
+  differenceInCalendarMonths,
+  addDays,
+} from 'date-fns';
+
+export 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 = startOfMonth(targetInterval.start || new Date());
+  targetInterval.end = 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 (differenceInCalendarMonths(targetInterval.start, targetInterval.end) > months) {
+    // don't change focused if new selection in view area
+    return currentFocusedDate;
+  }
+  return targetDate;
+}
+
+export function findNextRangeIndex(ranges, currentRangeIndex = -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);
+}
+
+export function getMonthDisplayRange(date, dateOptions, fixedHeight) {
+  const startDateOfMonth = startOfMonth(date, dateOptions);
+  const endDateOfMonth = endOfMonth(date, dateOptions);
+  const startDateOfCalendar = startOfWeek(startDateOfMonth, dateOptions);
+  let endDateOfCalendar = endOfWeek(endDateOfMonth, dateOptions);
+  if (fixedHeight && differenceInCalendarDays(endDateOfCalendar, startDateOfCalendar) <= 34) {
+    endDateOfCalendar = addDays(endDateOfCalendar, 7);
+  }
+  return {
+    start: startDateOfCalendar,
+    end: endDateOfCalendar,
+    startDateOfMonth,
+    endDateOfMonth,
+  };
+}
+
+export function generateStyles(sources) {
+  if (!sources.length) return {};
+  const generatedStyles = sources
+    .filter(source => Boolean(source))
+    .reduce((styles, styleSource) => {
+      Object.keys(styleSource).forEach(key => {
+        styles[key] = classnames(styles[key], styleSource[key]);
+      });
+      return styles;
+    }, {});
+  return generatedStyles;
+}