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