[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> components.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["components"] =
   2  /******/ (function(modules) { // webpackBootstrap
   3  /******/     // The module cache
   4  /******/     var installedModules = {};
   5  /******/
   6  /******/     // The require function
   7  /******/ 	function __webpack_require__(moduleId) {
   8  /******/
   9  /******/         // Check if module is in cache
  10  /******/         if(installedModules[moduleId]) {
  11  /******/             return installedModules[moduleId].exports;
  12  /******/         }
  13  /******/         // Create a new module (and put it into the cache)
  14  /******/         var module = installedModules[moduleId] = {
  15  /******/             i: moduleId,
  16  /******/             l: false,
  17  /******/             exports: {}
  18  /******/         };
  19  /******/
  20  /******/         // Execute the module function
  21  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  22  /******/
  23  /******/         // Flag the module as loaded
  24  /******/         module.l = true;
  25  /******/
  26  /******/         // Return the exports of the module
  27  /******/         return module.exports;
  28  /******/     }
  29  /******/
  30  /******/
  31  /******/     // expose the modules object (__webpack_modules__)
  32  /******/     __webpack_require__.m = modules;
  33  /******/
  34  /******/     // expose the module cache
  35  /******/     __webpack_require__.c = installedModules;
  36  /******/
  37  /******/     // define getter function for harmony exports
  38  /******/     __webpack_require__.d = function(exports, name, getter) {
  39  /******/         if(!__webpack_require__.o(exports, name)) {
  40  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
  41  /******/         }
  42  /******/     };
  43  /******/
  44  /******/     // define __esModule on exports
  45  /******/     __webpack_require__.r = function(exports) {
  46  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  47  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  48  /******/         }
  49  /******/         Object.defineProperty(exports, '__esModule', { value: true });
  50  /******/     };
  51  /******/
  52  /******/     // create a fake namespace object
  53  /******/     // mode & 1: value is a module id, require it
  54  /******/     // mode & 2: merge all properties of value into the ns
  55  /******/     // mode & 4: return value when already ns object
  56  /******/     // mode & 8|1: behave like require
  57  /******/     __webpack_require__.t = function(value, mode) {
  58  /******/         if(mode & 1) value = __webpack_require__(value);
  59  /******/         if(mode & 8) return value;
  60  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  61  /******/         var ns = Object.create(null);
  62  /******/         __webpack_require__.r(ns);
  63  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  64  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  65  /******/         return ns;
  66  /******/     };
  67  /******/
  68  /******/     // getDefaultExport function for compatibility with non-harmony modules
  69  /******/     __webpack_require__.n = function(module) {
  70  /******/         var getter = module && module.__esModule ?
  71  /******/ 			function getDefault() { return module['default']; } :
  72  /******/ 			function getModuleExports() { return module; };
  73  /******/         __webpack_require__.d(getter, 'a', getter);
  74  /******/         return getter;
  75  /******/     };
  76  /******/
  77  /******/     // Object.prototype.hasOwnProperty.call
  78  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  79  /******/
  80  /******/     // __webpack_public_path__
  81  /******/     __webpack_require__.p = "";
  82  /******/
  83  /******/
  84  /******/     // Load entry module and return exports
  85  /******/     return __webpack_require__(__webpack_require__.s = 361);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ([
  89  /* 0 */
  90  /***/ (function(module, exports) {
  91  
  92  (function() { module.exports = this["wp"]["element"]; }());
  93  
  94  /***/ }),
  95  /* 1 */
  96  /***/ (function(module, exports) {
  97  
  98  (function() { module.exports = this["wp"]["i18n"]; }());
  99  
 100  /***/ }),
 101  /* 2 */
 102  /***/ (function(module, exports) {
 103  
 104  (function() { module.exports = this["lodash"]; }());
 105  
 106  /***/ }),
 107  /* 3 */,
 108  /* 4 */,
 109  /* 5 */,
 110  /* 6 */
 111  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 112  
 113  "use strict";
 114  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
 115  function _assertThisInitialized(self) {
 116    if (self === void 0) {
 117      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 118    }
 119  
 120    return self;
 121  }
 122  
 123  /***/ }),
 124  /* 7 */
 125  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 126  
 127  "use strict";
 128  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; });
 129  /* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
 130  
 131  function _objectSpread(target) {
 132    for (var i = 1; i < arguments.length; i++) {
 133      var source = arguments[i] != null ? arguments[i] : {};
 134      var ownKeys = Object.keys(Object(source));
 135  
 136      if (typeof Object.getOwnPropertySymbols === 'function') {
 137        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
 138          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
 139        }));
 140      }
 141  
 142      ownKeys.forEach(function (key) {
 143        Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]);
 144      });
 145    }
 146  
 147    return target;
 148  }
 149  
 150  /***/ }),
 151  /* 8 */
 152  /***/ (function(module, exports) {
 153  
 154  (function() { module.exports = this["wp"]["compose"]; }());
 155  
 156  /***/ }),
 157  /* 9 */
 158  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 159  
 160  "use strict";
 161  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });
 162  function _defineProperty(obj, key, value) {
 163    if (key in obj) {
 164      Object.defineProperty(obj, key, {
 165        value: value,
 166        enumerable: true,
 167        configurable: true,
 168        writable: true
 169      });
 170    } else {
 171      obj[key] = value;
 172    }
 173  
 174    return obj;
 175  }
 176  
 177  /***/ }),
 178  /* 10 */,
 179  /* 11 */
 180  /***/ (function(module, exports, __webpack_require__) {
 181  
 182  var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 183    Copyright (c) 2017 Jed Watson.
 184    Licensed under the MIT License (MIT), see
 185    http://jedwatson.github.io/classnames
 186  */
 187  /* global define */
 188  
 189  (function () {
 190      'use strict';
 191  
 192      var hasOwn = {}.hasOwnProperty;
 193  
 194  	function classNames () {
 195          var classes = [];
 196  
 197          for (var i = 0; i < arguments.length; i++) {
 198              var arg = arguments[i];
 199              if (!arg) continue;
 200  
 201              var argType = typeof arg;
 202  
 203              if (argType === 'string' || argType === 'number') {
 204                  classes.push(arg);
 205              } else if (Array.isArray(arg) && arg.length) {
 206                  var inner = classNames.apply(null, arg);
 207                  if (inner) {
 208                      classes.push(inner);
 209                  }
 210              } else if (argType === 'object') {
 211                  for (var key in arg) {
 212                      if (hasOwn.call(arg, key) && arg[key]) {
 213                          classes.push(key);
 214                      }
 215                  }
 216              }
 217          }
 218  
 219          return classes.join(' ');
 220      }
 221  
 222      if ( true && module.exports) {
 223          classNames.default = classNames;
 224          module.exports = classNames;
 225      } else if (true) {
 226          // register as 'classnames', consistent with npm package name
 227          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
 228              return classNames;
 229          }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
 230                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 231      } else {}
 232  }());
 233  
 234  
 235  /***/ }),
 236  /* 12 */
 237  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 238  
 239  "use strict";
 240  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
 241  function _defineProperties(target, props) {
 242    for (var i = 0; i < props.length; i++) {
 243      var descriptor = props[i];
 244      descriptor.enumerable = descriptor.enumerable || false;
 245      descriptor.configurable = true;
 246      if ("value" in descriptor) descriptor.writable = true;
 247      Object.defineProperty(target, descriptor.key, descriptor);
 248    }
 249  }
 250  
 251  function _createClass(Constructor, protoProps, staticProps) {
 252    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 253    if (staticProps) _defineProperties(Constructor, staticProps);
 254    return Constructor;
 255  }
 256  
 257  /***/ }),
 258  /* 13 */
 259  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 260  
 261  "use strict";
 262  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
 263  function _classCallCheck(instance, Constructor) {
 264    if (!(instance instanceof Constructor)) {
 265      throw new TypeError("Cannot call a class as a function");
 266    }
 267  }
 268  
 269  /***/ }),
 270  /* 14 */
 271  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 272  
 273  "use strict";
 274  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
 275  function _extends() {
 276    _extends = Object.assign || function (target) {
 277      for (var i = 1; i < arguments.length; i++) {
 278        var source = arguments[i];
 279  
 280        for (var key in source) {
 281          if (Object.prototype.hasOwnProperty.call(source, key)) {
 282            target[key] = source[key];
 283          }
 284        }
 285      }
 286  
 287      return target;
 288    };
 289  
 290    return _extends.apply(this, arguments);
 291  }
 292  
 293  /***/ }),
 294  /* 15 */
 295  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 296  
 297  "use strict";
 298  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
 299  /* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31);
 300  /* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
 301  
 302  
 303  function _possibleConstructorReturn(self, call) {
 304    if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) {
 305      return call;
 306    }
 307  
 308    return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
 309  }
 310  
 311  /***/ }),
 312  /* 16 */
 313  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 314  
 315  "use strict";
 316  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });
 317  function _getPrototypeOf(o) {
 318    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
 319      return o.__proto__ || Object.getPrototypeOf(o);
 320    };
 321    return _getPrototypeOf(o);
 322  }
 323  
 324  /***/ }),
 325  /* 17 */
 326  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 327  
 328  "use strict";
 329  
 330  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
 331  function _setPrototypeOf(o, p) {
 332    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
 333      o.__proto__ = p;
 334      return o;
 335    };
 336  
 337    return _setPrototypeOf(o, p);
 338  }
 339  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
 340  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });
 341  
 342  function _inherits(subClass, superClass) {
 343    if (typeof superClass !== "function" && superClass !== null) {
 344      throw new TypeError("Super expression must either be null or a function");
 345    }
 346  
 347    subClass.prototype = Object.create(superClass && superClass.prototype, {
 348      constructor: {
 349        value: subClass,
 350        writable: true,
 351        configurable: true
 352      }
 353    });
 354    if (superClass) _setPrototypeOf(subClass, superClass);
 355  }
 356  
 357  /***/ }),
 358  /* 18 */
 359  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 360  
 361  "use strict";
 362  
 363  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
 364  function _arrayWithoutHoles(arr) {
 365    if (Array.isArray(arr)) {
 366      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
 367        arr2[i] = arr[i];
 368      }
 369  
 370      return arr2;
 371    }
 372  }
 373  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 374  var iterableToArray = __webpack_require__(32);
 375  
 376  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 377  function _nonIterableSpread() {
 378    throw new TypeError("Invalid attempt to spread non-iterable instance");
 379  }
 380  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 381  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; });
 382  
 383  
 384  
 385  function _toConsumableArray(arr) {
 386    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 387  }
 388  
 389  /***/ }),
 390  /* 19 */
 391  /***/ (function(module, exports) {
 392  
 393  (function() { module.exports = this["wp"]["keycodes"]; }());
 394  
 395  /***/ }),
 396  /* 20 */
 397  /***/ (function(module, exports) {
 398  
 399  (function() { module.exports = this["React"]; }());
 400  
 401  /***/ }),
 402  /* 21 */
 403  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 404  
 405  "use strict";
 406  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; });
 407  /* harmony import */ var _objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40);
 408  
 409  function _objectWithoutProperties(source, excluded) {
 410    if (source == null) return {};
 411    var target = Object(_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(source, excluded);
 412    var key, i;
 413  
 414    if (Object.getOwnPropertySymbols) {
 415      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
 416  
 417      for (i = 0; i < sourceSymbolKeys.length; i++) {
 418        key = sourceSymbolKeys[i];
 419        if (excluded.indexOf(key) >= 0) continue;
 420        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
 421        target[key] = source[key];
 422      }
 423    }
 424  
 425    return target;
 426  }
 427  
 428  /***/ }),
 429  /* 22 */
 430  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 431  
 432  "use strict";
 433  
 434  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
 435  var arrayWithHoles = __webpack_require__(33);
 436  
 437  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 438  function _iterableToArrayLimit(arr, i) {
 439    if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
 440      return;
 441    }
 442  
 443    var _arr = [];
 444    var _n = true;
 445    var _d = false;
 446    var _e = undefined;
 447  
 448    try {
 449      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 450        _arr.push(_s.value);
 451  
 452        if (i && _arr.length === i) break;
 453      }
 454    } catch (err) {
 455      _d = true;
 456      _e = err;
 457    } finally {
 458      try {
 459        if (!_n && _i["return"] != null) _i["return"]();
 460      } finally {
 461        if (_d) throw _e;
 462      }
 463    }
 464  
 465    return _arr;
 466  }
 467  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 468  var nonIterableRest = __webpack_require__(34);
 469  
 470  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 471  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; });
 472  
 473  
 474  
 475  function _slicedToArray(arr, i) {
 476    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])();
 477  }
 478  
 479  /***/ }),
 480  /* 23 */
 481  /***/ (function(module, exports) {
 482  
 483  (function() { module.exports = this["regeneratorRuntime"]; }());
 484  
 485  /***/ }),
 486  /* 24 */
 487  /***/ (function(module, exports) {
 488  
 489  (function() { module.exports = this["wp"]["richText"]; }());
 490  
 491  /***/ }),
 492  /* 25 */,
 493  /* 26 */,
 494  /* 27 */
 495  /***/ (function(module, exports) {
 496  
 497  (function() { module.exports = this["wp"]["hooks"]; }());
 498  
 499  /***/ }),
 500  /* 28 */
 501  /***/ (function(module, exports, __webpack_require__) {
 502  
 503  /**
 504   * Copyright (c) 2013-present, Facebook, Inc.
 505   *
 506   * This source code is licensed under the MIT license found in the
 507   * LICENSE file in the root directory of this source tree.
 508   */
 509  
 510  if (false) { var throwOnDirectAccess, ReactIs; } else {
 511    // By explicitly using `prop-types` you are opting into new production behavior.
 512    // http://fb.me/prop-types-in-prod
 513    module.exports = __webpack_require__(88)();
 514  }
 515  
 516  
 517  /***/ }),
 518  /* 29 */
 519  /***/ (function(module, exports) {
 520  
 521  (function() { module.exports = this["wp"]["dom"]; }());
 522  
 523  /***/ }),
 524  /* 30 */
 525  /***/ (function(module, exports) {
 526  
 527  (function() { module.exports = this["moment"]; }());
 528  
 529  /***/ }),
 530  /* 31 */
 531  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 532  
 533  "use strict";
 534  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; });
 535  function _typeof(obj) {
 536    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
 537      _typeof = function _typeof(obj) {
 538        return typeof obj;
 539      };
 540    } else {
 541      _typeof = function _typeof(obj) {
 542        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
 543      };
 544    }
 545  
 546    return _typeof(obj);
 547  }
 548  
 549  /***/ }),
 550  /* 32 */
 551  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 552  
 553  "use strict";
 554  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
 555  function _iterableToArray(iter) {
 556    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
 557  }
 558  
 559  /***/ }),
 560  /* 33 */
 561  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 562  
 563  "use strict";
 564  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
 565  function _arrayWithHoles(arr) {
 566    if (Array.isArray(arr)) return arr;
 567  }
 568  
 569  /***/ }),
 570  /* 34 */
 571  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 572  
 573  "use strict";
 574  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
 575  function _nonIterableRest() {
 576    throw new TypeError("Invalid attempt to destructure non-iterable instance");
 577  }
 578  
 579  /***/ }),
 580  /* 35 */
 581  /***/ (function(module, exports) {
 582  
 583  (function() { module.exports = this["wp"]["deprecated"]; }());
 584  
 585  /***/ }),
 586  /* 36 */,
 587  /* 37 */,
 588  /* 38 */,
 589  /* 39 */,
 590  /* 40 */
 591  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 592  
 593  "use strict";
 594  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutPropertiesLoose; });
 595  function _objectWithoutPropertiesLoose(source, excluded) {
 596    if (source == null) return {};
 597    var target = {};
 598    var sourceKeys = Object.keys(source);
 599    var key, i;
 600  
 601    for (i = 0; i < sourceKeys.length; i++) {
 602      key = sourceKeys[i];
 603      if (excluded.indexOf(key) >= 0) continue;
 604      target[key] = source[key];
 605    }
 606  
 607    return target;
 608  }
 609  
 610  /***/ }),
 611  /* 41 */
 612  /***/ (function(module, exports, __webpack_require__) {
 613  
 614  "use strict";
 615  
 616  
 617  Object.defineProperty(exports, "__esModule", {
 618    value: true
 619  });
 620  var DISPLAY_FORMAT = exports.DISPLAY_FORMAT = 'L';
 621  var ISO_FORMAT = exports.ISO_FORMAT = 'YYYY-MM-DD';
 622  var ISO_MONTH_FORMAT = exports.ISO_MONTH_FORMAT = 'YYYY-MM';
 623  
 624  var START_DATE = exports.START_DATE = 'startDate';
 625  var END_DATE = exports.END_DATE = 'endDate';
 626  
 627  var HORIZONTAL_ORIENTATION = exports.HORIZONTAL_ORIENTATION = 'horizontal';
 628  var VERTICAL_ORIENTATION = exports.VERTICAL_ORIENTATION = 'vertical';
 629  var VERTICAL_SCROLLABLE = exports.VERTICAL_SCROLLABLE = 'verticalScrollable';
 630  
 631  var ICON_BEFORE_POSITION = exports.ICON_BEFORE_POSITION = 'before';
 632  var ICON_AFTER_POSITION = exports.ICON_AFTER_POSITION = 'after';
 633  
 634  var INFO_POSITION_TOP = exports.INFO_POSITION_TOP = 'top';
 635  var INFO_POSITION_BOTTOM = exports.INFO_POSITION_BOTTOM = 'bottom';
 636  var INFO_POSITION_BEFORE = exports.INFO_POSITION_BEFORE = 'before';
 637  var INFO_POSITION_AFTER = exports.INFO_POSITION_AFTER = 'after';
 638  
 639  var ANCHOR_LEFT = exports.ANCHOR_LEFT = 'left';
 640  var ANCHOR_RIGHT = exports.ANCHOR_RIGHT = 'right';
 641  
 642  var OPEN_DOWN = exports.OPEN_DOWN = 'down';
 643  var OPEN_UP = exports.OPEN_UP = 'up';
 644  
 645  var DAY_SIZE = exports.DAY_SIZE = 39;
 646  var BLOCKED_MODIFIER = exports.BLOCKED_MODIFIER = 'blocked';
 647  var WEEKDAYS = exports.WEEKDAYS = [0, 1, 2, 3, 4, 5, 6];
 648  
 649  var FANG_WIDTH_PX = exports.FANG_WIDTH_PX = 20;
 650  var FANG_HEIGHT_PX = exports.FANG_HEIGHT_PX = 10;
 651  var DEFAULT_VERTICAL_SPACING = exports.DEFAULT_VERTICAL_SPACING = 22;
 652  
 653  var MODIFIER_KEY_NAMES = exports.MODIFIER_KEY_NAMES = new Set(['Shift', 'Control', 'Alt', 'Meta']);
 654  
 655  /***/ }),
 656  /* 42 */,
 657  /* 43 */
 658  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 659  
 660  "use strict";
 661  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; });
 662  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
 663    try {
 664      var info = gen[key](arg);
 665      var value = info.value;
 666    } catch (error) {
 667      reject(error);
 668      return;
 669    }
 670  
 671    if (info.done) {
 672      resolve(value);
 673    } else {
 674      Promise.resolve(value).then(_next, _throw);
 675    }
 676  }
 677  
 678  function _asyncToGenerator(fn) {
 679    return function () {
 680      var self = this,
 681          args = arguments;
 682      return new Promise(function (resolve, reject) {
 683        var gen = fn.apply(self, args);
 684  
 685        function _next(value) {
 686          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
 687        }
 688  
 689        function _throw(err) {
 690          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
 691        }
 692  
 693        _next(undefined);
 694      });
 695    };
 696  }
 697  
 698  /***/ }),
 699  /* 44 */
 700  /***/ (function(module, exports) {
 701  
 702  (function() { module.exports = this["wp"]["a11y"]; }());
 703  
 704  /***/ }),
 705  /* 45 */
 706  /***/ (function(module, exports) {
 707  
 708  (function() { module.exports = this["wp"]["isShallowEqual"]; }());
 709  
 710  /***/ }),
 711  /* 46 */
 712  /***/ (function(module, exports, __webpack_require__) {
 713  
 714  "use strict";
 715  
 716  
 717  /* globals
 718      Atomics,
 719      SharedArrayBuffer,
 720  */
 721  
 722  var undefined;
 723  
 724  var $TypeError = TypeError;
 725  
 726  var $gOPD = Object.getOwnPropertyDescriptor;
 727  if ($gOPD) {
 728      try {
 729          $gOPD({}, '');
 730      } catch (e) {
 731          $gOPD = null; // this is IE 8, which has a broken gOPD
 732      }
 733  }
 734  
 735  var throwTypeError = function () { throw new $TypeError(); };
 736  var ThrowTypeError = $gOPD
 737      ? (function () {
 738          try {
 739              // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
 740              arguments.callee; // IE 8 does not throw here
 741              return throwTypeError;
 742          } catch (calleeThrows) {
 743              try {
 744                  // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
 745                  return $gOPD(arguments, 'callee').get;
 746              } catch (gOPDthrows) {
 747                  return throwTypeError;
 748              }
 749          }
 750      }())
 751      : throwTypeError;
 752  
 753  var hasSymbols = __webpack_require__(245)();
 754  
 755  var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
 756  
 757  var generator; // = function * () {};
 758  var generatorFunction = generator ? getProto(generator) : undefined;
 759  var asyncFn; // async function() {};
 760  var asyncFunction = asyncFn ? asyncFn.constructor : undefined;
 761  var asyncGen; // async function * () {};
 762  var asyncGenFunction = asyncGen ? getProto(asyncGen) : undefined;
 763  var asyncGenIterator = asyncGen ? asyncGen() : undefined;
 764  
 765  var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
 766  
 767  var INTRINSICS = {
 768      '%Array%': Array,
 769      '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
 770      '%ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer.prototype,
 771      '%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
 772      '%ArrayPrototype%': Array.prototype,
 773      '%ArrayProto_entries%': Array.prototype.entries,
 774      '%ArrayProto_forEach%': Array.prototype.forEach,
 775      '%ArrayProto_keys%': Array.prototype.keys,
 776      '%ArrayProto_values%': Array.prototype.values,
 777      '%AsyncFromSyncIteratorPrototype%': undefined,
 778      '%AsyncFunction%': asyncFunction,
 779      '%AsyncFunctionPrototype%': asyncFunction ? asyncFunction.prototype : undefined,
 780      '%AsyncGenerator%': asyncGen ? getProto(asyncGenIterator) : undefined,
 781      '%AsyncGeneratorFunction%': asyncGenFunction,
 782      '%AsyncGeneratorPrototype%': asyncGenFunction ? asyncGenFunction.prototype : undefined,
 783      '%AsyncIteratorPrototype%': asyncGenIterator && hasSymbols && Symbol.asyncIterator ? asyncGenIterator[Symbol.asyncIterator]() : undefined,
 784      '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
 785      '%Boolean%': Boolean,
 786      '%BooleanPrototype%': Boolean.prototype,
 787      '%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
 788      '%DataViewPrototype%': typeof DataView === 'undefined' ? undefined : DataView.prototype,
 789      '%Date%': Date,
 790      '%DatePrototype%': Date.prototype,
 791      '%decodeURI%': decodeURI,
 792      '%decodeURIComponent%': decodeURIComponent,
 793      '%encodeURI%': encodeURI,
 794      '%encodeURIComponent%': encodeURIComponent,
 795      '%Error%': Error,
 796      '%ErrorPrototype%': Error.prototype,
 797      '%eval%': eval, // eslint-disable-line no-eval
 798      '%EvalError%': EvalError,
 799      '%EvalErrorPrototype%': EvalError.prototype,
 800      '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
 801      '%Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined : Float32Array.prototype,
 802      '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
 803      '%Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined : Float64Array.prototype,
 804      '%Function%': Function,
 805      '%FunctionPrototype%': Function.prototype,
 806      '%Generator%': generator ? getProto(generator()) : undefined,
 807      '%GeneratorFunction%': generatorFunction,
 808      '%GeneratorPrototype%': generatorFunction ? generatorFunction.prototype : undefined,
 809      '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
 810      '%Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined : Int8Array.prototype,
 811      '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
 812      '%Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined : Int8Array.prototype,
 813      '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
 814      '%Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined : Int32Array.prototype,
 815      '%isFinite%': isFinite,
 816      '%isNaN%': isNaN,
 817      '%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
 818      '%JSON%': typeof JSON === 'object' ? JSON : undefined,
 819      '%JSONParse%': typeof JSON === 'object' ? JSON.parse : undefined,
 820      '%Map%': typeof Map === 'undefined' ? undefined : Map,
 821      '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
 822      '%MapPrototype%': typeof Map === 'undefined' ? undefined : Map.prototype,
 823      '%Math%': Math,
 824      '%Number%': Number,
 825      '%NumberPrototype%': Number.prototype,
 826      '%Object%': Object,
 827      '%ObjectPrototype%': Object.prototype,
 828      '%ObjProto_toString%': Object.prototype.toString,
 829      '%ObjProto_valueOf%': Object.prototype.valueOf,
 830      '%parseFloat%': parseFloat,
 831      '%parseInt%': parseInt,
 832      '%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
 833      '%PromisePrototype%': typeof Promise === 'undefined' ? undefined : Promise.prototype,
 834      '%PromiseProto_then%': typeof Promise === 'undefined' ? undefined : Promise.prototype.then,
 835      '%Promise_all%': typeof Promise === 'undefined' ? undefined : Promise.all,
 836      '%Promise_reject%': typeof Promise === 'undefined' ? undefined : Promise.reject,
 837      '%Promise_resolve%': typeof Promise === 'undefined' ? undefined : Promise.resolve,
 838      '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
 839      '%RangeError%': RangeError,
 840      '%RangeErrorPrototype%': RangeError.prototype,
 841      '%ReferenceError%': ReferenceError,
 842      '%ReferenceErrorPrototype%': ReferenceError.prototype,
 843      '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
 844      '%RegExp%': RegExp,
 845      '%RegExpPrototype%': RegExp.prototype,
 846      '%Set%': typeof Set === 'undefined' ? undefined : Set,
 847      '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
 848      '%SetPrototype%': typeof Set === 'undefined' ? undefined : Set.prototype,
 849      '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
 850      '%SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer.prototype,
 851      '%String%': String,
 852      '%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
 853      '%StringPrototype%': String.prototype,
 854      '%Symbol%': hasSymbols ? Symbol : undefined,
 855      '%SymbolPrototype%': hasSymbols ? Symbol.prototype : undefined,
 856      '%SyntaxError%': SyntaxError,
 857      '%SyntaxErrorPrototype%': SyntaxError.prototype,
 858      '%ThrowTypeError%': ThrowTypeError,
 859      '%TypedArray%': TypedArray,
 860      '%TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined,
 861      '%TypeError%': $TypeError,
 862      '%TypeErrorPrototype%': $TypeError.prototype,
 863      '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
 864      '%Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array.prototype,
 865      '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
 866      '%Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray.prototype,
 867      '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
 868      '%Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array.prototype,
 869      '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
 870      '%Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array.prototype,
 871      '%URIError%': URIError,
 872      '%URIErrorPrototype%': URIError.prototype,
 873      '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
 874      '%WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined : WeakMap.prototype,
 875      '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,
 876      '%WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined : WeakSet.prototype
 877  };
 878  
 879  var bind = __webpack_require__(72);
 880  var $replace = bind.call(Function.call, String.prototype.replace);
 881  
 882  /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
 883  var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
 884  var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
 885  var stringToPath = function stringToPath(string) {
 886      var result = [];
 887      $replace(string, rePropName, function (match, number, quote, subString) {
 888          result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : (number || match);
 889      });
 890      return result;
 891  };
 892  /* end adaptation */
 893  
 894  var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
 895      if (!(name in INTRINSICS)) {
 896          throw new SyntaxError('intrinsic ' + name + ' does not exist!');
 897      }
 898  
 899      // istanbul ignore if // hopefully this is impossible to test :-)
 900      if (typeof INTRINSICS[name] === 'undefined' && !allowMissing) {
 901          throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
 902      }
 903  
 904      return INTRINSICS[name];
 905  };
 906  
 907  module.exports = function GetIntrinsic(name, allowMissing) {
 908      if (typeof name !== 'string' || name.length === 0) {
 909          throw new TypeError('intrinsic name must be a non-empty string');
 910      }
 911      if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
 912          throw new TypeError('"allowMissing" argument must be a boolean');
 913      }
 914  
 915      var parts = stringToPath(name);
 916  
 917      var value = getBaseIntrinsic('%' + (parts.length > 0 ? parts[0] : '') + '%', allowMissing);
 918      for (var i = 1; i < parts.length; i += 1) {
 919          if (value != null) {
 920              if ($gOPD && (i + 1) >= parts.length) {
 921                  var desc = $gOPD(value, parts[i]);
 922                  value = desc ? (desc.get || desc.value) : value[parts[i]];
 923              } else {
 924                  value = value[parts[i]];
 925              }
 926          }
 927      }
 928      return value;
 929  };
 930  
 931  
 932  /***/ }),
 933  /* 47 */
 934  /***/ (function(module, exports, __webpack_require__) {
 935  
 936  module.exports =  true ? __webpack_require__(287) : undefined;
 937  
 938  
 939  
 940  /***/ }),
 941  /* 48 */
 942  /***/ (function(module, exports, __webpack_require__) {
 943  
 944  var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.1
 945  // https://github.com/bgrins/TinyColor
 946  // Brian Grinstead, MIT License
 947  
 948  (function(Math) {
 949  
 950  var trimLeft = /^\s+/,
 951      trimRight = /\s+$/,
 952      tinyCounter = 0,
 953      mathRound = Math.round,
 954      mathMin = Math.min,
 955      mathMax = Math.max,
 956      mathRandom = Math.random;
 957  
 958  function tinycolor (color, opts) {
 959  
 960      color = (color) ? color : '';
 961      opts = opts || { };
 962  
 963      // If input is already a tinycolor, return itself
 964      if (color instanceof tinycolor) {
 965         return color;
 966      }
 967      // If we are called as a function, call using new instead
 968      if (!(this instanceof tinycolor)) {
 969          return new tinycolor(color, opts);
 970      }
 971  
 972      var rgb = inputToRGB(color);
 973      this._originalInput = color,
 974      this._r = rgb.r,
 975      this._g = rgb.g,
 976      this._b = rgb.b,
 977      this._a = rgb.a,
 978      this._roundA = mathRound(100*this._a) / 100,
 979      this._format = opts.format || rgb.format;
 980      this._gradientType = opts.gradientType;
 981  
 982      // Don't let the range of [0,255] come back in [0,1].
 983      // Potentially lose a little bit of precision here, but will fix issues where
 984      // .5 gets interpreted as half of the total, instead of half of 1
 985      // If it was supposed to be 128, this was already taken care of by `inputToRgb`
 986      if (this._r < 1) { this._r = mathRound(this._r); }
 987      if (this._g < 1) { this._g = mathRound(this._g); }
 988      if (this._b < 1) { this._b = mathRound(this._b); }
 989  
 990      this._ok = rgb.ok;
 991      this._tc_id = tinyCounter++;
 992  }
 993  
 994  tinycolor.prototype = {
 995      isDark: function() {
 996          return this.getBrightness() < 128;
 997      },
 998      isLight: function() {
 999          return !this.isDark();
1000      },
1001      isValid: function() {
1002          return this._ok;
1003      },
1004      getOriginalInput: function() {
1005        return this._originalInput;
1006      },
1007      getFormat: function() {
1008          return this._format;
1009      },
1010      getAlpha: function() {
1011          return this._a;
1012      },
1013      getBrightness: function() {
1014          //http://www.w3.org/TR/AERT#color-contrast
1015          var rgb = this.toRgb();
1016          return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
1017      },
1018      getLuminance: function() {
1019          //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
1020          var rgb = this.toRgb();
1021          var RsRGB, GsRGB, BsRGB, R, G, B;
1022          RsRGB = rgb.r/255;
1023          GsRGB = rgb.g/255;
1024          BsRGB = rgb.b/255;
1025  
1026          if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}
1027          if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}
1028          if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}
1029          return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
1030      },
1031      setAlpha: function(value) {
1032          this._a = boundAlpha(value);
1033          this._roundA = mathRound(100*this._a) / 100;
1034          return this;
1035      },
1036      toHsv: function() {
1037          var hsv = rgbToHsv(this._r, this._g, this._b);
1038          return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
1039      },
1040      toHsvString: function() {
1041          var hsv = rgbToHsv(this._r, this._g, this._b);
1042          var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
1043          return (this._a == 1) ?
1044            "hsv("  + h + ", " + s + "%, " + v + "%)" :
1045            "hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")";
1046      },
1047      toHsl: function() {
1048          var hsl = rgbToHsl(this._r, this._g, this._b);
1049          return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
1050      },
1051      toHslString: function() {
1052          var hsl = rgbToHsl(this._r, this._g, this._b);
1053          var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
1054          return (this._a == 1) ?
1055            "hsl("  + h + ", " + s + "%, " + l + "%)" :
1056            "hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")";
1057      },
1058      toHex: function(allow3Char) {
1059          return rgbToHex(this._r, this._g, this._b, allow3Char);
1060      },
1061      toHexString: function(allow3Char) {
1062          return '#' + this.toHex(allow3Char);
1063      },
1064      toHex8: function(allow4Char) {
1065          return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
1066      },
1067      toHex8String: function(allow4Char) {
1068          return '#' + this.toHex8(allow4Char);
1069      },
1070      toRgb: function() {
1071          return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
1072      },
1073      toRgbString: function() {
1074          return (this._a == 1) ?
1075            "rgb("  + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" :
1076            "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
1077      },
1078      toPercentageRgb: function() {
1079          return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a };
1080      },
1081      toPercentageRgbString: function() {
1082          return (this._a == 1) ?
1083            "rgb("  + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" :
1084            "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
1085      },
1086      toName: function() {
1087          if (this._a === 0) {
1088              return "transparent";
1089          }
1090  
1091          if (this._a < 1) {
1092              return false;
1093          }
1094  
1095          return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
1096      },
1097      toFilter: function(secondColor) {
1098          var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);
1099          var secondHex8String = hex8String;
1100          var gradientType = this._gradientType ? "GradientType = 1, " : "";
1101  
1102          if (secondColor) {
1103              var s = tinycolor(secondColor);
1104              secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);
1105          }
1106  
1107          return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")";
1108      },
1109      toString: function(format) {
1110          var formatSet = !!format;
1111          format = format || this._format;
1112  
1113          var formattedString = false;
1114          var hasAlpha = this._a < 1 && this._a >= 0;
1115          var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
1116  
1117          if (needsAlphaFormat) {
1118              // Special case for "transparent", all other non-alpha formats
1119              // will return rgba when there is transparency.
1120              if (format === "name" && this._a === 0) {
1121                  return this.toName();
1122              }
1123              return this.toRgbString();
1124          }
1125          if (format === "rgb") {
1126              formattedString = this.toRgbString();
1127          }
1128          if (format === "prgb") {
1129              formattedString = this.toPercentageRgbString();
1130          }
1131          if (format === "hex" || format === "hex6") {
1132              formattedString = this.toHexString();
1133          }
1134          if (format === "hex3") {
1135              formattedString = this.toHexString(true);
1136          }
1137          if (format === "hex4") {
1138              formattedString = this.toHex8String(true);
1139          }
1140          if (format === "hex8") {
1141              formattedString = this.toHex8String();
1142          }
1143          if (format === "name") {
1144              formattedString = this.toName();
1145          }
1146          if (format === "hsl") {
1147              formattedString = this.toHslString();
1148          }
1149          if (format === "hsv") {
1150              formattedString = this.toHsvString();
1151          }
1152  
1153          return formattedString || this.toHexString();
1154      },
1155      clone: function() {
1156          return tinycolor(this.toString());
1157      },
1158  
1159      _applyModification: function(fn, args) {
1160          var color = fn.apply(null, [this].concat([].slice.call(args)));
1161          this._r = color._r;
1162          this._g = color._g;
1163          this._b = color._b;
1164          this.setAlpha(color._a);
1165          return this;
1166      },
1167      lighten: function() {
1168          return this._applyModification(lighten, arguments);
1169      },
1170      brighten: function() {
1171          return this._applyModification(brighten, arguments);
1172      },
1173      darken: function() {
1174          return this._applyModification(darken, arguments);
1175      },
1176      desaturate: function() {
1177          return this._applyModification(desaturate, arguments);
1178      },
1179      saturate: function() {
1180          return this._applyModification(saturate, arguments);
1181      },
1182      greyscale: function() {
1183          return this._applyModification(greyscale, arguments);
1184      },
1185      spin: function() {
1186          return this._applyModification(spin, arguments);
1187      },
1188  
1189      _applyCombination: function(fn, args) {
1190          return fn.apply(null, [this].concat([].slice.call(args)));
1191      },
1192      analogous: function() {
1193          return this._applyCombination(analogous, arguments);
1194      },
1195      complement: function() {
1196          return this._applyCombination(complement, arguments);
1197      },
1198      monochromatic: function() {
1199          return this._applyCombination(monochromatic, arguments);
1200      },
1201      splitcomplement: function() {
1202          return this._applyCombination(splitcomplement, arguments);
1203      },
1204      triad: function() {
1205          return this._applyCombination(triad, arguments);
1206      },
1207      tetrad: function() {
1208          return this._applyCombination(tetrad, arguments);
1209      }
1210  };
1211  
1212  // If input is an object, force 1 into "1.0" to handle ratios properly
1213  // String input requires "1.0" as input, so 1 will be treated as 1
1214  tinycolor.fromRatio = function(color, opts) {
1215      if (typeof color == "object") {
1216          var newColor = {};
1217          for (var i in color) {
1218              if (color.hasOwnProperty(i)) {
1219                  if (i === "a") {
1220                      newColor[i] = color[i];
1221                  }
1222                  else {
1223                      newColor[i] = convertToPercentage(color[i]);
1224                  }
1225              }
1226          }
1227          color = newColor;
1228      }
1229  
1230      return tinycolor(color, opts);
1231  };
1232  
1233  // Given a string or object, convert that input to RGB
1234  // Possible string inputs:
1235  //
1236  //     "red"
1237  //     "#f00" or "f00"
1238  //     "#ff0000" or "ff0000"
1239  //     "#ff000000" or "ff000000"
1240  //     "rgb 255 0 0" or "rgb (255, 0, 0)"
1241  //     "rgb 1.0 0 0" or "rgb (1, 0, 0)"
1242  //     "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
1243  //     "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
1244  //     "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
1245  //     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
1246  //     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
1247  //
1248  function inputToRGB(color) {
1249  
1250      var rgb = { r: 0, g: 0, b: 0 };
1251      var a = 1;
1252      var s = null;
1253      var v = null;
1254      var l = null;
1255      var ok = false;
1256      var format = false;
1257  
1258      if (typeof color == "string") {
1259          color = stringInputToObject(color);
1260      }
1261  
1262      if (typeof color == "object") {
1263          if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
1264              rgb = rgbToRgb(color.r, color.g, color.b);
1265              ok = true;
1266              format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
1267          }
1268          else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
1269              s = convertToPercentage(color.s);
1270              v = convertToPercentage(color.v);
1271              rgb = hsvToRgb(color.h, s, v);
1272              ok = true;
1273              format = "hsv";
1274          }
1275          else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
1276              s = convertToPercentage(color.s);
1277              l = convertToPercentage(color.l);
1278              rgb = hslToRgb(color.h, s, l);
1279              ok = true;
1280              format = "hsl";
1281          }
1282  
1283          if (color.hasOwnProperty("a")) {
1284              a = color.a;
1285          }
1286      }
1287  
1288      a = boundAlpha(a);
1289  
1290      return {
1291          ok: ok,
1292          format: color.format || format,
1293          r: mathMin(255, mathMax(rgb.r, 0)),
1294          g: mathMin(255, mathMax(rgb.g, 0)),
1295          b: mathMin(255, mathMax(rgb.b, 0)),
1296          a: a
1297      };
1298  }
1299  
1300  
1301  // Conversion Functions
1302  // --------------------
1303  
1304  // `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
1305  // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
1306  
1307  // `rgbToRgb`
1308  // Handle bounds / percentage checking to conform to CSS color spec
1309  // <http://www.w3.org/TR/css3-color/>
1310  // *Assumes:* r, g, b in [0, 255] or [0, 1]
1311  // *Returns:* { r, g, b } in [0, 255]
1312  function rgbToRgb(r, g, b){
1313      return {
1314          r: bound01(r, 255) * 255,
1315          g: bound01(g, 255) * 255,
1316          b: bound01(b, 255) * 255
1317      };
1318  }
1319  
1320  // `rgbToHsl`
1321  // Converts an RGB color value to HSL.
1322  // *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
1323  // *Returns:* { h, s, l } in [0,1]
1324  function rgbToHsl(r, g, b) {
1325  
1326      r = bound01(r, 255);
1327      g = bound01(g, 255);
1328      b = bound01(b, 255);
1329  
1330      var max = mathMax(r, g, b), min = mathMin(r, g, b);
1331      var h, s, l = (max + min) / 2;
1332  
1333      if(max == min) {
1334          h = s = 0; // achromatic
1335      }
1336      else {
1337          var d = max - min;
1338          s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
1339          switch(max) {
1340              case r: h = (g - b) / d + (g < b ? 6 : 0); break;
1341              case g: h = (b - r) / d + 2; break;
1342              case b: h = (r - g) / d + 4; break;
1343          }
1344  
1345          h /= 6;
1346      }
1347  
1348      return { h: h, s: s, l: l };
1349  }
1350  
1351  // `hslToRgb`
1352  // Converts an HSL color value to RGB.
1353  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
1354  // *Returns:* { r, g, b } in the set [0, 255]
1355  function hslToRgb(h, s, l) {
1356      var r, g, b;
1357  
1358      h = bound01(h, 360);
1359      s = bound01(s, 100);
1360      l = bound01(l, 100);
1361  
1362      function hue2rgb(p, q, t) {
1363          if(t < 0) t += 1;
1364          if(t > 1) t -= 1;
1365          if(t < 1/6) return p + (q - p) * 6 * t;
1366          if(t < 1/2) return q;
1367          if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
1368          return p;
1369      }
1370  
1371      if(s === 0) {
1372          r = g = b = l; // achromatic
1373      }
1374      else {
1375          var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
1376          var p = 2 * l - q;
1377          r = hue2rgb(p, q, h + 1/3);
1378          g = hue2rgb(p, q, h);
1379          b = hue2rgb(p, q, h - 1/3);
1380      }
1381  
1382      return { r: r * 255, g: g * 255, b: b * 255 };
1383  }
1384  
1385  // `rgbToHsv`
1386  // Converts an RGB color value to HSV
1387  // *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
1388  // *Returns:* { h, s, v } in [0,1]
1389  function rgbToHsv(r, g, b) {
1390  
1391      r = bound01(r, 255);
1392      g = bound01(g, 255);
1393      b = bound01(b, 255);
1394  
1395      var max = mathMax(r, g, b), min = mathMin(r, g, b);
1396      var h, s, v = max;
1397  
1398      var d = max - min;
1399      s = max === 0 ? 0 : d / max;
1400  
1401      if(max == min) {
1402          h = 0; // achromatic
1403      }
1404      else {
1405          switch(max) {
1406              case r: h = (g - b) / d + (g < b ? 6 : 0); break;
1407              case g: h = (b - r) / d + 2; break;
1408              case b: h = (r - g) / d + 4; break;
1409          }
1410          h /= 6;
1411      }
1412      return { h: h, s: s, v: v };
1413  }
1414  
1415  // `hsvToRgb`
1416  // Converts an HSV color value to RGB.
1417  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
1418  // *Returns:* { r, g, b } in the set [0, 255]
1419   function hsvToRgb(h, s, v) {
1420  
1421      h = bound01(h, 360) * 6;
1422      s = bound01(s, 100);
1423      v = bound01(v, 100);
1424  
1425      var i = Math.floor(h),
1426          f = h - i,
1427          p = v * (1 - s),
1428          q = v * (1 - f * s),
1429          t = v * (1 - (1 - f) * s),
1430          mod = i % 6,
1431          r = [v, q, p, p, t, v][mod],
1432          g = [t, v, v, q, p, p][mod],
1433          b = [p, p, t, v, v, q][mod];
1434  
1435      return { r: r * 255, g: g * 255, b: b * 255 };
1436  }
1437  
1438  // `rgbToHex`
1439  // Converts an RGB color to hex
1440  // Assumes r, g, and b are contained in the set [0, 255]
1441  // Returns a 3 or 6 character hex
1442  function rgbToHex(r, g, b, allow3Char) {
1443  
1444      var hex = [
1445          pad2(mathRound(r).toString(16)),
1446          pad2(mathRound(g).toString(16)),
1447          pad2(mathRound(b).toString(16))
1448      ];
1449  
1450      // Return a 3 character hex if possible
1451      if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
1452          return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
1453      }
1454  
1455      return hex.join("");
1456  }
1457  
1458  // `rgbaToHex`
1459  // Converts an RGBA color plus alpha transparency to hex
1460  // Assumes r, g, b are contained in the set [0, 255] and
1461  // a in [0, 1]. Returns a 4 or 8 character rgba hex
1462  function rgbaToHex(r, g, b, a, allow4Char) {
1463  
1464      var hex = [
1465          pad2(mathRound(r).toString(16)),
1466          pad2(mathRound(g).toString(16)),
1467          pad2(mathRound(b).toString(16)),
1468          pad2(convertDecimalToHex(a))
1469      ];
1470  
1471      // Return a 4 character hex if possible
1472      if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {
1473          return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
1474      }
1475  
1476      return hex.join("");
1477  }
1478  
1479  // `rgbaToArgbHex`
1480  // Converts an RGBA color to an ARGB Hex8 string
1481  // Rarely used, but required for "toFilter()"
1482  function rgbaToArgbHex(r, g, b, a) {
1483  
1484      var hex = [
1485          pad2(convertDecimalToHex(a)),
1486          pad2(mathRound(r).toString(16)),
1487          pad2(mathRound(g).toString(16)),
1488          pad2(mathRound(b).toString(16))
1489      ];
1490  
1491      return hex.join("");
1492  }
1493  
1494  // `equals`
1495  // Can be called with any tinycolor input
1496  tinycolor.equals = function (color1, color2) {
1497      if (!color1 || !color2) { return false; }
1498      return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
1499  };
1500  
1501  tinycolor.random = function() {
1502      return tinycolor.fromRatio({
1503          r: mathRandom(),
1504          g: mathRandom(),
1505          b: mathRandom()
1506      });
1507  };
1508  
1509  
1510  // Modification Functions
1511  // ----------------------
1512  // Thanks to less.js for some of the basics here
1513  // <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
1514  
1515  function desaturate(color, amount) {
1516      amount = (amount === 0) ? 0 : (amount || 10);
1517      var hsl = tinycolor(color).toHsl();
1518      hsl.s -= amount / 100;
1519      hsl.s = clamp01(hsl.s);
1520      return tinycolor(hsl);
1521  }
1522  
1523  function saturate(color, amount) {
1524      amount = (amount === 0) ? 0 : (amount || 10);
1525      var hsl = tinycolor(color).toHsl();
1526      hsl.s += amount / 100;
1527      hsl.s = clamp01(hsl.s);
1528      return tinycolor(hsl);
1529  }
1530  
1531  function greyscale(color) {
1532      return tinycolor(color).desaturate(100);
1533  }
1534  
1535  function lighten (color, amount) {
1536      amount = (amount === 0) ? 0 : (amount || 10);
1537      var hsl = tinycolor(color).toHsl();
1538      hsl.l += amount / 100;
1539      hsl.l = clamp01(hsl.l);
1540      return tinycolor(hsl);
1541  }
1542  
1543  function brighten(color, amount) {
1544      amount = (amount === 0) ? 0 : (amount || 10);
1545      var rgb = tinycolor(color).toRgb();
1546      rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));
1547      rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));
1548      rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));
1549      return tinycolor(rgb);
1550  }
1551  
1552  function darken (color, amount) {
1553      amount = (amount === 0) ? 0 : (amount || 10);
1554      var hsl = tinycolor(color).toHsl();
1555      hsl.l -= amount / 100;
1556      hsl.l = clamp01(hsl.l);
1557      return tinycolor(hsl);
1558  }
1559  
1560  // Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
1561  // Values outside of this range will be wrapped into this range.
1562  function spin(color, amount) {
1563      var hsl = tinycolor(color).toHsl();
1564      var hue = (hsl.h + amount) % 360;
1565      hsl.h = hue < 0 ? 360 + hue : hue;
1566      return tinycolor(hsl);
1567  }
1568  
1569  // Combination Functions
1570  // ---------------------
1571  // Thanks to jQuery xColor for some of the ideas behind these
1572  // <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
1573  
1574  function complement(color) {
1575      var hsl = tinycolor(color).toHsl();
1576      hsl.h = (hsl.h + 180) % 360;
1577      return tinycolor(hsl);
1578  }
1579  
1580  function triad(color) {
1581      var hsl = tinycolor(color).toHsl();
1582      var h = hsl.h;
1583      return [
1584          tinycolor(color),
1585          tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
1586          tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })
1587      ];
1588  }
1589  
1590  function tetrad(color) {
1591      var hsl = tinycolor(color).toHsl();
1592      var h = hsl.h;
1593      return [
1594          tinycolor(color),
1595          tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
1596          tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
1597          tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })
1598      ];
1599  }
1600  
1601  function splitcomplement(color) {
1602      var hsl = tinycolor(color).toHsl();
1603      var h = hsl.h;
1604      return [
1605          tinycolor(color),
1606          tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),
1607          tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})
1608      ];
1609  }
1610  
1611  function analogous(color, results, slices) {
1612      results = results || 6;
1613      slices = slices || 30;
1614  
1615      var hsl = tinycolor(color).toHsl();
1616      var part = 360 / slices;
1617      var ret = [tinycolor(color)];
1618  
1619      for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
1620          hsl.h = (hsl.h + part) % 360;
1621          ret.push(tinycolor(hsl));
1622      }
1623      return ret;
1624  }
1625  
1626  function monochromatic(color, results) {
1627      results = results || 6;
1628      var hsv = tinycolor(color).toHsv();
1629      var h = hsv.h, s = hsv.s, v = hsv.v;
1630      var ret = [];
1631      var modification = 1 / results;
1632  
1633      while (results--) {
1634          ret.push(tinycolor({ h: h, s: s, v: v}));
1635          v = (v + modification) % 1;
1636      }
1637  
1638      return ret;
1639  }
1640  
1641  // Utility Functions
1642  // ---------------------
1643  
1644  tinycolor.mix = function(color1, color2, amount) {
1645      amount = (amount === 0) ? 0 : (amount || 50);
1646  
1647      var rgb1 = tinycolor(color1).toRgb();
1648      var rgb2 = tinycolor(color2).toRgb();
1649  
1650      var p = amount / 100;
1651  
1652      var rgba = {
1653          r: ((rgb2.r - rgb1.r) * p) + rgb1.r,
1654          g: ((rgb2.g - rgb1.g) * p) + rgb1.g,
1655          b: ((rgb2.b - rgb1.b) * p) + rgb1.b,
1656          a: ((rgb2.a - rgb1.a) * p) + rgb1.a
1657      };
1658  
1659      return tinycolor(rgba);
1660  };
1661  
1662  
1663  // Readability Functions
1664  // ---------------------
1665  // <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
1666  
1667  // `contrast`
1668  // Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
1669  tinycolor.readability = function(color1, color2) {
1670      var c1 = tinycolor(color1);
1671      var c2 = tinycolor(color2);
1672      return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);
1673  };
1674  
1675  // `isReadable`
1676  // Ensure that foreground and background color combinations meet WCAG2 guidelines.
1677  // The third argument is an optional Object.
1678  //      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
1679  //      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
1680  // If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
1681  
1682  // *Example*
1683  //    tinycolor.isReadable("#000", "#111") => false
1684  //    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
1685  tinycolor.isReadable = function(color1, color2, wcag2) {
1686      var readability = tinycolor.readability(color1, color2);
1687      var wcag2Parms, out;
1688  
1689      out = false;
1690  
1691      wcag2Parms = validateWCAG2Parms(wcag2);
1692      switch (wcag2Parms.level + wcag2Parms.size) {
1693          case "AAsmall":
1694          case "AAAlarge":
1695              out = readability >= 4.5;
1696              break;
1697          case "AAlarge":
1698              out = readability >= 3;
1699              break;
1700          case "AAAsmall":
1701              out = readability >= 7;
1702              break;
1703      }
1704      return out;
1705  
1706  };
1707  
1708  // `mostReadable`
1709  // Given a base color and a list of possible foreground or background
1710  // colors for that base, returns the most readable color.
1711  // Optionally returns Black or White if the most readable color is unreadable.
1712  // *Example*
1713  //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255"
1714  //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
1715  //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
1716  //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
1717  tinycolor.mostReadable = function(baseColor, colorList, args) {
1718      var bestColor = null;
1719      var bestScore = 0;
1720      var readability;
1721      var includeFallbackColors, level, size ;
1722      args = args || {};
1723      includeFallbackColors = args.includeFallbackColors ;
1724      level = args.level;
1725      size = args.size;
1726  
1727      for (var i= 0; i < colorList.length ; i++) {
1728          readability = tinycolor.readability(baseColor, colorList[i]);
1729          if (readability > bestScore) {
1730              bestScore = readability;
1731              bestColor = tinycolor(colorList[i]);
1732          }
1733      }
1734  
1735      if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) {
1736          return bestColor;
1737      }
1738      else {
1739          args.includeFallbackColors=false;
1740          return tinycolor.mostReadable(baseColor,["#fff", "#000"],args);
1741      }
1742  };
1743  
1744  
1745  // Big List of Colors
1746  // ------------------
1747  // <http://www.w3.org/TR/css3-color/#svg-color>
1748  var names = tinycolor.names = {
1749      aliceblue: "f0f8ff",
1750      antiquewhite: "faebd7",
1751      aqua: "0ff",
1752      aquamarine: "7fffd4",
1753      azure: "f0ffff",
1754      beige: "f5f5dc",
1755      bisque: "ffe4c4",
1756      black: "000",
1757      blanchedalmond: "ffebcd",
1758      blue: "00f",
1759      blueviolet: "8a2be2",
1760      brown: "a52a2a",
1761      burlywood: "deb887",
1762      burntsienna: "ea7e5d",
1763      cadetblue: "5f9ea0",
1764      chartreuse: "7fff00",
1765      chocolate: "d2691e",
1766      coral: "ff7f50",
1767      cornflowerblue: "6495ed",
1768      cornsilk: "fff8dc",
1769      crimson: "dc143c",
1770      cyan: "0ff",
1771      darkblue: "00008b",
1772      darkcyan: "008b8b",
1773      darkgoldenrod: "b8860b",
1774      darkgray: "a9a9a9",
1775      darkgreen: "006400",
1776      darkgrey: "a9a9a9",
1777      darkkhaki: "bdb76b",
1778      darkmagenta: "8b008b",
1779      darkolivegreen: "556b2f",
1780      darkorange: "ff8c00",
1781      darkorchid: "9932cc",
1782      darkred: "8b0000",
1783      darksalmon: "e9967a",
1784      darkseagreen: "8fbc8f",
1785      darkslateblue: "483d8b",
1786      darkslategray: "2f4f4f",
1787      darkslategrey: "2f4f4f",
1788      darkturquoise: "00ced1",
1789      darkviolet: "9400d3",
1790      deeppink: "ff1493",
1791      deepskyblue: "00bfff",
1792      dimgray: "696969",
1793      dimgrey: "696969",
1794      dodgerblue: "1e90ff",
1795      firebrick: "b22222",
1796      floralwhite: "fffaf0",
1797      forestgreen: "228b22",
1798      fuchsia: "f0f",
1799      gainsboro: "dcdcdc",
1800      ghostwhite: "f8f8ff",
1801      gold: "ffd700",
1802      goldenrod: "daa520",
1803      gray: "808080",
1804      green: "008000",
1805      greenyellow: "adff2f",
1806      grey: "808080",
1807      honeydew: "f0fff0",
1808      hotpink: "ff69b4",
1809      indianred: "cd5c5c",
1810      indigo: "4b0082",
1811      ivory: "fffff0",
1812      khaki: "f0e68c",
1813      lavender: "e6e6fa",
1814      lavenderblush: "fff0f5",
1815      lawngreen: "7cfc00",
1816      lemonchiffon: "fffacd",
1817      lightblue: "add8e6",
1818      lightcoral: "f08080",
1819      lightcyan: "e0ffff",
1820      lightgoldenrodyellow: "fafad2",
1821      lightgray: "d3d3d3",
1822      lightgreen: "90ee90",
1823      lightgrey: "d3d3d3",
1824      lightpink: "ffb6c1",
1825      lightsalmon: "ffa07a",
1826      lightseagreen: "20b2aa",
1827      lightskyblue: "87cefa",
1828      lightslategray: "789",
1829      lightslategrey: "789",
1830      lightsteelblue: "b0c4de",
1831      lightyellow: "ffffe0",
1832      lime: "0f0",
1833      limegreen: "32cd32",
1834      linen: "faf0e6",
1835      magenta: "f0f",
1836      maroon: "800000",
1837      mediumaquamarine: "66cdaa",
1838      mediumblue: "0000cd",
1839      mediumorchid: "ba55d3",
1840      mediumpurple: "9370db",
1841      mediumseagreen: "3cb371",
1842      mediumslateblue: "7b68ee",
1843      mediumspringgreen: "00fa9a",
1844      mediumturquoise: "48d1cc",
1845      mediumvioletred: "c71585",
1846      midnightblue: "191970",
1847      mintcream: "f5fffa",
1848      mistyrose: "ffe4e1",
1849      moccasin: "ffe4b5",
1850      navajowhite: "ffdead",
1851      navy: "000080",
1852      oldlace: "fdf5e6",
1853      olive: "808000",
1854      olivedrab: "6b8e23",
1855      orange: "ffa500",
1856      orangered: "ff4500",
1857      orchid: "da70d6",
1858      palegoldenrod: "eee8aa",
1859      palegreen: "98fb98",
1860      paleturquoise: "afeeee",
1861      palevioletred: "db7093",
1862      papayawhip: "ffefd5",
1863      peachpuff: "ffdab9",
1864      peru: "cd853f",
1865      pink: "ffc0cb",
1866      plum: "dda0dd",
1867      powderblue: "b0e0e6",
1868      purple: "800080",
1869      rebeccapurple: "663399",
1870      red: "f00",
1871      rosybrown: "bc8f8f",
1872      royalblue: "4169e1",
1873      saddlebrown: "8b4513",
1874      salmon: "fa8072",
1875      sandybrown: "f4a460",
1876      seagreen: "2e8b57",
1877      seashell: "fff5ee",
1878      sienna: "a0522d",
1879      silver: "c0c0c0",
1880      skyblue: "87ceeb",
1881      slateblue: "6a5acd",
1882      slategray: "708090",
1883      slategrey: "708090",
1884      snow: "fffafa",
1885      springgreen: "00ff7f",
1886      steelblue: "4682b4",
1887      tan: "d2b48c",
1888      teal: "008080",
1889      thistle: "d8bfd8",
1890      tomato: "ff6347",
1891      turquoise: "40e0d0",
1892      violet: "ee82ee",
1893      wheat: "f5deb3",
1894      white: "fff",
1895      whitesmoke: "f5f5f5",
1896      yellow: "ff0",
1897      yellowgreen: "9acd32"
1898  };
1899  
1900  // Make it easy to access colors via `hexNames[hex]`
1901  var hexNames = tinycolor.hexNames = flip(names);
1902  
1903  
1904  // Utilities
1905  // ---------
1906  
1907  // `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
1908  function flip(o) {
1909      var flipped = { };
1910      for (var i in o) {
1911          if (o.hasOwnProperty(i)) {
1912              flipped[o[i]] = i;
1913          }
1914      }
1915      return flipped;
1916  }
1917  
1918  // Return a valid alpha value [0,1] with all invalid values being set to 1
1919  function boundAlpha(a) {
1920      a = parseFloat(a);
1921  
1922      if (isNaN(a) || a < 0 || a > 1) {
1923          a = 1;
1924      }
1925  
1926      return a;
1927  }
1928  
1929  // Take input from [0, n] and return it as [0, 1]
1930  function bound01(n, max) {
1931      if (isOnePointZero(n)) { n = "100%"; }
1932  
1933      var processPercent = isPercentage(n);
1934      n = mathMin(max, mathMax(0, parseFloat(n)));
1935  
1936      // Automatically convert percentage into number
1937      if (processPercent) {
1938          n = parseInt(n * max, 10) / 100;
1939      }
1940  
1941      // Handle floating point rounding errors
1942      if ((Math.abs(n - max) < 0.000001)) {
1943          return 1;
1944      }
1945  
1946      // Convert into [0, 1] range if it isn't already
1947      return (n % max) / parseFloat(max);
1948  }
1949  
1950  // Force a number between 0 and 1
1951  function clamp01(val) {
1952      return mathMin(1, mathMax(0, val));
1953  }
1954  
1955  // Parse a base-16 hex value into a base-10 integer
1956  function parseIntFromHex(val) {
1957      return parseInt(val, 16);
1958  }
1959  
1960  // Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
1961  // <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
1962  function isOnePointZero(n) {
1963      return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
1964  }
1965  
1966  // Check to see if string passed in is a percentage
1967  function isPercentage(n) {
1968      return typeof n === "string" && n.indexOf('%') != -1;
1969  }
1970  
1971  // Force a hex value to have 2 characters
1972  function pad2(c) {
1973      return c.length == 1 ? '0' + c : '' + c;
1974  }
1975  
1976  // Replace a decimal with it's percentage value
1977  function convertToPercentage(n) {
1978      if (n <= 1) {
1979          n = (n * 100) + "%";
1980      }
1981  
1982      return n;
1983  }
1984  
1985  // Converts a decimal to a hex value
1986  function convertDecimalToHex(d) {
1987      return Math.round(parseFloat(d) * 255).toString(16);
1988  }
1989  // Converts a hex value to a decimal
1990  function convertHexToDecimal(h) {
1991      return (parseIntFromHex(h) / 255);
1992  }
1993  
1994  var matchers = (function() {
1995  
1996      // <http://www.w3.org/TR/css3-values/#integers>
1997      var CSS_INTEGER = "[-\\+]?\\d+%?";
1998  
1999      // <http://www.w3.org/TR/css3-values/#number-value>
2000      var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
2001  
2002      // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
2003      var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
2004  
2005      // Actual matching.
2006      // Parentheses and commas are optional, but not required.
2007      // Whitespace can take the place of commas or opening paren
2008      var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
2009      var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
2010  
2011      return {
2012          CSS_UNIT: new RegExp(CSS_UNIT),
2013          rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
2014          rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
2015          hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
2016          hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
2017          hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
2018          hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
2019          hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
2020          hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
2021          hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
2022          hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
2023      };
2024  })();
2025  
2026  // `isValidCSSUnit`
2027  // Take in a single string / number and check to see if it looks like a CSS unit
2028  // (see `matchers` above for definition).
2029  function isValidCSSUnit(color) {
2030      return !!matchers.CSS_UNIT.exec(color);
2031  }
2032  
2033  // `stringInputToObject`
2034  // Permissive string parsing.  Take in a number of formats, and output an object
2035  // based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
2036  function stringInputToObject(color) {
2037  
2038      color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
2039      var named = false;
2040      if (names[color]) {
2041          color = names[color];
2042          named = true;
2043      }
2044      else if (color == 'transparent') {
2045          return { r: 0, g: 0, b: 0, a: 0, format: "name" };
2046      }
2047  
2048      // Try to match string input using regular expressions.
2049      // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
2050      // Just return an object and let the conversion functions handle that.
2051      // This way the result will be the same whether the tinycolor is initialized with string or object.
2052      var match;
2053      if ((match = matchers.rgb.exec(color))) {
2054          return { r: match[1], g: match[2], b: match[3] };
2055      }
2056      if ((match = matchers.rgba.exec(color))) {
2057          return { r: match[1], g: match[2], b: match[3], a: match[4] };
2058      }
2059      if ((match = matchers.hsl.exec(color))) {
2060          return { h: match[1], s: match[2], l: match[3] };
2061      }
2062      if ((match = matchers.hsla.exec(color))) {
2063          return { h: match[1], s: match[2], l: match[3], a: match[4] };
2064      }
2065      if ((match = matchers.hsv.exec(color))) {
2066          return { h: match[1], s: match[2], v: match[3] };
2067      }
2068      if ((match = matchers.hsva.exec(color))) {
2069          return { h: match[1], s: match[2], v: match[3], a: match[4] };
2070      }
2071      if ((match = matchers.hex8.exec(color))) {
2072          return {
2073              r: parseIntFromHex(match[1]),
2074              g: parseIntFromHex(match[2]),
2075              b: parseIntFromHex(match[3]),
2076              a: convertHexToDecimal(match[4]),
2077              format: named ? "name" : "hex8"
2078          };
2079      }
2080      if ((match = matchers.hex6.exec(color))) {
2081          return {
2082              r: parseIntFromHex(match[1]),
2083              g: parseIntFromHex(match[2]),
2084              b: parseIntFromHex(match[3]),
2085              format: named ? "name" : "hex"
2086          };
2087      }
2088      if ((match = matchers.hex4.exec(color))) {
2089          return {
2090              r: parseIntFromHex(match[1] + '' + match[1]),
2091              g: parseIntFromHex(match[2] + '' + match[2]),
2092              b: parseIntFromHex(match[3] + '' + match[3]),
2093              a: convertHexToDecimal(match[4] + '' + match[4]),
2094              format: named ? "name" : "hex8"
2095          };
2096      }
2097      if ((match = matchers.hex3.exec(color))) {
2098          return {
2099              r: parseIntFromHex(match[1] + '' + match[1]),
2100              g: parseIntFromHex(match[2] + '' + match[2]),
2101              b: parseIntFromHex(match[3] + '' + match[3]),
2102              format: named ? "name" : "hex"
2103          };
2104      }
2105  
2106      return false;
2107  }
2108  
2109  function validateWCAG2Parms(parms) {
2110      // return valid WCAG2 parms for isReadable.
2111      // If input parms are invalid, return {"level":"AA", "size":"small"}
2112      var level, size;
2113      parms = parms || {"level":"AA", "size":"small"};
2114      level = (parms.level || "AA").toUpperCase();
2115      size = (parms.size || "small").toLowerCase();
2116      if (level !== "AA" && level !== "AAA") {
2117          level = "AA";
2118      }
2119      if (size !== "small" && size !== "large") {
2120          size = "small";
2121      }
2122      return {"level":level, "size":size};
2123  }
2124  
2125  // Node: Export function
2126  if ( true && module.exports) {
2127      module.exports = tinycolor;
2128  }
2129  // AMD/requirejs: Define the module
2130  else if (true) {
2131      !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {return tinycolor;}).call(exports, __webpack_require__, exports, module),
2132                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
2133  }
2134  // Browser: Expose to window
2135  else {}
2136  
2137  })(Math);
2138  
2139  
2140  /***/ }),
2141  /* 49 */,
2142  /* 50 */,
2143  /* 51 */
2144  /***/ (function(module, exports, __webpack_require__) {
2145  
2146  "use strict";
2147  
2148  
2149  var defineProperties = __webpack_require__(64);
2150  
2151  var implementation = __webpack_require__(167);
2152  var getPolyfill = __webpack_require__(168);
2153  var shim = __webpack_require__(283);
2154  
2155  var polyfill = getPolyfill();
2156  
2157  defineProperties(polyfill, {
2158      getPolyfill: getPolyfill,
2159      implementation: implementation,
2160      shim: shim
2161  });
2162  
2163  module.exports = polyfill;
2164  
2165  
2166  /***/ }),
2167  /* 52 */
2168  /***/ (function(module, exports, __webpack_require__) {
2169  
2170  "use strict";
2171  
2172  
2173  Object.defineProperty(exports, "__esModule", {
2174    value: true
2175  });
2176  var calendarLabel = 'Calendar';
2177  var closeDatePicker = 'Close';
2178  var focusStartDate = 'Interact with the calendar and add the check-in date for your trip.';
2179  var clearDate = 'Clear Date';
2180  var clearDates = 'Clear Dates';
2181  var jumpToPrevMonth = 'Move backward to switch to the previous month.';
2182  var jumpToNextMonth = 'Move forward to switch to the next month.';
2183  var keyboardShortcuts = 'Keyboard Shortcuts';
2184  var showKeyboardShortcutsPanel = 'Open the keyboard shortcuts panel.';
2185  var hideKeyboardShortcutsPanel = 'Close the shortcuts panel.';
2186  var openThisPanel = 'Open this panel.';
2187  var enterKey = 'Enter key';
2188  var leftArrowRightArrow = 'Right and left arrow keys';
2189  var upArrowDownArrow = 'up and down arrow keys';
2190  var pageUpPageDown = 'page up and page down keys';
2191  var homeEnd = 'Home and end keys';
2192  var escape = 'Escape key';
2193  var questionMark = 'Question mark';
2194  var selectFocusedDate = 'Select the date in focus.';
2195  var moveFocusByOneDay = 'Move backward (left) and forward (right) by one day.';
2196  var moveFocusByOneWeek = 'Move backward (up) and forward (down) by one week.';
2197  var moveFocusByOneMonth = 'Switch months.';
2198  var moveFocustoStartAndEndOfWeek = 'Go to the first or last day of a week.';
2199  var returnFocusToInput = 'Return to the date input field.';
2200  var keyboardNavigationInstructions = 'Press the down arrow key to interact with the calendar and\n  select a date. Press the question mark key to get the keyboard shortcuts for changing dates.';
2201  
2202  var chooseAvailableStartDate = function chooseAvailableStartDate(_ref) {
2203    var date = _ref.date;
2204    return 'Choose ' + String(date) + ' as your check-in date. It\u2019s available.';
2205  };
2206  var chooseAvailableEndDate = function chooseAvailableEndDate(_ref2) {
2207    var date = _ref2.date;
2208    return 'Choose ' + String(date) + ' as your check-out date. It\u2019s available.';
2209  };
2210  var chooseAvailableDate = function chooseAvailableDate(_ref3) {
2211    var date = _ref3.date;
2212    return date;
2213  };
2214  var dateIsUnavailable = function dateIsUnavailable(_ref4) {
2215    var date = _ref4.date;
2216    return 'Not available. ' + String(date);
2217  };
2218  var dateIsSelected = function dateIsSelected(_ref5) {
2219    var date = _ref5.date;
2220    return 'Selected. ' + String(date);
2221  };
2222  
2223  exports['default'] = {
2224    calendarLabel: calendarLabel,
2225    closeDatePicker: closeDatePicker,
2226    focusStartDate: focusStartDate,
2227    clearDate: clearDate,
2228    clearDates: clearDates,
2229    jumpToPrevMonth: jumpToPrevMonth,
2230    jumpToNextMonth: jumpToNextMonth,
2231    keyboardShortcuts: keyboardShortcuts,
2232    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
2233    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
2234    openThisPanel: openThisPanel,
2235    enterKey: enterKey,
2236    leftArrowRightArrow: leftArrowRightArrow,
2237    upArrowDownArrow: upArrowDownArrow,
2238    pageUpPageDown: pageUpPageDown,
2239    homeEnd: homeEnd,
2240    escape: escape,
2241    questionMark: questionMark,
2242    selectFocusedDate: selectFocusedDate,
2243    moveFocusByOneDay: moveFocusByOneDay,
2244    moveFocusByOneWeek: moveFocusByOneWeek,
2245    moveFocusByOneMonth: moveFocusByOneMonth,
2246    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
2247    returnFocusToInput: returnFocusToInput,
2248    keyboardNavigationInstructions: keyboardNavigationInstructions,
2249  
2250    chooseAvailableStartDate: chooseAvailableStartDate,
2251    chooseAvailableEndDate: chooseAvailableEndDate,
2252    dateIsUnavailable: dateIsUnavailable,
2253    dateIsSelected: dateIsSelected
2254  };
2255  var DateRangePickerPhrases = exports.DateRangePickerPhrases = {
2256    calendarLabel: calendarLabel,
2257    closeDatePicker: closeDatePicker,
2258    clearDates: clearDates,
2259    focusStartDate: focusStartDate,
2260    jumpToPrevMonth: jumpToPrevMonth,
2261    jumpToNextMonth: jumpToNextMonth,
2262    keyboardShortcuts: keyboardShortcuts,
2263    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
2264    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
2265    openThisPanel: openThisPanel,
2266    enterKey: enterKey,
2267    leftArrowRightArrow: leftArrowRightArrow,
2268    upArrowDownArrow: upArrowDownArrow,
2269    pageUpPageDown: pageUpPageDown,
2270    homeEnd: homeEnd,
2271    escape: escape,
2272    questionMark: questionMark,
2273    selectFocusedDate: selectFocusedDate,
2274    moveFocusByOneDay: moveFocusByOneDay,
2275    moveFocusByOneWeek: moveFocusByOneWeek,
2276    moveFocusByOneMonth: moveFocusByOneMonth,
2277    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
2278    returnFocusToInput: returnFocusToInput,
2279    keyboardNavigationInstructions: keyboardNavigationInstructions,
2280    chooseAvailableStartDate: chooseAvailableStartDate,
2281    chooseAvailableEndDate: chooseAvailableEndDate,
2282    dateIsUnavailable: dateIsUnavailable,
2283    dateIsSelected: dateIsSelected
2284  };
2285  
2286  var DateRangePickerInputPhrases = exports.DateRangePickerInputPhrases = {
2287    focusStartDate: focusStartDate,
2288    clearDates: clearDates,
2289    keyboardNavigationInstructions: keyboardNavigationInstructions
2290  };
2291  
2292  var SingleDatePickerPhrases = exports.SingleDatePickerPhrases = {
2293    calendarLabel: calendarLabel,
2294    closeDatePicker: closeDatePicker,
2295    clearDate: clearDate,
2296    jumpToPrevMonth: jumpToPrevMonth,
2297    jumpToNextMonth: jumpToNextMonth,
2298    keyboardShortcuts: keyboardShortcuts,
2299    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
2300    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
2301    openThisPanel: openThisPanel,
2302    enterKey: enterKey,
2303    leftArrowRightArrow: leftArrowRightArrow,
2304    upArrowDownArrow: upArrowDownArrow,
2305    pageUpPageDown: pageUpPageDown,
2306    homeEnd: homeEnd,
2307    escape: escape,
2308    questionMark: questionMark,
2309    selectFocusedDate: selectFocusedDate,
2310    moveFocusByOneDay: moveFocusByOneDay,
2311    moveFocusByOneWeek: moveFocusByOneWeek,
2312    moveFocusByOneMonth: moveFocusByOneMonth,
2313    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
2314    returnFocusToInput: returnFocusToInput,
2315    keyboardNavigationInstructions: keyboardNavigationInstructions,
2316    chooseAvailableDate: chooseAvailableDate,
2317    dateIsUnavailable: dateIsUnavailable,
2318    dateIsSelected: dateIsSelected
2319  };
2320  
2321  var SingleDatePickerInputPhrases = exports.SingleDatePickerInputPhrases = {
2322    clearDate: clearDate,
2323    keyboardNavigationInstructions: keyboardNavigationInstructions
2324  };
2325  
2326  var DayPickerPhrases = exports.DayPickerPhrases = {
2327    calendarLabel: calendarLabel,
2328    jumpToPrevMonth: jumpToPrevMonth,
2329    jumpToNextMonth: jumpToNextMonth,
2330    keyboardShortcuts: keyboardShortcuts,
2331    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
2332    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
2333    openThisPanel: openThisPanel,
2334    enterKey: enterKey,
2335    leftArrowRightArrow: leftArrowRightArrow,
2336    upArrowDownArrow: upArrowDownArrow,
2337    pageUpPageDown: pageUpPageDown,
2338    homeEnd: homeEnd,
2339    escape: escape,
2340    questionMark: questionMark,
2341    selectFocusedDate: selectFocusedDate,
2342    moveFocusByOneDay: moveFocusByOneDay,
2343    moveFocusByOneWeek: moveFocusByOneWeek,
2344    moveFocusByOneMonth: moveFocusByOneMonth,
2345    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
2346    returnFocusToInput: returnFocusToInput,
2347    chooseAvailableStartDate: chooseAvailableStartDate,
2348    chooseAvailableEndDate: chooseAvailableEndDate,
2349    chooseAvailableDate: chooseAvailableDate,
2350    dateIsUnavailable: dateIsUnavailable,
2351    dateIsSelected: dateIsSelected
2352  };
2353  
2354  var DayPickerKeyboardShortcutsPhrases = exports.DayPickerKeyboardShortcutsPhrases = {
2355    keyboardShortcuts: keyboardShortcuts,
2356    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
2357    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
2358    openThisPanel: openThisPanel,
2359    enterKey: enterKey,
2360    leftArrowRightArrow: leftArrowRightArrow,
2361    upArrowDownArrow: upArrowDownArrow,
2362    pageUpPageDown: pageUpPageDown,
2363    homeEnd: homeEnd,
2364    escape: escape,
2365    questionMark: questionMark,
2366    selectFocusedDate: selectFocusedDate,
2367    moveFocusByOneDay: moveFocusByOneDay,
2368    moveFocusByOneWeek: moveFocusByOneWeek,
2369    moveFocusByOneMonth: moveFocusByOneMonth,
2370    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
2371    returnFocusToInput: returnFocusToInput
2372  };
2373  
2374  var DayPickerNavigationPhrases = exports.DayPickerNavigationPhrases = {
2375    jumpToPrevMonth: jumpToPrevMonth,
2376    jumpToNextMonth: jumpToNextMonth
2377  };
2378  
2379  var CalendarDayPhrases = exports.CalendarDayPhrases = {
2380    chooseAvailableDate: chooseAvailableDate,
2381    dateIsUnavailable: dateIsUnavailable,
2382    dateIsSelected: dateIsSelected
2383  };
2384  
2385  /***/ }),
2386  /* 53 */,
2387  /* 54 */,
2388  /* 55 */
2389  /***/ (function(module, exports, __webpack_require__) {
2390  
2391  "use strict";
2392  
2393  
2394  Object.defineProperty(exports, "__esModule", {
2395    value: true
2396  });
2397  exports['default'] = getPhrasePropTypes;
2398  
2399  var _object = __webpack_require__(51);
2400  
2401  var _object2 = _interopRequireDefault(_object);
2402  
2403  var _propTypes = __webpack_require__(28);
2404  
2405  var _propTypes2 = _interopRequireDefault(_propTypes);
2406  
2407  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
2408  
2409  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; }
2410  
2411  function getPhrasePropTypes(defaultPhrases) {
2412    return Object.keys(defaultPhrases).reduce(function (phrases, key) {
2413      return (0, _object2['default'])({}, phrases, _defineProperty({}, key, _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func, _propTypes2['default'].node])));
2414    }, {});
2415  }
2416  
2417  /***/ }),
2418  /* 56 */
2419  /***/ (function(module, exports, __webpack_require__) {
2420  
2421  "use strict";
2422  
2423  
2424  Object.defineProperty(exports, "__esModule", {
2425    value: true
2426  });
2427  exports.withStylesPropTypes = exports.css = undefined;
2428  
2429  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; };
2430  
2431  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; }; }();
2432  
2433  exports.withStyles = withStyles;
2434  
2435  var _object = __webpack_require__(51);
2436  
2437  var _object2 = _interopRequireDefault(_object);
2438  
2439  var _react = __webpack_require__(20);
2440  
2441  var _react2 = _interopRequireDefault(_react);
2442  
2443  var _propTypes = __webpack_require__(28);
2444  
2445  var _propTypes2 = _interopRequireDefault(_propTypes);
2446  
2447  var _hoistNonReactStatics = __webpack_require__(288);
2448  
2449  var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
2450  
2451  var _constants = __webpack_require__(291);
2452  
2453  var _brcast = __webpack_require__(292);
2454  
2455  var _brcast2 = _interopRequireDefault(_brcast);
2456  
2457  var _ThemedStyleSheet = __webpack_require__(165);
2458  
2459  var _ThemedStyleSheet2 = _interopRequireDefault(_ThemedStyleSheet);
2460  
2461  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
2462  
2463  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
2464  
2465  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; }
2466  
2467  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; }
2468  
2469  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; } /* eslint react/forbid-foreign-prop-types: off */
2470  
2471  // Add some named exports to assist in upgrading and for convenience
2472  var css = exports.css = _ThemedStyleSheet2['default'].resolveLTR;
2473  var withStylesPropTypes = exports.withStylesPropTypes = {
2474    styles: _propTypes2['default'].object.isRequired, // eslint-disable-line react/forbid-prop-types
2475    theme: _propTypes2['default'].object.isRequired, // eslint-disable-line react/forbid-prop-types
2476    css: _propTypes2['default'].func.isRequired
2477  };
2478  
2479  var EMPTY_STYLES = {};
2480  var EMPTY_STYLES_FN = function EMPTY_STYLES_FN() {
2481    return EMPTY_STYLES;
2482  };
2483  
2484  var START_MARK = 'react-with-styles.createStyles.start';
2485  var END_MARK = 'react-with-styles.createStyles.end';
2486  
2487  function baseClass(pureComponent) {
2488    if (pureComponent) {
2489      if (!_react2['default'].PureComponent) {
2490        throw new ReferenceError('withStyles() pureComponent option requires React 15.3.0 or later');
2491      }
2492  
2493      return _react2['default'].PureComponent;
2494    }
2495  
2496    return _react2['default'].Component;
2497  }
2498  
2499  var contextTypes = _defineProperty({}, _constants.CHANNEL, _brcast2['default']);
2500  
2501  var defaultDirection = _constants.DIRECTIONS.LTR;
2502  
2503  function withStyles(styleFn) {
2504    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
2505        _ref$stylesPropName = _ref.stylesPropName,
2506        stylesPropName = _ref$stylesPropName === undefined ? 'styles' : _ref$stylesPropName,
2507        _ref$themePropName = _ref.themePropName,
2508        themePropName = _ref$themePropName === undefined ? 'theme' : _ref$themePropName,
2509        _ref$cssPropName = _ref.cssPropName,
2510        cssPropName = _ref$cssPropName === undefined ? 'css' : _ref$cssPropName,
2511        _ref$flushBefore = _ref.flushBefore,
2512        flushBefore = _ref$flushBefore === undefined ? false : _ref$flushBefore,
2513        _ref$pureComponent = _ref.pureComponent,
2514        pureComponent = _ref$pureComponent === undefined ? false : _ref$pureComponent;
2515  
2516    var styleDefLTR = void 0;
2517    var styleDefRTL = void 0;
2518    var currentThemeLTR = void 0;
2519    var currentThemeRTL = void 0;
2520    var BaseClass = baseClass(pureComponent);
2521  
2522    function getResolveMethod(direction) {
2523      return direction === _constants.DIRECTIONS.LTR ? _ThemedStyleSheet2['default'].resolveLTR : _ThemedStyleSheet2['default'].resolveRTL;
2524    }
2525  
2526    function getCurrentTheme(direction) {
2527      return direction === _constants.DIRECTIONS.LTR ? currentThemeLTR : currentThemeRTL;
2528    }
2529  
2530    function getStyleDef(direction, wrappedComponentName) {
2531      var currentTheme = getCurrentTheme(direction);
2532      var styleDef = direction === _constants.DIRECTIONS.LTR ? styleDefLTR : styleDefRTL;
2533  
2534      var registeredTheme = _ThemedStyleSheet2['default'].get();
2535  
2536      // Return the existing styles if they've already been defined
2537      // and if the theme used to create them corresponds to the theme
2538      // registered with ThemedStyleSheet
2539      if (styleDef && currentTheme === registeredTheme) {
2540        return styleDef;
2541      }
2542  
2543      if (false) {}
2544  
2545      var isRTL = direction === _constants.DIRECTIONS.RTL;
2546  
2547      if (isRTL) {
2548        styleDefRTL = styleFn ? _ThemedStyleSheet2['default'].createRTL(styleFn) : EMPTY_STYLES_FN;
2549  
2550        currentThemeRTL = registeredTheme;
2551        styleDef = styleDefRTL;
2552      } else {
2553        styleDefLTR = styleFn ? _ThemedStyleSheet2['default'].createLTR(styleFn) : EMPTY_STYLES_FN;
2554  
2555        currentThemeLTR = registeredTheme;
2556        styleDef = styleDefLTR;
2557      }
2558  
2559      if (false) { var measureName; }
2560  
2561      return styleDef;
2562    }
2563  
2564    function getState(direction, wrappedComponentName) {
2565      return {
2566        resolveMethod: getResolveMethod(direction),
2567        styleDef: getStyleDef(direction, wrappedComponentName)
2568      };
2569    }
2570  
2571    return function () {
2572      function withStylesHOC(WrappedComponent) {
2573        var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';
2574  
2575        // NOTE: Use a class here so components are ref-able if need be:
2576        // eslint-disable-next-line react/prefer-stateless-function
2577  
2578        var WithStyles = function (_BaseClass) {
2579          _inherits(WithStyles, _BaseClass);
2580  
2581          function WithStyles(props, context) {
2582            _classCallCheck(this, WithStyles);
2583  
2584            var _this = _possibleConstructorReturn(this, (WithStyles.__proto__ || Object.getPrototypeOf(WithStyles)).call(this, props, context));
2585  
2586            var direction = _this.context[_constants.CHANNEL] ? _this.context[_constants.CHANNEL].getState() : defaultDirection;
2587  
2588            _this.state = getState(direction, wrappedComponentName);
2589            return _this;
2590          }
2591  
2592          _createClass(WithStyles, [{
2593            key: 'componentDidMount',
2594            value: function () {
2595              function componentDidMount() {
2596                var _this2 = this;
2597  
2598                if (this.context[_constants.CHANNEL]) {
2599                  // subscribe to future direction changes
2600                  this.channelUnsubscribe = this.context[_constants.CHANNEL].subscribe(function (direction) {
2601                    _this2.setState(getState(direction, wrappedComponentName));
2602                  });
2603                }
2604              }
2605  
2606              return componentDidMount;
2607            }()
2608          }, {
2609            key: 'componentWillUnmount',
2610            value: function () {
2611              function componentWillUnmount() {
2612                if (this.channelUnsubscribe) {
2613                  this.channelUnsubscribe();
2614                }
2615              }
2616  
2617              return componentWillUnmount;
2618            }()
2619          }, {
2620            key: 'render',
2621            value: function () {
2622              function render() {
2623                var _ref2;
2624  
2625                // As some components will depend on previous styles in
2626                // the component tree, we provide the option of flushing the
2627                // buffered styles (i.e. to a style tag) **before** the rendering
2628                // cycle begins.
2629                //
2630                // The interfaces provide the optional "flush" method which
2631                // is run in turn by ThemedStyleSheet.flush.
2632                if (flushBefore) {
2633                  _ThemedStyleSheet2['default'].flush();
2634                }
2635  
2636                var _state = this.state,
2637                    resolveMethod = _state.resolveMethod,
2638                    styleDef = _state.styleDef;
2639  
2640  
2641                return _react2['default'].createElement(WrappedComponent, _extends({}, this.props, (_ref2 = {}, _defineProperty(_ref2, themePropName, _ThemedStyleSheet2['default'].get()), _defineProperty(_ref2, stylesPropName, styleDef()), _defineProperty(_ref2, cssPropName, resolveMethod), _ref2)));
2642              }
2643  
2644              return render;
2645            }()
2646          }]);
2647  
2648          return WithStyles;
2649        }(BaseClass);
2650  
2651        WithStyles.WrappedComponent = WrappedComponent;
2652        WithStyles.displayName = 'withStyles(' + String(wrappedComponentName) + ')';
2653        WithStyles.contextTypes = contextTypes;
2654        if (WrappedComponent.propTypes) {
2655          WithStyles.propTypes = (0, _object2['default'])({}, WrappedComponent.propTypes);
2656          delete WithStyles.propTypes[stylesPropName];
2657          delete WithStyles.propTypes[themePropName];
2658          delete WithStyles.propTypes[cssPropName];
2659        }
2660        if (WrappedComponent.defaultProps) {
2661          WithStyles.defaultProps = (0, _object2['default'])({}, WrappedComponent.defaultProps);
2662        }
2663  
2664        return (0, _hoistNonReactStatics2['default'])(WithStyles, WrappedComponent);
2665      }
2666  
2667      return withStylesHOC;
2668    }();
2669  }
2670  
2671  /***/ }),
2672  /* 57 */
2673  /***/ (function(module, exports) {
2674  
2675  (function() { module.exports = this["ReactDOM"]; }());
2676  
2677  /***/ }),
2678  /* 58 */,
2679  /* 59 */,
2680  /* 60 */,
2681  /* 61 */
2682  /***/ (function(module, exports) {
2683  
2684  var g;
2685  
2686  // This works in non-strict mode
2687  g = (function() {
2688      return this;
2689  })();
2690  
2691  try {
2692      // This works if eval is allowed (see CSP)
2693      g = g || new Function("return this")();
2694  } catch (e) {
2695      // This works if the window reference is available
2696      if (typeof window === "object") g = window;
2697  }
2698  
2699  // g can still be undefined, but nothing to do about it...
2700  // We return undefined, instead of nothing here, so it's
2701  // easier to handle this case. if(!global) { ...}
2702  
2703  module.exports = g;
2704  
2705  
2706  /***/ }),
2707  /* 62 */,
2708  /* 63 */
2709  /***/ (function(module, exports, __webpack_require__) {
2710  
2711  "use strict";
2712  
2713  
2714  Object.defineProperty(exports, '__esModule', { value: true });
2715  
2716  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
2717  
2718  var _extends = _interopDefault(__webpack_require__(117));
2719  var _objectWithoutPropertiesLoose = _interopDefault(__webpack_require__(118));
2720  var React = __webpack_require__(20);
2721  var React__default = _interopDefault(React);
2722  var _inheritsLoose = _interopDefault(__webpack_require__(95));
2723  var _assertThisInitialized = _interopDefault(__webpack_require__(119));
2724  
2725  var is = {
2726    arr: Array.isArray,
2727    obj: function obj(a) {
2728      return Object.prototype.toString.call(a) === '[object Object]';
2729    },
2730    fun: function fun(a) {
2731      return typeof a === 'function';
2732    },
2733    str: function str(a) {
2734      return typeof a === 'string';
2735    },
2736    num: function num(a) {
2737      return typeof a === 'number';
2738    },
2739    und: function und(a) {
2740      return a === void 0;
2741    },
2742    nul: function nul(a) {
2743      return a === null;
2744    },
2745    set: function set(a) {
2746      return a instanceof Set;
2747    },
2748    map: function map(a) {
2749      return a instanceof Map;
2750    },
2751    equ: function equ(a, b) {
2752      if (typeof a !== typeof b) return false;
2753      if (is.str(a) || is.num(a)) return a === b;
2754      if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true;
2755      var i;
2756  
2757      for (i in a) {
2758        if (!(i in b)) return false;
2759      }
2760  
2761      for (i in b) {
2762        if (a[i] !== b[i]) return false;
2763      }
2764  
2765      return is.und(i) ? a === b : true;
2766    }
2767  };
2768  function merge(target, lowercase) {
2769    if (lowercase === void 0) {
2770      lowercase = true;
2771    }
2772  
2773    return function (object) {
2774      return (is.arr(object) ? object : Object.keys(object)).reduce(function (acc, element) {
2775        var key = lowercase ? element[0].toLowerCase() + element.substring(1) : element;
2776        acc[key] = target(key);
2777        return acc;
2778      }, target);
2779    };
2780  }
2781  function useForceUpdate() {
2782    var _useState = React.useState(false),
2783        f = _useState[1];
2784  
2785    var forceUpdate = React.useCallback(function () {
2786      return f(function (v) {
2787        return !v;
2788      });
2789    }, []);
2790    return forceUpdate;
2791  }
2792  function withDefault(value, defaultValue) {
2793    return is.und(value) || is.nul(value) ? defaultValue : value;
2794  }
2795  function toArray(a) {
2796    return !is.und(a) ? is.arr(a) ? a : [a] : [];
2797  }
2798  function callProp(obj) {
2799    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
2800      args[_key - 1] = arguments[_key];
2801    }
2802  
2803    return is.fun(obj) ? obj.apply(void 0, args) : obj;
2804  }
2805  
2806  function getForwardProps(props) {
2807    var to = props.to,
2808        from = props.from,
2809        config = props.config,
2810        onStart = props.onStart,
2811        onRest = props.onRest,
2812        onFrame = props.onFrame,
2813        children = props.children,
2814        reset = props.reset,
2815        reverse = props.reverse,
2816        force = props.force,
2817        immediate = props.immediate,
2818        delay = props.delay,
2819        attach = props.attach,
2820        destroyed = props.destroyed,
2821        interpolateTo = props.interpolateTo,
2822        ref = props.ref,
2823        lazy = props.lazy,
2824        forward = _objectWithoutPropertiesLoose(props, ["to", "from", "config", "onStart", "onRest", "onFrame", "children", "reset", "reverse", "force", "immediate", "delay", "attach", "destroyed", "interpolateTo", "ref", "lazy"]);
2825  
2826    return forward;
2827  }
2828  
2829  function interpolateTo(props) {
2830    var forward = getForwardProps(props);
2831    if (is.und(forward)) return _extends({
2832      to: forward
2833    }, props);
2834    var rest = Object.keys(props).reduce(function (a, k) {
2835      var _extends2;
2836  
2837      return !is.und(forward[k]) ? a : _extends({}, a, (_extends2 = {}, _extends2[k] = props[k], _extends2));
2838    }, {});
2839    return _extends({
2840      to: forward
2841    }, rest);
2842  }
2843  function handleRef(ref, forward) {
2844    if (forward) {
2845      // If it's a function, assume it's a ref callback
2846      if (is.fun(forward)) forward(ref);else if (is.obj(forward)) {
2847        forward.current = ref;
2848      }
2849    }
2850  
2851    return ref;
2852  }
2853  
2854  var Animated =
2855  /*#__PURE__*/
2856  function () {
2857    function Animated() {
2858      this.payload = void 0;
2859      this.children = [];
2860    }
2861  
2862    var _proto = Animated.prototype;
2863  
2864    _proto.getAnimatedValue = function getAnimatedValue() {
2865      return this.getValue();
2866    };
2867  
2868    _proto.getPayload = function getPayload() {
2869      return this.payload || this;
2870    };
2871  
2872    _proto.attach = function attach() {};
2873  
2874    _proto.detach = function detach() {};
2875  
2876    _proto.getChildren = function getChildren() {
2877      return this.children;
2878    };
2879  
2880    _proto.addChild = function addChild(child) {
2881      if (this.children.length === 0) this.attach();
2882      this.children.push(child);
2883    };
2884  
2885    _proto.removeChild = function removeChild(child) {
2886      var index = this.children.indexOf(child);
2887      this.children.splice(index, 1);
2888      if (this.children.length === 0) this.detach();
2889    };
2890  
2891    return Animated;
2892  }();
2893  var AnimatedArray =
2894  /*#__PURE__*/
2895  function (_Animated) {
2896    _inheritsLoose(AnimatedArray, _Animated);
2897  
2898    function AnimatedArray() {
2899      var _this;
2900  
2901      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2902        args[_key] = arguments[_key];
2903      }
2904  
2905      _this = _Animated.call.apply(_Animated, [this].concat(args)) || this;
2906      _this.payload = [];
2907  
2908      _this.attach = function () {
2909        return _this.payload.forEach(function (p) {
2910          return p instanceof Animated && p.addChild(_assertThisInitialized(_this));
2911        });
2912      };
2913  
2914      _this.detach = function () {
2915        return _this.payload.forEach(function (p) {
2916          return p instanceof Animated && p.removeChild(_assertThisInitialized(_this));
2917        });
2918      };
2919  
2920      return _this;
2921    }
2922  
2923    return AnimatedArray;
2924  }(Animated);
2925  var AnimatedObject =
2926  /*#__PURE__*/
2927  function (_Animated2) {
2928    _inheritsLoose(AnimatedObject, _Animated2);
2929  
2930    function AnimatedObject() {
2931      var _this2;
2932  
2933      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
2934        args[_key3] = arguments[_key3];
2935      }
2936  
2937      _this2 = _Animated2.call.apply(_Animated2, [this].concat(args)) || this;
2938      _this2.payload = {};
2939  
2940      _this2.attach = function () {
2941        return Object.values(_this2.payload).forEach(function (s) {
2942          return s instanceof Animated && s.addChild(_assertThisInitialized(_this2));
2943        });
2944      };
2945  
2946      _this2.detach = function () {
2947        return Object.values(_this2.payload).forEach(function (s) {
2948          return s instanceof Animated && s.removeChild(_assertThisInitialized(_this2));
2949        });
2950      };
2951  
2952      return _this2;
2953    }
2954  
2955    var _proto2 = AnimatedObject.prototype;
2956  
2957    _proto2.getValue = function getValue(animated) {
2958      if (animated === void 0) {
2959        animated = false;
2960      }
2961  
2962      var payload = {};
2963  
2964      for (var _key4 in this.payload) {
2965        var value = this.payload[_key4];
2966        if (animated && !(value instanceof Animated)) continue;
2967        payload[_key4] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value;
2968      }
2969  
2970      return payload;
2971    };
2972  
2973    _proto2.getAnimatedValue = function getAnimatedValue() {
2974      return this.getValue(true);
2975    };
2976  
2977    return AnimatedObject;
2978  }(Animated);
2979  
2980  var applyAnimatedValues;
2981  function injectApplyAnimatedValues(fn, transform) {
2982    applyAnimatedValues = {
2983      fn: fn,
2984      transform: transform
2985    };
2986  }
2987  var colorNames;
2988  function injectColorNames(names) {
2989    colorNames = names;
2990  }
2991  var requestFrame = function requestFrame(cb) {
2992    return typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1;
2993  };
2994  var cancelFrame = function cancelFrame(id) {
2995    typeof window !== 'undefined' && window.cancelAnimationFrame(id);
2996  };
2997  function injectFrame(raf, caf) {
2998    requestFrame = raf;
2999    cancelFrame = caf;
3000  }
3001  var interpolation;
3002  function injectStringInterpolator(fn) {
3003    interpolation = fn;
3004  }
3005  var now = function now() {
3006    return Date.now();
3007  };
3008  function injectNow(nowFn) {
3009    now = nowFn;
3010  }
3011  var defaultElement;
3012  function injectDefaultElement(el) {
3013    defaultElement = el;
3014  }
3015  var animatedApi = function animatedApi(node) {
3016    return node.current;
3017  };
3018  function injectAnimatedApi(fn) {
3019    animatedApi = fn;
3020  }
3021  var createAnimatedStyle;
3022  function injectCreateAnimatedStyle(factory) {
3023    createAnimatedStyle = factory;
3024  }
3025  var manualFrameloop;
3026  function injectManualFrameloop(callback) {
3027    manualFrameloop = callback;
3028  }
3029  
3030  var Globals = /*#__PURE__*/Object.freeze({
3031    get applyAnimatedValues () { return applyAnimatedValues; },
3032    injectApplyAnimatedValues: injectApplyAnimatedValues,
3033    get colorNames () { return colorNames; },
3034    injectColorNames: injectColorNames,
3035    get requestFrame () { return requestFrame; },
3036    get cancelFrame () { return cancelFrame; },
3037    injectFrame: injectFrame,
3038    get interpolation () { return interpolation; },
3039    injectStringInterpolator: injectStringInterpolator,
3040    get now () { return now; },
3041    injectNow: injectNow,
3042    get defaultElement () { return defaultElement; },
3043    injectDefaultElement: injectDefaultElement,
3044    get animatedApi () { return animatedApi; },
3045    injectAnimatedApi: injectAnimatedApi,
3046    get createAnimatedStyle () { return createAnimatedStyle; },
3047    injectCreateAnimatedStyle: injectCreateAnimatedStyle,
3048    get manualFrameloop () { return manualFrameloop; },
3049    injectManualFrameloop: injectManualFrameloop
3050  });
3051  
3052  /**
3053   * Wraps the `style` property with `AnimatedStyle`.
3054   */
3055  
3056  var AnimatedProps =
3057  /*#__PURE__*/
3058  function (_AnimatedObject) {
3059    _inheritsLoose(AnimatedProps, _AnimatedObject);
3060  
3061    function AnimatedProps(props, callback) {
3062      var _this;
3063  
3064      _this = _AnimatedObject.call(this) || this;
3065      _this.update = void 0;
3066      _this.payload = !props.style ? props : _extends({}, props, {
3067        style: createAnimatedStyle(props.style)
3068      });
3069      _this.update = callback;
3070  
3071      _this.attach();
3072  
3073      return _this;
3074    }
3075  
3076    return AnimatedProps;
3077  }(AnimatedObject);
3078  
3079  var isFunctionComponent = function isFunctionComponent(val) {
3080    return is.fun(val) && !(val.prototype instanceof React__default.Component);
3081  };
3082  
3083  var createAnimatedComponent = function createAnimatedComponent(Component) {
3084    var AnimatedComponent = React.forwardRef(function (props, ref) {
3085      var forceUpdate = useForceUpdate();
3086      var mounted = React.useRef(true);
3087      var propsAnimated = React.useRef(null);
3088      var node = React.useRef(null);
3089      var attachProps = React.useCallback(function (props) {
3090        var oldPropsAnimated = propsAnimated.current;
3091  
3092        var callback = function callback() {
3093          var didUpdate = false;
3094  
3095          if (node.current) {
3096            didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue());
3097          }
3098  
3099          if (!node.current || didUpdate === false) {
3100            // If no referenced node has been found, or the update target didn't have a
3101            // native-responder, then forceUpdate the animation ...
3102            forceUpdate();
3103          }
3104        };
3105  
3106        propsAnimated.current = new AnimatedProps(props, callback);
3107        oldPropsAnimated && oldPropsAnimated.detach();
3108      }, []);
3109      React.useEffect(function () {
3110        return function () {
3111          mounted.current = false;
3112          propsAnimated.current && propsAnimated.current.detach();
3113        };
3114      }, []);
3115      React.useImperativeHandle(ref, function () {
3116        return animatedApi(node, mounted, forceUpdate);
3117      });
3118      attachProps(props);
3119  
3120      var _getValue = propsAnimated.current.getValue(),
3121          scrollTop = _getValue.scrollTop,
3122          scrollLeft = _getValue.scrollLeft,
3123          animatedProps = _objectWithoutPropertiesLoose(_getValue, ["scrollTop", "scrollLeft"]); // Functions cannot have refs, see:
3124      // See: https://github.com/react-spring/react-spring/issues/569
3125  
3126  
3127      var refFn = isFunctionComponent(Component) ? undefined : function (childRef) {
3128        return node.current = handleRef(childRef, ref);
3129      };
3130      return React__default.createElement(Component, _extends({}, animatedProps, {
3131        ref: refFn
3132      }));
3133    });
3134    return AnimatedComponent;
3135  };
3136  
3137  var active = false;
3138  var controllers = new Set();
3139  
3140  var update = function update() {
3141    if (!active) return false;
3142    var time = now();
3143  
3144    for (var _iterator = controllers, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
3145      var _ref;
3146  
3147      if (_isArray) {
3148        if (_i >= _iterator.length) break;
3149        _ref = _iterator[_i++];
3150      } else {
3151        _i = _iterator.next();
3152        if (_i.done) break;
3153        _ref = _i.value;
3154      }
3155  
3156      var controller = _ref;
3157      var isActive = false;
3158  
3159      for (var configIdx = 0; configIdx < controller.configs.length; configIdx++) {
3160        var config = controller.configs[configIdx];
3161        var endOfAnimation = void 0,
3162            lastTime = void 0;
3163  
3164        for (var valIdx = 0; valIdx < config.animatedValues.length; valIdx++) {
3165          var animation = config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude
3166  
3167          if (animation.done) continue;
3168          var from = config.fromValues[valIdx];
3169          var to = config.toValues[valIdx];
3170          var position = animation.lastPosition;
3171          var isAnimated = to instanceof Animated;
3172          var velocity = Array.isArray(config.initialVelocity) ? config.initialVelocity[valIdx] : config.initialVelocity;
3173          if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state
3174  
3175          if (config.immediate) {
3176            animation.setValue(to);
3177            animation.done = true;
3178            continue;
3179          } // Break animation when string values are involved
3180  
3181  
3182          if (typeof from === 'string' || typeof to === 'string') {
3183            animation.setValue(to);
3184            animation.done = true;
3185            continue;
3186          }
3187  
3188          if (config.duration !== void 0) {
3189            /** Duration easing */
3190            position = from + config.easing((time - animation.startTime) / config.duration) * (to - from);
3191            endOfAnimation = time >= animation.startTime + config.duration;
3192          } else if (config.decay) {
3193            /** Decay easing */
3194            position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime)));
3195            endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1;
3196            if (endOfAnimation) to = position;
3197          } else {
3198            /** Spring easing */
3199            lastTime = animation.lastTime !== void 0 ? animation.lastTime : time;
3200            velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : config.initialVelocity; // If we lost a lot of frames just jump to the end.
3201  
3202            if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/
3203  
3204            var numSteps = Math.floor(time - lastTime);
3205  
3206            for (var i = 0; i < numSteps; ++i) {
3207              var force = -config.tension * (position - to);
3208              var damping = -config.friction * velocity;
3209              var acceleration = (force + damping) / config.mass;
3210              velocity = velocity + acceleration * 1 / 1000;
3211              position = position + velocity * 1 / 1000;
3212            } // Conditions for stopping the spring animation
3213  
3214  
3215            var isOvershooting = config.clamp && config.tension !== 0 ? from < to ? position > to : position < to : false;
3216            var isVelocity = Math.abs(velocity) <= config.precision;
3217            var isDisplacement = config.tension !== 0 ? Math.abs(to - position) <= config.precision : true;
3218            endOfAnimation = isOvershooting || isVelocity && isDisplacement;
3219            animation.lastVelocity = velocity;
3220            animation.lastTime = time;
3221          } // Trails aren't done until their parents conclude
3222  
3223  
3224          if (isAnimated && !config.toValues[valIdx].done) endOfAnimation = false;
3225  
3226          if (endOfAnimation) {
3227            // Ensure that we end up with a round value
3228            if (animation.value !== to) position = to;
3229            animation.done = true;
3230          } else isActive = true;
3231  
3232          animation.setValue(position);
3233          animation.lastPosition = position;
3234        } // Keep track of updated values only when necessary
3235  
3236  
3237        if (controller.props.onFrame) controller.values[config.name] = config.interpolation.getValue();
3238      } // Update callbacks in the end of the frame
3239  
3240  
3241      if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame
3242  
3243      if (!isActive) {
3244        controllers.delete(controller);
3245        controller.stop(true);
3246      }
3247    } // Loop over as long as there are controllers ...
3248  
3249  
3250    if (controllers.size) {
3251      if (manualFrameloop) manualFrameloop();else requestFrame(update);
3252    } else {
3253      active = false;
3254    }
3255  
3256    return active;
3257  };
3258  
3259  var start = function start(controller) {
3260    if (!controllers.has(controller)) controllers.add(controller);
3261  
3262    if (!active) {
3263      active = true;
3264      if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update);
3265    }
3266  };
3267  
3268  var stop = function stop(controller) {
3269    if (controllers.has(controller)) controllers.delete(controller);
3270  };
3271  
3272  function createInterpolator(range, output, extrapolate) {
3273    if (typeof range === 'function') {
3274      return range;
3275    }
3276  
3277    if (Array.isArray(range)) {
3278      return createInterpolator({
3279        range: range,
3280        output: output,
3281        extrapolate: extrapolate
3282      });
3283    }
3284  
3285    if (interpolation && typeof range.output[0] === 'string') {
3286      return interpolation(range);
3287    }
3288  
3289    var config = range;
3290    var outputRange = config.output;
3291    var inputRange = config.range || [0, 1];
3292    var extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend';
3293    var extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend';
3294  
3295    var easing = config.easing || function (t) {
3296      return t;
3297    };
3298  
3299    return function (input) {
3300      var range = findRange(input, inputRange);
3301      return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map);
3302    };
3303  }
3304  
3305  function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {
3306    var result = map ? map(input) : input; // Extrapolate
3307  
3308    if (result < inputMin) {
3309      if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin;
3310    }
3311  
3312    if (result > inputMax) {
3313      if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax;
3314    }
3315  
3316    if (outputMin === outputMax) return outputMin;
3317    if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range
3318  
3319    if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing
3320  
3321    result = easing(result); // Output Range
3322  
3323    if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin;
3324    return result;
3325  }
3326  
3327  function findRange(input, inputRange) {
3328    for (var i = 1; i < inputRange.length - 1; ++i) {
3329      if (inputRange[i] >= input) break;
3330    }
3331  
3332    return i - 1;
3333  }
3334  
3335  var AnimatedInterpolation =
3336  /*#__PURE__*/
3337  function (_AnimatedArray) {
3338    _inheritsLoose(AnimatedInterpolation, _AnimatedArray);
3339  
3340    function AnimatedInterpolation(parents, range, output, extrapolate) {
3341      var _this;
3342  
3343      _this = _AnimatedArray.call(this) || this;
3344      _this.calc = void 0;
3345      _this.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents];
3346      _this.calc = createInterpolator(range, output, extrapolate);
3347      return _this;
3348    }
3349  
3350    var _proto = AnimatedInterpolation.prototype;
3351  
3352    _proto.getValue = function getValue() {
3353      return this.calc.apply(this, this.payload.map(function (value) {
3354        return value.getValue();
3355      }));
3356    };
3357  
3358    _proto.updateConfig = function updateConfig(range, output, extrapolate) {
3359      this.calc = createInterpolator(range, output, extrapolate);
3360    };
3361  
3362    _proto.interpolate = function interpolate(range, output, extrapolate) {
3363      return new AnimatedInterpolation(this, range, output, extrapolate);
3364    };
3365  
3366    return AnimatedInterpolation;
3367  }(AnimatedArray);
3368  
3369  var interpolate$1 = function interpolate(parents, range, output) {
3370    return parents && new AnimatedInterpolation(parents, range, output);
3371  };
3372  
3373  var config = {
3374    default: {
3375      tension: 170,
3376      friction: 26
3377    },
3378    gentle: {
3379      tension: 120,
3380      friction: 14
3381    },
3382    wobbly: {
3383      tension: 180,
3384      friction: 12
3385    },
3386    stiff: {
3387      tension: 210,
3388      friction: 20
3389    },
3390    slow: {
3391      tension: 280,
3392      friction: 60
3393    },
3394    molasses: {
3395      tension: 280,
3396      friction: 120
3397    }
3398  };
3399  
3400  /** API
3401   *  useChain(references, timeSteps, timeFrame)
3402   */
3403  
3404  function useChain(refs, timeSteps, timeFrame) {
3405    if (timeFrame === void 0) {
3406      timeFrame = 1000;
3407    }
3408  
3409    var previous = React.useRef();
3410    React.useEffect(function () {
3411      if (is.equ(refs, previous.current)) refs.forEach(function (_ref) {
3412        var current = _ref.current;
3413        return current && current.start();
3414      });else if (timeSteps) {
3415        refs.forEach(function (_ref2, index) {
3416          var current = _ref2.current;
3417  
3418          if (current) {
3419            var ctrls = current.controllers;
3420  
3421            if (ctrls.length) {
3422              var t = timeFrame * timeSteps[index];
3423              ctrls.forEach(function (ctrl) {
3424                ctrl.queue = ctrl.queue.map(function (e) {
3425                  return _extends({}, e, {
3426                    delay: e.delay + t
3427                  });
3428                });
3429                ctrl.start();
3430              });
3431            }
3432          }
3433        });
3434      } else refs.reduce(function (q, _ref3, rI) {
3435        var current = _ref3.current;
3436        return q = q.then(function () {
3437          return current.start();
3438        });
3439      }, Promise.resolve());
3440      previous.current = refs;
3441    });
3442  }
3443  
3444  /**
3445   * Animated works by building a directed acyclic graph of dependencies
3446   * transparently when you render your Animated components.
3447   *
3448   *               new Animated.Value(0)
3449   *     .interpolate()        .interpolate()    new Animated.Value(1)
3450   *         opacity               translateY      scale
3451   *          style                         transform
3452   *         View#234                         style
3453   *                                         View#123
3454   *
3455   * A) Top Down phase
3456   * When an AnimatedValue is updated, we recursively go down through this
3457   * graph in order to find leaf nodes: the views that we flag as needing
3458   * an update.
3459   *
3460   * B) Bottom Up phase
3461   * When a view is flagged as needing an update, we recursively go back up
3462   * in order to build the new value that it needs. The reason why we need
3463   * this two-phases process is to deal with composite props such as
3464   * transform which can receive values from multiple parents.
3465   */
3466  function addAnimatedStyles(node, styles) {
3467    if ('update' in node) {
3468      styles.add(node);
3469    } else {
3470      node.getChildren().forEach(function (child) {
3471        return addAnimatedStyles(child, styles);
3472      });
3473    }
3474  }
3475  
3476  var AnimatedValue =
3477  /*#__PURE__*/
3478  function (_Animated) {
3479    _inheritsLoose(AnimatedValue, _Animated);
3480  
3481    function AnimatedValue(_value) {
3482      var _this;
3483  
3484      _this = _Animated.call(this) || this;
3485      _this.animatedStyles = new Set();
3486      _this.value = void 0;
3487      _this.startPosition = void 0;
3488      _this.lastPosition = void 0;
3489      _this.lastVelocity = void 0;
3490      _this.startTime = void 0;
3491      _this.lastTime = void 0;
3492      _this.done = false;
3493  
3494      _this.setValue = function (value, flush) {
3495        if (flush === void 0) {
3496          flush = true;
3497        }
3498  
3499        _this.value = value;
3500        if (flush) _this.flush();
3501      };
3502  
3503      _this.value = _value;
3504      _this.startPosition = _value;
3505      _this.lastPosition = _value;
3506      return _this;
3507    }
3508  
3509    var _proto = AnimatedValue.prototype;
3510  
3511    _proto.flush = function flush() {
3512      if (this.animatedStyles.size === 0) {
3513        addAnimatedStyles(this, this.animatedStyles);
3514      }
3515  
3516      this.animatedStyles.forEach(function (animatedStyle) {
3517        return animatedStyle.update();
3518      });
3519    };
3520  
3521    _proto.clearStyles = function clearStyles() {
3522      this.animatedStyles.clear();
3523    };
3524  
3525    _proto.getValue = function getValue() {
3526      return this.value;
3527    };
3528  
3529    _proto.interpolate = function interpolate(range, output, extrapolate) {
3530      return new AnimatedInterpolation(this, range, output, extrapolate);
3531    };
3532  
3533    return AnimatedValue;
3534  }(Animated);
3535  
3536  var AnimatedValueArray =
3537  /*#__PURE__*/
3538  function (_AnimatedArray) {
3539    _inheritsLoose(AnimatedValueArray, _AnimatedArray);
3540  
3541    function AnimatedValueArray(values) {
3542      var _this;
3543  
3544      _this = _AnimatedArray.call(this) || this;
3545      _this.payload = values.map(function (n) {
3546        return new AnimatedValue(n);
3547      });
3548      return _this;
3549    }
3550  
3551    var _proto = AnimatedValueArray.prototype;
3552  
3553    _proto.setValue = function setValue(value, flush) {
3554      var _this2 = this;
3555  
3556      if (flush === void 0) {
3557        flush = true;
3558      }
3559  
3560      if (Array.isArray(value)) {
3561        if (value.length === this.payload.length) {
3562          value.forEach(function (v, i) {
3563            return _this2.payload[i].setValue(v, flush);
3564          });
3565        }
3566      } else {
3567        this.payload.forEach(function (p) {
3568          return p.setValue(value, flush);
3569        });
3570      }
3571    };
3572  
3573    _proto.getValue = function getValue() {
3574      return this.payload.map(function (v) {
3575        return v.getValue();
3576      });
3577    };
3578  
3579    _proto.interpolate = function interpolate(range, output) {
3580      return new AnimatedInterpolation(this, range, output);
3581    };
3582  
3583    return AnimatedValueArray;
3584  }(AnimatedArray);
3585  
3586  var G = 0;
3587  
3588  var Controller =
3589  /*#__PURE__*/
3590  function () {
3591    function Controller() {
3592      var _this = this;
3593  
3594      this.id = void 0;
3595      this.idle = true;
3596      this.hasChanged = false;
3597      this.guid = 0;
3598      this.local = 0;
3599      this.props = {};
3600      this.merged = {};
3601      this.animations = {};
3602      this.interpolations = {};
3603      this.values = {};
3604      this.configs = [];
3605      this.listeners = [];
3606      this.queue = [];
3607      this.localQueue = void 0;
3608  
3609      this.getValues = function () {
3610        return _this.interpolations;
3611      };
3612  
3613      this.id = G++;
3614    }
3615    /** update(props)
3616     *  This function filters input props and creates an array of tasks which are executed in .start()
3617     *  Each task is allowed to carry a delay, which means it can execute asnychroneously */
3618  
3619  
3620    var _proto = Controller.prototype;
3621  
3622    _proto.update = function update$$1(args) {
3623      //this._id = n + this.id
3624      if (!args) return this; // Extract delay and the to-prop from props
3625  
3626      var _ref = interpolateTo(args),
3627          _ref$delay = _ref.delay,
3628          delay = _ref$delay === void 0 ? 0 : _ref$delay,
3629          to = _ref.to,
3630          props = _objectWithoutPropertiesLoose(_ref, ["delay", "to"]);
3631  
3632      if (is.arr(to) || is.fun(to)) {
3633        // If config is either a function or an array queue it up as is
3634        this.queue.push(_extends({}, props, {
3635          delay: delay,
3636          to: to
3637        }));
3638      } else if (to) {
3639        // Otherwise go through each key since it could be delayed individually
3640        var ops = {};
3641        Object.entries(to).forEach(function (_ref2) {
3642          var _to;
3643  
3644          var k = _ref2[0],
3645              v = _ref2[1];
3646  
3647          // Fetch delay and create an entry, consisting of the to-props, the delay, and basic props
3648          var entry = _extends({
3649            to: (_to = {}, _to[k] = v, _to),
3650            delay: callProp(delay, k)
3651          }, props);
3652  
3653          var previous = ops[entry.delay] && ops[entry.delay].to;
3654          ops[entry.delay] = _extends({}, ops[entry.delay], entry, {
3655            to: _extends({}, previous, entry.to)
3656          });
3657        });
3658        this.queue = Object.values(ops);
3659      } // Sort queue, so that async calls go last
3660  
3661  
3662      this.queue = this.queue.sort(function (a, b) {
3663        return a.delay - b.delay;
3664      }); // Diff the reduced props immediately (they'll contain the from-prop and some config)
3665  
3666      this.diff(props);
3667      return this;
3668    }
3669    /** start(onEnd)
3670     *  This function either executes a queue, if present, or starts the frameloop, which animates */
3671    ;
3672  
3673    _proto.start = function start$$1(onEnd) {
3674      var _this2 = this;
3675  
3676      // If a queue is present we must excecute it
3677      if (this.queue.length) {
3678        this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values
3679  
3680        if (this.localQueue) {
3681          this.localQueue.forEach(function (_ref3) {
3682            var _ref3$from = _ref3.from,
3683                from = _ref3$from === void 0 ? {} : _ref3$from,
3684                _ref3$to = _ref3.to,
3685                to = _ref3$to === void 0 ? {} : _ref3$to;
3686            if (is.obj(from)) _this2.merged = _extends({}, from, _this2.merged);
3687            if (is.obj(to)) _this2.merged = _extends({}, _this2.merged, to);
3688          });
3689        } // The guid helps us tracking frames, a new queue over an old one means an override
3690        // We discard async calls in that caseÍ
3691  
3692  
3693        var local = this.local = ++this.guid;
3694        var queue = this.localQueue = this.queue;
3695        this.queue = []; // Go through each entry and execute it
3696  
3697        queue.forEach(function (_ref4, index) {
3698          var delay = _ref4.delay,
3699              props = _objectWithoutPropertiesLoose(_ref4, ["delay"]);
3700  
3701          var cb = function cb(finished) {
3702            if (index === queue.length - 1 && local === _this2.guid && finished) {
3703              _this2.idle = true;
3704              if (_this2.props.onRest) _this2.props.onRest(_this2.merged);
3705            }
3706  
3707            if (onEnd) onEnd();
3708          }; // Entries can be delayed, ansyc or immediate
3709  
3710  
3711          var async = is.arr(props.to) || is.fun(props.to);
3712  
3713          if (delay) {
3714            setTimeout(function () {
3715              if (local === _this2.guid) {
3716                if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb);
3717              }
3718            }, delay);
3719          } else if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb);
3720        });
3721      } // Otherwise we kick of the frameloop
3722      else {
3723          if (is.fun(onEnd)) this.listeners.push(onEnd);
3724          if (this.props.onStart) this.props.onStart();
3725  
3726          start(this);
3727        }
3728  
3729      return this;
3730    };
3731  
3732    _proto.stop = function stop$$1(finished) {
3733      this.listeners.forEach(function (onEnd) {
3734        return onEnd(finished);
3735      });
3736      this.listeners = [];
3737      return this;
3738    }
3739    /** Pause sets onEnd listeners free, but also removes the controller from the frameloop */
3740    ;
3741  
3742    _proto.pause = function pause(finished) {
3743      this.stop(true);
3744      if (finished) stop(this);
3745      return this;
3746    };
3747  
3748    _proto.runAsync = function runAsync(_ref5, onEnd) {
3749      var _this3 = this;
3750  
3751      var delay = _ref5.delay,
3752          props = _objectWithoutPropertiesLoose(_ref5, ["delay"]);
3753  
3754      var local = this.local; // If "to" is either a function or an array it will be processed async, therefor "to" should be empty right now
3755      // If the view relies on certain values "from" has to be present
3756  
3757      var queue = Promise.resolve(undefined);
3758  
3759      if (is.arr(props.to)) {
3760        var _loop = function _loop(i) {
3761          var index = i;
3762  
3763          var fresh = _extends({}, props, interpolateTo(props.to[index]));
3764  
3765          if (is.arr(fresh.config)) fresh.config = fresh.config[index];
3766          queue = queue.then(function () {
3767            //this.stop()
3768            if (local === _this3.guid) return new Promise(function (r) {
3769              return _this3.diff(fresh).start(r);
3770            });
3771          });
3772        };
3773  
3774        for (var i = 0; i < props.to.length; i++) {
3775          _loop(i);
3776        }
3777      } else if (is.fun(props.to)) {
3778        var index = 0;
3779        var last;
3780        queue = queue.then(function () {
3781          return props.to( // next(props)
3782          function (p) {
3783            var fresh = _extends({}, props, interpolateTo(p));
3784  
3785            if (is.arr(fresh.config)) fresh.config = fresh.config[index];
3786            index++; //this.stop()
3787  
3788            if (local === _this3.guid) return last = new Promise(function (r) {
3789              return _this3.diff(fresh).start(r);
3790            });
3791            return;
3792          }, // cancel()
3793          function (finished) {
3794            if (finished === void 0) {
3795              finished = true;
3796            }
3797  
3798            return _this3.stop(finished);
3799          }).then(function () {
3800            return last;
3801          });
3802        });
3803      }
3804  
3805      queue.then(onEnd);
3806    };
3807  
3808    _proto.diff = function diff(props) {
3809      var _this4 = this;
3810  
3811      this.props = _extends({}, this.props, props);
3812      var _this$props = this.props,
3813          _this$props$from = _this$props.from,
3814          from = _this$props$from === void 0 ? {} : _this$props$from,
3815          _this$props$to = _this$props.to,
3816          to = _this$props$to === void 0 ? {} : _this$props$to,
3817          _this$props$config = _this$props.config,
3818          config = _this$props$config === void 0 ? {} : _this$props$config,
3819          reverse = _this$props.reverse,
3820          attach = _this$props.attach,
3821          reset = _this$props.reset,
3822          immediate = _this$props.immediate; // Reverse values when requested
3823  
3824      if (reverse) {
3825        var _ref6 = [to, from];
3826        from = _ref6[0];
3827        to = _ref6[1];
3828      } // This will collect all props that were ever set, reset merged props when necessary
3829  
3830  
3831      this.merged = _extends({}, from, this.merged, to);
3832      this.hasChanged = false; // Attachment handling, trailed springs can "attach" themselves to a previous spring
3833  
3834      var target = attach && attach(this); // Reduces input { name: value } pairs into animated values
3835  
3836      this.animations = Object.entries(this.merged).reduce(function (acc, _ref7) {
3837        var name = _ref7[0],
3838            value = _ref7[1];
3839        // Issue cached entries, except on reset
3840        var entry = acc[name] || {}; // Figure out what the value is supposed to be
3841  
3842        var isNumber = is.num(value);
3843        var isString = is.str(value) && !value.startsWith('#') && !/\d/.test(value) && !colorNames[value];
3844        var isArray = is.arr(value);
3845        var isInterpolation = !isNumber && !isArray && !isString;
3846        var fromValue = !is.und(from[name]) ? from[name] : value;
3847        var toValue = isNumber || isArray ? value : isString ? value : 1;
3848        var toConfig = callProp(config, name);
3849        if (target) toValue = target.animations[name].parent;
3850        var parent = entry.parent,
3851            interpolation$$1 = entry.interpolation,
3852            toValues = toArray(target ? toValue.getPayload() : toValue),
3853            animatedValues;
3854        var newValue = value;
3855        if (isInterpolation) newValue = interpolation({
3856          range: [0, 1],
3857          output: [value, value]
3858        })(1);
3859        var currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags
3860  
3861        var isFirst = is.und(parent);
3862        var isActive = !isFirst && entry.animatedValues.some(function (v) {
3863          return !v.done;
3864        });
3865        var currentValueDiffersFromGoal = !is.equ(newValue, currentValue);
3866        var hasNewGoal = !is.equ(newValue, entry.previous);
3867        var hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one)
3868        // and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?)
3869  
3870        if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) {
3871          var _extends2;
3872  
3873          // Convert regular values into animated values, ALWAYS re-use if possible
3874          if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) {
3875            var prev = entry.interpolation && entry.interpolation.calc(entry.parent.value);
3876            prev = prev !== void 0 && !reset ? prev : fromValue;
3877  
3878            if (entry.parent) {
3879              parent = entry.parent;
3880              parent.setValue(0, false);
3881            } else parent = new AnimatedValue(0);
3882  
3883            var range = {
3884              output: [prev, value]
3885            };
3886  
3887            if (entry.interpolation) {
3888              interpolation$$1 = entry.interpolation;
3889              entry.interpolation.updateConfig(range);
3890            } else interpolation$$1 = parent.interpolate(range);
3891          }
3892          toValues = toArray(target ? toValue.getPayload() : toValue);
3893          animatedValues = toArray(parent.getPayload());
3894          if (reset && !isInterpolation) parent.setValue(fromValue, false);
3895          _this4.hasChanged = true; // Reset animated values
3896  
3897          animatedValues.forEach(function (value) {
3898            value.startPosition = value.value;
3899            value.lastPosition = value.value;
3900            value.lastVelocity = isActive ? value.lastVelocity : undefined;
3901            value.lastTime = isActive ? value.lastTime : undefined;
3902            value.startTime = now();
3903            value.done = false;
3904            value.animatedStyles.clear();
3905          }); // Set immediate values
3906  
3907          if (callProp(immediate, name)) {
3908            parent.setValue(isInterpolation ? toValue : value, false);
3909          }
3910  
3911          return _extends({}, acc, (_extends2 = {}, _extends2[name] = _extends({}, entry, {
3912            name: name,
3913            parent: parent,
3914            interpolation: interpolation$$1,
3915            animatedValues: animatedValues,
3916            toValues: toValues,
3917            previous: newValue,
3918            config: toConfig,
3919            fromValues: toArray(parent.getValue()),
3920            immediate: callProp(immediate, name),
3921            initialVelocity: withDefault(toConfig.velocity, 0),
3922            clamp: withDefault(toConfig.clamp, false),
3923            precision: withDefault(toConfig.precision, 0.01),
3924            tension: withDefault(toConfig.tension, 170),
3925            friction: withDefault(toConfig.friction, 26),
3926            mass: withDefault(toConfig.mass, 1),
3927            duration: toConfig.duration,
3928            easing: withDefault(toConfig.easing, function (t) {
3929              return t;
3930            }),
3931            decay: toConfig.decay
3932          }), _extends2));
3933        } else {
3934          if (!currentValueDiffersFromGoal) {
3935            var _extends3;
3936  
3937            // So ... the current target value (newValue) appears to be different from the previous value,
3938            // which normally constitutes an update, but the actual value (currentValue) matches the target!
3939            // In order to resolve this without causing an animation update we silently flag the animation as done,
3940            // which it technically is. Interpolations also needs a config update with their target set to 1.
3941            if (isInterpolation) {
3942              parent.setValue(1, false);
3943              interpolation$$1.updateConfig({
3944                output: [newValue, newValue]
3945              });
3946            }
3947  
3948            parent.done = true;
3949            _this4.hasChanged = true;
3950            return _extends({}, acc, (_extends3 = {}, _extends3[name] = _extends({}, acc[name], {
3951              previous: newValue
3952            }), _extends3));
3953          }
3954  
3955          return acc;
3956        }
3957      }, this.animations);
3958  
3959      if (this.hasChanged) {
3960        // Make animations available to frameloop
3961        this.configs = Object.values(this.animations);
3962        this.values = {};
3963        this.interpolations = {};
3964  
3965        for (var key in this.animations) {
3966          this.interpolations[key] = this.animations[key].interpolation;
3967          this.values[key] = this.animations[key].interpolation.getValue();
3968        }
3969      }
3970  
3971      return this;
3972    };
3973  
3974    _proto.destroy = function destroy() {
3975      this.stop();
3976      this.props = {};
3977      this.merged = {};
3978      this.animations = {};
3979      this.interpolations = {};
3980      this.values = {};
3981      this.configs = [];
3982      this.local = 0;
3983    };
3984  
3985    return Controller;
3986  }();
3987  
3988  /** API
3989   * const props = useSprings(number, [{ ... }, { ... }, ...])
3990   * const [props, set] = useSprings(number, (i, controller) => ({ ... }))
3991   */
3992  
3993  var useSprings = function useSprings(length, props) {
3994    var mounted = React.useRef(false);
3995    var ctrl = React.useRef();
3996    var isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations
3997  
3998    var _useMemo = React.useMemo(function () {
3999      // Remove old controllers
4000      if (ctrl.current) {
4001        ctrl.current.map(function (c) {
4002          return c.destroy();
4003        });
4004        ctrl.current = undefined;
4005      }
4006  
4007      var ref;
4008      return [new Array(length).fill().map(function (_, i) {
4009        var ctrl = new Controller();
4010        var newProps = isFn ? callProp(props, i, ctrl) : props[i];
4011        if (i === 0) ref = newProps.ref;
4012        ctrl.update(newProps);
4013        if (!ref) ctrl.start();
4014        return ctrl;
4015      }), ref];
4016    }, [length]),
4017        controllers = _useMemo[0],
4018        ref = _useMemo[1];
4019  
4020    ctrl.current = controllers; // The hooks reference api gets defined here ...
4021  
4022    var api = React.useImperativeHandle(ref, function () {
4023      return {
4024        start: function start() {
4025          return Promise.all(ctrl.current.map(function (c) {
4026            return new Promise(function (r) {
4027              return c.start(r);
4028            });
4029          }));
4030        },
4031        stop: function stop(finished) {
4032          return ctrl.current.forEach(function (c) {
4033            return c.stop(finished);
4034          });
4035        },
4036  
4037        get controllers() {
4038          return ctrl.current;
4039        }
4040  
4041      };
4042    }); // This function updates the controllers
4043  
4044    var updateCtrl = React.useMemo(function () {
4045      return function (updateProps) {
4046        return ctrl.current.map(function (c, i) {
4047          c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]);
4048          if (!ref) c.start();
4049        });
4050      };
4051    }, [length]); // Update controller if props aren't functional
4052  
4053    React.useEffect(function () {
4054      if (mounted.current) {
4055        if (!isFn) updateCtrl(props);
4056      } else if (!ref) ctrl.current.forEach(function (c) {
4057        return c.start();
4058      });
4059    }); // Update mounted flag and destroy controller on unmount
4060  
4061    React.useEffect(function () {
4062      return mounted.current = true, function () {
4063        return ctrl.current.forEach(function (c) {
4064          return c.destroy();
4065        });
4066      };
4067    }, []); // Return animated props, or, anim-props + the update-setter above
4068  
4069    var propValues = ctrl.current.map(function (c) {
4070      return c.getValues();
4071    });
4072    return isFn ? [propValues, updateCtrl, function (finished) {
4073      return ctrl.current.forEach(function (c) {
4074        return c.pause(finished);
4075      });
4076    }] : propValues;
4077  };
4078  
4079  /** API
4080   * const props = useSpring({ ... })
4081   * const [props, set] = useSpring(() => ({ ... }))
4082   */
4083  
4084  var useSpring = function useSpring(props) {
4085    var isFn = is.fun(props);
4086  
4087    var _useSprings = useSprings(1, isFn ? props : [props]),
4088        result = _useSprings[0],
4089        set = _useSprings[1],
4090        pause = _useSprings[2];
4091  
4092    return isFn ? [result[0], set, pause] : result;
4093  };
4094  
4095  /** API
4096   * const trails = useTrail(number, { ... })
4097   * const [trails, set] = useTrail(number, () => ({ ... }))
4098   */
4099  
4100  var useTrail = function useTrail(length, props) {
4101    var mounted = React.useRef(false);
4102    var isFn = is.fun(props);
4103    var updateProps = callProp(props);
4104    var instances = React.useRef();
4105  
4106    var _useSprings = useSprings(length, function (i, ctrl) {
4107      if (i === 0) instances.current = [];
4108      instances.current.push(ctrl);
4109      return _extends({}, updateProps, {
4110        config: callProp(updateProps.config, i),
4111        attach: i > 0 && function () {
4112          return instances.current[i - 1];
4113        }
4114      });
4115    }),
4116        result = _useSprings[0],
4117        set = _useSprings[1],
4118        pause = _useSprings[2]; // Set up function to update controller
4119  
4120  
4121    var updateCtrl = React.useMemo(function () {
4122      return function (props) {
4123        return set(function (i, ctrl) {
4124          var last = props.reverse ? i === 0 : length - 1 === i;
4125          var attachIdx = props.reverse ? i + 1 : i - 1;
4126          var attachController = instances.current[attachIdx];
4127          return _extends({}, props, {
4128            config: callProp(props.config || updateProps.config, i),
4129            attach: attachController && function () {
4130              return attachController;
4131            }
4132          });
4133        });
4134      };
4135    }, [length, updateProps.reverse]); // Update controller if props aren't functional
4136  
4137    React.useEffect(function () {
4138      return void (mounted.current && !isFn && updateCtrl(props));
4139    }); // Update mounted flag and destroy controller on unmount
4140  
4141    React.useEffect(function () {
4142      return void (mounted.current = true);
4143    }, []);
4144    return isFn ? [result, updateCtrl, pause] : result;
4145  };
4146  
4147  /** API
4148   * const transitions = useTransition(items, itemKeys, { ... })
4149   * const [transitions, update] = useTransition(items, itemKeys, () => ({ ... }))
4150   */
4151  
4152  var guid = 0;
4153  var ENTER = 'enter';
4154  var LEAVE = 'leave';
4155  var UPDATE = 'update';
4156  
4157  var mapKeys = function mapKeys(items, keys) {
4158    return (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String);
4159  };
4160  
4161  var get = function get(props) {
4162    var items = props.items,
4163        _props$keys = props.keys,
4164        keys = _props$keys === void 0 ? function (item) {
4165      return item;
4166    } : _props$keys,
4167        rest = _objectWithoutPropertiesLoose(props, ["items", "keys"]);
4168  
4169    items = toArray(items !== void 0 ? items : null);
4170    return _extends({
4171      items: items,
4172      keys: mapKeys(items, keys)
4173    }, rest);
4174  };
4175  
4176  function useTransition(input, keyTransform, config) {
4177    var props = _extends({
4178      items: input,
4179      keys: keyTransform || function (i) {
4180        return i;
4181      }
4182    }, config);
4183  
4184    var _get = get(props),
4185        _get$lazy = _get.lazy,
4186        lazy = _get$lazy === void 0 ? false : _get$lazy,
4187        _get$unique = _get.unique,
4188        _get$reset = _get.reset,
4189        reset = _get$reset === void 0 ? false : _get$reset,
4190        enter = _get.enter,
4191        leave = _get.leave,
4192        update = _get.update,
4193        onDestroyed = _get.onDestroyed,
4194        keys = _get.keys,
4195        items = _get.items,
4196        onFrame = _get.onFrame,
4197        _onRest = _get.onRest,
4198        onStart = _get.onStart,
4199        ref = _get.ref,
4200        extra = _objectWithoutPropertiesLoose(_get, ["lazy", "unique", "reset", "enter", "leave", "update", "onDestroyed", "keys", "items", "onFrame", "onRest", "onStart", "ref"]);
4201  
4202    var forceUpdate = useForceUpdate();
4203    var mounted = React.useRef(false);
4204    var state = React.useRef({
4205      mounted: false,
4206      first: true,
4207      deleted: [],
4208      current: {},
4209      transitions: [],
4210      prevProps: {},
4211      paused: !!props.ref,
4212      instances: !mounted.current && new Map(),
4213      forceUpdate: forceUpdate
4214    });
4215    React.useImperativeHandle(props.ref, function () {
4216      return {
4217        start: function start() {
4218          return Promise.all(Array.from(state.current.instances).map(function (_ref) {
4219            var c = _ref[1];
4220            return new Promise(function (r) {
4221              return c.start(r);
4222            });
4223          }));
4224        },
4225        stop: function stop(finished) {
4226          return Array.from(state.current.instances).forEach(function (_ref2) {
4227            var c = _ref2[1];
4228            return c.stop(finished);
4229          });
4230        },
4231  
4232        get controllers() {
4233          return Array.from(state.current.instances).map(function (_ref3) {
4234            var c = _ref3[1];
4235            return c;
4236          });
4237        }
4238  
4239      };
4240    }); // Update state
4241  
4242    state.current = diffItems(state.current, props);
4243  
4244    if (state.current.changed) {
4245      // Update state
4246      state.current.transitions.forEach(function (transition) {
4247        var slot = transition.slot,
4248            from = transition.from,
4249            to = transition.to,
4250            config = transition.config,
4251            trail = transition.trail,
4252            key = transition.key,
4253            item = transition.item;
4254        if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object
4255  
4256        var ctrl = state.current.instances.get(key);
4257  
4258        var newProps = _extends({}, extra, {
4259          to: to,
4260          from: from,
4261          config: config,
4262          ref: ref,
4263          onRest: function onRest(values) {
4264            if (state.current.mounted) {
4265              if (transition.destroyed) {
4266                // If no ref is given delete destroyed items immediately
4267                if (!ref && !lazy) cleanUp(state, key);
4268                if (onDestroyed) onDestroyed(item);
4269              } // A transition comes to rest once all its springs conclude
4270  
4271  
4272              var curInstances = Array.from(state.current.instances);
4273              var active = curInstances.some(function (_ref4) {
4274                var c = _ref4[1];
4275                return !c.idle;
4276              });
4277              if (!active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state);
4278              if (_onRest) _onRest(item, slot, values);
4279            }
4280          },
4281          onStart: onStart && function () {
4282            return onStart(item, slot);
4283          },
4284          onFrame: onFrame && function (values) {
4285            return onFrame(item, slot, values);
4286          },
4287          delay: trail,
4288          reset: reset && slot === ENTER // Update controller
4289  
4290        });
4291  
4292        ctrl.update(newProps);
4293        if (!state.current.paused) ctrl.start();
4294      });
4295    }
4296  
4297    React.useEffect(function () {
4298      state.current.mounted = mounted.current = true;
4299      return function () {
4300        state.current.mounted = mounted.current = false;
4301        Array.from(state.current.instances).map(function (_ref5) {
4302          var c = _ref5[1];
4303          return c.destroy();
4304        });
4305        state.current.instances.clear();
4306      };
4307    }, []);
4308    return state.current.transitions.map(function (_ref6) {
4309      var item = _ref6.item,
4310          slot = _ref6.slot,
4311          key = _ref6.key;
4312      return {
4313        item: item,
4314        key: key,
4315        state: slot,
4316        props: state.current.instances.get(key).getValues()
4317      };
4318    });
4319  }
4320  
4321  function cleanUp(state, filterKey) {
4322    var deleted = state.current.deleted;
4323  
4324    var _loop = function _loop() {
4325      if (_isArray) {
4326        if (_i >= _iterator.length) return "break";
4327        _ref8 = _iterator[_i++];
4328      } else {
4329        _i = _iterator.next();
4330        if (_i.done) return "break";
4331        _ref8 = _i.value;
4332      }
4333  
4334      var _ref7 = _ref8;
4335      var key = _ref7.key;
4336  
4337      var filter = function filter(t) {
4338        return t.key !== key;
4339      };
4340  
4341      if (is.und(filterKey) || filterKey === key) {
4342        state.current.instances.delete(key);
4343        state.current.transitions = state.current.transitions.filter(filter);
4344        state.current.deleted = state.current.deleted.filter(filter);
4345      }
4346    };
4347  
4348    for (var _iterator = deleted, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
4349      var _ref8;
4350  
4351      var _ret = _loop();
4352  
4353      if (_ret === "break") break;
4354    }
4355  
4356    state.current.forceUpdate();
4357  }
4358  
4359  function diffItems(_ref9, props) {
4360    var first = _ref9.first,
4361        prevProps = _ref9.prevProps,
4362        state = _objectWithoutPropertiesLoose(_ref9, ["first", "prevProps"]);
4363  
4364    var _get2 = get(props),
4365        items = _get2.items,
4366        keys = _get2.keys,
4367        initial = _get2.initial,
4368        from = _get2.from,
4369        enter = _get2.enter,
4370        leave = _get2.leave,
4371        update = _get2.update,
4372        _get2$trail = _get2.trail,
4373        trail = _get2$trail === void 0 ? 0 : _get2$trail,
4374        unique = _get2.unique,
4375        config = _get2.config,
4376        _get2$order = _get2.order,
4377        order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order;
4378  
4379    var _get3 = get(prevProps),
4380        _keys = _get3.keys,
4381        _items = _get3.items;
4382  
4383    var current = _extends({}, state.current);
4384  
4385    var deleted = [].concat(state.deleted); // Compare next keys with current keys
4386  
4387    var currentKeys = Object.keys(current);
4388    var currentSet = new Set(currentKeys);
4389    var nextSet = new Set(keys);
4390    var added = keys.filter(function (item) {
4391      return !currentSet.has(item);
4392    });
4393    var removed = state.transitions.filter(function (item) {
4394      return !item.destroyed && !nextSet.has(item.originalKey);
4395    }).map(function (i) {
4396      return i.originalKey;
4397    });
4398    var updated = keys.filter(function (item) {
4399      return currentSet.has(item);
4400    });
4401    var delay = -trail;
4402  
4403    while (order.length) {
4404      var changeType = order.shift();
4405  
4406      switch (changeType) {
4407        case ENTER:
4408          {
4409            added.forEach(function (key, index) {
4410              // In unique mode, remove fading out transitions if their key comes in again
4411              if (unique && deleted.find(function (d) {
4412                return d.originalKey === key;
4413              })) deleted = deleted.filter(function (t) {
4414                return t.originalKey !== key;
4415              });
4416              var keyIndex = keys.indexOf(key);
4417              var item = items[keyIndex];
4418              var slot = first && initial !== void 0 ? 'initial' : ENTER;
4419              current[key] = {
4420                slot: slot,
4421                originalKey: key,
4422                key: unique ? String(key) : guid++,
4423                item: item,
4424                trail: delay = delay + trail,
4425                config: callProp(config, item, slot),
4426                from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item),
4427                to: callProp(enter, item)
4428              };
4429            });
4430            break;
4431          }
4432  
4433        case LEAVE:
4434          {
4435            removed.forEach(function (key) {
4436              var keyIndex = _keys.indexOf(key);
4437  
4438              var item = _items[keyIndex];
4439              var slot = LEAVE;
4440              deleted.unshift(_extends({}, current[key], {
4441                slot: slot,
4442                destroyed: true,
4443                left: _keys[Math.max(0, keyIndex - 1)],
4444                right: _keys[Math.min(_keys.length, keyIndex + 1)],
4445                trail: delay = delay + trail,
4446                config: callProp(config, item, slot),
4447                to: callProp(leave, item)
4448              }));
4449              delete current[key];
4450            });
4451            break;
4452          }
4453  
4454        case UPDATE:
4455          {
4456            updated.forEach(function (key) {
4457              var keyIndex = keys.indexOf(key);
4458              var item = items[keyIndex];
4459              var slot = UPDATE;
4460              current[key] = _extends({}, current[key], {
4461                item: item,
4462                slot: slot,
4463                trail: delay = delay + trail,
4464                config: callProp(config, item, slot),
4465                to: callProp(update, item)
4466              });
4467            });
4468            break;
4469          }
4470      }
4471    }
4472  
4473    var out = keys.map(function (key) {
4474      return current[key];
4475    }); // This tries to restore order for deleted items by finding their last known siblings
4476    // only using the left sibling to keep order placement consistent for all deleted items
4477  
4478    deleted.forEach(function (_ref10) {
4479      var left = _ref10.left,
4480          right = _ref10.right,
4481          item = _objectWithoutPropertiesLoose(_ref10, ["left", "right"]);
4482  
4483      var pos; // Was it the element on the left, if yes, move there ...
4484  
4485      if ((pos = out.findIndex(function (t) {
4486        return t.originalKey === left;
4487      })) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\_(ツ)_/¯
4488  
4489      pos = Math.max(0, pos);
4490      out = [].concat(out.slice(0, pos), [item], out.slice(pos));
4491    });
4492    return _extends({}, state, {
4493      changed: added.length || removed.length || updated.length,
4494      first: first && added.length === 0,
4495      transitions: out,
4496      current: current,
4497      deleted: deleted,
4498      prevProps: props
4499    });
4500  }
4501  
4502  var AnimatedStyle =
4503  /*#__PURE__*/
4504  function (_AnimatedObject) {
4505    _inheritsLoose(AnimatedStyle, _AnimatedObject);
4506  
4507    function AnimatedStyle(style) {
4508      var _this;
4509  
4510      if (style === void 0) {
4511        style = {};
4512      }
4513  
4514      _this = _AnimatedObject.call(this) || this;
4515  
4516      if (style.transform && !(style.transform instanceof Animated)) {
4517        style = applyAnimatedValues.transform(style);
4518      }
4519  
4520      _this.payload = style;
4521      return _this;
4522    }
4523  
4524    return AnimatedStyle;
4525  }(AnimatedObject);
4526  
4527  // http://www.w3.org/TR/css3-color/#svg-color
4528  var colors = {
4529    transparent: 0x00000000,
4530    aliceblue: 0xf0f8ffff,
4531    antiquewhite: 0xfaebd7ff,
4532    aqua: 0x00ffffff,
4533    aquamarine: 0x7fffd4ff,
4534    azure: 0xf0ffffff,
4535    beige: 0xf5f5dcff,
4536    bisque: 0xffe4c4ff,
4537    black: 0x000000ff,
4538    blanchedalmond: 0xffebcdff,
4539    blue: 0x0000ffff,
4540    blueviolet: 0x8a2be2ff,
4541    brown: 0xa52a2aff,
4542    burlywood: 0xdeb887ff,
4543    burntsienna: 0xea7e5dff,
4544    cadetblue: 0x5f9ea0ff,
4545    chartreuse: 0x7fff00ff,
4546    chocolate: 0xd2691eff,
4547    coral: 0xff7f50ff,
4548    cornflowerblue: 0x6495edff,
4549    cornsilk: 0xfff8dcff,
4550    crimson: 0xdc143cff,
4551    cyan: 0x00ffffff,
4552    darkblue: 0x00008bff,
4553    darkcyan: 0x008b8bff,
4554    darkgoldenrod: 0xb8860bff,
4555    darkgray: 0xa9a9a9ff,
4556    darkgreen: 0x006400ff,
4557    darkgrey: 0xa9a9a9ff,
4558    darkkhaki: 0xbdb76bff,
4559    darkmagenta: 0x8b008bff,
4560    darkolivegreen: 0x556b2fff,
4561    darkorange: 0xff8c00ff,
4562    darkorchid: 0x9932ccff,
4563    darkred: 0x8b0000ff,
4564    darksalmon: 0xe9967aff,
4565    darkseagreen: 0x8fbc8fff,
4566    darkslateblue: 0x483d8bff,
4567    darkslategray: 0x2f4f4fff,
4568    darkslategrey: 0x2f4f4fff,
4569    darkturquoise: 0x00ced1ff,
4570    darkviolet: 0x9400d3ff,
4571    deeppink: 0xff1493ff,
4572    deepskyblue: 0x00bfffff,
4573    dimgray: 0x696969ff,
4574    dimgrey: 0x696969ff,
4575    dodgerblue: 0x1e90ffff,
4576    firebrick: 0xb22222ff,
4577    floralwhite: 0xfffaf0ff,
4578    forestgreen: 0x228b22ff,
4579    fuchsia: 0xff00ffff,
4580    gainsboro: 0xdcdcdcff,
4581    ghostwhite: 0xf8f8ffff,
4582    gold: 0xffd700ff,
4583    goldenrod: 0xdaa520ff,
4584    gray: 0x808080ff,
4585    green: 0x008000ff,
4586    greenyellow: 0xadff2fff,
4587    grey: 0x808080ff,
4588    honeydew: 0xf0fff0ff,
4589    hotpink: 0xff69b4ff,
4590    indianred: 0xcd5c5cff,
4591    indigo: 0x4b0082ff,
4592    ivory: 0xfffff0ff,
4593    khaki: 0xf0e68cff,
4594    lavender: 0xe6e6faff,
4595    lavenderblush: 0xfff0f5ff,
4596    lawngreen: 0x7cfc00ff,
4597    lemonchiffon: 0xfffacdff,
4598    lightblue: 0xadd8e6ff,
4599    lightcoral: 0xf08080ff,
4600    lightcyan: 0xe0ffffff,
4601    lightgoldenrodyellow: 0xfafad2ff,
4602    lightgray: 0xd3d3d3ff,
4603    lightgreen: 0x90ee90ff,
4604    lightgrey: 0xd3d3d3ff,
4605    lightpink: 0xffb6c1ff,
4606    lightsalmon: 0xffa07aff,
4607    lightseagreen: 0x20b2aaff,
4608    lightskyblue: 0x87cefaff,
4609    lightslategray: 0x778899ff,
4610    lightslategrey: 0x778899ff,
4611    lightsteelblue: 0xb0c4deff,
4612    lightyellow: 0xffffe0ff,
4613    lime: 0x00ff00ff,
4614    limegreen: 0x32cd32ff,
4615    linen: 0xfaf0e6ff,
4616    magenta: 0xff00ffff,
4617    maroon: 0x800000ff,
4618    mediumaquamarine: 0x66cdaaff,
4619    mediumblue: 0x0000cdff,
4620    mediumorchid: 0xba55d3ff,
4621    mediumpurple: 0x9370dbff,
4622    mediumseagreen: 0x3cb371ff,
4623    mediumslateblue: 0x7b68eeff,
4624    mediumspringgreen: 0x00fa9aff,
4625    mediumturquoise: 0x48d1ccff,
4626    mediumvioletred: 0xc71585ff,
4627    midnightblue: 0x191970ff,
4628    mintcream: 0xf5fffaff,
4629    mistyrose: 0xffe4e1ff,
4630    moccasin: 0xffe4b5ff,
4631    navajowhite: 0xffdeadff,
4632    navy: 0x000080ff,
4633    oldlace: 0xfdf5e6ff,
4634    olive: 0x808000ff,
4635    olivedrab: 0x6b8e23ff,
4636    orange: 0xffa500ff,
4637    orangered: 0xff4500ff,
4638    orchid: 0xda70d6ff,
4639    palegoldenrod: 0xeee8aaff,
4640    palegreen: 0x98fb98ff,
4641    paleturquoise: 0xafeeeeff,
4642    palevioletred: 0xdb7093ff,
4643    papayawhip: 0xffefd5ff,
4644    peachpuff: 0xffdab9ff,
4645    peru: 0xcd853fff,
4646    pink: 0xffc0cbff,
4647    plum: 0xdda0ddff,
4648    powderblue: 0xb0e0e6ff,
4649    purple: 0x800080ff,
4650    rebeccapurple: 0x663399ff,
4651    red: 0xff0000ff,
4652    rosybrown: 0xbc8f8fff,
4653    royalblue: 0x4169e1ff,
4654    saddlebrown: 0x8b4513ff,
4655    salmon: 0xfa8072ff,
4656    sandybrown: 0xf4a460ff,
4657    seagreen: 0x2e8b57ff,
4658    seashell: 0xfff5eeff,
4659    sienna: 0xa0522dff,
4660    silver: 0xc0c0c0ff,
4661    skyblue: 0x87ceebff,
4662    slateblue: 0x6a5acdff,
4663    slategray: 0x708090ff,
4664    slategrey: 0x708090ff,
4665    snow: 0xfffafaff,
4666    springgreen: 0x00ff7fff,
4667    steelblue: 0x4682b4ff,
4668    tan: 0xd2b48cff,
4669    teal: 0x008080ff,
4670    thistle: 0xd8bfd8ff,
4671    tomato: 0xff6347ff,
4672    turquoise: 0x40e0d0ff,
4673    violet: 0xee82eeff,
4674    wheat: 0xf5deb3ff,
4675    white: 0xffffffff,
4676    whitesmoke: 0xf5f5f5ff,
4677    yellow: 0xffff00ff,
4678    yellowgreen: 0x9acd32ff
4679  };
4680  
4681  // const INTEGER = '[-+]?\\d+';
4682  var NUMBER = '[-+]?\\d*\\.?\\d+';
4683  var PERCENTAGE = NUMBER + '%';
4684  
4685  function call() {
4686    for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {
4687      parts[_key] = arguments[_key];
4688    }
4689  
4690    return '\\(\\s*(' + parts.join(')\\s*,\\s*(') + ')\\s*\\)';
4691  }
4692  
4693  var rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));
4694  var rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));
4695  var hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));
4696  var hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
4697  var hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
4698  var hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
4699  var hex6 = /^#([0-9a-fA-F]{6})$/;
4700  var hex8 = /^#([0-9a-fA-F]{8})$/;
4701  
4702  /*
4703  https://github.com/react-community/normalize-css-color
4704  
4705  BSD 3-Clause License
4706  
4707  Copyright (c) 2016, React Community
4708  All rights reserved.
4709  
4710  Redistribution and use in source and binary forms, with or without
4711  modification, are permitted provided that the following conditions are met:
4712  
4713  * Redistributions of source code must retain the above copyright notice, this
4714    list of conditions and the following disclaimer.
4715  
4716  * Redistributions in binary form must reproduce the above copyright notice,
4717    this list of conditions and the following disclaimer in the documentation
4718    and/or other materials provided with the distribution.
4719  
4720  * Neither the name of the copyright holder nor the names of its
4721    contributors may be used to endorse or promote products derived from
4722    this software without specific prior written permission.
4723  
4724  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
4725  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
4726  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
4727  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
4728  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
4729  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
4730  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
4731  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
4732  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
4733  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4734  */
4735  function normalizeColor(color) {
4736    var match;
4737  
4738    if (typeof color === 'number') {
4739      return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null;
4740    } // Ordered based on occurrences on Facebook codebase
4741  
4742  
4743    if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;
4744    if (colors.hasOwnProperty(color)) return colors[color];
4745  
4746    if (match = rgb.exec(color)) {
4747      return (parse255(match[1]) << 24 | // r
4748      parse255(match[2]) << 16 | // g
4749      parse255(match[3]) << 8 | // b
4750      0x000000ff) >>> // a
4751      0;
4752    }
4753  
4754    if (match = rgba.exec(color)) {
4755      return (parse255(match[1]) << 24 | // r
4756      parse255(match[2]) << 16 | // g
4757      parse255(match[3]) << 8 | // b
4758      parse1(match[4])) >>> // a
4759      0;
4760    }
4761  
4762    if (match = hex3.exec(color)) {
4763      return parseInt(match[1] + match[1] + // r
4764      match[2] + match[2] + // g
4765      match[3] + match[3] + // b
4766      'ff', // a
4767      16) >>> 0;
4768    } // https://drafts.csswg.org/css-color-4/#hex-notation
4769  
4770  
4771    if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;
4772  
4773    if (match = hex4.exec(color)) {
4774      return parseInt(match[1] + match[1] + // r
4775      match[2] + match[2] + // g
4776      match[3] + match[3] + // b
4777      match[4] + match[4], // a
4778      16) >>> 0;
4779    }
4780  
4781    if (match = hsl.exec(color)) {
4782      return (hslToRgb(parse360(match[1]), // h
4783      parsePercentage(match[2]), // s
4784      parsePercentage(match[3]) // l
4785      ) | 0x000000ff) >>> // a
4786      0;
4787    }
4788  
4789    if (match = hsla.exec(color)) {
4790      return (hslToRgb(parse360(match[1]), // h
4791      parsePercentage(match[2]), // s
4792      parsePercentage(match[3]) // l
4793      ) | parse1(match[4])) >>> // a
4794      0;
4795    }
4796  
4797    return null;
4798  }
4799  
4800  function hue2rgb(p, q, t) {
4801    if (t < 0) t += 1;
4802    if (t > 1) t -= 1;
4803    if (t < 1 / 6) return p + (q - p) * 6 * t;
4804    if (t < 1 / 2) return q;
4805    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
4806    return p;
4807  }
4808  
4809  function hslToRgb(h, s, l) {
4810    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
4811    var p = 2 * l - q;
4812    var r = hue2rgb(p, q, h + 1 / 3);
4813    var g = hue2rgb(p, q, h);
4814    var b = hue2rgb(p, q, h - 1 / 3);
4815    return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
4816  }
4817  
4818  function parse255(str) {
4819    var int = parseInt(str, 10);
4820    if (int < 0) return 0;
4821    if (int > 255) return 255;
4822    return int;
4823  }
4824  
4825  function parse360(str) {
4826    var int = parseFloat(str);
4827    return (int % 360 + 360) % 360 / 360;
4828  }
4829  
4830  function parse1(str) {
4831    var num = parseFloat(str);
4832    if (num < 0) return 0;
4833    if (num > 1) return 255;
4834    return Math.round(num * 255);
4835  }
4836  
4837  function parsePercentage(str) {
4838    // parseFloat conveniently ignores the final %
4839    var int = parseFloat(str);
4840    if (int < 0) return 0;
4841    if (int > 100) return 1;
4842    return int / 100;
4843  }
4844  
4845  function colorToRgba(input) {
4846    var int32Color = normalizeColor(input);
4847    if (int32Color === null) return input;
4848    int32Color = int32Color || 0;
4849    var r = (int32Color & 0xff000000) >>> 24;
4850    var g = (int32Color & 0x00ff0000) >>> 16;
4851    var b = (int32Color & 0x0000ff00) >>> 8;
4852    var a = (int32Color & 0x000000ff) / 255;
4853    return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
4854  } // Problem: https://github.com/animatedjs/animated/pull/102
4855  // Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662
4856  
4857  
4858  var stringShapeRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; // Covers rgb, rgba, hsl, hsla
4859  // Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e
4860  
4861  var colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi; // Covers color names (transparent, blue, etc.)
4862  
4863  var colorNamesRegex = new RegExp("(" + Object.keys(colors).join('|') + ")", 'g');
4864  /**
4865   * Supports string shapes by extracting numbers so new values can be computed,
4866   * and recombines those values into new strings of the same shape.  Supports
4867   * things like:
4868   *
4869   *   rgba(123, 42, 99, 0.36)           // colors
4870   *   -45deg                            // values with units
4871   *   0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows
4872   */
4873  
4874  var createStringInterpolator = function createStringInterpolator(config) {
4875    // Replace colors with rgba
4876    var outputRange = config.output.map(function (rangeValue) {
4877      return rangeValue.replace(colorRegex, colorToRgba);
4878    }).map(function (rangeValue) {
4879      return rangeValue.replace(colorNamesRegex, colorToRgba);
4880    });
4881    var outputRanges = outputRange[0].match(stringShapeRegex).map(function () {
4882      return [];
4883    });
4884    outputRange.forEach(function (value) {
4885      value.match(stringShapeRegex).forEach(function (number, i) {
4886        return outputRanges[i].push(+number);
4887      });
4888    });
4889    var interpolations = outputRange[0].match(stringShapeRegex).map(function (_value, i) {
4890      return createInterpolator(_extends({}, config, {
4891        output: outputRanges[i]
4892      }));
4893    });
4894    return function (input) {
4895      var i = 0;
4896      return outputRange[0] // 'rgba(0, 100, 200, 0)'
4897      // ->
4898      // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'
4899      .replace(stringShapeRegex, function () {
4900        return interpolations[i++](input);
4901      }) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to
4902      // round the opacity (4th column).
4903      .replace(/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, function (_, p1, p2, p3, p4) {
4904        return "rgba(" + Math.round(p1) + ", " + Math.round(p2) + ", " + Math.round(p3) + ", " + p4 + ")";
4905      });
4906    };
4907  };
4908  
4909  var isUnitlessNumber = {
4910    animationIterationCount: true,
4911    borderImageOutset: true,
4912    borderImageSlice: true,
4913    borderImageWidth: true,
4914    boxFlex: true,
4915    boxFlexGroup: true,
4916    boxOrdinalGroup: true,
4917    columnCount: true,
4918    columns: true,
4919    flex: true,
4920    flexGrow: true,
4921    flexPositive: true,
4922    flexShrink: true,
4923    flexNegative: true,
4924    flexOrder: true,
4925    gridRow: true,
4926    gridRowEnd: true,
4927    gridRowSpan: true,
4928    gridRowStart: true,
4929    gridColumn: true,
4930    gridColumnEnd: true,
4931    gridColumnSpan: true,
4932    gridColumnStart: true,
4933    fontWeight: true,
4934    lineClamp: true,
4935    lineHeight: true,
4936    opacity: true,
4937    order: true,
4938    orphans: true,
4939    tabSize: true,
4940    widows: true,
4941    zIndex: true,
4942    zoom: true,
4943    // SVG-related properties
4944    fillOpacity: true,
4945    floodOpacity: true,
4946    stopOpacity: true,
4947    strokeDasharray: true,
4948    strokeDashoffset: true,
4949    strokeMiterlimit: true,
4950    strokeOpacity: true,
4951    strokeWidth: true
4952  };
4953  
4954  var prefixKey = function prefixKey(prefix, key) {
4955    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
4956  };
4957  
4958  var prefixes = ['Webkit', 'Ms', 'Moz', 'O'];
4959  isUnitlessNumber = Object.keys(isUnitlessNumber).reduce(function (acc, prop) {
4960    prefixes.forEach(function (prefix) {
4961      return acc[prefixKey(prefix, prop)] = acc[prop];
4962    });
4963    return acc;
4964  }, isUnitlessNumber);
4965  
4966  function dangerousStyleValue(name, value, isCustomProperty) {
4967    if (value == null || typeof value === 'boolean' || value === '') return '';
4968    if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
4969  
4970    return ('' + value).trim();
4971  }
4972  
4973  var attributeCache = {};
4974  injectCreateAnimatedStyle(function (style) {
4975    return new AnimatedStyle(style);
4976  });
4977  injectDefaultElement('div');
4978  injectStringInterpolator(createStringInterpolator);
4979  injectColorNames(colors);
4980  injectApplyAnimatedValues(function (instance, props) {
4981    if (instance.nodeType && instance.setAttribute !== undefined) {
4982      var style = props.style,
4983          children = props.children,
4984          scrollTop = props.scrollTop,
4985          scrollLeft = props.scrollLeft,
4986          attributes = _objectWithoutPropertiesLoose(props, ["style", "children", "scrollTop", "scrollLeft"]);
4987  
4988      var filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';
4989      if (scrollTop !== void 0) instance.scrollTop = scrollTop;
4990      if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value
4991  
4992      if (children !== void 0) instance.textContent = children; // Set styles ...
4993  
4994      for (var styleName in style) {
4995        if (!style.hasOwnProperty(styleName)) continue;
4996        var isCustomProperty = styleName.indexOf('--') === 0;
4997        var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty);
4998        if (styleName === 'float') styleName = 'cssFloat';
4999        if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue;
5000      } // Set attributes ...
5001  
5002  
5003      for (var name in attributes) {
5004        // Attributes are written in dash case
5005        var dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, function (n) {
5006          return '-' + n.toLowerCase();
5007        }));
5008        if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]);
5009      }
5010  
5011      return;
5012    } else return false;
5013  }, function (style) {
5014    return style;
5015  });
5016  
5017  var domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG
5018  'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];
5019  // Extend animated with all the available THREE elements
5020  var apply = merge(createAnimatedComponent, false);
5021  var extendedAnimated = apply(domElements);
5022  
5023  exports.apply = apply;
5024  exports.config = config;
5025  exports.update = update;
5026  exports.animated = extendedAnimated;
5027  exports.a = extendedAnimated;
5028  exports.interpolate = interpolate$1;
5029  exports.Globals = Globals;
5030  exports.useSpring = useSpring;
5031  exports.useTrail = useTrail;
5032  exports.useTransition = useTransition;
5033  exports.useChain = useChain;
5034  exports.useSprings = useSprings;
5035  
5036  
5037  /***/ }),
5038  /* 64 */
5039  /***/ (function(module, exports, __webpack_require__) {
5040  
5041  "use strict";
5042  
5043  
5044  var keys = __webpack_require__(126);
5045  var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
5046  
5047  var toStr = Object.prototype.toString;
5048  var concat = Array.prototype.concat;
5049  var origDefineProperty = Object.defineProperty;
5050  
5051  var isFunction = function (fn) {
5052      return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
5053  };
5054  
5055  var arePropertyDescriptorsSupported = function () {
5056      var obj = {};
5057      try {
5058          origDefineProperty(obj, 'x', { enumerable: false, value: obj });
5059          // eslint-disable-next-line no-unused-vars, no-restricted-syntax
5060          for (var _ in obj) { // jscs:ignore disallowUnusedVariables
5061              return false;
5062          }
5063          return obj.x === obj;
5064      } catch (e) { /* this is IE 8. */
5065          return false;
5066      }
5067  };
5068  var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
5069  
5070  var defineProperty = function (object, name, value, predicate) {
5071      if (name in object && (!isFunction(predicate) || !predicate())) {
5072          return;
5073      }
5074      if (supportsDescriptors) {
5075          origDefineProperty(object, name, {
5076              configurable: true,
5077              enumerable: false,
5078              value: value,
5079              writable: true
5080          });
5081      } else {
5082          object[name] = value;
5083      }
5084  };
5085  
5086  var defineProperties = function (object, map) {
5087      var predicates = arguments.length > 2 ? arguments[2] : {};
5088      var props = keys(map);
5089      if (hasSymbols) {
5090          props = concat.call(props, Object.getOwnPropertySymbols(map));
5091      }
5092      for (var i = 0; i < props.length; i += 1) {
5093          defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
5094      }
5095  };
5096  
5097  defineProperties.supportsDescriptors = !!supportsDescriptors;
5098  
5099  module.exports = defineProperties;
5100  
5101  
5102  /***/ }),
5103  /* 65 */
5104  /***/ (function(module, exports, __webpack_require__) {
5105  
5106  var moment = __webpack_require__(30);
5107  var momentValidationWrapper = __webpack_require__(285);
5108  var core = __webpack_require__(286);
5109  
5110  module.exports = {
5111  
5112    momentObj : core.createMomentChecker(
5113      'object',
5114      function(obj) {
5115        return typeof obj === 'object';
5116      },
5117      function isValid(value) {
5118        return momentValidationWrapper.isValidMoment(value);
5119      },
5120      'Moment'
5121    ),
5122  
5123    momentString : core.createMomentChecker(
5124      'string',
5125      function(str) {
5126        return typeof str === 'string';
5127      },
5128      function isValid(value) {
5129        return momentValidationWrapper.isValidMoment(moment(value));
5130      },
5131      'Moment'
5132    ),
5133  
5134    momentDurationObj : core.createMomentChecker(
5135      'object',
5136      function(obj) {
5137        return typeof obj === 'object';
5138      },
5139      function isValid(value) {
5140        return moment.isDuration(value);
5141      },
5142      'Duration'
5143    ),
5144  
5145  };
5146  
5147  
5148  /***/ }),
5149  /* 66 */
5150  /***/ (function(module, exports, __webpack_require__) {
5151  
5152  var rng = __webpack_require__(86);
5153  var bytesToUuid = __webpack_require__(87);
5154  
5155  function v4(options, buf, offset) {
5156    var i = buf && offset || 0;
5157  
5158    if (typeof(options) == 'string') {
5159      buf = options === 'binary' ? new Array(16) : null;
5160      options = null;
5161    }
5162    options = options || {};
5163  
5164    var rnds = options.random || (options.rng || rng)();
5165  
5166    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
5167    rnds[6] = (rnds[6] & 0x0f) | 0x40;
5168    rnds[8] = (rnds[8] & 0x3f) | 0x80;
5169  
5170    // Copy bytes to buffer, if provided
5171    if (buf) {
5172      for (var ii = 0; ii < 16; ++ii) {
5173        buf[i + ii] = rnds[ii];
5174      }
5175    }
5176  
5177    return buf || bytesToUuid(rnds);
5178  }
5179  
5180  module.exports = v4;
5181  
5182  
5183  /***/ }),
5184  /* 67 */
5185  /***/ (function(module, exports, __webpack_require__) {
5186  
5187  "use strict";
5188  
5189  
5190  module.exports = __webpack_require__(111);
5191  
5192  /***/ }),
5193  /* 68 */,
5194  /* 69 */,
5195  /* 70 */,
5196  /* 71 */,
5197  /* 72 */
5198  /***/ (function(module, exports, __webpack_require__) {
5199  
5200  "use strict";
5201  
5202  
5203  var implementation = __webpack_require__(244);
5204  
5205  module.exports = Function.prototype.bind || implementation;
5206  
5207  
5208  /***/ }),
5209  /* 73 */
5210  /***/ (function(module, exports, __webpack_require__) {
5211  
5212  "use strict";
5213  
5214  
5215  var ES5Type = __webpack_require__(249);
5216  
5217  // https://www.ecma-international.org/ecma-262/6.0/#sec-tostring
5218  
5219  module.exports = function Type(x) {
5220      if (typeof x === 'symbol') {
5221          return 'Symbol';
5222      }
5223      return ES5Type(x);
5224  };
5225  
5226  
5227  /***/ }),
5228  /* 74 */
5229  /***/ (function(module, exports, __webpack_require__) {
5230  
5231  "use strict";
5232  
5233  
5234  var bind = __webpack_require__(72);
5235  
5236  module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
5237  
5238  
5239  /***/ }),
5240  /* 75 */
5241  /***/ (function(module, exports, __webpack_require__) {
5242  
5243  "use strict";
5244  
5245  
5246  Object.defineProperty(exports, "__esModule", {
5247    value: true
5248  });
5249  
5250  var _propTypes = __webpack_require__(28);
5251  
5252  var _propTypes2 = _interopRequireDefault(_propTypes);
5253  
5254  var _constants = __webpack_require__(41);
5255  
5256  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5257  
5258  exports['default'] = _propTypes2['default'].oneOf(_constants.WEEKDAYS);
5259  
5260  /***/ }),
5261  /* 76 */,
5262  /* 77 */
5263  /***/ (function(module, exports, __webpack_require__) {
5264  
5265  "use strict";
5266  /**
5267   * Copyright (c) 2013-present, Facebook, Inc.
5268   *
5269   * This source code is licensed under the MIT license found in the
5270   * LICENSE file in the root directory of this source tree.
5271   *
5272   * @providesModule shallowCompare
5273   */
5274  
5275  
5276  
5277  var shallowEqual = __webpack_require__(284);
5278  
5279  /**
5280   * Does a shallow comparison for props and state.
5281   * See ReactComponentWithPureRenderMixin
5282   * See also https://facebook.github.io/react/docs/shallow-compare.html
5283   */
5284  function shallowCompare(instance, nextProps, nextState) {
5285    return (
5286      !shallowEqual(instance.props, nextProps) ||
5287      !shallowEqual(instance.state, nextState)
5288    );
5289  }
5290  
5291  module.exports = shallowCompare;
5292  
5293  
5294  /***/ }),
5295  /* 78 */
5296  /***/ (function(module, exports, __webpack_require__) {
5297  
5298  "use strict";
5299  
5300  
5301  Object.defineProperty(exports, "__esModule", {
5302    value: true
5303  });
5304  exports['default'] = isSameDay;
5305  
5306  var _moment = __webpack_require__(30);
5307  
5308  var _moment2 = _interopRequireDefault(_moment);
5309  
5310  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5311  
5312  function isSameDay(a, b) {
5313    if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false;
5314    // Compare least significant, most likely to change units first
5315    // Moment's isSame clones moment inputs and is a tad slow
5316    return a.date() === b.date() && a.month() === b.month() && a.year() === b.year();
5317  }
5318  
5319  /***/ }),
5320  /* 79 */
5321  /***/ (function(module, exports, __webpack_require__) {
5322  
5323  "use strict";
5324  
5325  
5326  Object.defineProperty(exports, "__esModule", {
5327    value: true
5328  });
5329  exports['default'] = toMomentObject;
5330  
5331  var _moment = __webpack_require__(30);
5332  
5333  var _moment2 = _interopRequireDefault(_moment);
5334  
5335  var _constants = __webpack_require__(41);
5336  
5337  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5338  
5339  function toMomentObject(dateString, customFormat) {
5340    var dateFormats = customFormat ? [customFormat, _constants.DISPLAY_FORMAT, _constants.ISO_FORMAT] : [_constants.DISPLAY_FORMAT, _constants.ISO_FORMAT];
5341  
5342    var date = (0, _moment2['default'])(dateString, dateFormats, true);
5343    return date.isValid() ? date.hour(12) : null;
5344  }
5345  
5346  /***/ }),
5347  /* 80 */
5348  /***/ (function(module, exports, __webpack_require__) {
5349  
5350  "use strict";
5351  
5352  
5353  Object.defineProperty(exports, "__esModule", {
5354    value: true
5355  });
5356  
5357  var _propTypes = __webpack_require__(28);
5358  
5359  var _propTypes2 = _interopRequireDefault(_propTypes);
5360  
5361  var _constants = __webpack_require__(41);
5362  
5363  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5364  
5365  exports['default'] = _propTypes2['default'].oneOf([_constants.HORIZONTAL_ORIENTATION, _constants.VERTICAL_ORIENTATION, _constants.VERTICAL_SCROLLABLE]);
5366  
5367  /***/ }),
5368  /* 81 */
5369  /***/ (function(module, exports) {
5370  
5371  Object.defineProperty(exports, "__esModule", {
5372    value: true
5373  });
5374  exports['default'] = isTouchDevice;
5375  function isTouchDevice() {
5376    return !!(typeof window !== 'undefined' && ('ontouchstart' in window || window.DocumentTouch && typeof document !== 'undefined' && document instanceof window.DocumentTouch)) || !!(typeof navigator !== 'undefined' && (navigator.maxTouchPoints || navigator.msMaxTouchPoints));
5377  }
5378  module.exports = exports['default'];
5379  
5380  /***/ }),
5381  /* 82 */
5382  /***/ (function(module, exports, __webpack_require__) {
5383  
5384  "use strict";
5385  
5386  
5387  Object.defineProperty(exports, "__esModule", {
5388    value: true
5389  });
5390  
5391  var _propTypes = __webpack_require__(28);
5392  
5393  var _propTypes2 = _interopRequireDefault(_propTypes);
5394  
5395  var _constants = __webpack_require__(41);
5396  
5397  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5398  
5399  exports['default'] = _propTypes2['default'].oneOf([_constants.OPEN_DOWN, _constants.OPEN_UP]);
5400  
5401  /***/ }),
5402  /* 83 */,
5403  /* 84 */,
5404  /* 85 */,
5405  /* 86 */
5406  /***/ (function(module, exports) {
5407  
5408  // Unique ID creation requires a high quality random # generator.  In the
5409  // browser this is a little complicated due to unknown quality of Math.random()
5410  // and inconsistent support for the `crypto` API.  We do the best we can via
5411  // feature-detection
5412  
5413  // getRandomValues needs to be invoked in a context where "this" is a Crypto
5414  // implementation. Also, find the complete implementation of crypto on IE11.
5415  var getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||
5416                        (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));
5417  
5418  if (getRandomValues) {
5419    // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
5420    var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
5421  
5422    module.exports = function whatwgRNG() {
5423      getRandomValues(rnds8);
5424      return rnds8;
5425    };
5426  } else {
5427    // Math.random()-based (RNG)
5428    //
5429    // If all else fails, use Math.random().  It's fast, but is of unspecified
5430    // quality.
5431    var rnds = new Array(16);
5432  
5433    module.exports = function mathRNG() {
5434      for (var i = 0, r; i < 16; i++) {
5435        if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
5436        rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
5437      }
5438  
5439      return rnds;
5440    };
5441  }
5442  
5443  
5444  /***/ }),
5445  /* 87 */
5446  /***/ (function(module, exports) {
5447  
5448  /**
5449   * Convert array of 16 byte values to UUID string format of the form:
5450   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
5451   */
5452  var byteToHex = [];
5453  for (var i = 0; i < 256; ++i) {
5454    byteToHex[i] = (i + 0x100).toString(16).substr(1);
5455  }
5456  
5457  function bytesToUuid(buf, offset) {
5458    var i = offset || 0;
5459    var bth = byteToHex;
5460    // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
5461    return ([bth[buf[i++]], bth[buf[i++]], 
5462      bth[buf[i++]], bth[buf[i++]], '-',
5463      bth[buf[i++]], bth[buf[i++]], '-',
5464      bth[buf[i++]], bth[buf[i++]], '-',
5465      bth[buf[i++]], bth[buf[i++]], '-',
5466      bth[buf[i++]], bth[buf[i++]],
5467      bth[buf[i++]], bth[buf[i++]],
5468      bth[buf[i++]], bth[buf[i++]]]).join('');
5469  }
5470  
5471  module.exports = bytesToUuid;
5472  
5473  
5474  /***/ }),
5475  /* 88 */
5476  /***/ (function(module, exports, __webpack_require__) {
5477  
5478  "use strict";
5479  /**
5480   * Copyright (c) 2013-present, Facebook, Inc.
5481   *
5482   * This source code is licensed under the MIT license found in the
5483   * LICENSE file in the root directory of this source tree.
5484   */
5485  
5486  
5487  
5488  var ReactPropTypesSecret = __webpack_require__(89);
5489  
5490  function emptyFunction() {}
5491  function emptyFunctionWithReset() {}
5492  emptyFunctionWithReset.resetWarningCache = emptyFunction;
5493  
5494  module.exports = function() {
5495    function shim(props, propName, componentName, location, propFullName, secret) {
5496      if (secret === ReactPropTypesSecret) {
5497        // It is still safe when called from React.
5498        return;
5499      }
5500      var err = new Error(
5501        'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
5502        'Use PropTypes.checkPropTypes() to call them. ' +
5503        'Read more at http://fb.me/use-check-prop-types'
5504      );
5505      err.name = 'Invariant Violation';
5506      throw err;
5507    };
5508    shim.isRequired = shim;
5509    function getShim() {
5510      return shim;
5511    };
5512    // Important!
5513    // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
5514    var ReactPropTypes = {
5515      array: shim,
5516      bool: shim,
5517      func: shim,
5518      number: shim,
5519      object: shim,
5520      string: shim,
5521      symbol: shim,
5522  
5523      any: shim,
5524      arrayOf: getShim,
5525      element: shim,
5526      elementType: shim,
5527      instanceOf: getShim,
5528      node: shim,
5529      objectOf: getShim,
5530      oneOf: getShim,
5531      oneOfType: getShim,
5532      shape: getShim,
5533      exact: getShim,
5534  
5535      checkPropTypes: emptyFunctionWithReset,
5536      resetWarningCache: emptyFunction
5537    };
5538  
5539    ReactPropTypes.PropTypes = ReactPropTypes;
5540  
5541    return ReactPropTypes;
5542  };
5543  
5544  
5545  /***/ }),
5546  /* 89 */
5547  /***/ (function(module, exports, __webpack_require__) {
5548  
5549  "use strict";
5550  /**
5551   * Copyright (c) 2013-present, Facebook, Inc.
5552   *
5553   * This source code is licensed under the MIT license found in the
5554   * LICENSE file in the root directory of this source tree.
5555   */
5556  
5557  
5558  
5559  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
5560  
5561  module.exports = ReactPropTypesSecret;
5562  
5563  
5564  /***/ }),
5565  /* 90 */
5566  /***/ (function(module, exports, __webpack_require__) {
5567  
5568  "use strict";
5569  
5570  
5571  Object.defineProperty(exports, "__esModule", {
5572    value: true
5573  });
5574  
5575  var _propTypes = __webpack_require__(28);
5576  
5577  var _propTypes2 = _interopRequireDefault(_propTypes);
5578  
5579  var _constants = __webpack_require__(41);
5580  
5581  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5582  
5583  exports['default'] = _propTypes2['default'].oneOf([_constants.ICON_BEFORE_POSITION, _constants.ICON_AFTER_POSITION]);
5584  
5585  /***/ }),
5586  /* 91 */
5587  /***/ (function(module, exports, __webpack_require__) {
5588  
5589  "use strict";
5590  
5591  
5592  Object.defineProperty(exports, "__esModule", {
5593    value: true
5594  });
5595  
5596  var _propTypes = __webpack_require__(28);
5597  
5598  var _propTypes2 = _interopRequireDefault(_propTypes);
5599  
5600  var _constants = __webpack_require__(41);
5601  
5602  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5603  
5604  exports['default'] = _propTypes2['default'].oneOf([_constants.INFO_POSITION_TOP, _constants.INFO_POSITION_BOTTOM, _constants.INFO_POSITION_BEFORE, _constants.INFO_POSITION_AFTER]);
5605  
5606  /***/ }),
5607  /* 92 */
5608  /***/ (function(module, exports, __webpack_require__) {
5609  
5610  "use strict";
5611  
5612  
5613  Object.defineProperty(exports, "__esModule", {
5614    value: true
5615  });
5616  exports['default'] = isInclusivelyAfterDay;
5617  
5618  var _moment = __webpack_require__(30);
5619  
5620  var _moment2 = _interopRequireDefault(_moment);
5621  
5622  var _isBeforeDay = __webpack_require__(93);
5623  
5624  var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay);
5625  
5626  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5627  
5628  function isInclusivelyAfterDay(a, b) {
5629    if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false;
5630    return !(0, _isBeforeDay2['default'])(a, b);
5631  }
5632  
5633  /***/ }),
5634  /* 93 */
5635  /***/ (function(module, exports, __webpack_require__) {
5636  
5637  "use strict";
5638  
5639  
5640  Object.defineProperty(exports, "__esModule", {
5641    value: true
5642  });
5643  exports['default'] = isBeforeDay;
5644  
5645  var _moment = __webpack_require__(30);
5646  
5647  var _moment2 = _interopRequireDefault(_moment);
5648  
5649  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5650  
5651  function isBeforeDay(a, b) {
5652    if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false;
5653  
5654    var aYear = a.year();
5655    var aMonth = a.month();
5656  
5657    var bYear = b.year();
5658    var bMonth = b.month();
5659  
5660    var isSameYear = aYear === bYear;
5661    var isSameMonth = aMonth === bMonth;
5662  
5663    if (isSameYear && isSameMonth) return a.date() < b.date();
5664    if (isSameYear) return aMonth < bMonth;
5665    return aYear < bYear;
5666  }
5667  
5668  /***/ }),
5669  /* 94 */
5670  /***/ (function(module, exports, __webpack_require__) {
5671  
5672  "use strict";
5673  
5674  
5675  Object.defineProperty(exports, "__esModule", {
5676    value: true
5677  });
5678  
5679  var _react = __webpack_require__(20);
5680  
5681  var _react2 = _interopRequireDefault(_react);
5682  
5683  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5684  
5685  var CloseButton = function () {
5686    function CloseButton(props) {
5687      return _react2['default'].createElement(
5688        'svg',
5689        props,
5690        _react2['default'].createElement('path', {
5691          fillRule: 'evenodd',
5692          d: 'M11.53.47a.75.75 0 0 0-1.061 0l-4.47 4.47L1.529.47A.75.75 0 1 0 .468 1.531l4.47 4.47-4.47 4.47a.75.75 0 1 0 1.061 1.061l4.47-4.47 4.47 4.47a.75.75 0 1 0 1.061-1.061l-4.47-4.47 4.47-4.47a.75.75 0 0 0 0-1.061z'
5693        })
5694      );
5695    }
5696  
5697    return CloseButton;
5698  }();
5699  
5700  CloseButton.defaultProps = {
5701    viewBox: '0 0 12 12'
5702  };
5703  exports['default'] = CloseButton;
5704  
5705  /***/ }),
5706  /* 95 */
5707  /***/ (function(module, exports) {
5708  
5709  function _inheritsLoose(subClass, superClass) {
5710    subClass.prototype = Object.create(superClass.prototype);
5711    subClass.prototype.constructor = subClass;
5712    subClass.__proto__ = superClass;
5713  }
5714  
5715  module.exports = _inheritsLoose;
5716  
5717  /***/ }),
5718  /* 96 */,
5719  /* 97 */,
5720  /* 98 */,
5721  /* 99 */,
5722  /* 100 */
5723  /***/ (function(module, exports, __webpack_require__) {
5724  
5725  "use strict";
5726  
5727  
5728  // https://www.ecma-international.org/ecma-262/6.0/#sec-ispropertykey
5729  
5730  module.exports = function IsPropertyKey(argument) {
5731      return typeof argument === 'string' || typeof argument === 'symbol';
5732  };
5733  
5734  
5735  /***/ }),
5736  /* 101 */
5737  /***/ (function(module, exports, __webpack_require__) {
5738  
5739  "use strict";
5740  
5741  
5742  Object.defineProperty(exports, "__esModule", {
5743    value: true
5744  });
5745  
5746  var _propTypes = __webpack_require__(28);
5747  
5748  var _propTypes2 = _interopRequireDefault(_propTypes);
5749  
5750  var _airbnbPropTypes = __webpack_require__(47);
5751  
5752  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5753  
5754  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; }
5755  
5756  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
5757  
5758  exports['default'] = (0, _airbnbPropTypes.and)([_propTypes2['default'].instanceOf(Set), function () {
5759    function modifiers(props, propName) {
5760      for (var _len = arguments.length, rest = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
5761        rest[_key - 2] = arguments[_key];
5762      }
5763  
5764      var propValue = props[propName];
5765  
5766      var firstError = void 0;
5767      [].concat(_toConsumableArray(propValue)).some(function (v, i) {
5768        var _PropTypes$string;
5769  
5770        var fakePropName = String(propName) + ': index ' + String(i);
5771        firstError = (_PropTypes$string = _propTypes2['default'].string).isRequired.apply(_PropTypes$string, [_defineProperty({}, fakePropName, v), fakePropName].concat(rest));
5772        return firstError != null;
5773      });
5774      return firstError == null ? null : firstError;
5775    }
5776  
5777    return modifiers;
5778  }()], 'Modifiers (Set of Strings)');
5779  
5780  /***/ }),
5781  /* 102 */
5782  /***/ (function(module, exports, __webpack_require__) {
5783  
5784  "use strict";
5785  
5786  
5787  Object.defineProperty(exports, "__esModule", {
5788    value: true
5789  });
5790  exports['default'] = toISODateString;
5791  
5792  var _moment = __webpack_require__(30);
5793  
5794  var _moment2 = _interopRequireDefault(_moment);
5795  
5796  var _toMomentObject = __webpack_require__(79);
5797  
5798  var _toMomentObject2 = _interopRequireDefault(_toMomentObject);
5799  
5800  var _constants = __webpack_require__(41);
5801  
5802  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
5803  
5804  function toISODateString(date, currentFormat) {
5805    var dateObj = _moment2['default'].isMoment(date) ? date : (0, _toMomentObject2['default'])(date, currentFormat);
5806    if (!dateObj) return null;
5807  
5808    return dateObj.format(_constants.ISO_FORMAT);
5809  }
5810  
5811  /***/ }),
5812  /* 103 */
5813  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5814  
5815  "use strict";
5816  __webpack_require__.r(__webpack_exports__);
5817  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addEventListener", function() { return addEventListener; });
5818  var CAN_USE_DOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
5819  
5820  // Adapted from Modernizr
5821  // https://github.com/Modernizr/Modernizr/blob/acb3f0d9/feature-detects/dom/passiveeventlisteners.js#L26-L37
5822  function testPassiveEventListeners() {
5823    if (!CAN_USE_DOM) {
5824      return false;
5825    }
5826  
5827    if (!window.addEventListener || !window.removeEventListener || !Object.defineProperty) {
5828      return false;
5829    }
5830  
5831    var supportsPassiveOption = false;
5832    try {
5833      var opts = Object.defineProperty({}, 'passive', {
5834        // eslint-disable-next-line getter-return
5835        get: function () {
5836          function get() {
5837            supportsPassiveOption = true;
5838          }
5839  
5840          return get;
5841        }()
5842      });
5843      var noop = function noop() {};
5844      window.addEventListener('testPassiveEventSupport', noop, opts);
5845      window.removeEventListener('testPassiveEventSupport', noop, opts);
5846    } catch (e) {
5847      // do nothing
5848    }
5849  
5850    return supportsPassiveOption;
5851  }
5852  
5853  var memoized = void 0;
5854  
5855  function canUsePassiveEventListeners() {
5856    if (memoized === undefined) {
5857      memoized = testPassiveEventListeners();
5858    }
5859    return memoized;
5860  }
5861  
5862  function normalizeEventOptions(eventOptions) {
5863    if (!eventOptions) {
5864      return undefined;
5865    }
5866  
5867    if (!canUsePassiveEventListeners()) {
5868      // If the browser does not support the passive option, then it is expecting
5869      // a boolean for the options argument to specify whether it should use
5870      // capture or not. In more modern browsers, this is passed via the `capture`
5871      // option, so let's just hoist that value up.
5872      return !!eventOptions.capture;
5873    }
5874  
5875    return eventOptions;
5876  }
5877  
5878  /* eslint-disable no-bitwise */
5879  
5880  /**
5881   * Generate a unique key for any set of event options
5882   */
5883  function eventOptionsKey(normalizedEventOptions) {
5884    if (!normalizedEventOptions) {
5885      return 0;
5886    }
5887  
5888    // If the browser does not support passive event listeners, the normalized
5889    // event options will be a boolean.
5890    if (normalizedEventOptions === true) {
5891      return 100;
5892    }
5893  
5894    // At this point, the browser supports passive event listeners, so we expect
5895    // the event options to be an object with possible properties of capture,
5896    // passive, and once.
5897    //
5898    // We want to consistently return the same value, regardless of the order of
5899    // these properties, so let's use binary maths to assign each property to a
5900    // bit, and then add those together (with an offset to account for the
5901    // booleans at the beginning of this function).
5902    var capture = normalizedEventOptions.capture << 0;
5903    var passive = normalizedEventOptions.passive << 1;
5904    var once = normalizedEventOptions.once << 2;
5905    return capture + passive + once;
5906  }
5907  
5908  function ensureCanMutateNextEventHandlers(eventHandlers) {
5909    if (eventHandlers.handlers === eventHandlers.nextHandlers) {
5910      // eslint-disable-next-line no-param-reassign
5911      eventHandlers.nextHandlers = eventHandlers.handlers.slice();
5912    }
5913  }
5914  
5915  function TargetEventHandlers(target) {
5916    this.target = target;
5917    this.events = {};
5918  }
5919  
5920  TargetEventHandlers.prototype.getEventHandlers = function () {
5921    function getEventHandlers(eventName, options) {
5922      var key = String(eventName) + ' ' + String(eventOptionsKey(options));
5923  
5924      if (!this.events[key]) {
5925        this.events[key] = {
5926          handlers: [],
5927          handleEvent: undefined
5928        };
5929        this.events[key].nextHandlers = this.events[key].handlers;
5930      }
5931  
5932      return this.events[key];
5933    }
5934  
5935    return getEventHandlers;
5936  }();
5937  
5938  TargetEventHandlers.prototype.handleEvent = function () {
5939    function handleEvent(eventName, options, event) {
5940      var eventHandlers = this.getEventHandlers(eventName, options);
5941      eventHandlers.handlers = eventHandlers.nextHandlers;
5942      eventHandlers.handlers.forEach(function (handler) {
5943        if (handler) {
5944          // We need to check for presence here because a handler function may
5945          // cause later handlers to get removed. This can happen if you for
5946          // instance have a waypoint that unmounts another waypoint as part of an
5947          // onEnter/onLeave handler.
5948          handler(event);
5949        }
5950      });
5951    }
5952  
5953    return handleEvent;
5954  }();
5955  
5956  TargetEventHandlers.prototype.add = function () {
5957    function add(eventName, listener, options) {
5958      var _this = this;
5959  
5960      // options has already been normalized at this point.
5961      var eventHandlers = this.getEventHandlers(eventName, options);
5962  
5963      ensureCanMutateNextEventHandlers(eventHandlers);
5964  
5965      if (eventHandlers.nextHandlers.length === 0) {
5966        eventHandlers.handleEvent = this.handleEvent.bind(this, eventName, options);
5967  
5968        this.target.addEventListener(eventName, eventHandlers.handleEvent, options);
5969      }
5970  
5971      eventHandlers.nextHandlers.push(listener);
5972  
5973      var isSubscribed = true;
5974      var unsubscribe = function () {
5975        function unsubscribe() {
5976          if (!isSubscribed) {
5977            return;
5978          }
5979  
5980          isSubscribed = false;
5981  
5982          ensureCanMutateNextEventHandlers(eventHandlers);
5983          var index = eventHandlers.nextHandlers.indexOf(listener);
5984          eventHandlers.nextHandlers.splice(index, 1);
5985  
5986          if (eventHandlers.nextHandlers.length === 0) {
5987            // All event handlers have been removed, so we want to remove the event
5988            // listener from the target node.
5989  
5990            if (_this.target) {
5991              // There can be a race condition where the target may no longer exist
5992              // when this function is called, e.g. when a React component is
5993              // unmounting. Guarding against this prevents the following error:
5994              //
5995              //   Cannot read property 'removeEventListener' of undefined
5996              _this.target.removeEventListener(eventName, eventHandlers.handleEvent, options);
5997            }
5998  
5999            eventHandlers.handleEvent = undefined;
6000          }
6001        }
6002  
6003        return unsubscribe;
6004      }();
6005      return unsubscribe;
6006    }
6007  
6008    return add;
6009  }();
6010  
6011  var EVENT_HANDLERS_KEY = '__consolidated_events_handlers__';
6012  
6013  // eslint-disable-next-line import/prefer-default-export
6014  function addEventListener(target, eventName, listener, options) {
6015    if (!target[EVENT_HANDLERS_KEY]) {
6016      // eslint-disable-next-line no-param-reassign
6017      target[EVENT_HANDLERS_KEY] = new TargetEventHandlers(target);
6018    }
6019    var normalizedEventOptions = normalizeEventOptions(options);
6020    return target[EVENT_HANDLERS_KEY].add(eventName, listener, normalizedEventOptions);
6021  }
6022  
6023  
6024  
6025  
6026  /***/ }),
6027  /* 104 */
6028  /***/ (function(module, exports, __webpack_require__) {
6029  
6030  "use strict";
6031  
6032  
6033  Object.defineProperty(exports, "__esModule", {
6034    value: true
6035  });
6036  exports['default'] = toISOMonthString;
6037  
6038  var _moment = __webpack_require__(30);
6039  
6040  var _moment2 = _interopRequireDefault(_moment);
6041  
6042  var _toMomentObject = __webpack_require__(79);
6043  
6044  var _toMomentObject2 = _interopRequireDefault(_toMomentObject);
6045  
6046  var _constants = __webpack_require__(41);
6047  
6048  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
6049  
6050  function toISOMonthString(date, currentFormat) {
6051    var dateObj = _moment2['default'].isMoment(date) ? date : (0, _toMomentObject2['default'])(date, currentFormat);
6052    if (!dateObj) return null;
6053  
6054    return dateObj.format(_constants.ISO_MONTH_FORMAT);
6055  }
6056  
6057  /***/ }),
6058  /* 105 */
6059  /***/ (function(module, exports, __webpack_require__) {
6060  
6061  "use strict";
6062  
6063  
6064  Object.defineProperty(exports, "__esModule", {
6065    value: true
6066  });
6067  
6068  var _propTypes = __webpack_require__(28);
6069  
6070  var _propTypes2 = _interopRequireDefault(_propTypes);
6071  
6072  var _constants = __webpack_require__(41);
6073  
6074  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
6075  
6076  exports['default'] = _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].oneOf([_constants.START_DATE, _constants.END_DATE])]);
6077  
6078  /***/ }),
6079  /* 106 */
6080  /***/ (function(module, exports, __webpack_require__) {
6081  
6082  "use strict";
6083  
6084  
6085  Object.defineProperty(exports, "__esModule", {
6086    value: true
6087  });
6088  exports['default'] = isAfterDay;
6089  
6090  var _moment = __webpack_require__(30);
6091  
6092  var _moment2 = _interopRequireDefault(_moment);
6093  
6094  var _isBeforeDay = __webpack_require__(93);
6095  
6096  var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay);
6097  
6098  var _isSameDay = __webpack_require__(78);
6099  
6100  var _isSameDay2 = _interopRequireDefault(_isSameDay);
6101  
6102  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
6103  
6104  function isAfterDay(a, b) {
6105    if (!_moment2['default'].isMoment(a) || !_moment2['default'].isMoment(b)) return false;
6106    return !(0, _isBeforeDay2['default'])(a, b) && !(0, _isSameDay2['default'])(a, b);
6107  }
6108  
6109  /***/ }),
6110  /* 107 */,
6111  /* 108 */,
6112  /* 109 */,
6113  /* 110 */,
6114  /* 111 */
6115  /***/ (function(module, exports, __webpack_require__) {
6116  
6117  "use strict";
6118  
6119  
6120  var util = __webpack_require__(112);
6121  
6122  function scrollIntoView(elem, container, config) {
6123    config = config || {};
6124    // document 归一化到 window
6125    if (container.nodeType === 9) {
6126      container = util.getWindow(container);
6127    }
6128  
6129    var allowHorizontalScroll = config.allowHorizontalScroll;
6130    var onlyScrollIfNeeded = config.onlyScrollIfNeeded;
6131    var alignWithTop = config.alignWithTop;
6132    var alignWithLeft = config.alignWithLeft;
6133    var offsetTop = config.offsetTop || 0;
6134    var offsetLeft = config.offsetLeft || 0;
6135    var offsetBottom = config.offsetBottom || 0;
6136    var offsetRight = config.offsetRight || 0;
6137  
6138    allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll;
6139  
6140    var isWin = util.isWindow(container);
6141    var elemOffset = util.offset(elem);
6142    var eh = util.outerHeight(elem);
6143    var ew = util.outerWidth(elem);
6144    var containerOffset = undefined;
6145    var ch = undefined;
6146    var cw = undefined;
6147    var containerScroll = undefined;
6148    var diffTop = undefined;
6149    var diffBottom = undefined;
6150    var win = undefined;
6151    var winScroll = undefined;
6152    var ww = undefined;
6153    var wh = undefined;
6154  
6155    if (isWin) {
6156      win = container;
6157      wh = util.height(win);
6158      ww = util.width(win);
6159      winScroll = {
6160        left: util.scrollLeft(win),
6161        top: util.scrollTop(win)
6162      };
6163      // elem 相对 container 可视视窗的距离
6164      diffTop = {
6165        left: elemOffset.left - winScroll.left - offsetLeft,
6166        top: elemOffset.top - winScroll.top - offsetTop
6167      };
6168      diffBottom = {
6169        left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight,
6170        top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom
6171      };
6172      containerScroll = winScroll;
6173    } else {
6174      containerOffset = util.offset(container);
6175      ch = container.clientHeight;
6176      cw = container.clientWidth;
6177      containerScroll = {
6178        left: container.scrollLeft,
6179        top: container.scrollTop
6180      };
6181      // elem 相对 container 可视视窗的距离
6182      // 注意边框, offset 是边框到根节点
6183      diffTop = {
6184        left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft,
6185        top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop
6186      };
6187      diffBottom = {
6188        left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight,
6189        top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom
6190      };
6191    }
6192  
6193    if (diffTop.top < 0 || diffBottom.top > 0) {
6194      // 强制向上
6195      if (alignWithTop === true) {
6196        util.scrollTop(container, containerScroll.top + diffTop.top);
6197      } else if (alignWithTop === false) {
6198        util.scrollTop(container, containerScroll.top + diffBottom.top);
6199      } else {
6200        // 自动调整
6201        if (diffTop.top < 0) {
6202          util.scrollTop(container, containerScroll.top + diffTop.top);
6203        } else {
6204          util.scrollTop(container, containerScroll.top + diffBottom.top);
6205        }
6206      }
6207    } else {
6208      if (!onlyScrollIfNeeded) {
6209        alignWithTop = alignWithTop === undefined ? true : !!alignWithTop;
6210        if (alignWithTop) {
6211          util.scrollTop(container, containerScroll.top + diffTop.top);
6212        } else {
6213          util.scrollTop(container, containerScroll.top + diffBottom.top);
6214        }
6215      }
6216    }
6217  
6218    if (allowHorizontalScroll) {
6219      if (diffTop.left < 0 || diffBottom.left > 0) {
6220        // 强制向上
6221        if (alignWithLeft === true) {
6222          util.scrollLeft(container, containerScroll.left + diffTop.left);
6223        } else if (alignWithLeft === false) {
6224          util.scrollLeft(container, containerScroll.left + diffBottom.left);
6225        } else {
6226          // 自动调整
6227          if (diffTop.left < 0) {
6228            util.scrollLeft(container, containerScroll.left + diffTop.left);
6229          } else {
6230            util.scrollLeft(container, containerScroll.left + diffBottom.left);
6231          }
6232        }
6233      } else {
6234        if (!onlyScrollIfNeeded) {
6235          alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft;
6236          if (alignWithLeft) {
6237            util.scrollLeft(container, containerScroll.left + diffTop.left);
6238          } else {
6239            util.scrollLeft(container, containerScroll.left + diffBottom.left);
6240          }
6241        }
6242      }
6243    }
6244  }
6245  
6246  module.exports = scrollIntoView;
6247  
6248  /***/ }),
6249  /* 112 */
6250  /***/ (function(module, exports, __webpack_require__) {
6251  
6252  "use strict";
6253  
6254  
6255  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; };
6256  
6257  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
6258  
6259  var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
6260  
6261  function getClientPosition(elem) {
6262    var box = undefined;
6263    var x = undefined;
6264    var y = undefined;
6265    var doc = elem.ownerDocument;
6266    var body = doc.body;
6267    var docElem = doc && doc.documentElement;
6268    // 根据 GBS 最新数据,A-Grade Browsers 都已支持 getBoundingClientRect 方法,不用再考虑传统的实现方式
6269    box = elem.getBoundingClientRect();
6270  
6271    // 注:jQuery 还考虑减去 docElem.clientLeft/clientTop
6272    // 但测试发现,这样反而会导致当 html 和 body 有边距/边框样式时,获取的值不正确
6273    // 此外,ie6 会忽略 html 的 margin 值,幸运地是没有谁会去设置 html 的 margin
6274  
6275    x = box.left;
6276    y = box.top;
6277  
6278    // In IE, most of the time, 2 extra pixels are added to the top and left
6279    // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
6280    // IE6 standards mode, this border can be overridden by setting the
6281    // document element's border to zero -- thus, we cannot rely on the
6282    // offset always being 2 pixels.
6283  
6284    // In quirks mode, the offset can be determined by querying the body's
6285    // clientLeft/clientTop, but in standards mode, it is found by querying
6286    // the document element's clientLeft/clientTop.  Since we already called
6287    // getClientBoundingRect we have already forced a reflow, so it is not
6288    // too expensive just to query them all.
6289  
6290    // ie 下应该减去窗口的边框吧,毕竟默认 absolute 都是相对窗口定位的
6291    // 窗口边框标准是设 documentElement ,quirks 时设置 body
6292    // 最好禁止在 body 和 html 上边框 ,但 ie < 9 html 默认有 2px ,减去
6293    // 但是非 ie 不可能设置窗口边框,body html 也不是窗口 ,ie 可以通过 html,body 设置
6294    // 标准 ie 下 docElem.clientTop 就是 border-top
6295    // ie7 html 即窗口边框改变不了。永远为 2
6296    // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框,即使设了 border-top 也为 0
6297  
6298    x -= docElem.clientLeft || body.clientLeft || 0;
6299    y -= docElem.clientTop || body.clientTop || 0;
6300  
6301    return {
6302      left: x,
6303      top: y
6304    };
6305  }
6306  
6307  function getScroll(w, top) {
6308    var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
6309    var method = 'scroll' + (top ? 'Top' : 'Left');
6310    if (typeof ret !== 'number') {
6311      var d = w.document;
6312      // ie6,7,8 standard mode
6313      ret = d.documentElement[method];
6314      if (typeof ret !== 'number') {
6315        // quirks mode
6316        ret = d.body[method];
6317      }
6318    }
6319    return ret;
6320  }
6321  
6322  function getScrollLeft(w) {
6323    return getScroll(w);
6324  }
6325  
6326  function getScrollTop(w) {
6327    return getScroll(w, true);
6328  }
6329  
6330  function getOffset(el) {
6331    var pos = getClientPosition(el);
6332    var doc = el.ownerDocument;
6333    var w = doc.defaultView || doc.parentWindow;
6334    pos.left += getScrollLeft(w);
6335    pos.top += getScrollTop(w);
6336    return pos;
6337  }
6338  function _getComputedStyle(elem, name, computedStyle_) {
6339    var val = '';
6340    var d = elem.ownerDocument;
6341    var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null);
6342  
6343    // https://github.com/kissyteam/kissy/issues/61
6344    if (computedStyle) {
6345      val = computedStyle.getPropertyValue(name) || computedStyle[name];
6346    }
6347  
6348    return val;
6349  }
6350  
6351  var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i');
6352  var RE_POS = /^(top|right|bottom|left)$/;
6353  var CURRENT_STYLE = 'currentStyle';
6354  var RUNTIME_STYLE = 'runtimeStyle';
6355  var LEFT = 'left';
6356  var PX = 'px';
6357  
6358  function _getComputedStyleIE(elem, name) {
6359    // currentStyle maybe null
6360    // http://msdn.microsoft.com/en-us/library/ms535231.aspx
6361    var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];
6362  
6363    // 当 width/height 设置为百分比时,通过 pixelLeft 方式转换的 width/height 值
6364    // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
6365    // 在 ie 下不对,需要直接用 offset 方式
6366    // borderWidth 等值也有问题,但考虑到 borderWidth 设为百分比的概率很小,这里就不考虑了
6367  
6368    // From the awesome hack by Dean Edwards
6369    // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6370    // If we're not dealing with a regular pixel number
6371    // but a number that has a weird ending, we need to convert it to pixels
6372    // exclude left right for relativity
6373    if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
6374      // Remember the original values
6375      var style = elem.style;
6376      var left = style[LEFT];
6377      var rsLeft = elem[RUNTIME_STYLE][LEFT];
6378  
6379      // prevent flashing of content
6380      elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];
6381  
6382      // Put in the new values to get a computed value out
6383      style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
6384      ret = style.pixelLeft + PX;
6385  
6386      // Revert the changed values
6387      style[LEFT] = left;
6388  
6389      elem[RUNTIME_STYLE][LEFT] = rsLeft;
6390    }
6391    return ret === '' ? 'auto' : ret;
6392  }
6393  
6394  var getComputedStyleX = undefined;
6395  if (typeof window !== 'undefined') {
6396    getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
6397  }
6398  
6399  function each(arr, fn) {
6400    for (var i = 0; i < arr.length; i++) {
6401      fn(arr[i]);
6402    }
6403  }
6404  
6405  function isBorderBoxFn(elem) {
6406    return getComputedStyleX(elem, 'boxSizing') === 'border-box';
6407  }
6408  
6409  var BOX_MODELS = ['margin', 'border', 'padding'];
6410  var CONTENT_INDEX = -1;
6411  var PADDING_INDEX = 2;
6412  var BORDER_INDEX = 1;
6413  var MARGIN_INDEX = 0;
6414  
6415  function swap(elem, options, callback) {
6416    var old = {};
6417    var style = elem.style;
6418    var name = undefined;
6419  
6420    // Remember the old values, and insert the new ones
6421    for (name in options) {
6422      if (options.hasOwnProperty(name)) {
6423        old[name] = style[name];
6424        style[name] = options[name];
6425      }
6426    }
6427  
6428    callback.call(elem);
6429  
6430    // Revert the old values
6431    for (name in options) {
6432      if (options.hasOwnProperty(name)) {
6433        style[name] = old[name];
6434      }
6435    }
6436  }
6437  
6438  function getPBMWidth(elem, props, which) {
6439    var value = 0;
6440    var prop = undefined;
6441    var j = undefined;
6442    var i = undefined;
6443    for (j = 0; j < props.length; j++) {
6444      prop = props[j];
6445      if (prop) {
6446        for (i = 0; i < which.length; i++) {
6447          var cssProp = undefined;
6448          if (prop === 'border') {
6449            cssProp = prop + which[i] + 'Width';
6450          } else {
6451            cssProp = prop + which[i];
6452          }
6453          value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
6454        }
6455      }
6456    }
6457    return value;
6458  }
6459  
6460  /**
6461   * A crude way of determining if an object is a window
6462   * @member util
6463   */
6464  function isWindow(obj) {
6465    // must use == for ie8
6466    /* eslint eqeqeq:0 */
6467    return obj != null && obj == obj.window;
6468  }
6469  
6470  var domUtils = {};
6471  
6472  each(['Width', 'Height'], function (name) {
6473    domUtils['doc' + name] = function (refWin) {
6474      var d = refWin.document;
6475      return Math.max(
6476      // firefox chrome documentElement.scrollHeight< body.scrollHeight
6477      // ie standard mode : documentElement.scrollHeight> body.scrollHeight
6478      d.documentElement['scroll' + name],
6479      // quirks : documentElement.scrollHeight 最大等于可视窗口多一点?
6480      d.body['scroll' + name], domUtils['viewport' + name](d));
6481    };
6482  
6483    domUtils['viewport' + name] = function (win) {
6484      // pc browser includes scrollbar in window.innerWidth
6485      var prop = 'client' + name;
6486      var doc = win.document;
6487      var body = doc.body;
6488      var documentElement = doc.documentElement;
6489      var documentElementProp = documentElement[prop];
6490      // 标准模式取 documentElement
6491      // backcompat 取 body
6492      return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
6493    };
6494  });
6495  
6496  /*
6497   得到元素的大小信息
6498   @param elem
6499   @param name
6500   @param {String} [extra]  'padding' : (css width) + padding
6501   'border' : (css width) + padding + border
6502   'margin' : (css width) + padding + border + margin
6503   */
6504  function getWH(elem, name, extra) {
6505    if (isWindow(elem)) {
6506      return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
6507    } else if (elem.nodeType === 9) {
6508      return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
6509    }
6510    var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
6511    var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight;
6512    var computedStyle = getComputedStyleX(elem);
6513    var isBorderBox = isBorderBoxFn(elem, computedStyle);
6514    var cssBoxValue = 0;
6515    if (borderBoxValue == null || borderBoxValue <= 0) {
6516      borderBoxValue = undefined;
6517      // Fall back to computed then un computed css if necessary
6518      cssBoxValue = getComputedStyleX(elem, name);
6519      if (cssBoxValue == null || Number(cssBoxValue) < 0) {
6520        cssBoxValue = elem.style[name] || 0;
6521      }
6522      // Normalize '', auto, and prepare for extra
6523      cssBoxValue = parseFloat(cssBoxValue) || 0;
6524    }
6525    if (extra === undefined) {
6526      extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
6527    }
6528    var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
6529    var val = borderBoxValue || cssBoxValue;
6530    if (extra === CONTENT_INDEX) {
6531      if (borderBoxValueOrIsBorderBox) {
6532        return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle);
6533      }
6534      return cssBoxValue;
6535    }
6536    if (borderBoxValueOrIsBorderBox) {
6537      var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle);
6538      return val + (extra === BORDER_INDEX ? 0 : padding);
6539    }
6540    return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle);
6541  }
6542  
6543  var cssShow = {
6544    position: 'absolute',
6545    visibility: 'hidden',
6546    display: 'block'
6547  };
6548  
6549  // fix #119 : https://github.com/kissyteam/kissy/issues/119
6550  function getWHIgnoreDisplay(elem) {
6551    var val = undefined;
6552    var args = arguments;
6553    // in case elem is window
6554    // elem.offsetWidth === undefined
6555    if (elem.offsetWidth !== 0) {
6556      val = getWH.apply(undefined, args);
6557    } else {
6558      swap(elem, cssShow, function () {
6559        val = getWH.apply(undefined, args);
6560      });
6561    }
6562    return val;
6563  }
6564  
6565  function css(el, name, v) {
6566    var value = v;
6567    if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
6568      for (var i in name) {
6569        if (name.hasOwnProperty(i)) {
6570          css(el, i, name[i]);
6571        }
6572      }
6573      return undefined;
6574    }
6575    if (typeof value !== 'undefined') {
6576      if (typeof value === 'number') {
6577        value += 'px';
6578      }
6579      el.style[name] = value;
6580      return undefined;
6581    }
6582    return getComputedStyleX(el, name);
6583  }
6584  
6585  each(['width', 'height'], function (name) {
6586    var first = name.charAt(0).toUpperCase() + name.slice(1);
6587    domUtils['outer' + first] = function (el, includeMargin) {
6588      return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
6589    };
6590    var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
6591  
6592    domUtils[name] = function (elem, val) {
6593      if (val !== undefined) {
6594        if (elem) {
6595          var computedStyle = getComputedStyleX(elem);
6596          var isBorderBox = isBorderBoxFn(elem);
6597          if (isBorderBox) {
6598            val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle);
6599          }
6600          return css(elem, name, val);
6601        }
6602        return undefined;
6603      }
6604      return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
6605    };
6606  });
6607  
6608  // 设置 elem 相对 elem.ownerDocument 的坐标
6609  function setOffset(elem, offset) {
6610    // set position first, in-case top/left are set even on static elem
6611    if (css(elem, 'position') === 'static') {
6612      elem.style.position = 'relative';
6613    }
6614  
6615    var old = getOffset(elem);
6616    var ret = {};
6617    var current = undefined;
6618    var key = undefined;
6619  
6620    for (key in offset) {
6621      if (offset.hasOwnProperty(key)) {
6622        current = parseFloat(css(elem, key)) || 0;
6623        ret[key] = current + offset[key] - old[key];
6624      }
6625    }
6626    css(elem, ret);
6627  }
6628  
6629  module.exports = _extends({
6630    getWindow: function getWindow(node) {
6631      var doc = node.ownerDocument || node;
6632      return doc.defaultView || doc.parentWindow;
6633    },
6634    offset: function offset(el, value) {
6635      if (typeof value !== 'undefined') {
6636        setOffset(el, value);
6637      } else {
6638        return getOffset(el);
6639      }
6640    },
6641  
6642    isWindow: isWindow,
6643    each: each,
6644    css: css,
6645    clone: function clone(obj) {
6646      var ret = {};
6647      for (var i in obj) {
6648        if (obj.hasOwnProperty(i)) {
6649          ret[i] = obj[i];
6650        }
6651      }
6652      var overflow = obj.overflow;
6653      if (overflow) {
6654        for (var i in obj) {
6655          if (obj.hasOwnProperty(i)) {
6656            ret.overflow[i] = obj.overflow[i];
6657          }
6658        }
6659      }
6660      return ret;
6661    },
6662    scrollLeft: function scrollLeft(w, v) {
6663      if (isWindow(w)) {
6664        if (v === undefined) {
6665          return getScrollLeft(w);
6666        }
6667        window.scrollTo(v, getScrollTop(w));
6668      } else {
6669        if (v === undefined) {
6670          return w.scrollLeft;
6671        }
6672        w.scrollLeft = v;
6673      }
6674    },
6675    scrollTop: function scrollTop(w, v) {
6676      if (isWindow(w)) {
6677        if (v === undefined) {
6678          return getScrollTop(w);
6679        }
6680        window.scrollTo(getScrollLeft(w), v);
6681      } else {
6682        if (v === undefined) {
6683          return w.scrollTop;
6684        }
6685        w.scrollTop = v;
6686      }
6687    },
6688  
6689    viewportWidth: 0,
6690    viewportHeight: 0
6691  }, domUtils);
6692  
6693  /***/ }),
6694  /* 113 */,
6695  /* 114 */,
6696  /* 115 */,
6697  /* 116 */,
6698  /* 117 */
6699  /***/ (function(module, exports) {
6700  
6701  function _extends() {
6702    module.exports = _extends = Object.assign || function (target) {
6703      for (var i = 1; i < arguments.length; i++) {
6704        var source = arguments[i];
6705  
6706        for (var key in source) {
6707          if (Object.prototype.hasOwnProperty.call(source, key)) {
6708            target[key] = source[key];
6709          }
6710        }
6711      }
6712  
6713      return target;
6714    };
6715  
6716    return _extends.apply(this, arguments);
6717  }
6718  
6719  module.exports = _extends;
6720  
6721  /***/ }),
6722  /* 118 */
6723  /***/ (function(module, exports) {
6724  
6725  function _objectWithoutPropertiesLoose(source, excluded) {
6726    if (source == null) return {};
6727    var target = {};
6728    var sourceKeys = Object.keys(source);
6729    var key, i;
6730  
6731    for (i = 0; i < sourceKeys.length; i++) {
6732      key = sourceKeys[i];
6733      if (excluded.indexOf(key) >= 0) continue;
6734      target[key] = source[key];
6735    }
6736  
6737    return target;
6738  }
6739  
6740  module.exports = _objectWithoutPropertiesLoose;
6741  
6742  /***/ }),
6743  /* 119 */
6744  /***/ (function(module, exports) {
6745  
6746  function _assertThisInitialized(self) {
6747    if (self === void 0) {
6748      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
6749    }
6750  
6751    return self;
6752  }
6753  
6754  module.exports = _assertThisInitialized;
6755  
6756  /***/ }),
6757  /* 120 */,
6758  /* 121 */,
6759  /* 122 */,
6760  /* 123 */,
6761  /* 124 */,
6762  /* 125 */,
6763  /* 126 */
6764  /***/ (function(module, exports, __webpack_require__) {
6765  
6766  "use strict";
6767  
6768  
6769  var slice = Array.prototype.slice;
6770  var isArgs = __webpack_require__(151);
6771  
6772  var origKeys = Object.keys;
6773  var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(243);
6774  
6775  var originalKeys = Object.keys;
6776  
6777  keysShim.shim = function shimObjectKeys() {
6778      if (Object.keys) {
6779          var keysWorksWithArguments = (function () {
6780              // Safari 5.0 bug
6781              var args = Object.keys(arguments);
6782              return args && args.length === arguments.length;
6783          }(1, 2));
6784          if (!keysWorksWithArguments) {
6785              Object.keys = function keys(object) { // eslint-disable-line func-name-matching
6786                  if (isArgs(object)) {
6787                      return originalKeys(slice.call(object));
6788                  }
6789                  return originalKeys(object);
6790              };
6791          }
6792      } else {
6793          Object.keys = keysShim;
6794      }
6795      return Object.keys || keysShim;
6796  };
6797  
6798  module.exports = keysShim;
6799  
6800  
6801  /***/ }),
6802  /* 127 */
6803  /***/ (function(module, exports, __webpack_require__) {
6804  
6805  "use strict";
6806  
6807  
6808  var bind = __webpack_require__(72);
6809  
6810  var GetIntrinsic = __webpack_require__(46);
6811  
6812  var $Function = GetIntrinsic('%Function%');
6813  var $apply = $Function.apply;
6814  var $call = $Function.call;
6815  
6816  module.exports = function callBind() {
6817      return bind.apply($call, arguments);
6818  };
6819  
6820  module.exports.apply = function applyBind() {
6821      return bind.apply($apply, arguments);
6822  };
6823  
6824  
6825  /***/ }),
6826  /* 128 */
6827  /***/ (function(module, exports, __webpack_require__) {
6828  
6829  "use strict";
6830  
6831  
6832  var GetIntrinsic = __webpack_require__(46);
6833  
6834  var $TypeError = GetIntrinsic('%TypeError%');
6835  
6836  var inspect = __webpack_require__(153);
6837  
6838  var IsPropertyKey = __webpack_require__(100);
6839  var Type = __webpack_require__(73);
6840  
6841  /**
6842   * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
6843   * 1. Assert: Type(O) is Object.
6844   * 2. Assert: IsPropertyKey(P) is true.
6845   * 3. Return O.[[Get]](P, O).
6846   */
6847  
6848  module.exports = function Get(O, P) {
6849      // 7.3.1.1
6850      if (Type(O) !== 'Object') {
6851          throw new $TypeError('Assertion failed: Type(O) is not Object');
6852      }
6853      // 7.3.1.2
6854      if (!IsPropertyKey(P)) {
6855          throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));
6856      }
6857      // 7.3.1.3
6858      return O[P];
6859  };
6860  
6861  
6862  /***/ }),
6863  /* 129 */
6864  /***/ (function(module, exports, __webpack_require__) {
6865  
6866  "use strict";
6867  
6868  
6869  var GetIntrinsic = __webpack_require__(46);
6870  
6871  var callBind = __webpack_require__(127);
6872  
6873  var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
6874  
6875  module.exports = function callBoundIntrinsic(name, allowMissing) {
6876      var intrinsic = GetIntrinsic(name, !!allowMissing);
6877      if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.')) {
6878          return callBind(intrinsic);
6879      }
6880      return intrinsic;
6881  };
6882  
6883  
6884  /***/ }),
6885  /* 130 */
6886  /***/ (function(module, exports, __webpack_require__) {
6887  
6888  "use strict";
6889  
6890  
6891  module.exports = Number.isNaN || function isNaN(a) {
6892      return a !== a;
6893  };
6894  
6895  
6896  /***/ }),
6897  /* 131 */
6898  /***/ (function(module, exports, __webpack_require__) {
6899  
6900  "use strict";
6901  
6902  
6903  var toStr = Object.prototype.toString;
6904  var hasSymbols = __webpack_require__(271)();
6905  
6906  if (hasSymbols) {
6907      var symToStr = Symbol.prototype.toString;
6908      var symStringRegex = /^Symbol\(.*\)$/;
6909      var isSymbolObject = function isRealSymbolObject(value) {
6910          if (typeof value.valueOf() !== 'symbol') {
6911              return false;
6912          }
6913          return symStringRegex.test(symToStr.call(value));
6914      };
6915  
6916      module.exports = function isSymbol(value) {
6917          if (typeof value === 'symbol') {
6918              return true;
6919          }
6920          if (toStr.call(value) !== '[object Symbol]') {
6921              return false;
6922          }
6923          try {
6924              return isSymbolObject(value);
6925          } catch (e) {
6926              return false;
6927          }
6928      };
6929  } else {
6930  
6931      module.exports = function isSymbol(value) {
6932          // this environment does not support Symbols.
6933          return  false && false;
6934      };
6935  }
6936  
6937  
6938  /***/ }),
6939  /* 132 */
6940  /***/ (function(module, exports, __webpack_require__) {
6941  
6942  "use strict";
6943  
6944  
6945  Object.defineProperty(exports, "__esModule", {
6946    value: true
6947  });
6948  exports.PureCalendarDay = undefined;
6949  
6950  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; };
6951  
6952  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; }; }();
6953  
6954  var _object = __webpack_require__(51);
6955  
6956  var _object2 = _interopRequireDefault(_object);
6957  
6958  var _react = __webpack_require__(20);
6959  
6960  var _react2 = _interopRequireDefault(_react);
6961  
6962  var _propTypes = __webpack_require__(28);
6963  
6964  var _propTypes2 = _interopRequireDefault(_propTypes);
6965  
6966  var _reactAddonsShallowCompare = __webpack_require__(77);
6967  
6968  var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);
6969  
6970  var _reactMomentProptypes = __webpack_require__(65);
6971  
6972  var _reactMomentProptypes2 = _interopRequireDefault(_reactMomentProptypes);
6973  
6974  var _airbnbPropTypes = __webpack_require__(47);
6975  
6976  var _reactWithStyles = __webpack_require__(56);
6977  
6978  var _moment = __webpack_require__(30);
6979  
6980  var _moment2 = _interopRequireDefault(_moment);
6981  
6982  var _defaultPhrases = __webpack_require__(52);
6983  
6984  var _getPhrasePropTypes = __webpack_require__(55);
6985  
6986  var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes);
6987  
6988  var _getCalendarDaySettings = __webpack_require__(169);
6989  
6990  var _getCalendarDaySettings2 = _interopRequireDefault(_getCalendarDaySettings);
6991  
6992  var _ModifiersShape = __webpack_require__(101);
6993  
6994  var _ModifiersShape2 = _interopRequireDefault(_ModifiersShape);
6995  
6996  var _constants = __webpack_require__(41);
6997  
6998  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
6999  
7000  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
7001  
7002  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; }
7003  
7004  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; }
7005  
7006  var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, {
7007    day: _reactMomentProptypes2['default'].momentObj,
7008    daySize: _airbnbPropTypes.nonNegativeInteger,
7009    isOutsideDay: _propTypes2['default'].bool,
7010    modifiers: _ModifiersShape2['default'],
7011    isFocused: _propTypes2['default'].bool,
7012    tabIndex: _propTypes2['default'].oneOf([0, -1]),
7013    onDayClick: _propTypes2['default'].func,
7014    onDayMouseEnter: _propTypes2['default'].func,
7015    onDayMouseLeave: _propTypes2['default'].func,
7016    renderDayContents: _propTypes2['default'].func,
7017    ariaLabelFormat: _propTypes2['default'].string,
7018  
7019    // internationalization
7020    phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.CalendarDayPhrases))
7021  }));
7022  
7023  var defaultProps = {
7024    day: (0, _moment2['default'])(),
7025    daySize: _constants.DAY_SIZE,
7026    isOutsideDay: false,
7027    modifiers: new Set(),
7028    isFocused: false,
7029    tabIndex: -1,
7030    onDayClick: function () {
7031      function onDayClick() {}
7032  
7033      return onDayClick;
7034    }(),
7035    onDayMouseEnter: function () {
7036      function onDayMouseEnter() {}
7037  
7038      return onDayMouseEnter;
7039    }(),
7040    onDayMouseLeave: function () {
7041      function onDayMouseLeave() {}
7042  
7043      return onDayMouseLeave;
7044    }(),
7045  
7046    renderDayContents: null,
7047    ariaLabelFormat: 'dddd, LL',
7048  
7049    // internationalization
7050    phrases: _defaultPhrases.CalendarDayPhrases
7051  };
7052  
7053  var CalendarDay = function (_React$Component) {
7054    _inherits(CalendarDay, _React$Component);
7055  
7056    function CalendarDay() {
7057      var _ref;
7058  
7059      _classCallCheck(this, CalendarDay);
7060  
7061      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
7062        args[_key] = arguments[_key];
7063      }
7064  
7065      var _this = _possibleConstructorReturn(this, (_ref = CalendarDay.__proto__ || Object.getPrototypeOf(CalendarDay)).call.apply(_ref, [this].concat(args)));
7066  
7067      _this.setButtonRef = _this.setButtonRef.bind(_this);
7068      return _this;
7069    }
7070  
7071    _createClass(CalendarDay, [{
7072      key: 'shouldComponentUpdate',
7073      value: function () {
7074        function shouldComponentUpdate(nextProps, nextState) {
7075          return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState);
7076        }
7077  
7078        return shouldComponentUpdate;
7079      }()
7080    }, {
7081      key: 'componentDidUpdate',
7082      value: function () {
7083        function componentDidUpdate(prevProps) {
7084          var _props = this.props,
7085              isFocused = _props.isFocused,
7086              tabIndex = _props.tabIndex;
7087  
7088          if (tabIndex === 0) {
7089            if (isFocused || tabIndex !== prevProps.tabIndex) {
7090              this.buttonRef.focus();
7091            }
7092          }
7093        }
7094  
7095        return componentDidUpdate;
7096      }()
7097    }, {
7098      key: 'onDayClick',
7099      value: function () {
7100        function onDayClick(day, e) {
7101          var onDayClick = this.props.onDayClick;
7102  
7103          onDayClick(day, e);
7104        }
7105  
7106        return onDayClick;
7107      }()
7108    }, {
7109      key: 'onDayMouseEnter',
7110      value: function () {
7111        function onDayMouseEnter(day, e) {
7112          var onDayMouseEnter = this.props.onDayMouseEnter;
7113  
7114          onDayMouseEnter(day, e);
7115        }
7116  
7117        return onDayMouseEnter;
7118      }()
7119    }, {
7120      key: 'onDayMouseLeave',
7121      value: function () {
7122        function onDayMouseLeave(day, e) {
7123          var onDayMouseLeave = this.props.onDayMouseLeave;
7124  
7125          onDayMouseLeave(day, e);
7126        }
7127  
7128        return onDayMouseLeave;
7129      }()
7130    }, {
7131      key: 'onKeyDown',
7132      value: function () {
7133        function onKeyDown(day, e) {
7134          var onDayClick = this.props.onDayClick;
7135          var key = e.key;
7136  
7137          if (key === 'Enter' || key === ' ') {
7138            onDayClick(day, e);
7139          }
7140        }
7141  
7142        return onKeyDown;
7143      }()
7144    }, {
7145      key: 'setButtonRef',
7146      value: function () {
7147        function setButtonRef(ref) {
7148          this.buttonRef = ref;
7149        }
7150  
7151        return setButtonRef;
7152      }()
7153    }, {
7154      key: 'render',
7155      value: function () {
7156        function render() {
7157          var _this2 = this;
7158  
7159          var _props2 = this.props,
7160              day = _props2.day,
7161              ariaLabelFormat = _props2.ariaLabelFormat,
7162              daySize = _props2.daySize,
7163              isOutsideDay = _props2.isOutsideDay,
7164              modifiers = _props2.modifiers,
7165              renderDayContents = _props2.renderDayContents,
7166              tabIndex = _props2.tabIndex,
7167              styles = _props2.styles,
7168              phrases = _props2.phrases;
7169  
7170  
7171          if (!day) return _react2['default'].createElement('td', null);
7172  
7173          var _getCalendarDaySettin = (0, _getCalendarDaySettings2['default'])(day, ariaLabelFormat, daySize, modifiers, phrases),
7174              daySizeStyles = _getCalendarDaySettin.daySizeStyles,
7175              useDefaultCursor = _getCalendarDaySettin.useDefaultCursor,
7176              selected = _getCalendarDaySettin.selected,
7177              hoveredSpan = _getCalendarDaySettin.hoveredSpan,
7178              isOutsideRange = _getCalendarDaySettin.isOutsideRange,
7179              ariaLabel = _getCalendarDaySettin.ariaLabel;
7180  
7181          return _react2['default'].createElement(
7182            'td',
7183            _extends({}, (0, _reactWithStyles.css)(styles.CalendarDay, useDefaultCursor && styles.CalendarDay__defaultCursor, styles.CalendarDay__default, isOutsideDay && styles.CalendarDay__outside, modifiers.has('today') && styles.CalendarDay__today, modifiers.has('first-day-of-week') && styles.CalendarDay__firstDayOfWeek, modifiers.has('last-day-of-week') && styles.CalendarDay__lastDayOfWeek, modifiers.has('hovered-offset') && styles.CalendarDay__hovered_offset, modifiers.has('highlighted-calendar') && styles.CalendarDay__highlighted_calendar, modifiers.has('blocked-minimum-nights') && styles.CalendarDay__blocked_minimum_nights, modifiers.has('blocked-calendar') && styles.CalendarDay__blocked_calendar, hoveredSpan && styles.CalendarDay__hovered_span, modifiers.has('selected-span') && styles.CalendarDay__selected_span, modifiers.has('last-in-range') && styles.CalendarDay__last_in_range, modifiers.has('selected-start') && styles.CalendarDay__selected_start, modifiers.has('selected-end') && styles.CalendarDay__selected_end, selected && styles.CalendarDay__selected, isOutsideRange && styles.CalendarDay__blocked_out_of_range, daySizeStyles), {
7184              role: 'button' // eslint-disable-line jsx-a11y/no-noninteractive-element-to-interactive-role
7185              , ref: this.setButtonRef,
7186              'aria-label': ariaLabel,
7187              onMouseEnter: function () {
7188                function onMouseEnter(e) {
7189                  _this2.onDayMouseEnter(day, e);
7190                }
7191  
7192                return onMouseEnter;
7193              }(),
7194              onMouseLeave: function () {
7195                function onMouseLeave(e) {
7196                  _this2.onDayMouseLeave(day, e);
7197                }
7198  
7199                return onMouseLeave;
7200              }(),
7201              onMouseUp: function () {
7202                function onMouseUp(e) {
7203                  e.currentTarget.blur();
7204                }
7205  
7206                return onMouseUp;
7207              }(),
7208              onClick: function () {
7209                function onClick(e) {
7210                  _this2.onDayClick(day, e);
7211                }
7212  
7213                return onClick;
7214              }(),
7215              onKeyDown: function () {
7216                function onKeyDown(e) {
7217                  _this2.onKeyDown(day, e);
7218                }
7219  
7220                return onKeyDown;
7221              }(),
7222              tabIndex: tabIndex
7223            }),
7224            renderDayContents ? renderDayContents(day, modifiers) : day.format('D')
7225          );
7226        }
7227  
7228        return render;
7229      }()
7230    }]);
7231  
7232    return CalendarDay;
7233  }(_react2['default'].Component);
7234  
7235  CalendarDay.propTypes = propTypes;
7236  CalendarDay.defaultProps = defaultProps;
7237  
7238  exports.PureCalendarDay = CalendarDay;
7239  exports['default'] = (0, _reactWithStyles.withStyles)(function (_ref2) {
7240    var _ref2$reactDates = _ref2.reactDates,
7241        color = _ref2$reactDates.color,
7242        font = _ref2$reactDates.font;
7243    return {
7244      CalendarDay: {
7245        boxSizing: 'border-box',
7246        cursor: 'pointer',
7247        fontSize: font.size,
7248        textAlign: 'center',
7249  
7250        ':active': {
7251          outline: 0
7252        }
7253      },
7254  
7255      CalendarDay__defaultCursor: {
7256        cursor: 'default'
7257      },
7258  
7259      CalendarDay__default: {
7260        border: '1px solid ' + String(color.core.borderLight),
7261        color: color.text,
7262        background: color.background,
7263  
7264        ':hover': {
7265          background: color.core.borderLight,
7266          border: '1px double ' + String(color.core.borderLight),
7267          color: 'inherit'
7268        }
7269      },
7270  
7271      CalendarDay__hovered_offset: {
7272        background: color.core.borderBright,
7273        border: '1px double ' + String(color.core.borderLight),
7274        color: 'inherit'
7275      },
7276  
7277      CalendarDay__outside: {
7278        border: 0,
7279        background: color.outside.backgroundColor,
7280        color: color.outside.color,
7281  
7282        ':hover': {
7283          border: 0
7284        }
7285      },
7286  
7287      CalendarDay__blocked_minimum_nights: {
7288        background: color.minimumNights.backgroundColor,
7289        border: '1px solid ' + String(color.minimumNights.borderColor),
7290        color: color.minimumNights.color,
7291  
7292        ':hover': {
7293          background: color.minimumNights.backgroundColor_hover,
7294          color: color.minimumNights.color_active
7295        },
7296  
7297        ':active': {
7298          background: color.minimumNights.backgroundColor_active,
7299          color: color.minimumNights.color_active
7300        }
7301      },
7302  
7303      CalendarDay__highlighted_calendar: {
7304        background: color.highlighted.backgroundColor,
7305        color: color.highlighted.color,
7306  
7307        ':hover': {
7308          background: color.highlighted.backgroundColor_hover,
7309          color: color.highlighted.color_active
7310        },
7311  
7312        ':active': {
7313          background: color.highlighted.backgroundColor_active,
7314          color: color.highlighted.color_active
7315        }
7316      },
7317  
7318      CalendarDay__selected_span: {
7319        background: color.selectedSpan.backgroundColor,
7320        border: '1px solid ' + String(color.selectedSpan.borderColor),
7321        color: color.selectedSpan.color,
7322  
7323        ':hover': {
7324          background: color.selectedSpan.backgroundColor_hover,
7325          border: '1px solid ' + String(color.selectedSpan.borderColor),
7326          color: color.selectedSpan.color_active
7327        },
7328  
7329        ':active': {
7330          background: color.selectedSpan.backgroundColor_active,
7331          border: '1px solid ' + String(color.selectedSpan.borderColor),
7332          color: color.selectedSpan.color_active
7333        }
7334      },
7335  
7336      CalendarDay__last_in_range: {
7337        borderRight: color.core.primary
7338      },
7339  
7340      CalendarDay__selected: {
7341        background: color.selected.backgroundColor,
7342        border: '1px solid ' + String(color.selected.borderColor),
7343        color: color.selected.color,
7344  
7345        ':hover': {
7346          background: color.selected.backgroundColor_hover,
7347          border: '1px solid ' + String(color.selected.borderColor),
7348          color: color.selected.color_active
7349        },
7350  
7351        ':active': {
7352          background: color.selected.backgroundColor_active,
7353          border: '1px solid ' + String(color.selected.borderColor),
7354          color: color.selected.color_active
7355        }
7356      },
7357  
7358      CalendarDay__hovered_span: {
7359        background: color.hoveredSpan.backgroundColor,
7360        border: '1px solid ' + String(color.hoveredSpan.borderColor),
7361        color: color.hoveredSpan.color,
7362  
7363        ':hover': {
7364          background: color.hoveredSpan.backgroundColor_hover,
7365          border: '1px solid ' + String(color.hoveredSpan.borderColor),
7366          color: color.hoveredSpan.color_active
7367        },
7368  
7369        ':active': {
7370          background: color.hoveredSpan.backgroundColor_active,
7371          border: '1px solid ' + String(color.hoveredSpan.borderColor),
7372          color: color.hoveredSpan.color_active
7373        }
7374      },
7375  
7376      CalendarDay__blocked_calendar: {
7377        background: color.blocked_calendar.backgroundColor,
7378        border: '1px solid ' + String(color.blocked_calendar.borderColor),
7379        color: color.blocked_calendar.color,
7380  
7381        ':hover': {
7382          background: color.blocked_calendar.backgroundColor_hover,
7383          border: '1px solid ' + String(color.blocked_calendar.borderColor),
7384          color: color.blocked_calendar.color_active
7385        },
7386  
7387        ':active': {
7388          background: color.blocked_calendar.backgroundColor_active,
7389          border: '1px solid ' + String(color.blocked_calendar.borderColor),
7390          color: color.blocked_calendar.color_active
7391        }
7392      },
7393  
7394      CalendarDay__blocked_out_of_range: {
7395        background: color.blocked_out_of_range.backgroundColor,
7396        border: '1px solid ' + String(color.blocked_out_of_range.borderColor),
7397        color: color.blocked_out_of_range.color,
7398  
7399        ':hover': {
7400          background: color.blocked_out_of_range.backgroundColor_hover,
7401          border: '1px solid ' + String(color.blocked_out_of_range.borderColor),
7402          color: color.blocked_out_of_range.color_active
7403        },
7404  
7405        ':active': {
7406          background: color.blocked_out_of_range.backgroundColor_active,
7407          border: '1px solid ' + String(color.blocked_out_of_range.borderColor),
7408          color: color.blocked_out_of_range.color_active
7409        }
7410      },
7411  
7412      CalendarDay__selected_start: {},
7413      CalendarDay__selected_end: {},
7414      CalendarDay__today: {},
7415      CalendarDay__firstDayOfWeek: {},
7416      CalendarDay__lastDayOfWeek: {}
7417    };
7418  })(CalendarDay);
7419  
7420  /***/ }),
7421  /* 133 */
7422  /***/ (function(module, exports, __webpack_require__) {
7423  
7424  // eslint-disable-next-line import/no-unresolved
7425  module.exports = __webpack_require__(302);
7426  
7427  
7428  /***/ }),
7429  /* 134 */
7430  /***/ (function(module, exports, __webpack_require__) {
7431  
7432  "use strict";
7433  
7434  
7435  var define = __webpack_require__(64);
7436  
7437  var implementation = __webpack_require__(175);
7438  var getPolyfill = __webpack_require__(183);
7439  var shim = __webpack_require__(312);
7440  
7441  var polyfill = getPolyfill();
7442  
7443  define(polyfill, {
7444      getPolyfill: getPolyfill,
7445      implementation: implementation,
7446      shim: shim
7447  });
7448  
7449  module.exports = polyfill;
7450  
7451  
7452  /***/ }),
7453  /* 135 */
7454  /***/ (function(module, exports, __webpack_require__) {
7455  
7456  "use strict";
7457  
7458  
7459  var fnToStr = Function.prototype.toString;
7460  
7461  var constructorRegex = /^\s*class\b/;
7462  var isES6ClassFn = function isES6ClassFunction(value) {
7463      try {
7464          var fnStr = fnToStr.call(value);
7465          return constructorRegex.test(fnStr);
7466      } catch (e) {
7467          return false; // not a function
7468      }
7469  };
7470  
7471  var tryFunctionObject = function tryFunctionToStr(value) {
7472      try {
7473          if (isES6ClassFn(value)) { return false; }
7474          fnToStr.call(value);
7475          return true;
7476      } catch (e) {
7477          return false;
7478      }
7479  };
7480  var toStr = Object.prototype.toString;
7481  var fnClass = '[object Function]';
7482  var genClass = '[object GeneratorFunction]';
7483  var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
7484  
7485  module.exports = function isCallable(value) {
7486      if (!value) { return false; }
7487      if (typeof value !== 'function' && typeof value !== 'object') { return false; }
7488      if (typeof value === 'function' && !value.prototype) { return true; }
7489      if (hasToStringTag) { return tryFunctionObject(value); }
7490      if (isES6ClassFn(value)) { return false; }
7491      var strClass = toStr.call(value);
7492      return strClass === fnClass || strClass === genClass;
7493  };
7494  
7495  
7496  /***/ }),
7497  /* 136 */
7498  /***/ (function(module, exports, __webpack_require__) {
7499  
7500  "use strict";
7501  
7502  
7503  /* globals
7504      Set,
7505      Map,
7506      WeakSet,
7507      WeakMap,
7508  
7509      Promise,
7510  
7511      Symbol,
7512      Proxy,
7513  
7514      Atomics,
7515      SharedArrayBuffer,
7516  
7517      ArrayBuffer,
7518      DataView,
7519      Uint8Array,
7520      Float32Array,
7521      Float64Array,
7522      Int8Array,
7523      Int16Array,
7524      Int32Array,
7525      Uint8ClampedArray,
7526      Uint16Array,
7527      Uint32Array,
7528  */
7529  
7530  var undefined; // eslint-disable-line no-shadow-restricted-names
7531  
7532  var ThrowTypeError = Object.getOwnPropertyDescriptor
7533      ? (function () { return Object.getOwnPropertyDescriptor(arguments, 'callee').get; }())
7534      : function () { throw new TypeError(); };
7535  
7536  var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';
7537  
7538  var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
7539  
7540  var generator; // = function * () {};
7541  var generatorFunction = generator ? getProto(generator) : undefined;
7542  var asyncFn; // async function() {};
7543  var asyncFunction = asyncFn ? asyncFn.constructor : undefined;
7544  var asyncGen; // async function * () {};
7545  var asyncGenFunction = asyncGen ? getProto(asyncGen) : undefined;
7546  var asyncGenIterator = asyncGen ? asyncGen() : undefined;
7547  
7548  var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
7549  
7550  var INTRINSICS = {
7551      '$ %Array%': Array,
7552      '$ %ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
7553      '$ %ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer.prototype,
7554      '$ %ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
7555      '$ %ArrayPrototype%': Array.prototype,
7556      '$ %ArrayProto_entries%': Array.prototype.entries,
7557      '$ %ArrayProto_forEach%': Array.prototype.forEach,
7558      '$ %ArrayProto_keys%': Array.prototype.keys,
7559      '$ %ArrayProto_values%': Array.prototype.values,
7560      '$ %AsyncFromSyncIteratorPrototype%': undefined,
7561      '$ %AsyncFunction%': asyncFunction,
7562      '$ %AsyncFunctionPrototype%': asyncFunction ? asyncFunction.prototype : undefined,
7563      '$ %AsyncGenerator%': asyncGen ? getProto(asyncGenIterator) : undefined,
7564      '$ %AsyncGeneratorFunction%': asyncGenFunction,
7565      '$ %AsyncGeneratorPrototype%': asyncGenFunction ? asyncGenFunction.prototype : undefined,
7566      '$ %AsyncIteratorPrototype%': asyncGenIterator && hasSymbols && Symbol.asyncIterator ? asyncGenIterator[Symbol.asyncIterator]() : undefined,
7567      '$ %Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
7568      '$ %Boolean%': Boolean,
7569      '$ %BooleanPrototype%': Boolean.prototype,
7570      '$ %DataView%': typeof DataView === 'undefined' ? undefined : DataView,
7571      '$ %DataViewPrototype%': typeof DataView === 'undefined' ? undefined : DataView.prototype,
7572      '$ %Date%': Date,
7573      '$ %DatePrototype%': Date.prototype,
7574      '$ %decodeURI%': decodeURI,
7575      '$ %decodeURIComponent%': decodeURIComponent,
7576      '$ %encodeURI%': encodeURI,
7577      '$ %encodeURIComponent%': encodeURIComponent,
7578      '$ %Error%': Error,
7579      '$ %ErrorPrototype%': Error.prototype,
7580      '$ %eval%': eval, // eslint-disable-line no-eval
7581      '$ %EvalError%': EvalError,
7582      '$ %EvalErrorPrototype%': EvalError.prototype,
7583      '$ %Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
7584      '$ %Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined : Float32Array.prototype,
7585      '$ %Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
7586      '$ %Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined : Float64Array.prototype,
7587      '$ %Function%': Function,
7588      '$ %FunctionPrototype%': Function.prototype,
7589      '$ %Generator%': generator ? getProto(generator()) : undefined,
7590      '$ %GeneratorFunction%': generatorFunction,
7591      '$ %GeneratorPrototype%': generatorFunction ? generatorFunction.prototype : undefined,
7592      '$ %Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
7593      '$ %Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined : Int8Array.prototype,
7594      '$ %Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
7595      '$ %Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined : Int8Array.prototype,
7596      '$ %Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
7597      '$ %Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined : Int32Array.prototype,
7598      '$ %isFinite%': isFinite,
7599      '$ %isNaN%': isNaN,
7600      '$ %IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
7601      '$ %JSON%': JSON,
7602      '$ %JSONParse%': JSON.parse,
7603      '$ %Map%': typeof Map === 'undefined' ? undefined : Map,
7604      '$ %MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
7605      '$ %MapPrototype%': typeof Map === 'undefined' ? undefined : Map.prototype,
7606      '$ %Math%': Math,
7607      '$ %Number%': Number,
7608      '$ %NumberPrototype%': Number.prototype,
7609      '$ %Object%': Object,
7610      '$ %ObjectPrototype%': Object.prototype,
7611      '$ %ObjProto_toString%': Object.prototype.toString,
7612      '$ %ObjProto_valueOf%': Object.prototype.valueOf,
7613      '$ %parseFloat%': parseFloat,
7614      '$ %parseInt%': parseInt,
7615      '$ %Promise%': typeof Promise === 'undefined' ? undefined : Promise,
7616      '$ %PromisePrototype%': typeof Promise === 'undefined' ? undefined : Promise.prototype,
7617      '$ %PromiseProto_then%': typeof Promise === 'undefined' ? undefined : Promise.prototype.then,
7618      '$ %Promise_all%': typeof Promise === 'undefined' ? undefined : Promise.all,
7619      '$ %Promise_reject%': typeof Promise === 'undefined' ? undefined : Promise.reject,
7620      '$ %Promise_resolve%': typeof Promise === 'undefined' ? undefined : Promise.resolve,
7621      '$ %Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
7622      '$ %RangeError%': RangeError,
7623      '$ %RangeErrorPrototype%': RangeError.prototype,
7624      '$ %ReferenceError%': ReferenceError,
7625      '$ %ReferenceErrorPrototype%': ReferenceError.prototype,
7626      '$ %Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
7627      '$ %RegExp%': RegExp,
7628      '$ %RegExpPrototype%': RegExp.prototype,
7629      '$ %Set%': typeof Set === 'undefined' ? undefined : Set,
7630      '$ %SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
7631      '$ %SetPrototype%': typeof Set === 'undefined' ? undefined : Set.prototype,
7632      '$ %SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
7633      '$ %SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer.prototype,
7634      '$ %String%': String,
7635      '$ %StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
7636      '$ %StringPrototype%': String.prototype,
7637      '$ %Symbol%': hasSymbols ? Symbol : undefined,
7638      '$ %SymbolPrototype%': hasSymbols ? Symbol.prototype : undefined,
7639      '$ %SyntaxError%': SyntaxError,
7640      '$ %SyntaxErrorPrototype%': SyntaxError.prototype,
7641      '$ %ThrowTypeError%': ThrowTypeError,
7642      '$ %TypedArray%': TypedArray,
7643      '$ %TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined,
7644      '$ %TypeError%': TypeError,
7645      '$ %TypeErrorPrototype%': TypeError.prototype,
7646      '$ %Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
7647      '$ %Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array.prototype,
7648      '$ %Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
7649      '$ %Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray.prototype,
7650      '$ %Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
7651      '$ %Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array.prototype,
7652      '$ %Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
7653      '$ %Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array.prototype,
7654      '$ %URIError%': URIError,
7655      '$ %URIErrorPrototype%': URIError.prototype,
7656      '$ %WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
7657      '$ %WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined : WeakMap.prototype,
7658      '$ %WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,
7659      '$ %WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined : WeakSet.prototype
7660  };
7661  
7662  module.exports = function GetIntrinsic(name, allowMissing) {
7663      if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
7664          throw new TypeError('"allowMissing" argument must be a boolean');
7665      }
7666  
7667      var key = '$ ' + name;
7668      if (!(key in INTRINSICS)) {
7669          throw new SyntaxError('intrinsic ' + name + ' does not exist!');
7670      }
7671  
7672      // istanbul ignore if // hopefully this is impossible to test :-)
7673      if (typeof INTRINSICS[key] === 'undefined' && !allowMissing) {
7674          throw new TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
7675      }
7676      return INTRINSICS[key];
7677  };
7678  
7679  
7680  /***/ }),
7681  /* 137 */
7682  /***/ (function(module, exports, __webpack_require__) {
7683  
7684  "use strict";
7685  
7686  
7687  Object.defineProperty(exports, "__esModule", {
7688    value: true
7689  });
7690  exports['default'] = getInputHeight;
7691  /* eslint-disable camelcase */
7692  
7693  function getPadding(vertical, top, bottom) {
7694    var isTopDefined = typeof top === 'number';
7695    var isBottomDefined = typeof bottom === 'number';
7696    var isVerticalDefined = typeof vertical === 'number';
7697  
7698    if (isTopDefined && isBottomDefined) {
7699      return top + bottom;
7700    }
7701  
7702    if (isTopDefined && isVerticalDefined) {
7703      return top + vertical;
7704    }
7705  
7706    if (isTopDefined) {
7707      return top;
7708    }
7709  
7710    if (isBottomDefined && isVerticalDefined) {
7711      return bottom + vertical;
7712    }
7713  
7714    if (isBottomDefined) {
7715      return bottom;
7716    }
7717  
7718    if (isVerticalDefined) {
7719      return 2 * vertical;
7720    }
7721  
7722    return 0;
7723  }
7724  
7725  function getInputHeight(_ref, small) {
7726    var _ref$font$input = _ref.font.input,
7727        lineHeight = _ref$font$input.lineHeight,
7728        lineHeight_small = _ref$font$input.lineHeight_small,
7729        _ref$spacing = _ref.spacing,
7730        inputPadding = _ref$spacing.inputPadding,
7731        displayTextPaddingVertical = _ref$spacing.displayTextPaddingVertical,
7732        displayTextPaddingTop = _ref$spacing.displayTextPaddingTop,
7733        displayTextPaddingBottom = _ref$spacing.displayTextPaddingBottom,
7734        displayTextPaddingVertical_small = _ref$spacing.displayTextPaddingVertical_small,
7735        displayTextPaddingTop_small = _ref$spacing.displayTextPaddingTop_small,
7736        displayTextPaddingBottom_small = _ref$spacing.displayTextPaddingBottom_small;
7737  
7738    var calcLineHeight = small ? lineHeight_small : lineHeight;
7739  
7740    var padding = small ? getPadding(displayTextPaddingVertical_small, displayTextPaddingTop_small, displayTextPaddingBottom_small) : getPadding(displayTextPaddingVertical, displayTextPaddingTop, displayTextPaddingBottom);
7741  
7742    return parseInt(calcLineHeight, 10) + 2 * inputPadding + padding;
7743  }
7744  
7745  /***/ }),
7746  /* 138 */
7747  /***/ (function(module, exports) {
7748  
7749  /**
7750   * Checks if `value` is the
7751   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
7752   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
7753   *
7754   * @static
7755   * @memberOf _
7756   * @since 0.1.0
7757   * @category Lang
7758   * @param {*} value The value to check.
7759   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
7760   * @example
7761   *
7762   * _.isObject({});
7763   * // => true
7764   *
7765   * _.isObject([1, 2, 3]);
7766   * // => true
7767   *
7768   * _.isObject(_.noop);
7769   * // => true
7770   *
7771   * _.isObject(null);
7772   * // => false
7773   */
7774  function isObject(value) {
7775    var type = typeof value;
7776    return value != null && (type == 'object' || type == 'function');
7777  }
7778  
7779  module.exports = isObject;
7780  
7781  
7782  /***/ }),
7783  /* 139 */
7784  /***/ (function(module, exports, __webpack_require__) {
7785  
7786  "use strict";
7787  
7788  
7789  Object.defineProperty(exports, "__esModule", {
7790    value: true
7791  });
7792  exports['default'] = toLocalizedDateString;
7793  
7794  var _moment = __webpack_require__(30);
7795  
7796  var _moment2 = _interopRequireDefault(_moment);
7797  
7798  var _toMomentObject = __webpack_require__(79);
7799  
7800  var _toMomentObject2 = _interopRequireDefault(_toMomentObject);
7801  
7802  var _constants = __webpack_require__(41);
7803  
7804  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
7805  
7806  function toLocalizedDateString(date, currentFormat) {
7807    var dateObj = _moment2['default'].isMoment(date) ? date : (0, _toMomentObject2['default'])(date, currentFormat);
7808    if (!dateObj) return null;
7809  
7810    return dateObj.format(_constants.DISPLAY_FORMAT);
7811  }
7812  
7813  /***/ }),
7814  /* 140 */
7815  /***/ (function(module, exports, __webpack_require__) {
7816  
7817  "use strict";
7818  
7819  
7820  Object.defineProperty(exports, "__esModule", {
7821    value: true
7822  });
7823  exports['default'] = isDayVisible;
7824  
7825  var _isBeforeDay = __webpack_require__(93);
7826  
7827  var _isBeforeDay2 = _interopRequireDefault(_isBeforeDay);
7828  
7829  var _isAfterDay = __webpack_require__(106);
7830  
7831  var _isAfterDay2 = _interopRequireDefault(_isAfterDay);
7832  
7833  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
7834  
7835  function isDayVisible(day, month, numberOfMonths, enableOutsideDays) {
7836    var firstDayOfFirstMonth = month.clone().startOf('month');
7837    if (enableOutsideDays) firstDayOfFirstMonth = firstDayOfFirstMonth.startOf('week');
7838    if ((0, _isBeforeDay2['default'])(day, firstDayOfFirstMonth)) return false;
7839  
7840    var lastDayOfLastMonth = month.clone().add(numberOfMonths - 1, 'months').endOf('month');
7841    if (enableOutsideDays) lastDayOfLastMonth = lastDayOfLastMonth.endOf('week');
7842    return !(0, _isAfterDay2['default'])(day, lastDayOfLastMonth);
7843  }
7844  
7845  /***/ }),
7846  /* 141 */
7847  /***/ (function(module, exports, __webpack_require__) {
7848  
7849  "use strict";
7850  
7851  
7852  Object.defineProperty(exports, "__esModule", {
7853    value: true
7854  });
7855  exports.PureDayPicker = exports.defaultProps = undefined;
7856  
7857  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; };
7858  
7859  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; }; }();
7860  
7861  var _object = __webpack_require__(51);
7862  
7863  var _object2 = _interopRequireDefault(_object);
7864  
7865  var _react = __webpack_require__(20);
7866  
7867  var _react2 = _interopRequireDefault(_react);
7868  
7869  var _propTypes = __webpack_require__(28);
7870  
7871  var _propTypes2 = _interopRequireDefault(_propTypes);
7872  
7873  var _reactAddonsShallowCompare = __webpack_require__(77);
7874  
7875  var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);
7876  
7877  var _airbnbPropTypes = __webpack_require__(47);
7878  
7879  var _reactWithStyles = __webpack_require__(56);
7880  
7881  var _moment = __webpack_require__(30);
7882  
7883  var _moment2 = _interopRequireDefault(_moment);
7884  
7885  var _throttle = __webpack_require__(196);
7886  
7887  var _throttle2 = _interopRequireDefault(_throttle);
7888  
7889  var _isTouchDevice = __webpack_require__(81);
7890  
7891  var _isTouchDevice2 = _interopRequireDefault(_isTouchDevice);
7892  
7893  var _reactOutsideClickHandler = __webpack_require__(133);
7894  
7895  var _reactOutsideClickHandler2 = _interopRequireDefault(_reactOutsideClickHandler);
7896  
7897  var _defaultPhrases = __webpack_require__(52);
7898  
7899  var _getPhrasePropTypes = __webpack_require__(55);
7900  
7901  var _getPhrasePropTypes2 = _interopRequireDefault(_getPhrasePropTypes);
7902  
7903  var _CalendarMonthGrid = __webpack_require__(172);
7904  
7905  var _CalendarMonthGrid2 = _interopRequireDefault(_CalendarMonthGrid);
7906  
7907  var _DayPickerNavigation = __webpack_require__(325);
7908  
7909  var _DayPickerNavigation2 = _interopRequireDefault(_DayPickerNavigation);
7910  
7911  var _DayPickerKeyboardShortcuts = __webpack_require__(328);
7912  
7913  var _DayPickerKeyboardShortcuts2 = _interopRequireDefault(_DayPickerKeyboardShortcuts);
7914  
7915  var _getNumberOfCalendarMonthWeeks = __webpack_require__(330);
7916  
7917  var _getNumberOfCalendarMonthWeeks2 = _interopRequireDefault(_getNumberOfCalendarMonthWeeks);
7918  
7919  var _getCalendarMonthWidth = __webpack_require__(173);
7920  
7921  var _getCalendarMonthWidth2 = _interopRequireDefault(_getCalendarMonthWidth);
7922  
7923  var _calculateDimension = __webpack_require__(171);
7924  
7925  var _calculateDimension2 = _interopRequireDefault(_calculateDimension);
7926  
7927  var _getActiveElement = __webpack_require__(331);
7928  
7929  var _getActiveElement2 = _interopRequireDefault(_getActiveElement);
7930  
7931  var _isDayVisible = __webpack_require__(140);
7932  
7933  var _isDayVisible2 = _interopRequireDefault(_isDayVisible);
7934  
7935  var _ModifiersShape = __webpack_require__(101);
7936  
7937  var _ModifiersShape2 = _interopRequireDefault(_ModifiersShape);
7938  
7939  var _ScrollableOrientationShape = __webpack_require__(80);
7940  
7941  var _ScrollableOrientationShape2 = _interopRequireDefault(_ScrollableOrientationShape);
7942  
7943  var _DayOfWeekShape = __webpack_require__(75);
7944  
7945  var _DayOfWeekShape2 = _interopRequireDefault(_DayOfWeekShape);
7946  
7947  var _CalendarInfoPositionShape = __webpack_require__(91);
7948  
7949  var _CalendarInfoPositionShape2 = _interopRequireDefault(_CalendarInfoPositionShape);
7950  
7951  var _constants = __webpack_require__(41);
7952  
7953  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
7954  
7955  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
7956  
7957  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
7958  
7959  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; }
7960  
7961  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; }
7962  
7963  var MONTH_PADDING = 23;
7964  var PREV_TRANSITION = 'prev';
7965  var NEXT_TRANSITION = 'next';
7966  var MONTH_SELECTION_TRANSITION = 'month_selection';
7967  var YEAR_SELECTION_TRANSITION = 'year_selection';
7968  
7969  var propTypes = (0, _airbnbPropTypes.forbidExtraProps)((0, _object2['default'])({}, _reactWithStyles.withStylesPropTypes, {
7970  
7971    // calendar presentation props
7972    enableOutsideDays: _propTypes2['default'].bool,
7973    numberOfMonths: _propTypes2['default'].number,
7974    orientation: _ScrollableOrientationShape2['default'],
7975    withPortal: _propTypes2['default'].bool,
7976    onOutsideClick: _propTypes2['default'].func,
7977    hidden: _propTypes2['default'].bool,
7978    initialVisibleMonth: _propTypes2['default'].func,
7979    firstDayOfWeek: _DayOfWeekShape2['default'],
7980    renderCalendarInfo: _propTypes2['default'].func,
7981    calendarInfoPosition: _CalendarInfoPositionShape2['default'],
7982    hideKeyboardShortcutsPanel: _propTypes2['default'].bool,
7983    daySize: _airbnbPropTypes.nonNegativeInteger,
7984    isRTL: _propTypes2['default'].bool,
7985    verticalHeight: _airbnbPropTypes.nonNegativeInteger,
7986    noBorder: _propTypes2['default'].bool,
7987    transitionDuration: _airbnbPropTypes.nonNegativeInteger,
7988    verticalBorderSpacing: _airbnbPropTypes.nonNegativeInteger,
7989    horizontalMonthPadding: _airbnbPropTypes.nonNegativeInteger,
7990  
7991    // navigation props
7992    navPrev: _propTypes2['default'].node,
7993    navNext: _propTypes2['default'].node,
7994    noNavButtons: _propTypes2['default'].bool,
7995    onPrevMonthClick: _propTypes2['default'].func,
7996    onNextMonthClick: _propTypes2['default'].func,
7997    onMonthChange: _propTypes2['default'].func,
7998    onYearChange: _propTypes2['default'].func,
7999    onMultiplyScrollableMonths: _propTypes2['default'].func, // VERTICAL_SCROLLABLE daypickers only
8000  
8001    // month props
8002    renderMonthText: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'),
8003    renderMonthElement: (0, _airbnbPropTypes.mutuallyExclusiveProps)(_propTypes2['default'].func, 'renderMonthText', 'renderMonthElement'),
8004  
8005    // day props
8006    modifiers: _propTypes2['default'].objectOf(_propTypes2['default'].objectOf(_ModifiersShape2['default'])),
8007    renderCalendarDay: _propTypes2['default'].func,
8008    renderDayContents: _propTypes2['default'].func,
8009    onDayClick: _propTypes2['default'].func,
8010    onDayMouseEnter: _propTypes2['default'].func,
8011    onDayMouseLeave: _propTypes2['default'].func,
8012  
8013    // accessibility props
8014    isFocused: _propTypes2['default'].bool,
8015    getFirstFocusableDay: _propTypes2['default'].func,
8016    onBlur: _propTypes2['default'].func,
8017    showKeyboardShortcuts: _propTypes2['default'].bool,
8018  
8019    // internationalization
8020    monthFormat: _propTypes2['default'].string,
8021    weekDayFormat: _propTypes2['default'].string,
8022    phrases: _propTypes2['default'].shape((0, _getPhrasePropTypes2['default'])(_defaultPhrases.DayPickerPhrases)),
8023    dayAriaLabelFormat: _propTypes2['default'].string
8024  }));
8025  
8026  var defaultProps = exports.defaultProps = {
8027    // calendar presentation props
8028    enableOutsideDays: false,
8029    numberOfMonths: 2,
8030    orientation: _constants.HORIZONTAL_ORIENTATION,
8031    withPortal: false,
8032    onOutsideClick: function () {
8033      function onOutsideClick() {}
8034  
8035      return onOutsideClick;
8036    }(),
8037  
8038    hidden: false,
8039    initialVisibleMonth: function () {
8040      function initialVisibleMonth() {
8041        return (0, _moment2['default'])();
8042      }
8043  
8044      return initialVisibleMonth;
8045    }(),
8046    firstDayOfWeek: null,
8047    renderCalendarInfo: null,
8048    calendarInfoPosition: _constants.INFO_POSITION_BOTTOM,
8049    hideKeyboardShortcutsPanel: false,
8050    daySize: _constants.DAY_SIZE,
8051    isRTL: false,
8052    verticalHeight: null,
8053    noBorder: false,
8054    transitionDuration: undefined,
8055    verticalBorderSpacing: undefined,
8056    horizontalMonthPadding: 13,
8057  
8058    // navigation props
8059    navPrev: null,
8060    navNext: null,
8061    noNavButtons: false,
8062    onPrevMonthClick: function () {
8063      function onPrevMonthClick() {}
8064  
8065      return onPrevMonthClick;
8066    }(),
8067    onNextMonthClick: function () {
8068      function onNextMonthClick() {}
8069  
8070      return onNextMonthClick;
8071    }(),
8072    onMonthChange: function () {
8073      function onMonthChange() {}
8074  
8075      return onMonthChange;
8076    }(),
8077    onYearChange: function () {
8078      function onYearChange() {}
8079  
8080      return onYearChange;
8081    }(),
8082    onMultiplyScrollableMonths: function () {
8083      function onMultiplyScrollableMonths() {}
8084  
8085      return onMultiplyScrollableMonths;
8086    }(),
8087  
8088  
8089    // month props
8090    renderMonthText: null,
8091    renderMonthElement: null,
8092  
8093    // day props
8094    modifiers: {},
8095    renderCalendarDay: undefined,
8096    renderDayContents: null,
8097    onDayClick: function () {
8098      function onDayClick() {}
8099  
8100      return onDayClick;
8101    }(),
8102    onDayMouseEnter: function () {
8103      function onDayMouseEnter() {}
8104  
8105      return onDayMouseEnter;
8106    }(),
8107    onDayMouseLeave: function () {
8108      function onDayMouseLeave() {}
8109  
8110      return onDayMouseLeave;
8111    }(),
8112  
8113  
8114    // accessibility props
8115    isFocused: false,
8116    getFirstFocusableDay: null,
8117    onBlur: function () {
8118      function onBlur() {}
8119  
8120      return onBlur;
8121    }(),
8122  
8123    showKeyboardShortcuts: false,
8124  
8125    // internationalization
8126    monthFormat: 'MMMM YYYY',
8127    weekDayFormat: 'dd',
8128    phrases: _defaultPhrases.DayPickerPhrases,
8129    dayAriaLabelFormat: undefined
8130  };
8131  
8132  var DayPicker = function (_React$Component) {
8133    _inherits(DayPicker, _React$Component);
8134  
8135    function DayPicker(props) {
8136      _classCallCheck(this, DayPicker);
8137  
8138      var _this = _possibleConstructorReturn(this, (DayPicker.__proto__ || Object.getPrototypeOf(DayPicker)).call(this, props));
8139  
8140      var currentMonth = props.hidden ? (0, _moment2['default'])() : props.initialVisibleMonth();
8141  
8142      var focusedDate = currentMonth.clone().startOf('month');
8143      if (props.getFirstFocusableDay) {
8144        focusedDate = props.getFirstFocusableDay(currentMonth);
8145      }
8146  
8147      var horizontalMonthPadding = props.horizontalMonthPadding;
8148  
8149  
8150      var translationValue = props.isRTL && _this.isHorizontal() ? -(0, _getCalendarMonthWidth2['default'])(props.daySize, horizontalMonthPadding) : 0;
8151  
8152      _this.hasSetInitialVisibleMonth = !props.hidden;
8153      _this.state = {
8154        currentMonth: currentMonth,
8155        monthTransition: null,
8156        translationValue: translationValue,
8157        scrollableMonthMultiple: 1,
8158        calendarMonthWidth: (0, _getCalendarMonthWidth2['default'])(props.daySize, horizontalMonthPadding),
8159        focusedDate: !props.hidden || props.isFocused ? focusedDate : null,
8160        nextFocusedDate: null,
8161        showKeyboardShortcuts: props.showKeyboardShortcuts,
8162        onKeyboardShortcutsPanelClose: function () {
8163          function onKeyboardShortcutsPanelClose() {}
8164  
8165          return onKeyboardShortcutsPanelClose;
8166        }(),
8167  
8168        isTouchDevice: (0, _isTouchDevice2['default'])(),
8169        withMouseInteractions: true,
8170        calendarInfoWidth: 0,
8171        monthTitleHeight: null,
8172        hasSetHeight: false
8173      };
8174  
8175      _this.setCalendarMonthWeeks(currentMonth);
8176  
8177      _this.calendarMonthGridHeight = 0;
8178      _this.setCalendarInfoWidthTimeout = null;
8179  
8180      _this.onKeyDown = _this.onKeyDown.bind(_this);
8181      _this.throttledKeyDown = (0, _throttle2['default'])(_this.onFinalKeyDown, 200, { trailing: false });
8182      _this.onPrevMonthClick = _this.onPrevMonthClick.bind(_this);
8183      _this.onNextMonthClick = _this.onNextMonthClick.bind(_this);
8184      _this.onMonthChange = _this.onMonthChange.bind(_this);
8185      _this.onYearChange = _this.onYearChange.bind(_this);
8186  
8187      _this.multiplyScrollableMonths = _this.multiplyScrollableMonths.bind(_this);
8188      _this.updateStateAfterMonthTransition = _this.updateStateAfterMonthTransition.bind(_this);
8189  
8190      _this.openKeyboardShortcutsPanel = _this.openKeyboardShortcutsPanel.bind(_this);
8191      _this.closeKeyboardShortcutsPanel = _this.closeKeyboardShortcutsPanel.bind(_this);
8192  
8193      _this.setCalendarInfoRef = _this.setCalendarInfoRef.bind(_this);
8194      _this.setContainerRef = _this.setContainerRef.bind(_this);
8195      _this.setTransitionContainerRef = _this.setTransitionContainerRef.bind(_this);
8196      _this.setMonthTitleHeight = _this.setMonthTitleHeight.bind(_this);
8197      return _this;
8198    }
8199  
8200    _createClass(DayPicker, [{
8201      key: 'componentDidMount',
8202      value: function () {
8203        function componentDidMount() {
8204          var currentMonth = this.state.currentMonth;
8205  
8206          if (this.calendarInfo) {
8207            this.setState({
8208              isTouchDevice: (0, _isTouchDevice2['default'])(),
8209              calendarInfoWidth: (0, _calculateDimension2['default'])(this.calendarInfo, 'width', true, true)
8210            });
8211          } else {
8212            this.setState({ isTouchDevice: (0, _isTouchDevice2['default'])() });
8213          }
8214  
8215          this.setCalendarMonthWeeks(currentMonth);
8216        }
8217  
8218        return componentDidMount;
8219      }()
8220    }, {
8221      key: 'componentWillReceiveProps',
8222      value: function () {
8223        function componentWillReceiveProps(nextProps) {
8224          var hidden = nextProps.hidden,
8225              isFocused = nextProps.isFocused,
8226              showKeyboardShortcuts = nextProps.showKeyboardShortcuts,
8227              onBlur = nextProps.onBlur,
8228              renderMonthText = nextProps.renderMonthText,
8229              horizontalMonthPadding = nextProps.horizontalMonthPadding;
8230          var currentMonth = this.state.currentMonth;
8231  
8232  
8233          if (!hidden) {
8234            if (!this.hasSetInitialVisibleMonth) {
8235              this.hasSetInitialVisibleMonth = true;
8236              this.setState({
8237                currentMonth: nextProps.initialVisibleMonth()
8238              });
8239            }
8240          }
8241  
8242          var _props = this.props,
8243              daySize = _props.daySize,
8244              prevIsFocused = _props.isFocused,
8245              prevRenderMonthText = _props.renderMonthText;
8246  
8247  
8248          if (nextProps.daySize !== daySize) {
8249            this.setState({
8250              calendarMonthWidth: (0, _getCalendarMonthWidth2['default'])(nextProps.daySize, horizontalMonthPadding)
8251            });
8252          }
8253  
8254          if (isFocused !== prevIsFocused) {
8255            if (isFocused) {
8256              var focusedDate = this.getFocusedDay(currentMonth);
8257  
8258              var onKeyboardShortcutsPanelClose = this.state.onKeyboardShortcutsPanelClose;
8259  
8260              if (nextProps.showKeyboardShortcuts) {
8261                // the ? shortcut came from the input and we should return input there once it is close
8262                onKeyboardShortcutsPanelClose = onBlur;
8263              }
8264  
8265              this.setState({
8266                showKeyboardShortcuts: showKeyboardShortcuts,
8267                onKeyboardShortcutsPanelClose: onKeyboardShortcutsPanelClose,
8268                focusedDate: focusedDate,
8269                withMouseInteractions: false
8270              });
8271            } else {
8272              this.setState({ focusedDate: null });
8273            }
8274          }
8275  
8276          if (renderMonthText !== prevRenderMonthText) {
8277            this.setState({
8278              monthTitleHeight: null
8279            });
8280          }
8281        }
8282  
8283        return componentWillReceiveProps;
8284      }()
8285    }, {
8286      key: 'shouldComponentUpdate',
8287      value: function () {
8288        function shouldComponentUpdate(nextProps, nextState) {
8289          return (0, _reactAddonsShallowCompare2['default'])(this, nextProps, nextState);
8290        }
8291  
8292        return shouldComponentUpdate;
8293      }()
8294    }, {
8295      key: 'componentWillUpdate',
8296      value: function () {
8297        function componentWillUpdate() {
8298          var _this2 = this;
8299  
8300          var transitionDuration = this.props.transitionDuration;
8301  
8302          // Calculating the dimensions trigger a DOM repaint which
8303          // breaks the CSS transition.
8304          // The setTimeout will wait until the transition ends.
8305  
8306          if (this.calendarInfo) {
8307            this.setCalendarInfoWidthTimeout = setTimeout(function () {
8308              var calendarInfoWidth = _this2.state.calendarInfoWidth;
8309  
8310              var calendarInfoPanelWidth = (0, _calculateDimension2['default'])(_this2.calendarInfo, 'width', true, true);
8311              if (calendarInfoWidth !== calendarInfoPanelWidth) {
8312                _this2.setState({
8313                  calendarInfoWidth: calendarInfoPanelWidth
8314                });
8315              }
8316            }, transitionDuration);
8317          }
8318        }
8319  
8320        return componentWillUpdate;
8321      }()
8322    }, {
8323      key: 'componentDidUpdate',
8324      value: function () {
8325        function componentDidUpdate(prevProps) {
8326          var _props2 = this.props,
8327              orientation = _props2.orientation,
8328              daySize = _props2.daySize,
8329              isFocused = _props2.isFocused,
8330              numberOfMonths = _props2.numberOfMonths;
8331          var _state = this.state,
8332              focusedDate = _state.focusedDate,
8333              monthTitleHeight = _state.monthTitleHeight;
8334  
8335  
8336          if (this.isHorizontal() && (orientation !== prevProps.orientation || daySize !== prevProps.daySize)) {
8337            var visibleCalendarWeeks = this.calendarMonthWeeks.slice(1, numberOfMonths + 1);
8338            var calendarMonthWeeksHeight = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1);
8339            var newMonthHeight = monthTitleHeight + calendarMonthWeeksHeight + 1;
8340            this.adjustDayPickerHeight(newMonthHeight);
8341          }
8342  
8343          if (!prevProps.isFocused && isFocused && !focusedDate) {
8344            this.container.focus();
8345          }
8346        }
8347  
8348        return componentDidUpdate;
8349      }()
8350    }, {
8351      key: 'componentWillUnmount',
8352      value: function () {
8353        function componentWillUnmount() {
8354          clearTimeout(this.setCalendarInfoWidthTimeout);
8355        }
8356  
8357        return componentWillUnmount;
8358      }()
8359    }, {
8360      key: 'onKeyDown',
8361      value: function () {
8362        function onKeyDown(e) {
8363          e.stopPropagation();
8364          if (!_constants.MODIFIER_KEY_NAMES.has(e.key)) {
8365            this.throttledKeyDown(e);
8366          }
8367        }
8368  
8369        return onKeyDown;
8370      }()
8371    }, {
8372      key: 'onFinalKeyDown',
8373      value: function () {
8374        function onFinalKeyDown(e) {
8375          this.setState({ withMouseInteractions: false });
8376  
8377          var _props3 = this.props,
8378              onBlur = _props3.onBlur,
8379              isRTL = _props3.isRTL;
8380          var _state2 = this.state,
8381              focusedDate = _state2.focusedDate,
8382              showKeyboardShortcuts = _state2.showKeyboardShortcuts;
8383  
8384          if (!focusedDate) return;
8385  
8386          var newFocusedDate = focusedDate.clone();
8387  
8388          var didTransitionMonth = false;
8389  
8390          // focus might be anywhere when the keyboard shortcuts panel is opened so we want to
8391          // return it to wherever it was before when the panel was opened
8392          var activeElement = (0, _getActiveElement2['default'])();
8393          var onKeyboardShortcutsPanelClose = function () {
8394            function onKeyboardShortcutsPanelClose() {
8395              if (activeElement) activeElement.focus();
8396            }
8397  
8398            return onKeyboardShortcutsPanelClose;
8399          }();
8400  
8401          switch (e.key) {
8402            case 'ArrowUp':
8403              e.preventDefault();
8404              newFocusedDate.subtract(1, 'week');
8405              didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate);
8406              break;
8407            case 'ArrowLeft':
8408              e.preventDefault();
8409              if (isRTL) {
8410                newFocusedDate.add(1, 'day');
8411              } else {
8412                newFocusedDate.subtract(1, 'day');
8413              }
8414              didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate);
8415              break;
8416            case 'Home':
8417              e.preventDefault();
8418              newFocusedDate.startOf('week');
8419              didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate);
8420              break;
8421            case 'PageUp':
8422              e.preventDefault();
8423              newFocusedDate.subtract(1, 'month');
8424              didTransitionMonth = this.maybeTransitionPrevMonth(newFocusedDate);
8425              break;
8426  
8427            case 'ArrowDown':
8428              e.preventDefault();
8429              newFocusedDate.add(1, 'week');
8430              didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate);
8431              break;
8432            case 'ArrowRight':
8433              e.preventDefault();
8434              if (isRTL) {
8435                newFocusedDate.subtract(1, 'day');
8436              } else {
8437                newFocusedDate.add(1, 'day');
8438              }
8439              didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate);
8440              break;
8441            case 'End':
8442              e.preventDefault();
8443              newFocusedDate.endOf('week');
8444              didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate);
8445              break;
8446            case 'PageDown':
8447              e.preventDefault();
8448              newFocusedDate.add(1, 'month');
8449              didTransitionMonth = this.maybeTransitionNextMonth(newFocusedDate);
8450              break;
8451  
8452            case '?':
8453              this.openKeyboardShortcutsPanel(onKeyboardShortcutsPanelClose);
8454              break;
8455  
8456            case 'Escape':
8457              if (showKeyboardShortcuts) {
8458                this.closeKeyboardShortcutsPanel();
8459              } else {
8460                onBlur();
8461              }
8462              break;
8463  
8464            default:
8465              break;
8466          }
8467  
8468          // If there was a month transition, do not update the focused date until the transition has
8469          // completed. Otherwise, attempting to focus on a DOM node may interrupt the CSS animation. If
8470          // didTransitionMonth is true, the focusedDate gets updated in #updateStateAfterMonthTransition
8471          if (!didTransitionMonth) {
8472            this.setState({
8473              focusedDate: newFocusedDate
8474            });
8475          }
8476        }
8477  
8478        return onFinalKeyDown;
8479      }()
8480    }, {
8481      key: 'onPrevMonthClick',
8482      value: function () {
8483        function onPrevMonthClick(nextFocusedDate, e) {
8484          var _props4 = this.props,
8485              daySize = _props4.daySize,
8486              isRTL = _props4.isRTL,
8487              numberOfMonths = _props4.numberOfMonths;
8488          var _state3 = this.state,
8489              calendarMonthWidth = _state3.calendarMonthWidth,
8490              monthTitleHeight = _state3.monthTitleHeight;
8491  
8492  
8493          if (e) e.preventDefault();
8494  
8495          var translationValue = void 0;
8496          if (this.isVertical()) {
8497            var calendarMonthWeeksHeight = this.calendarMonthWeeks[0] * (daySize - 1);
8498            translationValue = monthTitleHeight + calendarMonthWeeksHeight + 1;
8499          } else if (this.isHorizontal()) {
8500            translationValue = calendarMonthWidth;
8501            if (isRTL) {
8502              translationValue = -2 * calendarMonthWidth;
8503            }
8504  
8505            var visibleCalendarWeeks = this.calendarMonthWeeks.slice(0, numberOfMonths);
8506            var _calendarMonthWeeksHeight = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1);
8507            var newMonthHeight = monthTitleHeight + _calendarMonthWeeksHeight + 1;
8508            this.adjustDayPickerHeight(newMonthHeight);
8509          }
8510  
8511          this.setState({
8512            monthTransition: PREV_TRANSITION,
8513            translationValue: translationValue,
8514            focusedDate: null,
8515            nextFocusedDate: nextFocusedDate
8516          });
8517        }
8518  
8519        return onPrevMonthClick;
8520      }()
8521    }, {
8522      key: 'onMonthChange',
8523      value: function () {
8524        function onMonthChange(currentMonth) {
8525          this.setCalendarMonthWeeks(currentMonth);
8526          this.calculateAndSetDayPickerHeight();
8527  
8528          // Translation value is a hack to force an invisible transition that
8529          // properly rerenders the CalendarMonthGrid
8530          this.setState({
8531            monthTransition: MONTH_SELECTION_TRANSITION,
8532            translationValue: 0.00001,
8533            focusedDate: null,
8534            nextFocusedDate: currentMonth,
8535            currentMonth: currentMonth
8536          });
8537        }
8538  
8539        return onMonthChange;
8540      }()
8541    }, {
8542      key: 'onYearChange',
8543      value: function () {
8544        function onYearChange(currentMonth) {
8545          this.setCalendarMonthWeeks(currentMonth);
8546          this.calculateAndSetDayPickerHeight();
8547  
8548          // Translation value is a hack to force an invisible transition that
8549          // properly rerenders the CalendarMonthGrid
8550          this.setState({
8551            monthTransition: YEAR_SELECTION_TRANSITION,
8552            translationValue: 0.0001,
8553            focusedDate: null,
8554            nextFocusedDate: currentMonth,
8555            currentMonth: currentMonth
8556          });
8557        }
8558  
8559        return onYearChange;
8560      }()
8561    }, {
8562      key: 'onNextMonthClick',
8563      value: function () {
8564        function onNextMonthClick(nextFocusedDate, e) {
8565          var _props5 = this.props,
8566              isRTL = _props5.isRTL,
8567              numberOfMonths = _props5.numberOfMonths,
8568              daySize = _props5.daySize;
8569          var _state4 = this.state,
8570              calendarMonthWidth = _state4.calendarMonthWidth,
8571              monthTitleHeight = _state4.monthTitleHeight;
8572  
8573  
8574          if (e) e.preventDefault();
8575  
8576          var translationValue = void 0;
8577  
8578          if (this.isVertical()) {
8579            var firstVisibleMonthWeeks = this.calendarMonthWeeks[1];
8580            var calendarMonthWeeksHeight = firstVisibleMonthWeeks * (daySize - 1);
8581            translationValue = -(monthTitleHeight + calendarMonthWeeksHeight + 1);
8582          }
8583  
8584          if (this.isHorizontal()) {
8585            translationValue = -calendarMonthWidth;
8586            if (isRTL) {
8587              translationValue = 0;
8588            }
8589  
8590            var visibleCalendarWeeks = this.calendarMonthWeeks.slice(2, numberOfMonths + 2);
8591            var _calendarMonthWeeksHeight2 = Math.max.apply(Math, [0].concat(_toConsumableArray(visibleCalendarWeeks))) * (daySize - 1);
8592            var newMonthHeight = monthTitleHeight + _calendarMonthWeeksHeight2 + 1;
8593            this.adjustDayPickerHeight(newMonthHeight);
8594          }
8595  
8596          this.setState({
8597            monthTransition: NEXT_TRANSITION,
8598            translationValue: translationValue,
8599            focusedDate: null,
8600            nextFocusedDate: nextFocusedDate
8601          });
8602        }
8603  
8604        return onNextMonthClick;
8605      }()
8606    }, {
8607      key: 'getFirstDayOfWeek',
8608      value: function () {
8609        function getFirstDayOfWeek() {
8610          var firstDayOfWeek = this.props.firstDayOfWeek;
8611  
8612          if (firstDayOfWeek == null) {
8613            return _moment2['default'].localeData().firstDayOfWeek();
8614          }
8615  
8616          return firstDayOfWeek;
8617        }
8618  
8619        return getFirstDayOfWeek;
8620      }()
8621    }, {
8622      key: 'getFirstVisibleIndex',
8623      value: function () {
8624        function getFirstVisibleIndex() {
8625          var orientation = this.props.orientation;
8626          var monthTransition = this.state.monthTransition;
8627  
8628  
8629          if (orientation === _constants.VERTICAL_SCROLLABLE) return 0;
8630  
8631          var firstVisibleMonthIndex = 1;
8632          if (monthTransition === PREV_TRANSITION) {
8633            firstVisibleMonthIndex -= 1;
8634          } else if (monthTransition === NEXT_TRANSITION) {
8635            firstVisibleMonthIndex += 1;
8636          }
8637  
8638          return firstVisibleMonthIndex;
8639        }
8640  
8641        return getFirstVisibleIndex;
8642      }()
8643    }, {
8644      key: 'getFocusedDay',
8645      value: function () {
8646        function getFocusedDay(newMonth) {
8647          var _props6 = this.props,
8648              getFirstFocusableDay = _props6.getFirstFocusableDay,
8649              numberOfMonths = _props6.numberOfMonths;
8650  
8651  
8652          var focusedDate = void 0;
8653          if (getFirstFocusableDay) {
8654            focusedDate = getFirstFocusableDay(newMonth);
8655          }
8656  
8657          if (newMonth && (!focusedDate || !(0, _isDayVisible2['default'])(focusedDate, newMonth, numberOfMonths))) {
8658            focusedDate = newMonth.clone().