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