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