[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/js/dist/ -> block-editor.js (source)

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