@popsure/dirty-swan 0.63.0 → 0.63.2

package/dist/esm/Calendar-OjEwgyw8.js

@@ -0,0 +1,2191 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import React__default, { useRef, useState } from 'react';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
+import { u as useOnClickOutside, C as CalendarCaption } from './CalendarCaption-Bs7RbqJC.js';
+import './index-DLQEsiym.js';
+import CalendarIcon from './components/icon/icons/Calendar.js';
+import { s as styleInject } from './style-inject.es-tgCJW-Cu.js';
+import { Button } from './components/button/index.js';
+
+var dayjs_min$1 = {exports: {}};
+
+var dayjs_min = dayjs_min$1.exports;
+
+var hasRequiredDayjs_min;
+
+function requireDayjs_min () {
+	if (hasRequiredDayjs_min) return dayjs_min$1.exports;
+	hasRequiredDayjs_min = 1;
+	(function (module, exports$1) {
+		!function(t,e){module.exports=e();}(dayjs_min,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",f="month",h="quarter",c="year",d="date",$="Invalid Date",l=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_")},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},g={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return -t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,f),s=n-i<0,u=e.clone().add(r+(s?-1:1),f);return +(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return {M:f,y:c,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:h}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},D="en",v={};v[D]=M;var p=function(t){return t instanceof _},S=function(t,e,n){var r;if(!t)return D;if("string"==typeof t)v[t]&&(r=t),e&&(v[t]=e,r=t);else {var i=t.name;v[i]=t,r=i;}return !n&&r&&(D=r),r||!n&&D},w=function(t,e){if(p(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},O=g;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=S(t.locale,null,true),this.parse(t);}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match(l);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return O},m.isValid=function(){return !(this.$d.toString()===$)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,h=O.p(t),$=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},l=function(t,e){return O.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,g="set"+(this.$u?"UTC":"");switch(h){case c:return r?$(1,0):$(31,11);case f:return r?$(1,M):$(0,M+1);case o:var D=this.$locale().weekStart||0,v=(y<D?y+7:y)-D;return $(r?m-v:m+(6-v),M);case a:case d:return l(g+"Hours",0);case u:return l(g+"Minutes",1);case s:return l(g+"Seconds",2);case i:return l(g+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,false)},m.$set=function(t,e){var n,o=O.p(t),h="set"+(this.$u?"UTC":""),$=(n={},n[a]=h+"Date",n[d]=h+"Date",n[f]=h+"Month",n[c]=h+"FullYear",n[u]=h+"Hours",n[s]=h+"Minutes",n[i]=h+"Seconds",n[r]=h+"Milliseconds",n)[o],l=o===a?this.$D+(e-this.$W):e;if(o===f||o===c){var y=this.clone().set(d,1);y.$d[$](l),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d;}else $&&this.$d[$](l);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,h){var d,$=this;r=Number(r);var l=O.p(h),y=function(t){var e=w($);return O.w(e.date(e.date()+Math.round(t*r)),$)};if(l===f)return this.set(f,this.$M+r);if(l===c)return this.set(c,this.$y+r);if(l===a)return y(1);if(l===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[l]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||$;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,f=n.months,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].substr(0,s)},c=function(t){return O.s(s%12||12,t,"0")},d=n.meridiem||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r},l={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:O.s(a+1,2,"0"),MMM:h(n.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:O.s(this.$D,2,"0"),d:String(this.$W),dd:h(n.weekdaysMin,this.$W,o,2),ddd:h(n.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:O.s(s,2,"0"),h:c(1),hh:c(2),a:d(s,u,true),A:d(s,u,false),m:String(u),mm:O.s(u,2,"0"),s:String(this.$s),ss:O.s(this.$s,2,"0"),SSS:O.s(this.$ms,3,"0"),Z:i};return r.replace(y,(function(t,e){return e||l[t]||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,$){var l,y=O.p(d),M=w(r),m=(M.utcOffset()-this.utcOffset())*e,g=this-M,D=O.m(this,M);return D=(l={},l[c]=D/12,l[f]=D,l[h]=D/3,l[o]=(g-m)/6048e5,l[a]=(g-m)/864e5,l[u]=g/n,l[s]=g/e,l[i]=g/t,l)[y]||g,$?D:O.a(D)},m.daysInMonth=function(){return this.endOf(f).$D},m.$locale=function(){return v[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,true);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),b=_.prototype;return w.prototype=b,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",f],["$y",c],["$D",d]].forEach((function(t){b[t[1]]=function(e){return this.$g(e,t[0],t[1])};})),w.extend=function(t,e){return t.$i||(t(e,_,w),t.$i=true),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=v[D],w.Ls=v,w.p={},w})); 
+	} (dayjs_min$1));
+	return dayjs_min$1.exports;
+}
+
+var dayjs_minExports = requireDayjs_min();
+var dayjs = /*@__PURE__*/getDefaultExportFromCjs(dayjs_minExports);
+
+var build = {};
+
+var DayPicker$1 = {};
+
+var Caption = {};
+
+var LocaleUtils = {};
+
+var hasRequiredLocaleUtils;
+
+function requireLocaleUtils () {
+	if (hasRequiredLocaleUtils) return LocaleUtils;
+	hasRequiredLocaleUtils = 1;
+
+	Object.defineProperty(LocaleUtils, "__esModule", {
+	  value: true
+	});
+	LocaleUtils.formatDay = formatDay;
+	LocaleUtils.formatMonthTitle = formatMonthTitle;
+	LocaleUtils.formatWeekdayShort = formatWeekdayShort;
+	LocaleUtils.formatWeekdayLong = formatWeekdayLong;
+	LocaleUtils.getFirstDayOfWeek = getFirstDayOfWeek;
+	LocaleUtils.getMonths = getMonths;
+	var WEEKDAYS_LONG = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+	var WEEKDAYS_SHORT = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
+
+	var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+
+	function formatDay(day) {
+	  return day.toDateString();
+	}
+
+	function formatMonthTitle(d) {
+	  return MONTHS[d.getMonth()] + ' ' + d.getFullYear();
+	}
+
+	function formatWeekdayShort(i) {
+	  return WEEKDAYS_SHORT[i];
+	}
+
+	function formatWeekdayLong(i) {
+	  return WEEKDAYS_LONG[i];
+	}
+
+	function getFirstDayOfWeek() {
+	  return 0;
+	}
+
+	function getMonths() {
+	  return MONTHS;
+	}
+
+	LocaleUtils.default = {
+	  formatDay: formatDay,
+	  formatMonthTitle: formatMonthTitle,
+	  formatWeekdayShort: formatWeekdayShort,
+	  formatWeekdayLong: formatWeekdayLong,
+	  getFirstDayOfWeek: getFirstDayOfWeek,
+	  getMonths: getMonths
+	};
+	
+	return LocaleUtils;
+}
+
+var keys = {};
+
+var hasRequiredKeys;
+
+function requireKeys () {
+	if (hasRequiredKeys) return keys;
+	hasRequiredKeys = 1;
+
+	Object.defineProperty(keys, "__esModule", {
+	  value: true
+	});
+	keys.LEFT = 37;
+	keys.UP = 38;
+	keys.RIGHT = 39;
+	keys.DOWN = 40;
+	keys.ENTER = 13;
+	keys.SPACE = 32;
+	keys.ESC = 27;
+	keys.TAB = 9;
+	
+	return keys;
+}
+
+var hasRequiredCaption;
+
+function requireCaption () {
+	if (hasRequiredCaption) return Caption;
+	hasRequiredCaption = 1;
+
+	Object.defineProperty(Caption, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _LocaleUtils = requireLocaleUtils();
+
+	var _LocaleUtils2 = _interopRequireDefault(_LocaleUtils);
+
+	var _keys = requireKeys();
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var Caption$1 = function (_Component) {
+	  _inherits(Caption, _Component);
+
+	  function Caption(props) {
+	    _classCallCheck(this, Caption);
+
+	    var _this = _possibleConstructorReturn(this, (Caption.__proto__ || Object.getPrototypeOf(Caption)).call(this, props));
+
+	    _this.handleKeyUp = _this.handleKeyUp.bind(_this);
+	    return _this;
+	  }
+
+	  _createClass(Caption, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return nextProps.locale !== this.props.locale || nextProps.classNames !== this.props.classNames || nextProps.date.getMonth() !== this.props.date.getMonth() || nextProps.date.getFullYear() !== this.props.date.getFullYear();
+	    }
+	  }, {
+	    key: 'handleKeyUp',
+	    value: function handleKeyUp(e) {
+	      if (e.keyCode === _keys.ENTER) {
+	        this.props.onClick(e);
+	      }
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _props = this.props,
+	          classNames = _props.classNames,
+	          date = _props.date,
+	          months = _props.months,
+	          locale = _props.locale,
+	          localeUtils = _props.localeUtils,
+	          onClick = _props.onClick;
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: classNames.caption, role: 'heading', 'aria-live': 'polite' },
+	        _react2.default.createElement(
+	          'div',
+	          { onClick: onClick, onKeyUp: this.handleKeyUp },
+	          months ? months[date.getMonth()] + ' ' + date.getFullYear() : localeUtils.formatMonthTitle(date, locale)
+	        )
+	      );
+	    }
+	  }]);
+
+	  return Caption;
+	}(_react.Component);
+
+	Caption$1.defaultProps = {
+	  localeUtils: _LocaleUtils2.default
+	};
+	Caption.default = Caption$1;
+	
+	return Caption;
+}
+
+var Navbar = {};
+
+var classNames = {};
+
+var hasRequiredClassNames;
+
+function requireClassNames () {
+	if (hasRequiredClassNames) return classNames;
+	hasRequiredClassNames = 1;
+
+	Object.defineProperty(classNames, "__esModule", {
+	  value: true
+	});
+	// Proxy object to map classnames when css modules are not used
+
+	classNames.default = {
+	  container: 'DayPicker',
+	  wrapper: 'DayPicker-wrapper',
+	  interactionDisabled: 'DayPicker--interactionDisabled',
+	  months: 'DayPicker-Months',
+	  month: 'DayPicker-Month',
+
+	  navBar: 'DayPicker-NavBar',
+	  navButtonPrev: 'DayPicker-NavButton DayPicker-NavButton--prev',
+	  navButtonNext: 'DayPicker-NavButton DayPicker-NavButton--next',
+	  navButtonInteractionDisabled: 'DayPicker-NavButton--interactionDisabled',
+
+	  caption: 'DayPicker-Caption',
+	  weekdays: 'DayPicker-Weekdays',
+	  weekdaysRow: 'DayPicker-WeekdaysRow',
+	  weekday: 'DayPicker-Weekday',
+	  body: 'DayPicker-Body',
+	  week: 'DayPicker-Week',
+	  weekNumber: 'DayPicker-WeekNumber',
+	  day: 'DayPicker-Day',
+	  footer: 'DayPicker-Footer',
+	  todayButton: 'DayPicker-TodayButton',
+
+	  // default modifiers
+	  today: 'today',
+	  selected: 'selected',
+	  disabled: 'disabled',
+	  outside: 'outside'
+	};
+	
+	return classNames;
+}
+
+var hasRequiredNavbar;
+
+function requireNavbar () {
+	if (hasRequiredNavbar) return Navbar;
+	hasRequiredNavbar = 1;
+
+	Object.defineProperty(Navbar, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _classNames = requireClassNames();
+
+	var _classNames2 = _interopRequireDefault(_classNames);
+
+	var _keys = requireKeys();
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var Navbar$1 = function (_Component) {
+	  _inherits(Navbar, _Component);
+
+	  function Navbar() {
+	    var _ref;
+
+	    var _temp, _this, _ret;
+
+	    _classCallCheck(this, Navbar);
+
+	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
+
+	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Navbar.__proto__ || Object.getPrototypeOf(Navbar)).call.apply(_ref, [this].concat(args))), _this), _this.handleNextClick = function () {
+	      if (_this.props.onNextClick) {
+	        _this.props.onNextClick();
+	      }
+	    }, _this.handlePreviousClick = function () {
+	      if (_this.props.onPreviousClick) {
+	        _this.props.onPreviousClick();
+	      }
+	    }, _this.handleNextKeyDown = function (e) {
+	      if (e.keyCode !== _keys.ENTER && e.keyCode !== _keys.SPACE) {
+	        return;
+	      }
+	      e.preventDefault();
+	      _this.handleNextClick();
+	    }, _this.handlePreviousKeyDown = function (e) {
+	      if (e.keyCode !== _keys.ENTER && e.keyCode !== _keys.SPACE) {
+	        return;
+	      }
+	      e.preventDefault();
+	      _this.handlePreviousClick();
+	    }, _temp), _possibleConstructorReturn(_this, _ret);
+	  }
+
+	  _createClass(Navbar, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return nextProps.labels !== this.props.labels || nextProps.dir !== this.props.dir || this.props.showPreviousButton !== nextProps.showPreviousButton || this.props.showNextButton !== nextProps.showNextButton;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _props = this.props,
+	          classNames = _props.classNames,
+	          className = _props.className,
+	          showPreviousButton = _props.showPreviousButton,
+	          showNextButton = _props.showNextButton,
+	          labels = _props.labels,
+	          dir = _props.dir;
+
+
+	      var previousClickHandler = void 0;
+	      var nextClickHandler = void 0;
+	      var previousKeyDownHandler = void 0;
+	      var nextKeyDownHandler = void 0;
+	      var shouldShowPrevious = void 0;
+	      var shouldShowNext = void 0;
+
+	      if (dir === 'rtl') {
+	        previousClickHandler = this.handleNextClick;
+	        nextClickHandler = this.handlePreviousClick;
+	        previousKeyDownHandler = this.handleNextKeyDown;
+	        nextKeyDownHandler = this.handlePreviousKeyDown;
+	        shouldShowNext = showPreviousButton;
+	        shouldShowPrevious = showNextButton;
+	      } else {
+	        previousClickHandler = this.handlePreviousClick;
+	        nextClickHandler = this.handleNextClick;
+	        previousKeyDownHandler = this.handlePreviousKeyDown;
+	        nextKeyDownHandler = this.handleNextKeyDown;
+	        shouldShowNext = showNextButton;
+	        shouldShowPrevious = showPreviousButton;
+	      }
+
+	      var previousClassName = shouldShowPrevious ? classNames.navButtonPrev : classNames.navButtonPrev + ' ' + classNames.navButtonInteractionDisabled;
+
+	      var nextClassName = shouldShowNext ? classNames.navButtonNext : classNames.navButtonNext + ' ' + classNames.navButtonInteractionDisabled;
+
+	      var previousButton = _react2.default.createElement('span', {
+	        tabIndex: '0',
+	        role: 'button',
+	        'aria-label': labels.previousMonth,
+	        key: 'previous',
+	        className: previousClassName,
+	        onKeyDown: shouldShowPrevious ? previousKeyDownHandler : undefined,
+	        onClick: shouldShowPrevious ? previousClickHandler : undefined
+	      });
+
+	      var nextButton = _react2.default.createElement('span', {
+	        tabIndex: '0',
+	        role: 'button',
+	        'aria-label': labels.nextMonth,
+	        key: 'right',
+	        className: nextClassName,
+	        onKeyDown: shouldShowNext ? nextKeyDownHandler : undefined,
+	        onClick: shouldShowNext ? nextClickHandler : undefined
+	      });
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: className || classNames.navBar },
+	        dir === 'rtl' ? [nextButton, previousButton] : [previousButton, nextButton]
+	      );
+	    }
+	  }]);
+
+	  return Navbar;
+	}(_react.Component);
+
+	Navbar$1.defaultProps = {
+	  classNames: _classNames2.default,
+	  dir: 'ltr',
+	  labels: {
+	    previousMonth: 'Previous Month',
+	    nextMonth: 'Next Month'
+	  },
+	  showPreviousButton: true,
+	  showNextButton: true
+	};
+	Navbar.default = Navbar$1;
+	
+	return Navbar;
+}
+
+var Month = {};
+
+var Weekdays = {};
+
+var hasRequiredWeekdays;
+
+function requireWeekdays () {
+	if (hasRequiredWeekdays) return Weekdays;
+	hasRequiredWeekdays = 1;
+
+	Object.defineProperty(Weekdays, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var Weekdays$1 = function (_Component) {
+	  _inherits(Weekdays, _Component);
+
+	  function Weekdays() {
+	    _classCallCheck(this, Weekdays);
+
+	    return _possibleConstructorReturn(this, (Weekdays.__proto__ || Object.getPrototypeOf(Weekdays)).apply(this, arguments));
+	  }
+
+	  _createClass(Weekdays, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props !== nextProps;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _props = this.props,
+	          classNames = _props.classNames,
+	          firstDayOfWeek = _props.firstDayOfWeek,
+	          showWeekNumbers = _props.showWeekNumbers,
+	          weekdaysLong = _props.weekdaysLong,
+	          weekdaysShort = _props.weekdaysShort,
+	          locale = _props.locale,
+	          localeUtils = _props.localeUtils,
+	          weekdayElement = _props.weekdayElement;
+
+	      var days = [];
+	      for (var i = 0; i < 7; i += 1) {
+	        var weekday = (i + firstDayOfWeek) % 7;
+	        var elementProps = {
+	          key: i,
+	          className: classNames.weekday,
+	          weekday: weekday,
+	          weekdaysLong: weekdaysLong,
+	          weekdaysShort: weekdaysShort,
+	          localeUtils: localeUtils,
+	          locale: locale
+	        };
+	        var element = _react2.default.isValidElement(weekdayElement) ? _react2.default.cloneElement(weekdayElement, elementProps) : _react2.default.createElement(weekdayElement, elementProps);
+	        days.push(element);
+	      }
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: classNames.weekdays, role: 'rowgroup' },
+	        _react2.default.createElement(
+	          'div',
+	          { className: classNames.weekdaysRow, role: 'row' },
+	          showWeekNumbers && _react2.default.createElement('div', { className: classNames.weekday }),
+	          days
+	        )
+	      );
+	    }
+	  }]);
+
+	  return Weekdays;
+	}(_react.Component);
+
+	Weekdays.default = Weekdays$1;
+	
+	return Weekdays;
+}
+
+var Day = {};
+
+var DateUtils = {};
+
+var hasRequiredDateUtils;
+
+function requireDateUtils () {
+	if (hasRequiredDateUtils) return DateUtils;
+	hasRequiredDateUtils = 1;
+
+	Object.defineProperty(DateUtils, "__esModule", {
+	  value: true
+	});
+	DateUtils.clone = clone;
+	DateUtils.isDate = isDate;
+	DateUtils.addMonths = addMonths;
+	DateUtils.isSameDay = isSameDay;
+	DateUtils.isSameMonth = isSameMonth;
+	DateUtils.isDayBefore = isDayBefore;
+	DateUtils.isDayAfter = isDayAfter;
+	DateUtils.isPastDay = isPastDay;
+	DateUtils.isFutureDay = isFutureDay;
+	DateUtils.isDayBetween = isDayBetween;
+	DateUtils.addDayToRange = addDayToRange;
+	DateUtils.isDayInRange = isDayInRange;
+	DateUtils.getWeekNumber = getWeekNumber;
+	/**
+	 * Clone a date object.
+	 *
+	 * @export
+	 * @param  {Date} d The date to clone
+	 * @return {Date} The cloned date
+	 */
+	function clone(d) {
+	  return new Date(d.getTime());
+	}
+
+	/**
+	 * Return `true` if the passed value is a valid JavaScript Date object.
+	 *
+	 * @export
+	 * @param {any} value
+	 * @returns {Boolean}
+	 */
+	function isDate(value) {
+	  return value instanceof Date && !isNaN(value.valueOf());
+	}
+
+	/**
+	 * Return `d` as a new date with `n` months added.
+	 *
+	 * @export
+	 * @param {Date} d
+	 * @param {number} n
+	 */
+	function addMonths(d, n) {
+	  var newDate = clone(d);
+	  newDate.setMonth(d.getMonth() + n);
+	  return newDate;
+	}
+
+	/**
+	 * Return `true` if two dates are the same day, ignoring the time.
+	 *
+	 * @export
+	 * @param  {Date}  d1
+	 * @param  {Date}  d2
+	 * @return {Boolean}
+	 */
+	function isSameDay(d1, d2) {
+	  if (!d1 || !d2) {
+	    return false;
+	  }
+	  return d1.getDate() === d2.getDate() && d1.getMonth() === d2.getMonth() && d1.getFullYear() === d2.getFullYear();
+	}
+
+	/**
+	 * Return `true` if two dates fall in the same month.
+	 *
+	 * @export
+	 * @param  {Date}  d1
+	 * @param  {Date}  d2
+	 * @return {Boolean}
+	 */
+	function isSameMonth(d1, d2) {
+	  if (!d1 || !d2) {
+	    return false;
+	  }
+	  return d1.getMonth() === d2.getMonth() && d1.getFullYear() === d2.getFullYear();
+	}
+
+	/**
+	 * Returns `true` if the first day is before the second day.
+	 *
+	 * @export
+	 * @param {Date} d1
+	 * @param {Date} d2
+	 * @returns {Boolean}
+	 */
+	function isDayBefore(d1, d2) {
+	  var day1 = clone(d1).setHours(0, 0, 0, 0);
+	  var day2 = clone(d2).setHours(0, 0, 0, 0);
+	  return day1 < day2;
+	}
+
+	/**
+	 * Returns `true` if the first day is after the second day.
+	 *
+	 * @export
+	 * @param {Date} d1
+	 * @param {Date} d2
+	 * @returns {Boolean}
+	 */
+	function isDayAfter(d1, d2) {
+	  var day1 = clone(d1).setHours(0, 0, 0, 0);
+	  var day2 = clone(d2).setHours(0, 0, 0, 0);
+	  return day1 > day2;
+	}
+
+	/**
+	 * Return `true` if a day is in the past, e.g. yesterday or any day
+	 * before yesterday.
+	 *
+	 * @export
+	 * @param  {Date}  d
+	 * @return {Boolean}
+	 */
+	function isPastDay(d) {
+	  var today = new Date();
+	  today.setHours(0, 0, 0, 0);
+	  return isDayBefore(d, today);
+	}
+
+	/**
+	 * Return `true` if a day is in the future, e.g. tomorrow or any day
+	 * after tomorrow.
+	 *
+	 * @export
+	 * @param  {Date}  d
+	 * @return {Boolean}
+	 */
+	function isFutureDay(d) {
+	  var tomorrow = new Date(new Date().getTime() + 24 * 60 * 60 * 1000);
+	  tomorrow.setHours(0, 0, 0, 0);
+	  return d >= tomorrow;
+	}
+
+	/**
+	 * Return `true` if day `d` is between days `d1` and `d2`,
+	 * without including them.
+	 *
+	 * @export
+	 * @param  {Date}  d
+	 * @param  {Date}  d1
+	 * @param  {Date}  d2
+	 * @return {Boolean}
+	 */
+	function isDayBetween(d, d1, d2) {
+	  var date = clone(d);
+	  date.setHours(0, 0, 0, 0);
+	  return isDayAfter(date, d1) && isDayBefore(date, d2) || isDayAfter(date, d2) && isDayBefore(date, d1);
+	}
+
+	/**
+	 * Add a day to a range and return a new range. A range is an object with
+	 * `from` and `to` days.
+	 *
+	 * @export
+	 * @param {Date} day
+	 * @param {Object} range
+	 * @return {Object} Returns a new range object
+	 */
+	function addDayToRange(day) {
+	  var range = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { from: null, to: null };
+	  var from = range.from,
+	      to = range.to;
+
+	  if (!from) {
+	    from = day;
+	  } else if (from && to && isSameDay(from, to) && isSameDay(day, from)) {
+	    from = null;
+	    to = null;
+	  } else if (to && isDayBefore(day, from)) {
+	    from = day;
+	  } else if (to && isSameDay(day, to)) {
+	    from = day;
+	    to = day;
+	  } else {
+	    to = day;
+	    if (isDayBefore(to, from)) {
+	      to = from;
+	      from = day;
+	    }
+	  }
+
+	  return { from: from, to: to };
+	}
+
+	/**
+	 * Return `true` if a day is included in a range of days.
+	 *
+	 * @export
+	 * @param  {Date}  day
+	 * @param  {Object}  range
+	 * @return {Boolean}
+	 */
+	function isDayInRange(day, range) {
+	  var from = range.from,
+	      to = range.to;
+
+	  return from && isSameDay(day, from) || to && isSameDay(day, to) || from && to && isDayBetween(day, from, to);
+	}
+
+	/**
+	 * Return the year's week number (as per ISO, i.e. with the week starting from monday)
+	 * for the given day.
+	 *
+	 * @export
+	 * @param {Date} day
+	 * @returns {Number}
+	 */
+	function getWeekNumber(day) {
+	  var date = clone(day);
+	  date.setHours(0, 0, 0);
+	  date.setDate(date.getDate() + 4 - (date.getDay() || 7));
+	  return Math.ceil(((date - new Date(date.getFullYear(), 0, 1)) / 8.64e7 + 1) / 7);
+	}
+
+	DateUtils.default = {
+	  addDayToRange: addDayToRange,
+	  addMonths: addMonths,
+	  clone: clone,
+	  getWeekNumber: getWeekNumber,
+	  isDate: isDate,
+	  isDayAfter: isDayAfter,
+	  isDayBefore: isDayBefore,
+	  isDayBetween: isDayBetween,
+	  isDayInRange: isDayInRange,
+	  isFutureDay: isFutureDay,
+	  isPastDay: isPastDay,
+	  isSameDay: isSameDay,
+	  isSameMonth: isSameMonth
+	};
+	
+	return DateUtils;
+}
+
+var Helpers = {};
+
+var hasRequiredHelpers;
+
+function requireHelpers () {
+	if (hasRequiredHelpers) return Helpers;
+	hasRequiredHelpers = 1;
+
+	Object.defineProperty(Helpers, "__esModule", {
+	  value: true
+	});
+
+	var _extends = Object.assign || 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; };
+
+	Helpers.cancelEvent = cancelEvent;
+	Helpers.getFirstDayOfMonth = getFirstDayOfMonth;
+	Helpers.getDaysInMonth = getDaysInMonth;
+	Helpers.getModifiersFromProps = getModifiersFromProps;
+	Helpers.getFirstDayOfWeekFromProps = getFirstDayOfWeekFromProps;
+	Helpers.isRangeOfDates = isRangeOfDates;
+	Helpers.getMonthsDiff = getMonthsDiff;
+	Helpers.getWeekArray = getWeekArray;
+	Helpers.startOfMonth = startOfMonth;
+	Helpers.getDayNodes = getDayNodes;
+	Helpers.nodeListToArray = nodeListToArray;
+	Helpers.hasOwnProp = hasOwnProp;
+
+	var _DateUtils = requireDateUtils();
+
+	var _LocaleUtils = requireLocaleUtils();
+
+	var _classNames = requireClassNames();
+
+	var _classNames2 = _interopRequireDefault(_classNames);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function cancelEvent(e) {
+	  e.preventDefault();
+	  e.stopPropagation();
+	}
+
+	function getFirstDayOfMonth(d) {
+	  return new Date(d.getFullYear(), d.getMonth(), 1, 12);
+	}
+
+	function getDaysInMonth(d) {
+	  var resultDate = getFirstDayOfMonth(d);
+
+	  resultDate.setMonth(resultDate.getMonth() + 1);
+	  resultDate.setDate(resultDate.getDate() - 1);
+
+	  return resultDate.getDate();
+	}
+
+	function getModifiersFromProps(props) {
+	  var modifiers = _extends({}, props.modifiers);
+	  if (props.selectedDays) {
+	    modifiers[props.classNames.selected] = props.selectedDays;
+	  }
+	  if (props.disabledDays) {
+	    modifiers[props.classNames.disabled] = props.disabledDays;
+	  }
+	  return modifiers;
+	}
+
+	function getFirstDayOfWeekFromProps(props) {
+	  var firstDayOfWeek = props.firstDayOfWeek,
+	      _props$locale = props.locale,
+	      locale = _props$locale === undefined ? 'en' : _props$locale,
+	      _props$localeUtils = props.localeUtils,
+	      localeUtils = _props$localeUtils === undefined ? {} : _props$localeUtils;
+
+	  if (!isNaN(firstDayOfWeek)) {
+	    return firstDayOfWeek;
+	  }
+	  if (localeUtils.getFirstDayOfWeek) {
+	    return localeUtils.getFirstDayOfWeek(locale);
+	  }
+	  return 0;
+	}
+
+	function isRangeOfDates(value) {
+	  return !!(value && value.from && value.to);
+	}
+
+	function getMonthsDiff(d1, d2) {
+	  return d2.getMonth() - d1.getMonth() + 12 * (d2.getFullYear() - d1.getFullYear());
+	}
+
+	function getWeekArray(d) {
+	  var firstDayOfWeek = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (0, _LocaleUtils.getFirstDayOfWeek)();
+	  var fixedWeeks = arguments[2];
+
+	  var daysInMonth = getDaysInMonth(d);
+	  var dayArray = [];
+
+	  var week = [];
+	  var weekArray = [];
+
+	  for (var i = 1; i <= daysInMonth; i += 1) {
+	    dayArray.push(new Date(d.getFullYear(), d.getMonth(), i, 12));
+	  }
+
+	  dayArray.forEach(function (day) {
+	    if (week.length > 0 && day.getDay() === firstDayOfWeek) {
+	      weekArray.push(week);
+	      week = [];
+	    }
+	    week.push(day);
+	    if (dayArray.indexOf(day) === dayArray.length - 1) {
+	      weekArray.push(week);
+	    }
+	  });
+
+	  // unshift days to start the first week
+	  var firstWeek = weekArray[0];
+	  for (var _i = 7 - firstWeek.length; _i > 0; _i -= 1) {
+	    var outsideDate = (0, _DateUtils.clone)(firstWeek[0]);
+	    outsideDate.setDate(firstWeek[0].getDate() - 1);
+	    firstWeek.unshift(outsideDate);
+	  }
+
+	  // push days until the end of the last week
+	  var lastWeek = weekArray[weekArray.length - 1];
+	  for (var _i2 = lastWeek.length; _i2 < 7; _i2 += 1) {
+	    var _outsideDate = (0, _DateUtils.clone)(lastWeek[lastWeek.length - 1]);
+	    _outsideDate.setDate(lastWeek[lastWeek.length - 1].getDate() + 1);
+	    lastWeek.push(_outsideDate);
+	  }
+
+	  // add extra weeks to reach 6 weeks
+	  if (fixedWeeks && weekArray.length < 6) {
+	    var lastExtraWeek = void 0;
+
+	    for (var _i3 = weekArray.length; _i3 < 6; _i3 += 1) {
+	      lastExtraWeek = weekArray[weekArray.length - 1];
+	      var lastDay = lastExtraWeek[lastExtraWeek.length - 1];
+	      var extraWeek = [];
+
+	      for (var j = 0; j < 7; j += 1) {
+	        var _outsideDate2 = (0, _DateUtils.clone)(lastDay);
+	        _outsideDate2.setDate(lastDay.getDate() + j + 1);
+	        extraWeek.push(_outsideDate2);
+	      }
+
+	      weekArray.push(extraWeek);
+	    }
+	  }
+
+	  return weekArray;
+	}
+
+	function startOfMonth(d) {
+	  var newDate = (0, _DateUtils.clone)(d);
+	  newDate.setDate(1);
+	  newDate.setHours(12, 0, 0, 0); // always set noon to avoid time zone issues
+	  return newDate;
+	}
+
+	function getDayNodes(node, classNames) {
+	  var outsideClassName = void 0;
+	  if (classNames === _classNames2.default) {
+	    // When using CSS modules prefix the modifier as required by the BEM syntax
+	    outsideClassName = classNames.day + '--' + classNames.outside;
+	  } else {
+	    outsideClassName = '' + classNames.outside;
+	  }
+	  var dayQuery = classNames.day.replace(/ /g, '.');
+	  var outsideDayQuery = outsideClassName.replace(/ /g, '.');
+	  var selector = '.' + dayQuery + ':not(.' + outsideDayQuery + ')';
+	  return node.querySelectorAll(selector);
+	}
+
+	function nodeListToArray(nodeList) {
+	  return Array.prototype.slice.call(nodeList, 0);
+	}
+
+	function hasOwnProp(obj, prop) {
+	  return Object.prototype.hasOwnProperty.call(obj, prop);
+	}
+	
+	return Helpers;
+}
+
+var hasRequiredDay;
+
+function requireDay () {
+	if (hasRequiredDay) return Day;
+	hasRequiredDay = 1;
+
+	Object.defineProperty(Day, "__esModule", {
+	  value: true
+	});
+
+	var _extends = Object.assign || 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; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _DateUtils = requireDateUtils();
+
+	var _Helpers = requireHelpers();
+
+	var _classNames = requireClassNames();
+
+	var _classNames2 = _interopRequireDefault(_classNames);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable jsx-a11y/no-static-element-interactions, react/forbid-prop-types */
+
+	function handleEvent(handler, day, modifiers) {
+	  if (!handler) {
+	    return undefined;
+	  }
+	  return function (e) {
+	    e.persist();
+	    handler(day, modifiers, e);
+	  };
+	}
+
+	var Day$1 = function (_Component) {
+	  _inherits(Day, _Component);
+
+	  function Day() {
+	    _classCallCheck(this, Day);
+
+	    return _possibleConstructorReturn(this, (Day.__proto__ || Object.getPrototypeOf(Day)).apply(this, arguments));
+	  }
+
+	  _createClass(Day, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      var _this2 = this;
+
+	      var propNames = Object.keys(this.props);
+	      var nextPropNames = Object.keys(nextProps);
+	      if (propNames.length !== nextPropNames.length) {
+	        return true;
+	      }
+	      return propNames.some(function (name) {
+	        if (name === 'modifiers' || name === 'modifiersStyles' || name === 'classNames') {
+	          var prop = _this2.props[name];
+	          var nextProp = nextProps[name];
+	          var modifiers = Object.keys(prop);
+	          var nextModifiers = Object.keys(nextProp);
+	          if (modifiers.length !== nextModifiers.length) {
+	            return true;
+	          }
+	          return modifiers.some(function (mod) {
+	            return !(0, _Helpers.hasOwnProp)(nextProp, mod) || prop[mod] !== nextProp[mod];
+	          });
+	        }
+	        if (name === 'day') {
+	          return !(0, _DateUtils.isSameDay)(_this2.props[name], nextProps[name]);
+	        }
+	        return !(0, _Helpers.hasOwnProp)(nextProps, name) || _this2.props[name] !== nextProps[name];
+	      });
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _props = this.props,
+	          classNames = _props.classNames,
+	          modifiersStyles = _props.modifiersStyles,
+	          day = _props.day,
+	          tabIndex = _props.tabIndex,
+	          empty = _props.empty,
+	          modifiers = _props.modifiers,
+	          onMouseEnter = _props.onMouseEnter,
+	          onMouseLeave = _props.onMouseLeave,
+	          onMouseUp = _props.onMouseUp,
+	          onMouseDown = _props.onMouseDown,
+	          onClick = _props.onClick,
+	          onKeyDown = _props.onKeyDown,
+	          onTouchStart = _props.onTouchStart,
+	          onTouchEnd = _props.onTouchEnd,
+	          onFocus = _props.onFocus,
+	          ariaLabel = _props.ariaLabel,
+	          ariaDisabled = _props.ariaDisabled,
+	          ariaSelected = _props.ariaSelected,
+	          children = _props.children;
+
+
+	      var className = classNames.day;
+	      if (classNames !== _classNames2.default) {
+	        // When using CSS modules prefix the modifier as required by the BEM syntax
+	        className += ' ' + Object.keys(modifiers).join(' ');
+	      } else {
+	        className += Object.keys(modifiers).map(function (modifier) {
+	          return ' ' + className + '--' + modifier;
+	        }).join('');
+	      }
+
+	      var style = void 0;
+	      if (modifiersStyles) {
+	        Object.keys(modifiers).filter(function (modifier) {
+	          return !!modifiersStyles[modifier];
+	        }).forEach(function (modifier) {
+	          style = _extends({}, style, modifiersStyles[modifier]);
+	        });
+	      }
+
+	      if (empty) {
+	        return _react2.default.createElement('div', { 'aria-disabled': true, className: className, style: style });
+	      }
+	      return _react2.default.createElement(
+	        'div',
+	        {
+	          className: className,
+	          tabIndex: tabIndex,
+	          style: style,
+	          role: 'gridcell',
+	          'aria-label': ariaLabel,
+	          'aria-disabled': ariaDisabled,
+	          'aria-selected': ariaSelected,
+	          onClick: handleEvent(onClick, day, modifiers),
+	          onKeyDown: handleEvent(onKeyDown, day, modifiers),
+	          onMouseEnter: handleEvent(onMouseEnter, day, modifiers),
+	          onMouseLeave: handleEvent(onMouseLeave, day, modifiers),
+	          onMouseUp: handleEvent(onMouseUp, day, modifiers),
+	          onMouseDown: handleEvent(onMouseDown, day, modifiers),
+	          onTouchEnd: handleEvent(onTouchEnd, day, modifiers),
+	          onTouchStart: handleEvent(onTouchStart, day, modifiers),
+	          onFocus: handleEvent(onFocus, day, modifiers)
+	        },
+	        children
+	      );
+	    }
+	  }]);
+
+	  return Day;
+	}(_react.Component);
+
+	Day$1.defaultProps = {
+	  tabIndex: -1
+	};
+	Day$1.defaultProps = {
+	  modifiers: {},
+	  modifiersStyles: {},
+	  empty: false
+	};
+	Day.default = Day$1;
+	
+	return Day;
+}
+
+var ModifiersUtils = {};
+
+var hasRequiredModifiersUtils;
+
+function requireModifiersUtils () {
+	if (hasRequiredModifiersUtils) return ModifiersUtils;
+	hasRequiredModifiersUtils = 1;
+
+	Object.defineProperty(ModifiersUtils, "__esModule", {
+	  value: true
+	});
+	ModifiersUtils.dayMatchesModifier = dayMatchesModifier;
+	ModifiersUtils.getModifiersForDay = getModifiersForDay;
+
+	var _DateUtils = requireDateUtils();
+
+	var _Helpers = requireHelpers();
+
+	/**
+	 * Return `true` if a date matches the specified modifier.
+	 *
+	 * @export
+	 * @param {Date} day
+	 * @param {Any} modifier
+	 * @return {Boolean}
+	 */
+	function dayMatchesModifier(day, modifier) {
+	  if (!modifier) {
+	    return false;
+	  }
+	  var arr = Array.isArray(modifier) ? modifier : [modifier];
+	  return arr.some(function (mod) {
+	    if (!mod) {
+	      return false;
+	    }
+	    if (mod instanceof Date) {
+	      return (0, _DateUtils.isSameDay)(day, mod);
+	    }
+	    if ((0, _Helpers.isRangeOfDates)(mod)) {
+	      return (0, _DateUtils.isDayInRange)(day, mod);
+	    }
+	    if (mod.after && mod.before && (0, _DateUtils.isDayAfter)(mod.before, mod.after)) {
+	      return (0, _DateUtils.isDayAfter)(day, mod.after) && (0, _DateUtils.isDayBefore)(day, mod.before);
+	    }
+	    if (mod.after && mod.before && ((0, _DateUtils.isDayAfter)(mod.after, mod.before) || (0, _DateUtils.isSameDay)(mod.after, mod.before))) {
+	      return (0, _DateUtils.isDayAfter)(day, mod.after) || (0, _DateUtils.isDayBefore)(day, mod.before);
+	    }
+	    if (mod.after) {
+	      return (0, _DateUtils.isDayAfter)(day, mod.after);
+	    }
+	    if (mod.before) {
+	      return (0, _DateUtils.isDayBefore)(day, mod.before);
+	    }
+	    if (mod.daysOfWeek) {
+	      return mod.daysOfWeek.some(function (dayOfWeek) {
+	        return day.getDay() === dayOfWeek;
+	      });
+	    }
+	    if (typeof mod === 'function') {
+	      return mod(day);
+	    }
+	    return false;
+	  });
+	}
+
+	/**
+	 * Return the modifiers matching the given day for the given
+	 * object of modifiers.
+	 *
+	 * @export
+	 * @param {Date} day
+	 * @param {Object} [modifiersObj={}]
+	 * @return {Array}
+	 */
+	function getModifiersForDay(day) {
+	  var modifiersObj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+	  return Object.keys(modifiersObj).reduce(function (modifiers, modifierName) {
+	    var value = modifiersObj[modifierName];
+	    if (dayMatchesModifier(day, value)) {
+	      modifiers.push(modifierName);
+	    }
+	    return modifiers;
+	  }, []);
+	}
+
+	ModifiersUtils.default = { dayMatchesModifier: dayMatchesModifier, getModifiersForDay: getModifiersForDay };
+	
+	return ModifiersUtils;
+}
+
+var hasRequiredMonth;
+
+function requireMonth () {
+	if (hasRequiredMonth) return Month;
+	hasRequiredMonth = 1;
+
+	Object.defineProperty(Month, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _Weekdays = requireWeekdays();
+
+	var _Weekdays2 = _interopRequireDefault(_Weekdays);
+
+	var _Day = requireDay();
+
+	var _Day2 = _interopRequireDefault(_Day);
+
+	var _keys = requireKeys();
+
+	var _ModifiersUtils = requireModifiersUtils();
+
+	var ModifiersUtils = _interopRequireWildcard(_ModifiersUtils);
+
+	var _Helpers = requireHelpers();
+
+	var Helpers = _interopRequireWildcard(_Helpers);
+
+	var _DateUtils = requireDateUtils();
+
+	var DateUtils = _interopRequireWildcard(_DateUtils);
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var Month$1 = function (_Component) {
+	  _inherits(Month, _Component);
+
+	  function Month() {
+	    var _ref;
+
+	    var _temp, _this, _ret;
+
+	    _classCallCheck(this, Month);
+
+	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
+
+	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Month.__proto__ || Object.getPrototypeOf(Month)).call.apply(_ref, [this].concat(args))), _this), _this.renderDay = function (day) {
+	      var monthNumber = _this.props.month.getMonth();
+	      var propModifiers = Helpers.getModifiersFromProps(_this.props);
+	      var dayModifiers = ModifiersUtils.getModifiersForDay(day, propModifiers);
+	      if (DateUtils.isSameDay(day, new Date()) && !Object.prototype.hasOwnProperty.call(propModifiers, _this.props.classNames.today)) {
+	        dayModifiers.push(_this.props.classNames.today);
+	      }
+	      if (day.getMonth() !== monthNumber) {
+	        dayModifiers.push(_this.props.classNames.outside);
+	      }
+
+	      var isOutside = day.getMonth() !== monthNumber;
+	      var tabIndex = -1;
+	      // Focus on the first day of the month
+	      if (_this.props.onDayClick && !isOutside && day.getDate() === 1) {
+	        tabIndex = _this.props.tabIndex; // eslint-disable-line prefer-destructuring
+	      }
+	      var key = '' + day.getFullYear() + day.getMonth() + day.getDate();
+	      var modifiers = {};
+	      dayModifiers.forEach(function (modifier) {
+	        modifiers[modifier] = true;
+	      });
+
+	      return _react2.default.createElement(
+	        _Day2.default,
+	        {
+	          key: '' + (isOutside ? 'outside-' : '') + key,
+	          classNames: _this.props.classNames,
+	          day: day,
+	          modifiers: modifiers,
+	          modifiersStyles: _this.props.modifiersStyles,
+	          empty: isOutside && !_this.props.showOutsideDays && !_this.props.fixedWeeks,
+	          tabIndex: tabIndex,
+	          ariaLabel: _this.props.localeUtils.formatDay(day, _this.props.locale),
+	          ariaDisabled: isOutside || dayModifiers.indexOf(_this.props.classNames.disabled) > -1,
+	          ariaSelected: dayModifiers.indexOf(_this.props.classNames.selected) > -1,
+	          onClick: _this.props.onDayClick,
+	          onFocus: _this.props.onDayFocus,
+	          onKeyDown: _this.props.onDayKeyDown,
+	          onMouseEnter: _this.props.onDayMouseEnter,
+	          onMouseLeave: _this.props.onDayMouseLeave,
+	          onMouseDown: _this.props.onDayMouseDown,
+	          onMouseUp: _this.props.onDayMouseUp,
+	          onTouchEnd: _this.props.onDayTouchEnd,
+	          onTouchStart: _this.props.onDayTouchStart
+	        },
+	        _this.props.renderDay(day, modifiers)
+	      );
+	    }, _temp), _possibleConstructorReturn(_this, _ret);
+	  }
+
+	  _createClass(Month, [{
+	    key: 'render',
+	    value: function render() {
+	      var _this2 = this;
+
+	      var _props = this.props,
+	          classNames = _props.classNames,
+	          month = _props.month,
+	          months = _props.months,
+	          fixedWeeks = _props.fixedWeeks,
+	          captionElement = _props.captionElement,
+	          weekdayElement = _props.weekdayElement,
+	          locale = _props.locale,
+	          localeUtils = _props.localeUtils,
+	          weekdaysLong = _props.weekdaysLong,
+	          weekdaysShort = _props.weekdaysShort,
+	          firstDayOfWeek = _props.firstDayOfWeek,
+	          onCaptionClick = _props.onCaptionClick,
+	          showWeekNumbers = _props.showWeekNumbers,
+	          showWeekDays = _props.showWeekDays,
+	          onWeekClick = _props.onWeekClick;
+
+
+	      var captionProps = {
+	        date: month,
+	        classNames: classNames,
+	        months: months,
+	        localeUtils: localeUtils,
+	        locale: locale,
+	        onClick: onCaptionClick ? function (e) {
+	          return onCaptionClick(month, e);
+	        } : undefined
+	      };
+	      var caption = _react2.default.isValidElement(captionElement) ? _react2.default.cloneElement(captionElement, captionProps) : _react2.default.createElement(captionElement, captionProps);
+
+	      var weeks = Helpers.getWeekArray(month, firstDayOfWeek, fixedWeeks);
+	      return _react2.default.createElement(
+	        'div',
+	        { className: classNames.month, role: 'grid' },
+	        caption,
+	        showWeekDays && _react2.default.createElement(_Weekdays2.default, {
+	          classNames: classNames,
+	          weekdaysShort: weekdaysShort,
+	          weekdaysLong: weekdaysLong,
+	          firstDayOfWeek: firstDayOfWeek,
+	          showWeekNumbers: showWeekNumbers,
+	          locale: locale,
+	          localeUtils: localeUtils,
+	          weekdayElement: weekdayElement
+	        }),
+	        _react2.default.createElement(
+	          'div',
+	          { className: classNames.body, role: 'rowgroup' },
+	          weeks.map(function (week) {
+	            var weekNumber = void 0;
+	            if (showWeekNumbers) {
+	              weekNumber = DateUtils.getWeekNumber(week[6]);
+	            }
+	            return _react2.default.createElement(
+	              'div',
+	              {
+	                key: week[0].getTime(),
+	                className: classNames.week,
+	                role: 'row'
+	              },
+	              showWeekNumbers && _react2.default.createElement(
+	                'div',
+	                {
+	                  className: classNames.weekNumber,
+	                  tabIndex: onWeekClick ? 0 : -1,
+	                  role: 'gridcell',
+	                  onClick: onWeekClick ? function (e) {
+	                    return onWeekClick(weekNumber, week, e);
+	                  } : undefined,
+	                  onKeyUp: onWeekClick ? function (e) {
+	                    return e.keyCode === _keys.ENTER && onWeekClick(weekNumber, week, e);
+	                  } : undefined
+	                },
+	                _this2.props.renderWeek(weekNumber, week, month)
+	              ),
+	              week.map(_this2.renderDay)
+	            );
+	          })
+	        )
+	      );
+	    }
+	  }]);
+
+	  return Month;
+	}(_react.Component);
+
+	Month.default = Month$1;
+	
+	return Month;
+}
+
+var Weekday = {};
+
+var hasRequiredWeekday;
+
+function requireWeekday () {
+	if (hasRequiredWeekday) return Weekday;
+	hasRequiredWeekday = 1;
+
+	Object.defineProperty(Weekday, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var Weekday$1 = function (_Component) {
+	  _inherits(Weekday, _Component);
+
+	  function Weekday() {
+	    _classCallCheck(this, Weekday);
+
+	    return _possibleConstructorReturn(this, (Weekday.__proto__ || Object.getPrototypeOf(Weekday)).apply(this, arguments));
+	  }
+
+	  _createClass(Weekday, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props !== nextProps;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _props = this.props,
+	          weekday = _props.weekday,
+	          className = _props.className,
+	          weekdaysLong = _props.weekdaysLong,
+	          weekdaysShort = _props.weekdaysShort,
+	          localeUtils = _props.localeUtils,
+	          locale = _props.locale;
+
+	      var title = void 0;
+	      if (weekdaysLong) {
+	        title = weekdaysLong[weekday];
+	      } else {
+	        title = localeUtils.formatWeekdayLong(weekday, locale);
+	      }
+	      var content = void 0;
+	      if (weekdaysShort) {
+	        content = weekdaysShort[weekday];
+	      } else {
+	        content = localeUtils.formatWeekdayShort(weekday, locale);
+	      }
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: className, role: 'columnheader' },
+	        _react2.default.createElement(
+	          'abbr',
+	          { title: title },
+	          content
+	        )
+	      );
+	    }
+	  }]);
+
+	  return Weekday;
+	}(_react.Component);
+
+	Weekday.default = Weekday$1;
+	
+	return Weekday;
+}
+
+var hasRequiredDayPicker;
+
+function requireDayPicker () {
+	if (hasRequiredDayPicker) return DayPicker$1;
+	hasRequiredDayPicker = 1;
+
+	Object.defineProperty(DayPicker$1, "__esModule", {
+	  value: true
+	});
+	DayPicker$1.ModifiersUtils = DayPicker$1.LocaleUtils = DayPicker$1.DateUtils = DayPicker$1.DayPicker = undefined;
+
+	var _extends = Object.assign || 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; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = React__default;
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _Caption = requireCaption();
+
+	var _Caption2 = _interopRequireDefault(_Caption);
+
+	var _Navbar = requireNavbar();
+
+	var _Navbar2 = _interopRequireDefault(_Navbar);
+
+	var _Month = requireMonth();
+
+	var _Month2 = _interopRequireDefault(_Month);
+
+	var _Weekday = requireWeekday();
+
+	var _Weekday2 = _interopRequireDefault(_Weekday);
+
+	var _Helpers = requireHelpers();
+
+	var Helpers = _interopRequireWildcard(_Helpers);
+
+	var _DateUtils = requireDateUtils();
+
+	var DateUtils = _interopRequireWildcard(_DateUtils);
+
+	var _LocaleUtils = requireLocaleUtils();
+
+	var LocaleUtils = _interopRequireWildcard(_LocaleUtils);
+
+	var _ModifiersUtils = requireModifiersUtils();
+
+	var ModifiersUtils = _interopRequireWildcard(_ModifiersUtils);
+
+	var _classNames = requireClassNames();
+
+	var _classNames2 = _interopRequireDefault(_classNames);
+
+	var _keys = requireKeys();
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var DayPicker = DayPicker$1.DayPicker = function (_Component) {
+	  _inherits(DayPicker, _Component);
+
+	  function DayPicker(props) {
+	    _classCallCheck(this, DayPicker);
+
+	    var _this = _possibleConstructorReturn(this, (DayPicker.__proto__ || Object.getPrototypeOf(DayPicker)).call(this, props));
+
+	    _this.dayPicker = null;
+
+	    _this.showNextMonth = function (callback) {
+	      if (!_this.allowNextMonth()) {
+	        return;
+	      }
+	      var deltaMonths = _this.props.pagedNavigation ? _this.props.numberOfMonths : 1;
+	      var nextMonth = DateUtils.addMonths(_this.state.currentMonth, deltaMonths);
+	      _this.showMonth(nextMonth, callback);
+	    };
+
+	    _this.showPreviousMonth = function (callback) {
+	      if (!_this.allowPreviousMonth()) {
+	        return;
+	      }
+	      var deltaMonths = _this.props.pagedNavigation ? _this.props.numberOfMonths : 1;
+	      var previousMonth = DateUtils.addMonths(_this.state.currentMonth, -deltaMonths);
+	      _this.showMonth(previousMonth, callback);
+	    };
+
+	    _this.handleKeyDown = function (e) {
+	      e.persist();
+
+	      switch (e.keyCode) {
+	        case _keys.LEFT:
+	          if (_this.props.dir === 'rtl') {
+	            _this.showNextMonth();
+	          } else {
+	            _this.showPreviousMonth();
+	          }
+	          Helpers.cancelEvent(e);
+	          break;
+	        case _keys.RIGHT:
+	          if (_this.props.dir === 'rtl') {
+	            _this.showPreviousMonth();
+	          } else {
+	            _this.showNextMonth();
+	          }
+	          Helpers.cancelEvent(e);
+	          break;
+	        case _keys.UP:
+	          _this.showPreviousYear();
+	          Helpers.cancelEvent(e);
+	          break;
+	        case _keys.DOWN:
+	          _this.showNextYear();
+	          Helpers.cancelEvent(e);
+	          break;
+	      }
+
+	      if (_this.props.onKeyDown) {
+	        _this.props.onKeyDown(e);
+	      }
+	    };
+
+	    _this.handleDayKeyDown = function (day, modifiers, e) {
+	      e.persist();
+
+	      switch (e.keyCode) {
+	        case _keys.LEFT:
+	          Helpers.cancelEvent(e);
+	          if (_this.props.dir === 'rtl') {
+	            _this.focusNextDay(e.target);
+	          } else {
+	            _this.focusPreviousDay(e.target);
+	          }
+	          break;
+	        case _keys.RIGHT:
+	          Helpers.cancelEvent(e);
+	          if (_this.props.dir === 'rtl') {
+	            _this.focusPreviousDay(e.target);
+	          } else {
+	            _this.focusNextDay(e.target);
+	          }
+	          break;
+	        case _keys.UP:
+	          Helpers.cancelEvent(e);
+	          _this.focusPreviousWeek(e.target);
+	          break;
+	        case _keys.DOWN:
+	          Helpers.cancelEvent(e);
+	          _this.focusNextWeek(e.target);
+	          break;
+	        case _keys.ENTER:
+	        case _keys.SPACE:
+	          Helpers.cancelEvent(e);
+	          if (_this.props.onDayClick) {
+	            _this.handleDayClick(day, modifiers, e);
+	          }
+	          break;
+	      }
+	      if (_this.props.onDayKeyDown) {
+	        _this.props.onDayKeyDown(day, modifiers, e);
+	      }
+	    };
+
+	    _this.handleDayClick = function (day, modifiers, e) {
+	      e.persist();
+
+	      if (modifiers[_this.props.classNames.outside] && _this.props.enableOutsideDaysClick) {
+	        _this.handleOutsideDayClick(day);
+	      }
+	      if (_this.props.onDayClick) {
+	        _this.props.onDayClick(day, modifiers, e);
+	      }
+	    };
+
+	    _this.handleTodayButtonClick = function (e) {
+	      var today = new Date();
+	      var month = new Date(today.getFullYear(), today.getMonth());
+	      _this.showMonth(month);
+	      e.target.blur();
+	      if (_this.props.onTodayButtonClick) {
+	        e.persist();
+	        _this.props.onTodayButtonClick(new Date(today.getFullYear(), today.getMonth(), today.getDate()), ModifiersUtils.getModifiersForDay(today, _this.props.modifiers), e);
+	      }
+	    };
+
+	    var currentMonth = _this.getCurrentMonthFromProps(props);
+	    _this.state = { currentMonth: currentMonth };
+	    return _this;
+	  }
+
+	  _createClass(DayPicker, [{
+	    key: 'componentDidUpdate',
+	    value: function componentDidUpdate(prevProps) {
+	      // Changing the `month` props means changing the current displayed month
+	      if (prevProps.month !== this.props.month && !DateUtils.isSameMonth(prevProps.month, this.props.month)) {
+	        var currentMonth = this.getCurrentMonthFromProps(this.props);
+	        // eslint-disable-next-line react/no-did-update-set-state
+	        this.setState({ currentMonth: currentMonth });
+	      }
+	    }
+	  }, {
+	    key: 'getCurrentMonthFromProps',
+
+
+	    /**
+	     * Return the month to be shown in the calendar based on the component props.
+	     *
+	     * @param {Object} props
+	     * @returns Date
+	     * @memberof DayPicker
+	     * @private
+	     */
+	    value: function getCurrentMonthFromProps(props) {
+	      var initialMonth = Helpers.startOfMonth(props.month || props.initialMonth || new Date());
+	      var currentMonth = initialMonth;
+
+	      if (props.pagedNavigation && props.numberOfMonths > 1 && props.fromMonth) {
+	        var fromMonth = Helpers.startOfMonth(props.fromMonth);
+	        var diffInMonths = Helpers.getMonthsDiff(fromMonth, currentMonth);
+	        currentMonth = DateUtils.addMonths(fromMonth, Math.floor(diffInMonths / props.numberOfMonths) * props.numberOfMonths);
+	      } else if (props.toMonth && props.numberOfMonths > 1 && Helpers.getMonthsDiff(currentMonth, props.toMonth) <= 0) {
+	        currentMonth = DateUtils.addMonths(Helpers.startOfMonth(props.toMonth), 1 - this.props.numberOfMonths);
+	      }
+	      return currentMonth;
+	    }
+	  }, {
+	    key: 'getNextNavigableMonth',
+	    value: function getNextNavigableMonth() {
+	      return DateUtils.addMonths(this.state.currentMonth, this.props.numberOfMonths);
+	    }
+	  }, {
+	    key: 'getPreviousNavigableMonth',
+	    value: function getPreviousNavigableMonth() {
+	      return DateUtils.addMonths(this.state.currentMonth, -1);
+	    }
+	  }, {
+	    key: 'allowPreviousMonth',
+	    value: function allowPreviousMonth() {
+	      var previousMonth = DateUtils.addMonths(this.state.currentMonth, -1);
+	      return this.allowMonth(previousMonth);
+	    }
+	  }, {
+	    key: 'allowNextMonth',
+	    value: function allowNextMonth() {
+	      var nextMonth = DateUtils.addMonths(this.state.currentMonth, this.props.numberOfMonths);
+	      return this.allowMonth(nextMonth);
+	    }
+	  }, {
+	    key: 'allowMonth',
+	    value: function allowMonth(d) {
+	      var _props = this.props,
+	          fromMonth = _props.fromMonth,
+	          toMonth = _props.toMonth,
+	          canChangeMonth = _props.canChangeMonth;
+
+	      if (!canChangeMonth || fromMonth && Helpers.getMonthsDiff(fromMonth, d) < 0 || toMonth && Helpers.getMonthsDiff(toMonth, d) > 0) {
+	        return false;
+	      }
+	      return true;
+	    }
+	  }, {
+	    key: 'allowYearChange',
+	    value: function allowYearChange() {
+	      return this.props.canChangeMonth;
+	    }
+	  }, {
+	    key: 'showMonth',
+	    value: function showMonth(d, callback) {
+	      var _this2 = this;
+
+	      if (!this.allowMonth(d)) {
+	        return;
+	      }
+	      this.setState({ currentMonth: Helpers.startOfMonth(d) }, function () {
+	        if (callback) {
+	          callback();
+	        }
+	        if (_this2.props.onMonthChange) {
+	          _this2.props.onMonthChange(_this2.state.currentMonth);
+	        }
+	      });
+	    }
+	  }, {
+	    key: 'showNextYear',
+	    value: function showNextYear() {
+	      if (!this.allowYearChange()) {
+	        return;
+	      }
+	      var nextMonth = DateUtils.addMonths(this.state.currentMonth, 12);
+	      this.showMonth(nextMonth);
+	    }
+	  }, {
+	    key: 'showPreviousYear',
+	    value: function showPreviousYear() {
+	      if (!this.allowYearChange()) {
+	        return;
+	      }
+	      var nextMonth = DateUtils.addMonths(this.state.currentMonth, -12);
+	      this.showMonth(nextMonth);
+	    }
+	  }, {
+	    key: 'focus',
+	    value: function focus() {
+	      this.wrapper.focus();
+	    }
+	  }, {
+	    key: 'focusFirstDayOfMonth',
+	    value: function focusFirstDayOfMonth() {
+	      Helpers.getDayNodes(this.dayPicker, this.props.classNames)[0].focus();
+	    }
+	  }, {
+	    key: 'focusLastDayOfMonth',
+	    value: function focusLastDayOfMonth() {
+	      var dayNodes = Helpers.getDayNodes(this.dayPicker, this.props.classNames);
+	      dayNodes[dayNodes.length - 1].focus();
+	    }
+	  }, {
+	    key: 'focusPreviousDay',
+	    value: function focusPreviousDay(dayNode) {
+	      var _this3 = this;
+
+	      var dayNodes = Helpers.getDayNodes(this.dayPicker, this.props.classNames);
+	      var dayNodeIndex = Helpers.nodeListToArray(dayNodes).indexOf(dayNode);
+	      if (dayNodeIndex === -1) return;
+	      if (dayNodeIndex === 0) {
+	        this.showPreviousMonth(function () {
+	          return _this3.focusLastDayOfMonth();
+	        });
+	      } else {
+	        dayNodes[dayNodeIndex - 1].focus();
+	      }
+	    }
+	  }, {
+	    key: 'focusNextDay',
+	    value: function focusNextDay(dayNode) {
+	      var _this4 = this;
+
+	      var dayNodes = Helpers.getDayNodes(this.dayPicker, this.props.classNames);
+	      var dayNodeIndex = Helpers.nodeListToArray(dayNodes).indexOf(dayNode);
+	      if (dayNodeIndex === -1) return;
+	      if (dayNodeIndex === dayNodes.length - 1) {
+	        this.showNextMonth(function () {
+	          return _this4.focusFirstDayOfMonth();
+	        });
+	      } else {
+	        dayNodes[dayNodeIndex + 1].focus();
+	      }
+	    }
+	  }, {
+	    key: 'focusNextWeek',
+	    value: function focusNextWeek(dayNode) {
+	      var _this5 = this;
+
+	      var dayNodes = Helpers.getDayNodes(this.dayPicker, this.props.classNames);
+	      var dayNodeIndex = Helpers.nodeListToArray(dayNodes).indexOf(dayNode);
+	      var isInLastWeekOfMonth = dayNodeIndex > dayNodes.length - 8;
+
+	      if (isInLastWeekOfMonth) {
+	        this.showNextMonth(function () {
+	          var daysAfterIndex = dayNodes.length - dayNodeIndex;
+	          var nextMonthDayNodeIndex = 7 - daysAfterIndex;
+	          Helpers.getDayNodes(_this5.dayPicker, _this5.props.classNames)[nextMonthDayNodeIndex].focus();
+	        });
+	      } else {
+	        dayNodes[dayNodeIndex + 7].focus();
+	      }
+	    }
+	  }, {
+	    key: 'focusPreviousWeek',
+	    value: function focusPreviousWeek(dayNode) {
+	      var _this6 = this;
+
+	      var dayNodes = Helpers.getDayNodes(this.dayPicker, this.props.classNames);
+	      var dayNodeIndex = Helpers.nodeListToArray(dayNodes).indexOf(dayNode);
+	      var isInFirstWeekOfMonth = dayNodeIndex <= 6;
+
+	      if (isInFirstWeekOfMonth) {
+	        this.showPreviousMonth(function () {
+	          var previousMonthDayNodes = Helpers.getDayNodes(_this6.dayPicker, _this6.props.classNames);
+	          var startOfLastWeekOfMonth = previousMonthDayNodes.length - 7;
+	          var previousMonthDayNodeIndex = startOfLastWeekOfMonth + dayNodeIndex;
+	          previousMonthDayNodes[previousMonthDayNodeIndex].focus();
+	        });
+	      } else {
+	        dayNodes[dayNodeIndex - 7].focus();
+	      }
+	    }
+
+	    // Event handlers
+
+	  }, {
+	    key: 'handleOutsideDayClick',
+	    value: function handleOutsideDayClick(day) {
+	      var currentMonth = this.state.currentMonth;
+	      var numberOfMonths = this.props.numberOfMonths;
+
+	      var diffInMonths = Helpers.getMonthsDiff(currentMonth, day);
+	      if (diffInMonths > 0 && diffInMonths >= numberOfMonths) {
+	        this.showNextMonth();
+	      } else if (diffInMonths < 0) {
+	        this.showPreviousMonth();
+	      }
+	    }
+	  }, {
+	    key: 'renderNavbar',
+	    value: function renderNavbar() {
+	      var _props2 = this.props,
+	          labels = _props2.labels,
+	          locale = _props2.locale,
+	          localeUtils = _props2.localeUtils,
+	          canChangeMonth = _props2.canChangeMonth,
+	          navbarElement = _props2.navbarElement,
+	          attributes = _objectWithoutProperties(_props2, ['labels', 'locale', 'localeUtils', 'canChangeMonth', 'navbarElement']);
+
+	      if (!canChangeMonth) return null;
+
+	      var props = {
+	        month: this.state.currentMonth,
+	        classNames: this.props.classNames,
+	        className: this.props.classNames.navBar,
+	        nextMonth: this.getNextNavigableMonth(),
+	        previousMonth: this.getPreviousNavigableMonth(),
+	        showPreviousButton: this.allowPreviousMonth(),
+	        showNextButton: this.allowNextMonth(),
+	        onNextClick: this.showNextMonth,
+	        onPreviousClick: this.showPreviousMonth,
+	        dir: attributes.dir,
+	        labels: labels,
+	        locale: locale,
+	        localeUtils: localeUtils
+	      };
+	      return _react2.default.isValidElement(navbarElement) ? _react2.default.cloneElement(navbarElement, props) : _react2.default.createElement(navbarElement, props);
+	    }
+	  }, {
+	    key: 'renderMonths',
+	    value: function renderMonths() {
+	      var months = [];
+	      var firstDayOfWeek = Helpers.getFirstDayOfWeekFromProps(this.props);
+	      for (var i = 0; i < this.props.numberOfMonths; i += 1) {
+	        var month = DateUtils.addMonths(this.state.currentMonth, i);
+	        months.push(_react2.default.createElement(_Month2.default, _extends({
+	          key: i
+	        }, this.props, {
+	          month: month,
+	          firstDayOfWeek: firstDayOfWeek,
+	          onDayKeyDown: this.handleDayKeyDown,
+	          onDayClick: this.handleDayClick
+	        })));
+	      }
+
+	      if (this.props.reverseMonths) {
+	        months.reverse();
+	      }
+	      return months;
+	    }
+	  }, {
+	    key: 'renderFooter',
+	    value: function renderFooter() {
+	      if (this.props.todayButton) {
+	        return _react2.default.createElement(
+	          'div',
+	          { className: this.props.classNames.footer },
+	          this.renderTodayButton()
+	        );
+	      }
+	      return null;
+	    }
+	  }, {
+	    key: 'renderTodayButton',
+	    value: function renderTodayButton() {
+	      return _react2.default.createElement(
+	        'button',
+	        {
+	          type: 'button',
+	          tabIndex: 0,
+	          className: this.props.classNames.todayButton,
+	          'aria-label': this.props.todayButton,
+	          onClick: this.handleTodayButtonClick
+	        },
+	        this.props.todayButton
+	      );
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _this7 = this;
+
+	      var className = this.props.classNames.container;
+
+	      if (!this.props.onDayClick) {
+	        className = className + ' ' + this.props.classNames.interactionDisabled;
+	      }
+	      if (this.props.className) {
+	        className = className + ' ' + this.props.className;
+	      }
+	      return _react2.default.createElement(
+	        'div',
+	        _extends({}, this.props.containerProps, {
+	          className: className,
+	          ref: function ref(el) {
+	            return _this7.dayPicker = el;
+	          },
+	          lang: this.props.locale
+	        }),
+	        _react2.default.createElement(
+	          'div',
+	          {
+	            className: this.props.classNames.wrapper,
+	            ref: function ref(el) {
+	              return _this7.wrapper = el;
+	            },
+	            tabIndex: this.props.canChangeMonth && typeof this.props.tabIndex !== 'undefined' ? this.props.tabIndex : -1,
+	            onKeyDown: this.handleKeyDown,
+	            onFocus: this.props.onFocus,
+	            onBlur: this.props.onBlur
+	          },
+	          this.renderNavbar(),
+	          _react2.default.createElement(
+	            'div',
+	            { className: this.props.classNames.months },
+	            this.renderMonths()
+	          ),
+	          this.renderFooter()
+	        )
+	      );
+	    }
+	  }]);
+
+	  return DayPicker;
+	}(_react.Component);
+
+	DayPicker.defaultProps = {
+	  classNames: _classNames2.default,
+	  tabIndex: 0,
+	  numberOfMonths: 1,
+	  labels: {
+	    previousMonth: 'Previous Month',
+	    nextMonth: 'Next Month'
+	  },
+	  locale: 'en',
+	  localeUtils: LocaleUtils,
+	  showOutsideDays: false,
+	  enableOutsideDaysClick: true,
+	  fixedWeeks: false,
+	  canChangeMonth: true,
+	  reverseMonths: false,
+	  pagedNavigation: false,
+	  showWeekNumbers: false,
+	  showWeekDays: true,
+	  renderDay: function renderDay(day) {
+	    return day.getDate();
+	  },
+	  renderWeek: function renderWeek(weekNumber) {
+	    return weekNumber;
+	  },
+	  weekdayElement: _react2.default.createElement(_Weekday2.default, null),
+	  navbarElement: _react2.default.createElement(_Navbar2.default, { classNames: _classNames2.default }),
+	  captionElement: _react2.default.createElement(_Caption2.default, { classNames: _classNames2.default })
+	};
+	DayPicker.VERSION = '7.4.10';
+
+
+	DayPicker.DateUtils = DateUtils;
+	DayPicker.LocaleUtils = LocaleUtils;
+	DayPicker.ModifiersUtils = ModifiersUtils;
+
+	DayPicker$1.DateUtils = DateUtils;
+	DayPicker$1.LocaleUtils = LocaleUtils;
+	DayPicker$1.ModifiersUtils = ModifiersUtils;
+	DayPicker$1.default = DayPicker;
+	
+	return DayPicker$1;
+}
+
+var hasRequiredBuild;
+
+function requireBuild () {
+	if (hasRequiredBuild) return build;
+	hasRequiredBuild = 1;
+	(function (exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+
+		var _DayPicker = requireDayPicker();
+
+		Object.defineProperty(exports$1, 'default', {
+		  enumerable: true,
+		  get: function get() {
+		    return _interopRequireDefault(_DayPicker).default;
+		  }
+		});
+
+		var _DateUtils = requireDateUtils();
+
+		Object.defineProperty(exports$1, 'DateUtils', {
+		  enumerable: true,
+		  get: function get() {
+		    return _interopRequireDefault(_DateUtils).default;
+		  }
+		});
+
+		var _LocaleUtils = requireLocaleUtils();
+
+		Object.defineProperty(exports$1, 'LocaleUtils', {
+		  enumerable: true,
+		  get: function get() {
+		    return _interopRequireDefault(_LocaleUtils).default;
+		  }
+		});
+
+		var _ModifiersUtils = requireModifiersUtils();
+
+		Object.defineProperty(exports$1, 'ModifiersUtils', {
+		  enumerable: true,
+		  get: function get() {
+		    return _interopRequireDefault(_ModifiersUtils).default;
+		  }
+		});
+
+		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+		
+	} (build));
+	return build;
+}
+
+var buildExports = requireBuild();
+var DayPicker = /*@__PURE__*/getDefaultExportFromCjs(buildExports);
+
+var css_248z = ".style-module_container__3SY_g {\n  position: relative;\n}";
+var styles = {"container":"style-module_container__3SY_g"};
+styleInject(css_248z);
+
+var Calendar = function (_a) {
+    var _b, _c;
+    var dateFormat = _a.dateFormat, value = _a.value, onChange = _a.onChange, yearBoundaries = _a.yearBoundaries, displayCalendar = _a.displayCalendar, dayjsLocale = _a.dayjsLocale, firstDayOfWeek = _a.firstDayOfWeek, setCalendarOpen = _a.setCalendarOpen, isOpen = _a.isOpen, defaultDayPickerDate = _a.defaultDayPickerDate;
+    var localeDate = dayjsLocale
+        ? dayjs().locale(dayjsLocale).localeData()
+        : dayjs().locale('en').localeData();
+    var localizedWeekdays = localeDate.weekdays();
+    var localizedWeekdaysShort = localeDate.weekdaysMin();
+    var localizedMonths = localeDate.months();
+    var calendarContainerRef = useRef(null);
+    var _d = useState(undefined), displayedMonth = _d[0], setDisplayedMonth = _d[1];
+    var calendarDefaultDate = defaultDayPickerDate
+        ? dayjs(defaultDayPickerDate).toDate()
+        : dayjs().year() >= yearBoundaries.min && dayjs().year() <= yearBoundaries.max
+            ? dayjs().toDate()
+            : dayjs().set('year', yearBoundaries.max).toDate();
+    var selectedDateInDateType = value
+        ? dayjs(value).toDate()
+        : undefined;
+    var dateCalendarFromMonth = dayjs(String(yearBoundaries.min))
+        .startOf('year')
+        .toDate();
+    var dateCalendarToMonth = dayjs(String(yearBoundaries.max))
+        .endOf('year')
+        .toDate();
+    var currentMonth = (_b = displayedMonth !== null && displayedMonth !== void 0 ? displayedMonth : selectedDateInDateType) !== null && _b !== void 0 ? _b : calendarDefaultDate;
+    var handlePrevMonth = function () {
+        var prev = new Date(currentMonth);
+        prev.setMonth(prev.getMonth() - 1);
+        setDisplayedMonth(prev);
+    };
+    var handleNextMonth = function () {
+        var next = new Date(currentMonth);
+        next.setMonth(next.getMonth() + 1);
+        setDisplayedMonth(next);
+    };
+    useOnClickOutside(calendarContainerRef, function () { return setCalendarOpen(false); });
+    if (!displayCalendar) {
+        return null;
+    }
+    return (jsxs("div", { className: "".concat(styles.container, " ml8"), ref: calendarContainerRef, children: [jsx(Button, { onClick: function () { return setCalendarOpen(!isOpen); }, "data-testid": "calendar-button", hideLabel: true, variant: 'textBlack', type: "button", children: jsx(CalendarIcon, { size: 24 }) }), isOpen && (jsx(DayPicker, { month: (_c = displayedMonth !== null && displayedMonth !== void 0 ? displayedMonth : selectedDateInDateType) !== null && _c !== void 0 ? _c : calendarDefaultDate, showOutsideDays: true, fromMonth: dateCalendarFromMonth, toMonth: dateCalendarToMonth, selectedDays: selectedDateInDateType, onDayClick: function (date) {
+                    if (!dayjs(date).isValid()) {
+                        return;
+                    }
+                    if (dayjs(date).isAfter(dateCalendarFromMonth) ||
+                        dayjs(date).isBefore(dateCalendarToMonth)) {
+                        var selectedDate = dayjs(date).format(dateFormat);
+                        onChange(selectedDate);
+                        setCalendarOpen(false);
+                    }
+                }, navbarElement: function () { return null; }, onMonthChange: function (month) { return setDisplayedMonth(month); }, captionElement: function (_a) {
+                    var date = _a.date;
+                    return (jsx(CalendarCaption, { date: date, months: localizedMonths, yearBoundaries: yearBoundaries, onMonthChange: function (newDate) { return setDisplayedMonth(newDate); }, onPrevClick: handlePrevMonth, onNextClick: handleNextMonth }));
+                }, pagedNavigation: true, disabledDays: {
+                    before: dateCalendarFromMonth,
+                    after: dateCalendarToMonth,
+                }, firstDayOfWeek: firstDayOfWeek, locale: (dayjsLocale === null || dayjsLocale === void 0 ? void 0 : dayjsLocale.name) || 'en', months: localizedMonths, weekdaysLong: localizedWeekdays, weekdaysShort: localizedWeekdaysShort }))] }));
+};
+
+export { Calendar as C, dayjs as d, requireDayjs_min as r };
+//# sourceMappingURL=Calendar-OjEwgyw8.js.map