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