text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("react"));
  	else if(typeof define === 'function' && define.amd)
  		define(["react"], factory);
  	else if(typeof exports === 'object')
  		exports["DayPicker"] = factory(require("react"));
  	else
  		root["DayPicker"] = factory(root["React"]);
  })(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_1__) {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 10);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports) {
  
  // shim for using process in browser
  var process = module.exports = {};
  
  // cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  
  var cachedSetTimeout;
  var cachedClearTimeout;
  
  function defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      if (!draining || !currentQueue) {
          return;
      }
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;
  
      var len = queue.length;
      while(len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
              if (currentQueue) {
                  currentQueue[queueIndex].run();
              }
          }
          queueIndex = -1;
          len = queue.length;
      }
      currentQueue = null;
      draining = false;
      runClearTimeout(timeout);
  }
  
  process.nextTick = function (fun) {
      var args = new Array(arguments.length - 1);
      if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
          }
      }
      queue.push(new Item(fun, args));
      if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
      }
  };
  
  // v8 likes predictible objects
  function Item(fun, array) {
      this.fun = fun;
      this.array = array;
  }
  Item.prototype.run = function () {
      this.fun.apply(null, this.array);
  };
  process.title = 'browser';
  process.browser = true;
  process.env = {};
  process.argv = [];
  process.version = ''; // empty string to avoid regexp issues
  process.versions = {};
  
  function noop() {}
  
  process.on = noop;
  process.addListener = noop;
  process.once = noop;
  process.off = noop;
  process.removeListener = noop;
  process.removeAllListeners = noop;
  process.emit = noop;
  process.prependListener = noop;
  process.prependOnceListener = noop;
  
  process.listeners = function (name) { return [] }
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports) {
  
  // empty (null-loader)
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.clone = clone;
  exports.isDate = isDate;
  exports.addMonths = addMonths;
  exports.isSameDay = isSameDay;
  exports.isSameMonth = isSameMonth;
  exports.isDayBefore = isDayBefore;
  exports.isDayAfter = isDayAfter;
  exports.isPastDay = isPastDay;
  exports.isFutureDay = isFutureDay;
  exports.isDayBetween = isDayBetween;
  exports.addDayToRange = addDayToRange;
  exports.isDayInRange = isDayInRange;
  exports.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 {[type]} d
   * @param {[type]} 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);
  }
  
  exports.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
  };
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var LEFT = exports.LEFT = 37;
  var UP = exports.UP = 38;
  var RIGHT = exports.RIGHT = 39;
  var DOWN = exports.DOWN = 40;
  var ENTER = exports.ENTER = 13;
  var SPACE = exports.SPACE = 32;
  var ESC = exports.ESC = 27;
  var TAB = exports.TAB = 9;
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  // Proxy object to map classnames when css modules are not used
  
  exports.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'
  };
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__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; };
  
  exports.cancelEvent = cancelEvent;
  exports.getFirstDayOfMonth = getFirstDayOfMonth;
  exports.getDaysInMonth = getDaysInMonth;
  exports.getModifiersFromProps = getModifiersFromProps;
  exports.getFirstDayOfWeekFromProps = getFirstDayOfWeekFromProps;
  exports.isRangeOfDates = isRangeOfDates;
  exports.getMonthsDiff = getMonthsDiff;
  exports.getWeekArray = getWeekArray;
  exports.startOfMonth = startOfMonth;
  exports.getDayNodes = getDayNodes;
  exports.nodeListToArray = nodeListToArray;
  exports.hasOwnProp = hasOwnProp;
  
  var _DateUtils = __webpack_require__(3);
  
  var _LocaleUtils = __webpack_require__(7);
  
  var _classNames = __webpack_require__(5);
  
  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);
  }
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.formatDay = formatDay;
  exports.formatMonthTitle = formatMonthTitle;
  exports.formatWeekdayShort = formatWeekdayShort;
  exports.formatWeekdayLong = formatWeekdayLong;
  exports.getFirstDayOfWeek = getFirstDayOfWeek;
  exports.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;
  }
  
  exports.default = {
    formatDay: formatDay,
    formatMonthTitle: formatMonthTitle,
    formatWeekdayShort: formatWeekdayShort,
    formatWeekdayLong: formatWeekdayLong,
    getFirstDayOfWeek: getFirstDayOfWeek,
    getMonths: getMonths
  };
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.dayMatchesModifier = dayMatchesModifier;
  exports.getModifiersForDay = getModifiersForDay;
  
  var _DateUtils = __webpack_require__(3);
  
  var _Helpers = __webpack_require__(6);
  
  /**
   * 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;
    }, []);
  }
  
  exports.default = { dayMatchesModifier: dayMatchesModifier, getModifiersForDay: getModifiersForDay };
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.ModifiersUtils = exports.LocaleUtils = exports.DateUtils = exports.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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _Caption = __webpack_require__(11);
  
  var _Caption2 = _interopRequireDefault(_Caption);
  
  var _Navbar = __webpack_require__(12);
  
  var _Navbar2 = _interopRequireDefault(_Navbar);
  
  var _Month = __webpack_require__(13);
  
  var _Month2 = _interopRequireDefault(_Month);
  
  var _Weekday = __webpack_require__(16);
  
  var _Weekday2 = _interopRequireDefault(_Weekday);
  
  var _Helpers = __webpack_require__(6);
  
  var Helpers = _interopRequireWildcard(_Helpers);
  
  var _DateUtils = __webpack_require__(3);
  
  var DateUtils = _interopRequireWildcard(_DateUtils);
  
  var _LocaleUtils = __webpack_require__(7);
  
  var LocaleUtils = _interopRequireWildcard(_LocaleUtils);
  
  var _ModifiersUtils = __webpack_require__(8);
  
  var ModifiersUtils = _interopRequireWildcard(_ModifiersUtils);
  
  var _classNames = __webpack_require__(5);
  
  var _classNames2 = _interopRequireDefault(_classNames);
  
  var _keys = __webpack_require__(4);
  
  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 = exports.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:
            _this.showPreviousMonth();
            break;
          case _keys.RIGHT:
            _this.showNextMonth();
            break;
          case _keys.UP:
            _this.showPreviousYear();
            break;
          case _keys.DOWN:
            _this.showNextYear();
            break;
          default:
            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);
            _this.focusPreviousDay(e.target);
            break;
          case _keys.RIGHT:
            Helpers.cancelEvent(e);
            _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;
          default:
            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 });
        }
      }
  
      /**
       * Return the month to be shown in the calendar based on the component props.
       *
       * @param {Object} props
       * @returns Date
       * @memberof DayPicker
       * @private
       */
  
    }, {
      key: 'getCurrentMonthFromProps',
      value: function getCurrentMonthFromProps(props) {
        var initialMonth = Helpers.startOfMonth(props.month || props.initialMonth);
        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: '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,
              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.VERSION = '7.2.4';
  DayPicker.defaultProps = {
    classNames: _classNames2.default,
    tabIndex: 0,
    initialMonth: new Date(),
    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.propTypes = process.env.NODE_ENV !== "production" ? {
    // Rendering months
    initialMonth: _propTypes2.default.instanceOf(Date),
    month: _propTypes2.default.instanceOf(Date),
    numberOfMonths: _propTypes2.default.number,
    fromMonth: _propTypes2.default.instanceOf(Date),
    toMonth: _propTypes2.default.instanceOf(Date),
    canChangeMonth: _propTypes2.default.bool,
    reverseMonths: _propTypes2.default.bool,
    pagedNavigation: _propTypes2.default.bool,
    todayButton: _propTypes2.default.string,
    showWeekNumbers: _propTypes2.default.bool,
    showWeekDays: _propTypes2.default.bool,
  
    // Modifiers
    selectedDays: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func, _propTypes2.default.array]),
    disabledDays: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func, _propTypes2.default.array]),
  
    modifiers: _propTypes2.default.object,
    modifiersStyles: _propTypes2.default.object,
  
    // Localization
    dir: _propTypes2.default.string,
    firstDayOfWeek: _propTypes2.default.oneOf([0, 1, 2, 3, 4, 5, 6]),
    labels: _propTypes2.default.shape({
      nextMonth: _propTypes2.default.string.isRequired,
      previousMonth: _propTypes2.default.string.isRequired
    }),
    locale: _propTypes2.default.string,
    localeUtils: _propTypes2.default.shape({
      formatMonthTitle: _propTypes2.default.func,
      formatWeekdayShort: _propTypes2.default.func,
      formatWeekdayLong: _propTypes2.default.func,
      getFirstDayOfWeek: _propTypes2.default.func
    }),
    months: _propTypes2.default.arrayOf(_propTypes2.default.string),
    weekdaysLong: _propTypes2.default.arrayOf(_propTypes2.default.string),
    weekdaysShort: _propTypes2.default.arrayOf(_propTypes2.default.string),
  
    // Customization
    showOutsideDays: _propTypes2.default.bool,
    enableOutsideDaysClick: _propTypes2.default.bool,
    fixedWeeks: _propTypes2.default.bool,
  
    // CSS and HTML
    classNames: _propTypes2.default.shape({
      body: _propTypes2.default.string,
      container: _propTypes2.default.string,
      day: _propTypes2.default.string.isRequired,
      disabled: _propTypes2.default.string.isRequired,
      footer: _propTypes2.default.string,
      interactionDisabled: _propTypes2.default.string,
      months: _propTypes2.default.string,
      month: _propTypes2.default.string,
      navBar: _propTypes2.default.string,
      outside: _propTypes2.default.string.isRequired,
      selected: _propTypes2.default.string.isRequired,
      today: _propTypes2.default.string.isRequired,
      todayButton: _propTypes2.default.string,
      week: _propTypes2.default.string,
      wrapper: _propTypes2.default.string
    }),
    className: _propTypes2.default.string,
    containerProps: _propTypes2.default.object,
    tabIndex: _propTypes2.default.number,
  
    // Custom elements
    renderDay: _propTypes2.default.func,
    renderWeek: _propTypes2.default.func,
    weekdayElement: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func, _propTypes2.default.instanceOf(_react.Component)]),
    navbarElement: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func, _propTypes2.default.instanceOf(_react.Component)]),
    captionElement: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func, _propTypes2.default.instanceOf(_react.Component)]),
  
    // Events
    onBlur: _propTypes2.default.func,
    onFocus: _propTypes2.default.func,
    onKeyDown: _propTypes2.default.func,
    onDayClick: _propTypes2.default.func,
    onDayKeyDown: _propTypes2.default.func,
    onDayMouseEnter: _propTypes2.default.func,
    onDayMouseLeave: _propTypes2.default.func,
    onDayMouseDown: _propTypes2.default.func,
    onDayMouseUp: _propTypes2.default.func,
    onDayTouchStart: _propTypes2.default.func,
    onDayTouchEnd: _propTypes2.default.func,
    onDayFocus: _propTypes2.default.func,
    onMonthChange: _propTypes2.default.func,
    onCaptionClick: _propTypes2.default.func,
    onWeekClick: _propTypes2.default.func,
    onTodayButtonClick: _propTypes2.default.func
  } : {};
  
  
  DayPicker.DateUtils = DateUtils;
  DayPicker.LocaleUtils = LocaleUtils;
  DayPicker.ModifiersUtils = ModifiersUtils;
  
  exports.DateUtils = DateUtils;
  exports.LocaleUtils = LocaleUtils;
  exports.ModifiersUtils = ModifiersUtils;
  exports.default = DayPicker;
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /*
    Used to create /lib/daypicker.min.js (e.g. for unpkg)
  */
  
  /* eslint-disable no-var */
  /* eslint-env node */
  
  var DayPicker = __webpack_require__(9).default;
  DayPicker.Input = __webpack_require__(17).default;
  
  module.exports = DayPicker;
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _LocaleUtils = __webpack_require__(7);
  
  var _LocaleUtils2 = _interopRequireDefault(_LocaleUtils);
  
  var _keys = __webpack_require__(4);
  
  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 = 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' },
          _react2.default.createElement(
            'div',
            { onClick: onClick, onKeyUp: this.handleKeyUp },
            months ? months[date.getMonth()] + ' ' + date.getFullYear() : localeUtils.formatMonthTitle(date, locale)
          )
        );
      }
    }]);
  
    return Caption;
  }(_react.Component);
  
  Caption.defaultProps = {
    localeUtils: _LocaleUtils2.default
  };
  exports.default = Caption;
  Caption.propTypes = process.env.NODE_ENV !== "production" ? {
    date: _propTypes2.default.instanceOf(Date),
    months: _propTypes2.default.arrayOf(_propTypes2.default.string),
    locale: _propTypes2.default.string,
    localeUtils: _propTypes2.default.object,
    onClick: _propTypes2.default.func,
    classNames: _propTypes2.default.shape({
      caption: _propTypes2.default.string.isRequired
    }).isRequired
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _classNames = __webpack_require__(5);
  
  var _classNames2 = _interopRequireDefault(_classNames);
  
  var _keys = __webpack_require__(4);
  
  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 = 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.defaultProps = {
    classNames: _classNames2.default,
    dir: 'ltr',
    labels: {
      previousMonth: 'Previous Month',
      nextMonth: 'Next Month'
    },
    showPreviousButton: true,
    showNextButton: true
  };
  exports.default = Navbar;
  Navbar.propTypes = process.env.NODE_ENV !== "production" ? {
    classNames: _propTypes2.default.shape({
      navBar: _propTypes2.default.string.isRequired,
      navButtonPrev: _propTypes2.default.string.isRequired,
      navButtonNext: _propTypes2.default.string.isRequired
    }),
    className: _propTypes2.default.string,
    showPreviousButton: _propTypes2.default.bool,
    showNextButton: _propTypes2.default.bool,
    onPreviousClick: _propTypes2.default.func,
    onNextClick: _propTypes2.default.func,
    dir: _propTypes2.default.string,
    labels: _propTypes2.default.shape({
      previousMonth: _propTypes2.default.string.isRequired,
      nextMonth: _propTypes2.default.string.isRequired
    })
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _Weekdays = __webpack_require__(14);
  
  var _Weekdays2 = _interopRequireDefault(_Weekdays);
  
  var _Day = __webpack_require__(15);
  
  var _Day2 = _interopRequireDefault(_Day);
  
  var _keys = __webpack_require__(4);
  
  var _ModifiersUtils = __webpack_require__(8);
  
  var ModifiersUtils = _interopRequireWildcard(_ModifiersUtils);
  
  var _Helpers = __webpack_require__(6);
  
  var Helpers = _interopRequireWildcard(_Helpers);
  
  var _DateUtils = __webpack_require__(3);
  
  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 = 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('disabled') > -1,
            ariaSelected: dayModifiers.indexOf('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: 0,
                    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);
  
  exports.default = Month;
  Month.propTypes = process.env.NODE_ENV !== "production" ? {
    classNames: _propTypes2.default.shape({
      body: _propTypes2.default.string.isRequired,
      month: _propTypes2.default.string.isRequired,
      outside: _propTypes2.default.string.isRequired,
      today: _propTypes2.default.string.isRequired,
      week: _propTypes2.default.string.isRequired
    }).isRequired,
    tabIndex: _propTypes2.default.number,
  
    month: _propTypes2.default.instanceOf(Date).isRequired,
    months: _propTypes2.default.arrayOf(_propTypes2.default.string),
  
    modifiersStyles: _propTypes2.default.object,
  
    showWeekDays: _propTypes2.default.bool,
    showOutsideDays: _propTypes2.default.bool,
  
    renderDay: _propTypes2.default.func.isRequired,
    renderWeek: _propTypes2.default.func.isRequired,
  
    captionElement: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func, _propTypes2.default.instanceOf(_react2.default.Component)]).isRequired,
    weekdayElement: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func, _propTypes2.default.instanceOf(_react2.default.Component)]),
  
    fixedWeeks: _propTypes2.default.bool,
    showWeekNumbers: _propTypes2.default.bool,
  
    locale: _propTypes2.default.string.isRequired,
    localeUtils: _propTypes2.default.object.isRequired,
    weekdaysLong: _propTypes2.default.arrayOf(_propTypes2.default.string),
    weekdaysShort: _propTypes2.default.arrayOf(_propTypes2.default.string),
    firstDayOfWeek: _propTypes2.default.number.isRequired,
  
    onCaptionClick: _propTypes2.default.func,
    onDayClick: _propTypes2.default.func,
    onDayFocus: _propTypes2.default.func,
    onDayKeyDown: _propTypes2.default.func,
    onDayMouseEnter: _propTypes2.default.func,
    onDayMouseLeave: _propTypes2.default.func,
    onDayMouseDown: _propTypes2.default.func,
    onDayMouseUp: _propTypes2.default.func,
    onDayTouchEnd: _propTypes2.default.func,
    onDayTouchStart: _propTypes2.default.func,
    onWeekClick: _propTypes2.default.func
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  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 = 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);
  
  exports.default = Weekdays;
  Weekdays.propTypes = process.env.NODE_ENV !== "production" ? {
    classNames: _propTypes2.default.shape({
      weekday: _propTypes2.default.string.isRequired,
      weekdays: _propTypes2.default.string.isRequired,
      weekdaysRow: _propTypes2.default.string.isRequired
    }).isRequired,
  
    firstDayOfWeek: _propTypes2.default.number.isRequired,
    weekdaysLong: _propTypes2.default.arrayOf(_propTypes2.default.string),
    weekdaysShort: _propTypes2.default.arrayOf(_propTypes2.default.string),
    showWeekNumbers: _propTypes2.default.bool,
    locale: _propTypes2.default.string.isRequired,
    localeUtils: _propTypes2.default.object.isRequired,
    weekdayElement: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func, _propTypes2.default.instanceOf(_react2.default.Component)])
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _DateUtils = __webpack_require__(3);
  
  var _Helpers = __webpack_require__(6);
  
  var _classNames = __webpack_require__(5);
  
  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 = 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.defaultProps = {
    tabIndex: -1
  };
  Day.defaultProps = {
    modifiers: {},
    modifiersStyles: {},
    empty: false
  };
  exports.default = Day;
  Day.propTypes = process.env.NODE_ENV !== "production" ? {
    classNames: _propTypes2.default.shape({
      day: _propTypes2.default.string.isRequired
    }).isRequired,
  
    day: _propTypes2.default.instanceOf(Date).isRequired,
    children: _propTypes2.default.node.isRequired,
  
    ariaDisabled: _propTypes2.default.bool,
    ariaLabel: _propTypes2.default.string,
    ariaSelected: _propTypes2.default.bool,
    empty: _propTypes2.default.bool,
    modifiers: _propTypes2.default.object,
    modifiersStyles: _propTypes2.default.object,
    onClick: _propTypes2.default.func,
    onKeyDown: _propTypes2.default.func,
    onMouseEnter: _propTypes2.default.func,
    onMouseLeave: _propTypes2.default.func,
    onMouseDown: _propTypes2.default.func,
    onMouseUp: _propTypes2.default.func,
    onTouchEnd: _propTypes2.default.func,
    onTouchStart: _propTypes2.default.func,
    onFocus: _propTypes2.default.func,
    tabIndex: _propTypes2.default.number
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__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 = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  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 = 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);
  
  exports.default = Weekday;
  Weekday.propTypes = process.env.NODE_ENV !== "production" ? {
    weekday: _propTypes2.default.number,
    className: _propTypes2.default.string,
    locale: _propTypes2.default.string,
    localeUtils: _propTypes2.default.object,
  
    weekdaysLong: _propTypes2.default.arrayOf(_propTypes2.default.string),
    weekdaysShort: _propTypes2.default.arrayOf(_propTypes2.default.string)
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(process) {
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.HIDE_TIMEOUT = undefined;
  
  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 _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; };
  
  exports.OverlayComponent = OverlayComponent;
  exports.defaultFormat = defaultFormat;
  exports.defaultParse = defaultParse;
  
  var _react = __webpack_require__(1);
  
  var _react2 = _interopRequireDefault(_react);
  
  var _propTypes = __webpack_require__(2);
  
  var _propTypes2 = _interopRequireDefault(_propTypes);
  
  var _DayPicker = __webpack_require__(9);
  
  var _DayPicker2 = _interopRequireDefault(_DayPicker);
  
  var _DateUtils = __webpack_require__(3);
  
  var _ModifiersUtils = __webpack_require__(8);
  
  var _keys = __webpack_require__(4);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return 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; }
  
  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; }
  
  // When clicking on a day cell, overlay will be hidden after this timeout
  var HIDE_TIMEOUT = exports.HIDE_TIMEOUT = 100;
  
  /**
   * The default component used as Overlay.
   *
   * @param {Object} props
   */
  function OverlayComponent(_ref) {
    var input = _ref.input,
        selectedDay = _ref.selectedDay,
        month = _ref.month,
        children = _ref.children,
        classNames = _ref.classNames,
        props = _objectWithoutProperties(_ref, ['input', 'selectedDay', 'month', 'children', 'classNames']);
  
    return _react2.default.createElement(
      'div',
      _extends({ className: classNames.overlayWrapper }, props),
      _react2.default.createElement(
        'div',
        { className: classNames.overlay },
        children
      )
    );
  }
  
  OverlayComponent.propTypes = process.env.NODE_ENV !== "production" ? {
    input: _propTypes2.default.any,
    selectedDay: _propTypes2.default.any,
    month: _propTypes2.default.instanceOf(Date),
    children: _propTypes2.default.node,
    classNames: _propTypes2.default.object
  } : {};
  
  /**
   * The default function used to format a Date to String, passed to the `format`
   * prop.
   * @param {Date} d
   * @return {String}
   */
  function defaultFormat(d) {
    if ((0, _DateUtils.isDate)(d)) {
      var year = d.getFullYear();
      var month = '' + (d.getMonth() + 1);
      var day = '' + d.getDate();
      return year + '-' + month + '-' + day;
    }
    return '';
  }
  
  /**
   * The default function used to parse a String as Date, passed to the `parse`
   * prop.
   * @param {String} str
   * @return {Date}
   */
  function defaultParse(str) {
    if (typeof str !== 'string') {
      return undefined;
    }
    var split = str.split('-');
    if (split.length !== 3) {
      return undefined;
    }
    var year = parseInt(split[0], 10);
    var month = parseInt(split[1], 10) - 1;
    var day = parseInt(split[2], 10);
    if (isNaN(year) || String(year).length > 4 || isNaN(month) || isNaN(day) || day <= 0 || day > 31 || month < 0 || month >= 12) {
      return undefined;
    }
  
    return new Date(year, month, day);
  }
  
  var DayPickerInput = function (_React$Component) {
    _inherits(DayPickerInput, _React$Component);
  
    function DayPickerInput(props) {
      _classCallCheck(this, DayPickerInput);
  
      var _this = _possibleConstructorReturn(this, (DayPickerInput.__proto__ || Object.getPrototypeOf(DayPickerInput)).call(this, props));
  
      _this.input = null;
      _this.daypicker = null;
      _this.clickTimeout = null;
      _this.hideTimeout = null;
      _this.inputBlurTimeout = null;
      _this.inputFocusTimeout = null;
  
  
      _this.state = _this.getInitialStateFromProps(props);
      _this.state.showOverlay = props.showOverlay;
  
      _this.hideAfterDayClick = _this.hideAfterDayClick.bind(_this);
      _this.handleInputClick = _this.handleInputClick.bind(_this);
      _this.handleInputFocus = _this.handleInputFocus.bind(_this);
      _this.handleInputBlur = _this.handleInputBlur.bind(_this);
      _this.handleInputChange = _this.handleInputChange.bind(_this);
      _this.handleInputKeyDown = _this.handleInputKeyDown.bind(_this);
      _this.handleInputKeyUp = _this.handleInputKeyUp.bind(_this);
      _this.handleDayClick = _this.handleDayClick.bind(_this);
      _this.handleMonthChange = _this.handleMonthChange.bind(_this);
      _this.handleOverlayFocus = _this.handleOverlayFocus.bind(_this);
      _this.handleOverlayBlur = _this.handleOverlayBlur.bind(_this);
      return _this;
    }
  
    _createClass(DayPickerInput, [{
      key: 'componentDidUpdate',
      value: function componentDidUpdate(prevProps) {
        var newState = {};
  
        // Current props
        var _props = this.props,
            value = _props.value,
            formatDate = _props.formatDate,
            format = _props.format,
            dayPickerProps = _props.dayPickerProps;
  
        // Update the input value if the `value` prop has changed
  
        if (value !== prevProps.value) {
          if ((0, _DateUtils.isDate)(value)) {
            newState.value = formatDate(value, format, dayPickerProps.locale);
          } else {
            newState.value = value;
          }
        }
  
        // Update the month if the months from props changed
        var prevMonth = prevProps.dayPickerProps.month;
        if (dayPickerProps.month && dayPickerProps.month !== prevMonth && !(0, _DateUtils.isSameMonth)(dayPickerProps.month, prevMonth)) {
          newState.month = dayPickerProps.month;
        }
  
        // Updated the selected days from props if they changed
        if (prevProps.dayPickerProps.selectedDays !== dayPickerProps.selectedDays) {
          newState.selectedDays = dayPickerProps.selectedDays;
        }
  
        if (Object.keys(newState).length > 0) {
          // eslint-disable-next-line react/no-did-update-set-state
          this.setState(newState);
        }
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        clearTimeout(this.clickTimeout);
        clearTimeout(this.hideTimeout);
        clearTimeout(this.inputFocusTimeout);
        clearTimeout(this.inputBlurTimeout);
        clearTimeout(this.overlayBlurTimeout);
      }
    }, {
      key: 'getInitialMonthFromProps',
      value: function getInitialMonthFromProps(props) {
        var dayPickerProps = props.dayPickerProps,
            format = props.format;
  
        var day = void 0;
        if (props.value) {
          if ((0, _DateUtils.isDate)(props.value)) {
            day = props.value;
          } else {
            day = props.parseDate(props.value, format, dayPickerProps.locale);
          }
        }
        return dayPickerProps.initialMonth || dayPickerProps.month || day || new Date();
      }
    }, {
      key: 'getInitialStateFromProps',
      value: function getInitialStateFromProps(props) {
        var dayPickerProps = props.dayPickerProps,
            formatDate = props.formatDate,
            format = props.format;
        var value = props.value;
  
        if (props.value && (0, _DateUtils.isDate)(props.value)) {
          value = formatDate(props.value, format, dayPickerProps.locale);
        }
        return {
          value: value,
          month: this.getInitialMonthFromProps(props),
          selectedDays: dayPickerProps.selectedDays
        };
      }
    }, {
      key: 'getInput',
      value: function getInput() {
        return this.input;
      }
    }, {
      key: 'getDayPicker',
      value: function getDayPicker() {
        return this.daypicker;
      }
  
      /**
       * Update the component's state and fire the `onDayChange` event passing the
       * day's modifiers to it.
       *
       * @param {Date} day - Will be used for changing the month
       * @param {String} value - Input field value
       * @private
       */
  
    }, {
      key: 'updateState',
      value: function updateState(day, value, callback) {
        var _this2 = this;
  
        var _props2 = this.props,
            dayPickerProps = _props2.dayPickerProps,
            onDayChange = _props2.onDayChange;
  
        this.setState({ month: day, value: value, typedValue: undefined }, function () {
          if (callback) {
            callback();
          }
          if (!onDayChange) {
            return;
          }
          var modifiersObj = _extends({
            disabled: dayPickerProps.disabledDays,
            selected: dayPickerProps.selectedDays
          }, dayPickerProps.modifiers);
          var modifiers = (0, _ModifiersUtils.getModifiersForDay)(day, modifiersObj).reduce(function (obj, modifier) {
            return _extends({}, obj, _defineProperty({}, modifier, true));
          }, {});
          onDayChange(day, modifiers, _this2);
        });
      }
  
      /**
       * Show the Day Picker overlay.
       *
       * @memberof DayPickerInput
       */
  
    }, {
      key: 'showDayPicker',
      value: function showDayPicker() {
        var _props3 = this.props,
            parseDate = _props3.parseDate,
            format = _props3.format,
            dayPickerProps = _props3.dayPickerProps;
        var _state = this.state,
            value = _state.value,
            showOverlay = _state.showOverlay;
  
        if (showOverlay) {
          return;
        }
        // Reset the current displayed month when showing the overlay
        var month = value ? parseDate(value, format, dayPickerProps.locale) // Use the month in the input field
        : this.getInitialMonthFromProps(this.props); // Restore the month from the props
        this.setState(function (state) {
          return {
            showOverlay: true,
            month: month || state.month
          };
        });
      }
  
      /**
       * Hide the Day Picker overlay
       *
       * @memberof DayPickerInput
       */
  
    }, {
      key: 'hideDayPicker',
      value: function hideDayPicker() {
        var _this3 = this;
  
        if (this.state.showOverlay === false) {
          return;
        }
        this.setState({ showOverlay: false }, function () {
          if (_this3.props.onDayPickerHide) _this3.props.onDayPickerHide();
        });
      }
    }, {
      key: 'hideAfterDayClick',
      value: function hideAfterDayClick() {
        var _this4 = this;
  
        if (!this.props.hideOnDayClick) {
          return;
        }
        this.hideTimeout = setTimeout(function () {
          return _this4.hideDayPicker();
        }, HIDE_TIMEOUT);
      }
    }, {
      key: 'handleInputClick',
      value: function handleInputClick(e) {
        this.showDayPicker();
        if (this.props.inputProps.onClick) {
          e.persist();
          this.props.inputProps.onClick(e);
        }
      }
    }, {
      key: 'handleInputFocus',
      value: function handleInputFocus(e) {
        var _this5 = this;
  
        this.showDayPicker();
        // Set `overlayHasFocus` after a timeout so the overlay can be hidden when
        // the input is blurred
        this.inputFocusTimeout = setTimeout(function () {
          _this5.overlayHasFocus = false;
        }, 2);
        if (this.props.inputProps.onFocus) {
          e.persist();
          this.props.inputProps.onFocus(e);
        }
      }
  
      // When the input is blurred, the overlay should disappear. However the input
      // is blurred also when the user interacts with the overlay (e.g. the overlay
      // get the focus by clicking it). In these cases, the overlay should not be
      // hidden. There are different approaches to avoid hiding the overlay when
      // this happens, but the only cross-browser hack we’ve found is to set all
      // these timeouts in code before changing `overlayHasFocus`.
  
    }, {
      key: 'handleInputBlur',
      value: function handleInputBlur(e) {
        var _this6 = this;
  
        this.inputBlurTimeout = setTimeout(function () {
          if (!_this6.overlayHasFocus) {
            _this6.hideDayPicker();
          }
        }, 1);
        if (this.props.inputProps.onBlur) {
          e.persist();
          this.props.inputProps.onBlur(e);
        }
      }
    }, {
      key: 'handleOverlayFocus',
      value: function handleOverlayFocus(e) {
        e.preventDefault();
        this.overlayHasFocus = true;
        if (!this.props.keepFocus || !this.input || typeof this.input.focus !== 'function') {
          return;
        }
        this.input.focus();
      }
    }, {
      key: 'handleOverlayBlur',
      value: function handleOverlayBlur() {
        var _this7 = this;
  
        // We need to set a timeout otherwise IE11 will hide the overlay when
        // focusing it
        this.overlayBlurTimeout = setTimeout(function () {
          _this7.overlayHasFocus = false;
        }, 3);
      }
    }, {
      key: 'handleInputChange',
      value: function handleInputChange(e) {
        var _props4 = this.props,
            dayPickerProps = _props4.dayPickerProps,
            format = _props4.format,
            inputProps = _props4.inputProps,
            onDayChange = _props4.onDayChange,
            parseDate = _props4.parseDate;
  
        if (inputProps.onChange) {
          e.persist();
          inputProps.onChange(e);
        }
        var value = e.target.value;
  
        if (value.trim() === '') {
          this.setState({ value: value, typedValue: undefined });
          if (onDayChange) onDayChange(undefined, {}, this);
          return;
        }
        var day = parseDate(value, format, dayPickerProps.locale);
        if (!day) {
          // Day is invalid: we save the value in the typedValue state
          this.setState({ value: value, typedValue: value });
          if (onDayChange) onDayChange(undefined, {}, this);
          return;
        }
        this.updateState(day, value);
      }
    }, {
      key: 'handleInputKeyDown',
      value: function handleInputKeyDown(e) {
        if (e.keyCode === _keys.TAB) {
          this.hideDayPicker();
        } else {
          this.showDayPicker();
        }
        if (this.props.inputProps.onKeyDown) {
          e.persist();
          this.props.inputProps.onKeyDown(e);
        }
      }
    }, {
      key: 'handleInputKeyUp',
      value: function handleInputKeyUp(e) {
        if (e.keyCode === _keys.ESC) {
          this.hideDayPicker();
        } else {
          this.showDayPicker();
        }
        if (this.props.inputProps.onKeyUp) {
          e.persist();
          this.props.inputProps.onKeyUp(e);
        }
      }
    }, {
      key: 'handleMonthChange',
      value: function handleMonthChange(month) {
        var _this8 = this;
  
        this.setState({ month: month }, function () {
          if (_this8.props.dayPickerProps && _this8.props.dayPickerProps.onMonthChange) {
            _this8.props.dayPickerProps.onMonthChange(month);
          }
        });
      }
    }, {
      key: 'handleDayClick',
      value: function handleDayClick(day, modifiers, e) {
        var _this9 = this;
  
        var _props5 = this.props,
            clickUnselectsDay = _props5.clickUnselectsDay,
            dayPickerProps = _props5.dayPickerProps,
            onDayChange = _props5.onDayChange,
            formatDate = _props5.formatDate,
            format = _props5.format,
            changeMonthOnDayClick = _props5.changeMonthOnDayClick;
  
        if (dayPickerProps.onDayClick) {
          dayPickerProps.onDayClick(day, modifiers, e);
        }
  
        // Do nothing if the day is disabled
        if (modifiers.disabled || dayPickerProps && dayPickerProps.classNames && modifiers[dayPickerProps.classNames.disabled]) {
          return;
        }
  
        // If the clicked day is already selected, remove the clicked day
        // from the selected days and empty the field value
        if (modifiers.selected && clickUnselectsDay) {
          var selectedDays = this.state.selectedDays;
  
          if (Array.isArray(selectedDays)) {
            selectedDays = selectedDays.slice(0);
            var selectedDayIdx = selectedDays.indexOf(day);
            selectedDays.splice(selectedDayIdx, 1);
          } else if (selectedDays) {
            selectedDays = null;
          }
          this.setState({ value: '', typedValue: undefined, selectedDays: selectedDays }, this.hideAfterDayClick);
          if (onDayChange) {
            onDayChange(undefined, modifiers, this);
          }
          return;
        }
  
        var value = formatDate(day, format, dayPickerProps.locale);
  
        var newState = { value: value, typedValue: undefined };
  
        if (changeMonthOnDayClick) {
          newState.month = day;
        }
  
        this.setState(newState, function () {
          if (onDayChange) {
            onDayChange(day, modifiers, _this9);
          }
          _this9.hideAfterDayClick();
        });
      }
    }, {
      key: 'renderOverlay',
      value: function renderOverlay() {
        var _this10 = this;
  
        var _props6 = this.props,
            classNames = _props6.classNames,
            dayPickerProps = _props6.dayPickerProps,
            parseDate = _props6.parseDate,
            formatDate = _props6.formatDate,
            format = _props6.format;
        var _state2 = this.state,
            selectedDays = _state2.selectedDays,
            value = _state2.value;
  
        var selectedDay = void 0;
        if (!selectedDays && value) {
          var day = parseDate(value, format, dayPickerProps.locale);
          if (day) {
            selectedDay = day;
          }
        } else if (selectedDays) {
          selectedDay = selectedDays;
        }
        var onTodayButtonClick = void 0;
        if (dayPickerProps.todayButton) {
          // Set the current day when clicking the today button
          onTodayButtonClick = function onTodayButtonClick() {
            return _this10.updateState(new Date(), formatDate(new Date(), format, dayPickerProps.locale), _this10.hideAfterDayClick);
          };
        }
        var Overlay = this.props.overlayComponent;
        return _react2.default.createElement(
          Overlay,
          {
            classNames: classNames,
            month: this.state.month,
            selectedDay: selectedDay,
            input: this.input,
            tabIndex: 0 // tabIndex is necessary to catch focus/blur events on Safari
            , onFocus: this.handleOverlayFocus,
            onBlur: this.handleOverlayBlur
          },
          _react2.default.createElement(_DayPicker2.default, _extends({
            ref: function ref(el) {
              return _this10.daypicker = el;
            },
            onTodayButtonClick: onTodayButtonClick
          }, dayPickerProps, {
            month: this.state.month,
            selectedDays: selectedDay,
            onDayClick: this.handleDayClick,
            onMonthChange: this.handleMonthChange
          }))
        );
      }
    }, {
      key: 'render',
      value: function render() {
        var _this11 = this;
  
        var Input = this.props.component;
        var inputProps = this.props.inputProps;
  
        return _react2.default.createElement(
          'div',
          { className: this.props.classNames.container },
          _react2.default.createElement(Input, _extends({
            ref: function ref(el) {
              return _this11.input = el;
            },
            placeholder: this.props.placeholder
          }, inputProps, {
            value: this.state.typedValue || this.state.value,
            onChange: this.handleInputChange,
            onFocus: this.handleInputFocus,
            onBlur: this.handleInputBlur,
            onKeyDown: this.handleInputKeyDown,
            onKeyUp: this.handleInputKeyUp,
            onClick: !inputProps.disabled ? this.handleInputClick : undefined
          })),
          this.state.showOverlay && this.renderOverlay()
        );
      }
    }]);
  
    return DayPickerInput;
  }(_react2.default.Component);
  
  DayPickerInput.defaultProps = {
    dayPickerProps: {},
    value: '',
    placeholder: 'YYYY-M-D',
    format: 'L',
    formatDate: defaultFormat,
    parseDate: defaultParse,
    showOverlay: false,
    hideOnDayClick: true,
    clickUnselectsDay: false,
    keepFocus: true,
    component: 'input',
    inputProps: {},
    overlayComponent: OverlayComponent,
    classNames: {
      container: 'DayPickerInput',
      overlayWrapper: 'DayPickerInput-OverlayWrapper',
      overlay: 'DayPickerInput-Overlay'
    },
    changeMonthOnDayClick: true
  };
  exports.default = DayPickerInput;
  DayPickerInput.propTypes = process.env.NODE_ENV !== "production" ? {
    value: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.instanceOf(Date)]),
    inputProps: _propTypes2.default.object,
    placeholder: _propTypes2.default.string,
  
    format: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.arrayOf(_propTypes2.default.string)]),
  
    formatDate: _propTypes2.default.func,
    parseDate: _propTypes2.default.func,
  
    showOverlay: _propTypes2.default.bool,
    dayPickerProps: _propTypes2.default.object,
    hideOnDayClick: _propTypes2.default.bool,
    clickUnselectsDay: _propTypes2.default.bool,
    keepFocus: _propTypes2.default.bool,
    component: _propTypes2.default.any,
    overlayComponent: _propTypes2.default.any,
  
    changeMonthOnDayClick: _propTypes2.default.bool,
  
    classNames: _propTypes2.default.shape({
      container: _propTypes2.default.string,
      overlayWrapper: _propTypes2.default.string,
      overlay: _propTypes2.default.string.isRequired
    }),
  
    onDayChange: _propTypes2.default.func,
    onDayPickerHide: _propTypes2.default.func,
    onChange: _propTypes2.default.func,
    onClick: _propTypes2.default.func,
    onFocus: _propTypes2.default.func,
    onBlur: _propTypes2.default.func,
    onKeyUp: _propTypes2.default.func
  } : {};
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
  
  /***/ })
  /******/ ]);
  });
  //# sourceMappingURL=daypicker.js.map