[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> components.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["components"] =
   2  /******/ (function(modules) { // webpackBootstrap
   3  /******/     // The module cache
   4  /******/     var installedModules = {};
   5  /******/
   6  /******/     // The require function
   7  /******/ 	function __webpack_require__(moduleId) {
   8  /******/
   9  /******/         // Check if module is in cache
  10  /******/         if(installedModules[moduleId]) {
  11  /******/             return installedModules[moduleId].exports;
  12  /******/         }
  13  /******/         // Create a new module (and put it into the cache)
  14  /******/         var module = installedModules[moduleId] = {
  15  /******/             i: moduleId,
  16  /******/             l: false,
  17  /******/             exports: {}
  18  /******/         };
  19  /******/
  20  /******/         // Execute the module function
  21  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  22  /******/
  23  /******/         // Flag the module as loaded
  24  /******/         module.l = true;
  25  /******/
  26  /******/         // Return the exports of the module
  27  /******/         return module.exports;
  28  /******/     }
  29  /******/
  30  /******/
  31  /******/     // expose the modules object (__webpack_modules__)
  32  /******/     __webpack_require__.m = modules;
  33  /******/
  34  /******/     // expose the module cache
  35  /******/     __webpack_require__.c = installedModules;
  36  /******/
  37  /******/     // define getter function for harmony exports
  38  /******/     __webpack_require__.d = function(exports, name, getter) {
  39  /******/         if(!__webpack_require__.o(exports, name)) {
  40  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
  41  /******/         }
  42  /******/     };
  43  /******/
  44  /******/     // define __esModule on exports
  45  /******/     __webpack_require__.r = function(exports) {
  46  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  47  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  48  /******/         }
  49  /******/         Object.defineProperty(exports, '__esModule', { value: true });
  50  /******/     };
  51  /******/
  52  /******/     // create a fake namespace object
  53  /******/     // mode & 1: value is a module id, require it
  54  /******/     // mode & 2: merge all properties of value into the ns
  55  /******/     // mode & 4: return value when already ns object
  56  /******/     // mode & 8|1: behave like require
  57  /******/     __webpack_require__.t = function(value, mode) {
  58  /******/         if(mode & 1) value = __webpack_require__(value);
  59  /******/         if(mode & 8) return value;
  60  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  61  /******/         var ns = Object.create(null);
  62  /******/         __webpack_require__.r(ns);
  63  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  64  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  65  /******/         return ns;
  66  /******/     };
  67  /******/
  68  /******/     // getDefaultExport function for compatibility with non-harmony modules
  69  /******/     __webpack_require__.n = function(module) {
  70  /******/         var getter = module && module.__esModule ?
  71  /******/ 			function getDefault() { return module['default']; } :
  72  /******/ 			function getModuleExports() { return module; };
  73  /******/         __webpack_require__.d(getter, 'a', getter);
  74  /******/         return getter;
  75  /******/     };
  76  /******/
  77  /******/     // Object.prototype.hasOwnProperty.call
  78  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  79  /******/
  80  /******/     // __webpack_public_path__
  81  /******/     __webpack_require__.p = "";
  82  /******/
  83  /******/
  84  /******/     // Load entry module and return exports
  85  /******/     return __webpack_require__(__webpack_require__.s = 271);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ([
  89  /* 0 */
  90  /***/ (function(module, exports) {
  91  
  92  (function() { module.exports = window["wp"]["element"]; }());
  93  
  94  /***/ }),
  95  /* 1 */
  96  /***/ (function(module, exports) {
  97  
  98  (function() { module.exports = window["wp"]["i18n"]; }());
  99  
 100  /***/ }),
 101  /* 2 */
 102  /***/ (function(module, exports) {
 103  
 104  (function() { module.exports = window["lodash"]; }());
 105  
 106  /***/ }),
 107  /* 3 */,
 108  /* 4 */,
 109  /* 5 */
 110  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 111  
 112  "use strict";
 113  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });
 114  function _defineProperty(obj, key, value) {
 115    if (key in obj) {
 116      Object.defineProperty(obj, key, {
 117        value: value,
 118        enumerable: true,
 119        configurable: true,
 120        writable: true
 121      });
 122    } else {
 123      obj[key] = value;
 124    }
 125  
 126    return obj;
 127  }
 128  
 129  /***/ }),
 130  /* 6 */,
 131  /* 7 */
 132  /***/ (function(module, exports) {
 133  
 134  (function() { module.exports = window["wp"]["primitives"]; }());
 135  
 136  /***/ }),
 137  /* 8 */
 138  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 139  
 140  "use strict";
 141  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
 142  function _extends() {
 143    _extends = Object.assign || function (target) {
 144      for (var i = 1; i < arguments.length; i++) {
 145        var source = arguments[i];
 146  
 147        for (var key in source) {
 148          if (Object.prototype.hasOwnProperty.call(source, key)) {
 149            target[key] = source[key];
 150          }
 151        }
 152      }
 153  
 154      return target;
 155    };
 156  
 157    return _extends.apply(this, arguments);
 158  }
 159  
 160  /***/ }),
 161  /* 9 */,
 162  /* 10 */
 163  /***/ (function(module, exports, __webpack_require__) {
 164  
 165  var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 166    Copyright (c) 2018 Jed Watson.
 167    Licensed under the MIT License (MIT), see
 168    http://jedwatson.github.io/classnames
 169  */
 170  /* global define */
 171  
 172  (function () {
 173      'use strict';
 174  
 175      var hasOwn = {}.hasOwnProperty;
 176  
 177  	function classNames() {
 178          var classes = [];
 179  
 180          for (var i = 0; i < arguments.length; i++) {
 181              var arg = arguments[i];
 182              if (!arg) continue;
 183  
 184              var argType = typeof arg;
 185  
 186              if (argType === 'string' || argType === 'number') {
 187                  classes.push(arg);
 188              } else if (Array.isArray(arg)) {
 189                  if (arg.length) {
 190                      var inner = classNames.apply(null, arg);
 191                      if (inner) {
 192                          classes.push(inner);
 193                      }
 194                  }
 195              } else if (argType === 'object') {
 196                  if (arg.toString === Object.prototype.toString) {
 197                      for (var key in arg) {
 198                          if (hasOwn.call(arg, key) && arg[key]) {
 199                              classes.push(key);
 200                          }
 201                      }
 202                  } else {
 203                      classes.push(arg.toString());
 204                  }
 205              }
 206          }
 207  
 208          return classes.join(' ');
 209      }
 210  
 211      if ( true && module.exports) {
 212          classNames.default = classNames;
 213          module.exports = classNames;
 214      } else if (true) {
 215          // register as 'classnames', consistent with npm package name
 216          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
 217              return classNames;
 218          }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
 219                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 220      } else {}
 221  }());
 222  
 223  
 224  /***/ }),
 225  /* 11 */
 226  /***/ (function(module, exports) {
 227  
 228  (function() { module.exports = window["wp"]["compose"]; }());
 229  
 230  /***/ }),
 231  /* 12 */
 232  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 233  
 234  "use strict";
 235  
 236  // EXPORTS
 237  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; });
 238  
 239  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
 240  var arrayWithHoles = __webpack_require__(37);
 241  
 242  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 243  function _iterableToArrayLimit(arr, i) {
 244    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
 245    var _arr = [];
 246    var _n = true;
 247    var _d = false;
 248    var _e = undefined;
 249  
 250    try {
 251      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 252        _arr.push(_s.value);
 253  
 254        if (i && _arr.length === i) break;
 255      }
 256    } catch (err) {
 257      _d = true;
 258      _e = err;
 259    } finally {
 260      try {
 261        if (!_n && _i["return"] != null) _i["return"]();
 262      } finally {
 263        if (_d) throw _e;
 264      }
 265    }
 266  
 267    return _arr;
 268  }
 269  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 270  var unsupportedIterableToArray = __webpack_require__(28);
 271  
 272  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 273  var nonIterableRest = __webpack_require__(38);
 274  
 275  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 276  
 277  
 278  
 279  
 280  function _slicedToArray(arr, i) {
 281    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
 282  }
 283  
 284  /***/ }),
 285  /* 13 */
 286  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 287  
 288  "use strict";
 289  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; });
 290  /* harmony import */ var _objectWithoutPropertiesLoose_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44);
 291  
 292  function _objectWithoutProperties(source, excluded) {
 293    if (source == null) return {};
 294    var target = Object(_objectWithoutPropertiesLoose_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(source, excluded);
 295    var key, i;
 296  
 297    if (Object.getOwnPropertySymbols) {
 298      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
 299  
 300      for (i = 0; i < sourceSymbolKeys.length; i++) {
 301        key = sourceSymbolKeys[i];
 302        if (excluded.indexOf(key) >= 0) continue;
 303        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
 304        target[key] = source[key];
 305      }
 306    }
 307  
 308    return target;
 309  }
 310  
 311  /***/ }),
 312  /* 14 */
 313  /***/ (function(module, exports) {
 314  
 315  (function() { module.exports = window["React"]; }());
 316  
 317  /***/ }),
 318  /* 15 */
 319  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 320  
 321  "use strict";
 322  
 323  // EXPORTS
 324  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; });
 325  
 326  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
 327  var arrayLikeToArray = __webpack_require__(24);
 328  
 329  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
 330  
 331  function _arrayWithoutHoles(arr) {
 332    if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
 333  }
 334  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 335  var iterableToArray = __webpack_require__(39);
 336  
 337  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 338  var unsupportedIterableToArray = __webpack_require__(28);
 339  
 340  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 341  function _nonIterableSpread() {
 342    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 343  }
 344  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 345  
 346  
 347  
 348  
 349  function _toConsumableArray(arr) {
 350    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 351  }
 352  
 353  /***/ }),
 354  /* 16 */
 355  /***/ (function(module, exports) {
 356  
 357  (function() { module.exports = window["regeneratorRuntime"]; }());
 358  
 359  /***/ }),
 360  /* 17 */
 361  /***/ (function(module, exports) {
 362  
 363  (function() { module.exports = window["wp"]["keycodes"]; }());
 364  
 365  /***/ }),
 366  /* 18 */
 367  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 368  
 369  "use strict";
 370  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
 371  function _assertThisInitialized(self) {
 372    if (self === void 0) {
 373      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 374    }
 375  
 376    return self;
 377  }
 378  
 379  /***/ }),
 380  /* 19 */
 381  /***/ (function(module, exports) {
 382  
 383  (function() { module.exports = window["wp"]["richText"]; }());
 384  
 385  /***/ }),
 386  /* 20 */
 387  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 388  
 389  "use strict";
 390  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutPropertiesLoose; });
 391  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return _objectSpread2; });
 392  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return _createForOfIteratorHelperLoose; });
 393  function _defineProperty(obj, key, value) {
 394    if (key in obj) {
 395      Object.defineProperty(obj, key, {
 396        value: value,
 397        enumerable: true,
 398        configurable: true,
 399        writable: true
 400      });
 401    } else {
 402      obj[key] = value;
 403    }
 404  
 405    return obj;
 406  }
 407  
 408  function ownKeys(object, enumerableOnly) {
 409    var keys = Object.keys(object);
 410  
 411    if (Object.getOwnPropertySymbols) {
 412      var symbols = Object.getOwnPropertySymbols(object);
 413      if (enumerableOnly) symbols = symbols.filter(function (sym) {
 414        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
 415      });
 416      keys.push.apply(keys, symbols);
 417    }
 418  
 419    return keys;
 420  }
 421  
 422  function _objectSpread2(target) {
 423    for (var i = 1; i < arguments.length; i++) {
 424      var source = arguments[i] != null ? arguments[i] : {};
 425  
 426      if (i % 2) {
 427        ownKeys(Object(source), true).forEach(function (key) {
 428          _defineProperty(target, key, source[key]);
 429        });
 430      } else if (Object.getOwnPropertyDescriptors) {
 431        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
 432      } else {
 433        ownKeys(Object(source)).forEach(function (key) {
 434          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
 435        });
 436      }
 437    }
 438  
 439    return target;
 440  }
 441  
 442  function _objectWithoutPropertiesLoose(source, excluded) {
 443    if (source == null) return {};
 444    var target = {};
 445    var sourceKeys = Object.keys(source);
 446    var key, i;
 447  
 448    for (i = 0; i < sourceKeys.length; i++) {
 449      key = sourceKeys[i];
 450      if (excluded.indexOf(key) >= 0) continue;
 451      target[key] = source[key];
 452    }
 453  
 454    return target;
 455  }
 456  
 457  function _unsupportedIterableToArray(o, minLen) {
 458    if (!o) return;
 459    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
 460    var n = Object.prototype.toString.call(o).slice(8, -1);
 461    if (n === "Object" && o.constructor) n = o.constructor.name;
 462    if (n === "Map" || n === "Set") return Array.from(o);
 463    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 464  }
 465  
 466  function _arrayLikeToArray(arr, len) {
 467    if (len == null || len > arr.length) len = arr.length;
 468  
 469    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
 470  
 471    return arr2;
 472  }
 473  
 474  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
 475    var it;
 476  
 477    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
 478      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
 479        if (it) o = it;
 480        var i = 0;
 481        return function () {
 482          if (i >= o.length) return {
 483            done: true
 484          };
 485          return {
 486            done: false,
 487            value: o[i++]
 488          };
 489        };
 490      }
 491  
 492      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 493    }
 494  
 495    it = o[Symbol.iterator]();
 496    return it.next.bind(it);
 497  }
 498  
 499  
 500  
 501  
 502  /***/ }),
 503  /* 21 */,
 504  /* 22 */
 505  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 506  
 507  "use strict";
 508  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });
 509  function _getPrototypeOf(o) {
 510    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
 511      return o.__proto__ || Object.getPrototypeOf(o);
 512    };
 513    return _getPrototypeOf(o);
 514  }
 515  
 516  /***/ }),
 517  /* 23 */,
 518  /* 24 */
 519  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 520  
 521  "use strict";
 522  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
 523  function _arrayLikeToArray(arr, len) {
 524    if (len == null || len > arr.length) len = arr.length;
 525  
 526    for (var i = 0, arr2 = new Array(len); i < len; i++) {
 527      arr2[i] = arr[i];
 528    }
 529  
 530    return arr2;
 531  }
 532  
 533  /***/ }),
 534  /* 25 */
 535  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 536  
 537  "use strict";
 538  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
 539  function _classCallCheck(instance, Constructor) {
 540    if (!(instance instanceof Constructor)) {
 541      throw new TypeError("Cannot call a class as a function");
 542    }
 543  }
 544  
 545  /***/ }),
 546  /* 26 */
 547  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 548  
 549  "use strict";
 550  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
 551  function _defineProperties(target, props) {
 552    for (var i = 0; i < props.length; i++) {
 553      var descriptor = props[i];
 554      descriptor.enumerable = descriptor.enumerable || false;
 555      descriptor.configurable = true;
 556      if ("value" in descriptor) descriptor.writable = true;
 557      Object.defineProperty(target, descriptor.key, descriptor);
 558    }
 559  }
 560  
 561  function _createClass(Constructor, protoProps, staticProps) {
 562    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 563    if (staticProps) _defineProperties(Constructor, staticProps);
 564    return Constructor;
 565  }
 566  
 567  /***/ }),
 568  /* 27 */
 569  /***/ (function(module, exports) {
 570  
 571  (function() { module.exports = window["wp"]["dom"]; }());
 572  
 573  /***/ }),
 574  /* 28 */
 575  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 576  
 577  "use strict";
 578  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
 579  /* harmony import */ var _arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24);
 580  
 581  function _unsupportedIterableToArray(o, minLen) {
 582    if (!o) return;
 583    if (typeof o === "string") return Object(_arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
 584    var n = Object.prototype.toString.call(o).slice(8, -1);
 585    if (n === "Object" && o.constructor) n = o.constructor.name;
 586    if (n === "Map" || n === "Set") return Array.from(o);
 587    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
 588  }
 589  
 590  /***/ }),
 591  /* 29 */,
 592  /* 30 */,
 593  /* 31 */
 594  /***/ (function(module, exports, __webpack_require__) {
 595  
 596  /**
 597   * Copyright (c) 2013-present, Facebook, Inc.
 598   *
 599   * This source code is licensed under the MIT license found in the
 600   * LICENSE file in the root directory of this source tree.
 601   */
 602  
 603  if (false) { var throwOnDirectAccess, ReactIs; } else {
 604    // By explicitly using `prop-types` you are opting into new production behavior.
 605    // http://fb.me/prop-types-in-prod
 606    module.exports = __webpack_require__(137)();
 607  }
 608  
 609  
 610  /***/ }),
 611  /* 32 */
 612  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 613  
 614  "use strict";
 615  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });
 616  /* harmony import */ var _setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55);
 617  
 618  function _inherits(subClass, superClass) {
 619    if (typeof superClass !== "function" && superClass !== null) {
 620      throw new TypeError("Super expression must either be null or a function");
 621    }
 622  
 623    subClass.prototype = Object.create(superClass && superClass.prototype, {
 624      constructor: {
 625        value: subClass,
 626        writable: true,
 627        configurable: true
 628      }
 629    });
 630    if (superClass) Object(_setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(subClass, superClass);
 631  }
 632  
 633  /***/ }),
 634  /* 33 */
 635  /***/ (function(module, exports) {
 636  
 637  (function() { module.exports = window["wp"]["hooks"]; }());
 638  
 639  /***/ }),
 640  /* 34 */
 641  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 642  
 643  "use strict";
 644  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
 645  /* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59);
 646  /* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__);
 647  /* harmony import */ var _assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18);
 648  
 649  
 650  function _possibleConstructorReturn(self, call) {
 651    if (call && (_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default()(call) === "object" || typeof call === "function")) {
 652      return call;
 653    }
 654  
 655    return Object(_assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
 656  }
 657  
 658  /***/ }),
 659  /* 35 */
 660  /***/ (function(module, exports) {
 661  
 662  (function() { module.exports = window["wp"]["deprecated"]; }());
 663  
 664  /***/ }),
 665  /* 36 */
 666  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 667  
 668  "use strict";
 669  
 670  // UNUSED EXPORTS: Button
 671  
 672  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
 673  var esm_extends = __webpack_require__(8);
 674  
 675  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
 676  var objectWithoutProperties = __webpack_require__(13);
 677  
 678  // EXTERNAL MODULE: external ["wp","element"]
 679  var external_wp_element_ = __webpack_require__(0);
 680  
 681  // EXTERNAL MODULE: ./node_modules/classnames/index.js
 682  var classnames = __webpack_require__(10);
 683  var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
 684  
 685  // EXTERNAL MODULE: external "lodash"
 686  var external_lodash_ = __webpack_require__(2);
 687  
 688  // EXTERNAL MODULE: external ["wp","deprecated"]
 689  var external_wp_deprecated_ = __webpack_require__(35);
 690  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
 691  
 692  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/tooltip/index.js + 1 modules
 693  var tooltip = __webpack_require__(80);
 694  
 695  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/icon/index.js
 696  var build_module_icon = __webpack_require__(77);
 697  
 698  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/visually-hidden/index.js + 2 modules
 699  var visually_hidden = __webpack_require__(58);
 700  
 701  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
 702  var defineProperty = __webpack_require__(5);
 703  
 704  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/ui/context/with-next.js
 705  var with_next = __webpack_require__(526);
 706  
 707  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/button/next.js
 708  
 709  
 710  
 711  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 712  
 713  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 714  
 715  /**
 716   * Internal dependencies
 717   */
 718  
 719  
 720  var Button =  false ? undefined : undefined;
 721  
 722  var getVariant = function getVariant(_ref) {
 723    var isPrimary = _ref.isPrimary,
 724        isTertiary = _ref.isTertiary,
 725        isSecondary = _ref.isSecondary,
 726        isLink = _ref.isLink,
 727        isDefault = _ref.isDefault;
 728  
 729    if (isPrimary) {
 730      return 'primary';
 731    }
 732  
 733    if (isTertiary) {
 734      return 'tertiary';
 735    }
 736  
 737    if (isSecondary) {
 738      return 'secondary';
 739    }
 740  
 741    if (isDefault) {
 742      return 'plain';
 743    }
 744  
 745    if (isLink) {
 746      return 'link';
 747    }
 748  
 749    return 'plain';
 750  };
 751  
 752  var next_adapter = function adapter(_ref2) {
 753    var isPrimary = _ref2.isPrimary,
 754        isTertiary = _ref2.isTertiary,
 755        isSecondary = _ref2.isSecondary,
 756        isLink = _ref2.isLink,
 757        isDefault = _ref2.isDefault,
 758        isSmall = _ref2.isSmall,
 759        isBusy = _ref2.isBusy,
 760        label = _ref2.label,
 761        ariaLabel = _ref2['aria-label'],
 762        describedBy = _ref2.describedBy,
 763        shortcut = _ref2.shortcut,
 764        tooltipPosition = _ref2.tooltipPosition,
 765        text = _ref2.text,
 766        props = Object(objectWithoutProperties["a" /* default */])(_ref2, ["isPrimary", "isTertiary", "isSecondary", "isLink", "isDefault", "isSmall", "isBusy", "label", "aria-label", "describedBy", "shortcut", "tooltipPosition", "text"]);
 767  
 768    return _objectSpread(_objectSpread({}, props), {}, {
 769      describedBy: describedBy,
 770      variant: getVariant({
 771        isPrimary: isPrimary,
 772        isTertiary: isTertiary,
 773        isSecondary: isSecondary,
 774        isLink: isLink,
 775        isDefault: isDefault
 776      }),
 777      isActive: isBusy,
 778      isLoading: isBusy,
 779      size: isSmall ? 'small' : undefined,
 780      'aria-label': ariaLabel || label,
 781      pre: text,
 782      tooltip: {
 783        content: describedBy ? describedBy : ariaLabel || label,
 784        position: tooltipPosition,
 785        shortcut: shortcut
 786      }
 787    });
 788  };
 789  
 790  function withNextComponent(Component) {
 791    return Object(with_next["a" /* withNext */])(Component, Button, 'WPComponentsButton', next_adapter);
 792  }
 793  
 794  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/button/index.js
 795  
 796  
 797  
 798  
 799  function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 800  
 801  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 802  
 803  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 804  
 805  /**
 806   * External dependencies
 807   */
 808  
 809  
 810  /**
 811   * WordPress dependencies
 812   */
 813  
 814  
 815  
 816  /**
 817   * Internal dependencies
 818   */
 819  
 820  
 821  
 822  
 823  
 824  var disabledEventsOnDisabledButton = ['onMouseDown', 'onClick'];
 825  function button_Button(props, ref) {
 826    var href = props.href,
 827        target = props.target,
 828        isPrimary = props.isPrimary,
 829        isSmall = props.isSmall,
 830        isTertiary = props.isTertiary,
 831        isPressed = props.isPressed,
 832        isBusy = props.isBusy,
 833        isDefault = props.isDefault,
 834        isSecondary = props.isSecondary,
 835        isLink = props.isLink,
 836        isDestructive = props.isDestructive,
 837        className = props.className,
 838        disabled = props.disabled,
 839        icon = props.icon,
 840        _props$iconPosition = props.iconPosition,
 841        iconPosition = _props$iconPosition === void 0 ? 'left' : _props$iconPosition,
 842        iconSize = props.iconSize,
 843        showTooltip = props.showTooltip,
 844        tooltipPosition = props.tooltipPosition,
 845        shortcut = props.shortcut,
 846        label = props.label,
 847        children = props.children,
 848        text = props.text,
 849        isFocusable = props.__experimentalIsFocusable,
 850        describedBy = props.describedBy,
 851        additionalProps = Object(objectWithoutProperties["a" /* default */])(props, ["href", "target", "isPrimary", "isSmall", "isTertiary", "isPressed", "isBusy", "isDefault", "isSecondary", "isLink", "isDestructive", "className", "disabled", "icon", "iconPosition", "iconSize", "showTooltip", "tooltipPosition", "shortcut", "label", "children", "text", "__experimentalIsFocusable", "describedBy"]);
 852  
 853    if (isDefault) {
 854      external_wp_deprecated_default()('Button isDefault prop', {
 855        since: '5.4',
 856        alternative: 'isSecondary'
 857      });
 858    }
 859  
 860    var classes = classnames_default()('components-button', className, {
 861      'is-secondary': isDefault || isSecondary,
 862      'is-primary': isPrimary,
 863      'is-small': isSmall,
 864      'is-tertiary': isTertiary,
 865      'is-pressed': isPressed,
 866      'is-busy': isBusy,
 867      'is-link': isLink,
 868      'is-destructive': isDestructive,
 869      'has-text': !!icon && !!children,
 870      'has-icon': !!icon
 871    });
 872    var trulyDisabled = disabled && !isFocusable;
 873    var Tag = href !== undefined && !trulyDisabled ? 'a' : 'button';
 874    var tagProps = Tag === 'a' ? {
 875      href: href,
 876      target: target
 877    } : {
 878      type: 'button',
 879      disabled: trulyDisabled,
 880      'aria-pressed': isPressed
 881    };
 882  
 883    if (disabled && isFocusable) {
 884      // In this case, the button will be disabled, but still focusable and
 885      // perceivable by screen reader users.
 886      tagProps['aria-disabled'] = true;
 887  
 888      var _iterator = _createForOfIteratorHelper(disabledEventsOnDisabledButton),
 889          _step;
 890  
 891      try {
 892        for (_iterator.s(); !(_step = _iterator.n()).done;) {
 893          var disabledEvent = _step.value;
 894  
 895          additionalProps[disabledEvent] = function (event) {
 896            event.stopPropagation();
 897            event.preventDefault();
 898          };
 899        }
 900      } catch (err) {
 901        _iterator.e(err);
 902      } finally {
 903        _iterator.f();
 904      }
 905    } // Should show the tooltip if...
 906  
 907  
 908    var shouldShowTooltip = !trulyDisabled && ( // an explicit tooltip is passed or...
 909    showTooltip && label || // there's a shortcut or...
 910    shortcut || // there's a label and...
 911    !!label && ( // the children are empty and...
 912    !children || Object(external_lodash_["isArray"])(children) && !children.length) && // the tooltip is not explicitly disabled.
 913    false !== showTooltip);
 914    var descriptionId = describedBy ? Object(external_lodash_["uniqueId"])() : null;
 915    var describedById = additionalProps['aria-describedby'] || descriptionId;
 916    var element = Object(external_wp_element_["createElement"])(Tag, Object(esm_extends["a" /* default */])({}, tagProps, additionalProps, {
 917      className: classes,
 918      "aria-label": additionalProps['aria-label'] || label,
 919      "aria-describedby": describedById,
 920      ref: ref
 921    }), icon && iconPosition === 'left' && Object(external_wp_element_["createElement"])(build_module_icon["a" /* default */], {
 922      icon: icon,
 923      size: iconSize
 924    }), text && Object(external_wp_element_["createElement"])(external_wp_element_["Fragment"], null, text), icon && iconPosition === 'right' && Object(external_wp_element_["createElement"])(build_module_icon["a" /* default */], {
 925      icon: icon,
 926      size: iconSize
 927    }), children);
 928  
 929    if (!shouldShowTooltip) {
 930      return Object(external_wp_element_["createElement"])(external_wp_element_["Fragment"], null, element, describedBy && Object(external_wp_element_["createElement"])(visually_hidden["a" /* default */], null, Object(external_wp_element_["createElement"])("span", {
 931        id: descriptionId
 932      }, describedBy)));
 933    }
 934  
 935    return Object(external_wp_element_["createElement"])(external_wp_element_["Fragment"], null, Object(external_wp_element_["createElement"])(tooltip["a" /* default */], {
 936      text: describedBy ? describedBy : label,
 937      shortcut: shortcut,
 938      position: tooltipPosition
 939    }, element), describedBy && Object(external_wp_element_["createElement"])(visually_hidden["a" /* default */], null, Object(external_wp_element_["createElement"])("span", {
 940      id: descriptionId
 941    }, describedBy)));
 942  }
 943  /* harmony default export */ var build_module_button = __webpack_exports__["a"] = (withNextComponent(Object(external_wp_element_["forwardRef"])(button_Button)));
 944  
 945  
 946  /***/ }),
 947  /* 37 */
 948  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 949  
 950  "use strict";
 951  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
 952  function _arrayWithHoles(arr) {
 953    if (Array.isArray(arr)) return arr;
 954  }
 955  
 956  /***/ }),
 957  /* 38 */
 958  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 959  
 960  "use strict";
 961  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
 962  function _nonIterableRest() {
 963    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 964  }
 965  
 966  /***/ }),
 967  /* 39 */
 968  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 969  
 970  "use strict";
 971  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
 972  function _iterableToArray(iter) {
 973    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
 974  }
 975  
 976  /***/ }),
 977  /* 40 */,
 978  /* 41 */
 979  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 980  
 981  "use strict";
 982  
 983  // EXPORTS
 984  __webpack_require__.d(__webpack_exports__, "a", function() { return /* reexport */ ThemeContext; });
 985  __webpack_require__.d(__webpack_exports__, "d", function() { return /* reexport */ emotion_element_57a3a7a3_browser_esm_withEmotionCache; });
 986  __webpack_require__.d(__webpack_exports__, "b", function() { return /* reexport */ css_browser_esm; });
 987  __webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ core_browser_esm_keyframes; });
 988  
 989  // UNUSED EXPORTS: CacheProvider, ClassNames, Global, createElement, jsx
 990  
 991  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
 992  var inheritsLoose = __webpack_require__(178);
 993  
 994  // EXTERNAL MODULE: external "React"
 995  var external_React_ = __webpack_require__(14);
 996  
 997  // EXTERNAL MODULE: ./node_modules/@emotion/cache/dist/cache.browser.esm.js + 1 modules
 998  var cache_browser_esm = __webpack_require__(204);
 999  
1000  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/inheritsLoose.js
1001  var helpers_inheritsLoose = __webpack_require__(158);
1002  
1003  // EXTERNAL MODULE: ./node_modules/@emotion/utils/dist/utils.browser.esm.js
1004  var utils_browser_esm = __webpack_require__(99);
1005  
1006  // EXTERNAL MODULE: ./node_modules/@emotion/serialize/dist/serialize.browser.esm.js + 2 modules
1007  var serialize_browser_esm = __webpack_require__(98);
1008  
1009  // CONCATENATED MODULE: ./node_modules/@emotion/core/dist/emotion-element-57a3a7a3.browser.esm.js
1010  
1011  
1012  
1013  
1014  
1015  
1016  var emotion_element_57a3a7a3_browser_esm_hasOwnProperty = Object.prototype.hasOwnProperty;
1017  
1018  var EmotionCacheContext = /*#__PURE__*/Object(external_React_["createContext"])( // we're doing this to avoid preconstruct's dead code elimination in this one case
1019  // because this module is primarily intended for the browser and node
1020  // but it's also required in react native and similar environments sometimes
1021  // and we could have a special build just for that
1022  // but this is much easier and the native packages
1023  // might use a different theme context in the future anyway
1024  typeof HTMLElement !== 'undefined' ? Object(cache_browser_esm["a" /* default */])() : null);
1025  var ThemeContext = /*#__PURE__*/Object(external_React_["createContext"])({});
1026  var CacheProvider = EmotionCacheContext.Provider;
1027  
1028  var emotion_element_57a3a7a3_browser_esm_withEmotionCache = function withEmotionCache(func) {
1029    var render = function render(props, ref) {
1030      return /*#__PURE__*/Object(external_React_["createElement"])(EmotionCacheContext.Consumer, null, function (cache) {
1031        return func(props, cache, ref);
1032      });
1033    }; // $FlowFixMe
1034  
1035  
1036    return /*#__PURE__*/Object(external_React_["forwardRef"])(render);
1037  };
1038  
1039  // thus we only need to replace what is a valid character for JS, but not for CSS
1040  
1041  var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
1042    return identifier.replace(/\$/g, '-');
1043  };
1044  
1045  var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
1046  var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
1047  var createEmotionProps = function createEmotionProps(type, props) {
1048    if (false) {}
1049  
1050    var newProps = {};
1051  
1052    for (var key in props) {
1053      if (emotion_element_57a3a7a3_browser_esm_hasOwnProperty.call(props, key)) {
1054        newProps[key] = props[key];
1055      }
1056    }
1057  
1058    newProps[typePropName] = type; // TODO: check if this still works with all of those different JSX functions
1059  
1060    if (false) { var match, error; }
1061  
1062    return newProps;
1063  };
1064  
1065  var emotion_element_57a3a7a3_browser_esm_render = function render(cache, props, theme, ref) {
1066    var cssProp = theme === null ? props.css : props.css(theme); // so that using `css` from `emotion` and passing the result to the css prop works
1067    // not passing the registered cache to serializeStyles because it would
1068    // make certain babel optimisations not possible
1069  
1070    if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
1071      cssProp = cache.registered[cssProp];
1072    }
1073  
1074    var type = props[typePropName];
1075    var registeredStyles = [cssProp];
1076    var className = '';
1077  
1078    if (typeof props.className === 'string') {
1079      className = Object(utils_browser_esm["a" /* getRegisteredStyles */])(cache.registered, registeredStyles, props.className);
1080    } else if (props.className != null) {
1081      className = props.className + " ";
1082    }
1083  
1084    var serialized = Object(serialize_browser_esm["a" /* serializeStyles */])(registeredStyles);
1085  
1086    if (false) { var labelFromStack; }
1087  
1088    var rules = Object(utils_browser_esm["b" /* insertStyles */])(cache, serialized, typeof type === 'string');
1089    className += cache.key + "-" + serialized.name;
1090    var newProps = {};
1091  
1092    for (var key in props) {
1093      if (emotion_element_57a3a7a3_browser_esm_hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && ( true || false)) {
1094        newProps[key] = props[key];
1095      }
1096    }
1097  
1098    newProps.ref = ref;
1099    newProps.className = className;
1100    var ele = /*#__PURE__*/Object(external_React_["createElement"])(type, newProps);
1101  
1102    return ele;
1103  }; // eslint-disable-next-line no-undef
1104  
1105  
1106  var Emotion = /* #__PURE__ */emotion_element_57a3a7a3_browser_esm_withEmotionCache(function (props, cache, ref) {
1107    if (typeof props.css === 'function') {
1108      return /*#__PURE__*/Object(external_React_["createElement"])(ThemeContext.Consumer, null, function (theme) {
1109        return emotion_element_57a3a7a3_browser_esm_render(cache, props, theme, ref);
1110      });
1111    }
1112  
1113    return emotion_element_57a3a7a3_browser_esm_render(cache, props, null, ref);
1114  });
1115  
1116  if (false) {}
1117  
1118  
1119  
1120  // EXTERNAL MODULE: ./node_modules/@emotion/sheet/dist/sheet.browser.esm.js
1121  var sheet_browser_esm = __webpack_require__(179);
1122  
1123  // CONCATENATED MODULE: ./node_modules/@emotion/css/dist/css.browser.esm.js
1124  
1125  
1126  function css_browser_esm_css() {
1127    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1128      args[_key] = arguments[_key];
1129    }
1130  
1131    return Object(serialize_browser_esm["a" /* serializeStyles */])(args);
1132  }
1133  
1134  /* harmony default export */ var css_browser_esm = (css_browser_esm_css);
1135  
1136  // CONCATENATED MODULE: ./node_modules/@emotion/core/dist/core.browser.esm.js
1137  
1138  
1139  
1140  
1141  
1142  
1143  
1144  
1145  
1146  
1147  
1148  var core_browser_esm_jsx = function jsx(type, props) {
1149    var args = arguments;
1150  
1151    if (props == null || !emotion_element_57a3a7a3_browser_esm_hasOwnProperty.call(props, 'css')) {
1152      // $FlowFixMe
1153      return external_React_["createElement"].apply(undefined, args);
1154    }
1155  
1156    var argsLength = args.length;
1157    var createElementArgArray = new Array(argsLength);
1158    createElementArgArray[0] = Emotion;
1159    createElementArgArray[1] = createEmotionProps(type, props);
1160  
1161    for (var i = 2; i < argsLength; i++) {
1162      createElementArgArray[i] = args[i];
1163    } // $FlowFixMe
1164  
1165  
1166    return external_React_["createElement"].apply(null, createElementArgArray);
1167  };
1168  
1169  var warnedAboutCssPropForGlobal = false;
1170  var Global = /* #__PURE__ */emotion_element_57a3a7a3_browser_esm_withEmotionCache(function (props, cache) {
1171    if (false) {}
1172  
1173    var styles = props.styles;
1174  
1175    if (typeof styles === 'function') {
1176      return /*#__PURE__*/Object(external_React_["createElement"])(ThemeContext.Consumer, null, function (theme) {
1177        var serialized = Object(serialize_browser_esm["a" /* serializeStyles */])([styles(theme)]);
1178        return /*#__PURE__*/Object(external_React_["createElement"])(core_browser_esm_InnerGlobal, {
1179          serialized: serialized,
1180          cache: cache
1181        });
1182      });
1183    }
1184  
1185    var serialized = Object(serialize_browser_esm["a" /* serializeStyles */])([styles]);
1186    return /*#__PURE__*/Object(external_React_["createElement"])(core_browser_esm_InnerGlobal, {
1187      serialized: serialized,
1188      cache: cache
1189    });
1190  });
1191  
1192  // maintain place over rerenders.
1193  // initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
1194  // initial client-side render from SSR, use place of hydrating tag
1195  var core_browser_esm_InnerGlobal = /*#__PURE__*/function (_React$Component) {
1196    Object(inheritsLoose["a" /* default */])(InnerGlobal, _React$Component);
1197  
1198    function InnerGlobal(props, context, updater) {
1199      return _React$Component.call(this, props, context, updater) || this;
1200    }
1201  
1202    var _proto = InnerGlobal.prototype;
1203  
1204    _proto.componentDidMount = function componentDidMount() {
1205      this.sheet = new sheet_browser_esm["a" /* StyleSheet */]({
1206        key: this.props.cache.key + "-global",
1207        nonce: this.props.cache.sheet.nonce,
1208        container: this.props.cache.sheet.container
1209      }); // $FlowFixMe
1210  
1211      var node = document.querySelector("style[data-emotion-" + this.props.cache.key + "=\"" + this.props.serialized.name + "\"]");
1212  
1213      if (node !== null) {
1214        this.sheet.tags.push(node);
1215      }
1216  
1217      if (this.props.cache.sheet.tags.length) {
1218        this.sheet.before = this.props.cache.sheet.tags[0];
1219      }
1220  
1221      this.insertStyles();
1222    };
1223  
1224    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
1225      if (prevProps.serialized.name !== this.props.serialized.name) {
1226        this.insertStyles();
1227      }
1228    };
1229  
1230    _proto.insertStyles = function insertStyles$1() {
1231      if (this.props.serialized.next !== undefined) {
1232        // insert keyframes
1233        Object(utils_browser_esm["b" /* insertStyles */])(this.props.cache, this.props.serialized.next, true);
1234      }
1235  
1236      if (this.sheet.tags.length) {
1237        // if this doesn't exist then it will be null so the style element will be appended
1238        var element = this.sheet.tags[this.sheet.tags.length - 1].nextElementSibling;
1239        this.sheet.before = element;
1240        this.sheet.flush();
1241      }
1242  
1243      this.props.cache.insert("", this.props.serialized, this.sheet, false);
1244    };
1245  
1246    _proto.componentWillUnmount = function componentWillUnmount() {
1247      this.sheet.flush();
1248    };
1249  
1250    _proto.render = function render() {
1251  
1252      return null;
1253    };
1254  
1255    return InnerGlobal;
1256  }(external_React_["Component"]);
1257  
1258  var core_browser_esm_keyframes = function keyframes() {
1259    var insertable = css_browser_esm.apply(void 0, arguments);
1260    var name = "animation-" + insertable.name; // $FlowFixMe
1261  
1262    return {
1263      name: name,
1264      styles: "@keyframes " + name + "{" + insertable.styles + "}",
1265      anim: 1,
1266      toString: function toString() {
1267        return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
1268      }
1269    };
1270  };
1271  
1272  var classnames = function classnames(args) {
1273    var len = args.length;
1274    var i = 0;
1275    var cls = '';
1276  
1277    for (; i < len; i++) {
1278      var arg = args[i];
1279      if (arg == null) continue;
1280      var toAdd = void 0;
1281  
1282      switch (typeof arg) {
1283        case 'boolean':
1284          break;
1285  
1286        case 'object':
1287          {
1288            if (Array.isArray(arg)) {
1289              toAdd = classnames(arg);
1290            } else {
1291              toAdd = '';
1292  
1293              for (var k in arg) {
1294                if (arg[k] && k) {
1295                  toAdd && (toAdd += ' ');
1296                  toAdd += k;
1297                }
1298              }
1299            }
1300  
1301            break;
1302          }
1303  
1304        default:
1305          {
1306            toAdd = arg;
1307          }
1308      }
1309  
1310      if (toAdd) {
1311        cls && (cls += ' ');
1312        cls += toAdd;
1313      }
1314    }
1315  
1316    return cls;
1317  };
1318  
1319  function merge(registered, css, className) {
1320    var registeredStyles = [];
1321    var rawClassName = Object(utils_browser_esm["a" /* getRegisteredStyles */])(registered, registeredStyles, className);
1322  
1323    if (registeredStyles.length < 2) {
1324      return className;
1325    }
1326  
1327    return rawClassName + css(registeredStyles);
1328  }
1329  
1330  var ClassNames = emotion_element_57a3a7a3_browser_esm_withEmotionCache(function (props, context) {
1331    return /*#__PURE__*/Object(external_React_["createElement"])(ThemeContext.Consumer, null, function (theme) {
1332      var hasRendered = false;
1333  
1334      var css = function css() {
1335        if (hasRendered && "production" !== 'production') {
1336          throw new Error('css can only be used during render');
1337        }
1338  
1339        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1340          args[_key] = arguments[_key];
1341        }
1342  
1343        var serialized = Object(serialize_browser_esm["a" /* serializeStyles */])(args, context.registered);
1344  
1345        {
1346          Object(utils_browser_esm["b" /* insertStyles */])(context, serialized, false);
1347        }
1348  
1349        return context.key + "-" + serialized.name;
1350      };
1351  
1352      var cx = function cx() {
1353        if (hasRendered && "production" !== 'production') {
1354          throw new Error('cx can only be used during render');
1355        }
1356  
1357        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
1358          args[_key2] = arguments[_key2];
1359        }
1360  
1361        return merge(context.registered, css, classnames(args));
1362      };
1363  
1364      var content = {
1365        css: css,
1366        cx: cx,
1367        theme: theme
1368      };
1369      var ele = props.children(content);
1370      hasRendered = true;
1371  
1372      return ele;
1373    });
1374  });
1375  
1376  
1377  
1378  
1379  /***/ }),
1380  /* 42 */,
1381  /* 43 */,
1382  /* 44 */
1383  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1384  
1385  "use strict";
1386  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutPropertiesLoose; });
1387  function _objectWithoutPropertiesLoose(source, excluded) {
1388    if (source == null) return {};
1389    var target = {};
1390    var sourceKeys = Object.keys(source);
1391    var key, i;
1392  
1393    for (i = 0; i < sourceKeys.length; i++) {
1394      key = sourceKeys[i];
1395      if (excluded.indexOf(key) >= 0) continue;
1396      target[key] = source[key];
1397    }
1398  
1399    return target;
1400  }
1401  
1402  /***/ }),
1403  /* 45 */
1404  /***/ (function(module, exports) {
1405  
1406  (function() { module.exports = window["moment"]; }());
1407  
1408  /***/ }),
1409  /* 46 */
1410  /***/ (function(module, exports) {
1411  
1412  (function() { module.exports = window["wp"]["a11y"]; }());
1413  
1414  /***/ }),
1415  /* 47 */,
1416  /* 48 */
1417  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1418  
1419  "use strict";
1420  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; });
1421  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
1422    try {
1423      var info = gen[key](arg);
1424      var value = info.value;
1425    } catch (error) {
1426      reject(error);
1427      return;
1428    }
1429  
1430    if (info.done) {
1431      resolve(value);
1432    } else {
1433      Promise.resolve(value).then(_next, _throw);
1434    }
1435  }
1436  
1437  function _asyncToGenerator(fn) {
1438    return function () {
1439      var self = this,
1440          args = arguments;
1441      return new Promise(function (resolve, reject) {
1442        var gen = fn.apply(self, args);
1443  
1444        function _next(value) {
1445          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
1446        }
1447  
1448        function _throw(err) {
1449          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
1450        }
1451  
1452        _next(undefined);
1453      });
1454    };
1455  }
1456  
1457  /***/ }),
1458  /* 49 */,
1459  /* 50 */,
1460  /* 51 */,
1461  /* 52 */
1462  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1463  
1464  "use strict";
1465  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useLiveRef; });
1466  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
1467  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
1468  /* harmony import */ var _useIsomorphicEffect_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71);
1469  
1470  
1471  
1472  
1473  
1474  
1475  /**
1476   * A `React.Ref` that keeps track of the passed `value`.
1477   */
1478  
1479  function useLiveRef(value) {
1480    var ref = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(value);
1481    Object(_useIsomorphicEffect_js__WEBPACK_IMPORTED_MODULE_1__[/* useIsomorphicEffect */ "a"])(function () {
1482      ref.current = value;
1483    });
1484    return ref;
1485  }
1486  
1487  
1488  
1489  
1490  /***/ }),
1491  /* 53 */
1492  /***/ (function(module, exports, __webpack_require__) {
1493  
1494  "use strict";
1495  
1496  
1497  var undefined;
1498  
1499  var $SyntaxError = SyntaxError;
1500  var $Function = Function;
1501  var $TypeError = TypeError;
1502  
1503  // eslint-disable-next-line consistent-return
1504  var getEvalledConstructor = function (expressionSyntax) {
1505      try {
1506          return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
1507      } catch (e) {}
1508  };
1509  
1510  var $gOPD = Object.getOwnPropertyDescriptor;
1511  if ($gOPD) {
1512      try {
1513          $gOPD({}, '');
1514      } catch (e) {
1515          $gOPD = null; // this is IE 8, which has a broken gOPD
1516      }
1517  }
1518  
1519  var throwTypeError = function () {
1520      throw new $TypeError();
1521  };
1522  var ThrowTypeError = $gOPD
1523      ? (function () {
1524          try {
1525              // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
1526              arguments.callee; // IE 8 does not throw here
1527              return throwTypeError;
1528          } catch (calleeThrows) {
1529              try {
1530                  // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
1531                  return $gOPD(arguments, 'callee').get;
1532              } catch (gOPDthrows) {
1533                  return throwTypeError;
1534              }
1535          }
1536      }())
1537      : throwTypeError;
1538  
1539  var hasSymbols = __webpack_require__(226)();
1540  
1541  var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
1542  
1543  var needsEval = {};
1544  
1545  var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
1546  
1547  var INTRINSICS = {
1548      '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
1549      '%Array%': Array,
1550      '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
1551      '%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
1552      '%AsyncFromSyncIteratorPrototype%': undefined,
1553      '%AsyncFunction%': needsEval,
1554      '%AsyncGenerator%': needsEval,
1555      '%AsyncGeneratorFunction%': needsEval,
1556      '%AsyncIteratorPrototype%': needsEval,
1557      '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
1558      '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
1559      '%Boolean%': Boolean,
1560      '%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
1561      '%Date%': Date,
1562      '%decodeURI%': decodeURI,
1563      '%decodeURIComponent%': decodeURIComponent,
1564      '%encodeURI%': encodeURI,
1565      '%encodeURIComponent%': encodeURIComponent,
1566      '%Error%': Error,
1567      '%eval%': eval, // eslint-disable-line no-eval
1568      '%EvalError%': EvalError,
1569      '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
1570      '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
1571      '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
1572      '%Function%': $Function,
1573      '%GeneratorFunction%': needsEval,
1574      '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
1575      '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
1576      '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
1577      '%isFinite%': isFinite,
1578      '%isNaN%': isNaN,
1579      '%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
1580      '%JSON%': typeof JSON === 'object' ? JSON : undefined,
1581      '%Map%': typeof Map === 'undefined' ? undefined : Map,
1582      '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
1583      '%Math%': Math,
1584      '%Number%': Number,
1585      '%Object%': Object,
1586      '%parseFloat%': parseFloat,
1587      '%parseInt%': parseInt,
1588      '%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
1589      '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
1590      '%RangeError%': RangeError,
1591      '%ReferenceError%': ReferenceError,
1592      '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
1593      '%RegExp%': RegExp,
1594      '%Set%': typeof Set === 'undefined' ? undefined : Set,
1595      '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
1596      '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
1597      '%String%': String,
1598      '%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
1599      '%Symbol%': hasSymbols ? Symbol : undefined,
1600      '%SyntaxError%': $SyntaxError,
1601      '%ThrowTypeError%': ThrowTypeError,
1602      '%TypedArray%': TypedArray,
1603      '%TypeError%': $TypeError,
1604      '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
1605      '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
1606      '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
1607      '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
1608      '%URIError%': URIError,
1609      '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
1610      '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
1611      '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
1612  };
1613  
1614  var doEval = function doEval(name) {
1615      var value;
1616      if (name === '%AsyncFunction%') {
1617          value = getEvalledConstructor('async function () {}');
1618      } else if (name === '%GeneratorFunction%') {
1619          value = getEvalledConstructor('function* () {}');
1620      } else if (name === '%AsyncGeneratorFunction%') {
1621          value = getEvalledConstructor('async function* () {}');
1622      } else if (name === '%AsyncGenerator%') {
1623          var fn = doEval('%AsyncGeneratorFunction%');
1624          if (fn) {
1625              value = fn.prototype;
1626          }
1627      } else if (name === '%AsyncIteratorPrototype%') {
1628          var gen = doEval('%AsyncGenerator%');
1629          if (gen) {
1630              value = getProto(gen.prototype);
1631          }
1632      }
1633  
1634      INTRINSICS[name] = value;
1635  
1636      return value;
1637  };
1638  
1639  var LEGACY_ALIASES = {
1640      '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
1641      '%ArrayPrototype%': ['Array', 'prototype'],
1642      '%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
1643      '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
1644      '%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
1645      '%ArrayProto_values%': ['Array', 'prototype', 'values'],
1646      '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
1647      '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
1648      '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
1649      '%BooleanPrototype%': ['Boolean', 'prototype'],
1650      '%DataViewPrototype%': ['DataView', 'prototype'],
1651      '%DatePrototype%': ['Date', 'prototype'],
1652      '%ErrorPrototype%': ['Error', 'prototype'],
1653      '%EvalErrorPrototype%': ['EvalError', 'prototype'],
1654      '%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
1655      '%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
1656      '%FunctionPrototype%': ['Function', 'prototype'],
1657      '%Generator%': ['GeneratorFunction', 'prototype'],
1658      '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
1659      '%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
1660      '%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
1661      '%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
1662      '%JSONParse%': ['JSON', 'parse'],
1663      '%JSONStringify%': ['JSON', 'stringify'],
1664      '%MapPrototype%': ['Map', 'prototype'],
1665      '%NumberPrototype%': ['Number', 'prototype'],
1666      '%ObjectPrototype%': ['Object', 'prototype'],
1667      '%ObjProto_toString%': ['Object', 'prototype', 'toString'],
1668      '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
1669      '%PromisePrototype%': ['Promise', 'prototype'],
1670      '%PromiseProto_then%': ['Promise', 'prototype', 'then'],
1671      '%Promise_all%': ['Promise', 'all'],
1672      '%Promise_reject%': ['Promise', 'reject'],
1673      '%Promise_resolve%': ['Promise', 'resolve'],
1674      '%RangeErrorPrototype%': ['RangeError', 'prototype'],
1675      '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
1676      '%RegExpPrototype%': ['RegExp', 'prototype'],
1677      '%SetPrototype%': ['Set', 'prototype'],
1678      '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
1679      '%StringPrototype%': ['String', 'prototype'],
1680      '%SymbolPrototype%': ['Symbol', 'prototype'],
1681      '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
1682      '%TypedArrayPrototype%': ['TypedArray', 'prototype'],
1683      '%TypeErrorPrototype%': ['TypeError', 'prototype'],
1684      '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
1685      '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
1686      '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
1687      '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
1688      '%URIErrorPrototype%': ['URIError', 'prototype'],
1689      '%WeakMapPrototype%': ['WeakMap', 'prototype'],
1690      '%WeakSetPrototype%': ['WeakSet', 'prototype']
1691  };
1692  
1693  var bind = __webpack_require__(122);
1694  var hasOwn = __webpack_require__(92);
1695  var $concat = bind.call(Function.call, Array.prototype.concat);
1696  var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
1697  var $replace = bind.call(Function.call, String.prototype.replace);
1698  var $strSlice = bind.call(Function.call, String.prototype.slice);
1699  
1700  /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
1701  var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
1702  var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
1703  var stringToPath = function stringToPath(string) {
1704      var first = $strSlice(string, 0, 1);
1705      var last = $strSlice(string, -1);
1706      if (first === '%' && last !== '%') {
1707          throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
1708      } else if (last === '%' && first !== '%') {
1709          throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
1710      }
1711      var result = [];
1712      $replace(string, rePropName, function (match, number, quote, subString) {
1713          result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
1714      });
1715      return result;
1716  };
1717  /* end adaptation */
1718  
1719  var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
1720      var intrinsicName = name;
1721      var alias;
1722      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
1723          alias = LEGACY_ALIASES[intrinsicName];
1724          intrinsicName = '%' + alias[0] + '%';
1725      }
1726  
1727      if (hasOwn(INTRINSICS, intrinsicName)) {
1728          var value = INTRINSICS[intrinsicName];
1729          if (value === needsEval) {
1730              value = doEval(intrinsicName);
1731          }
1732          if (typeof value === 'undefined' && !allowMissing) {
1733              throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
1734          }
1735  
1736          return {
1737              alias: alias,
1738              name: intrinsicName,
1739              value: value
1740          };
1741      }
1742  
1743      throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
1744  };
1745  
1746  module.exports = function GetIntrinsic(name, allowMissing) {
1747      if (typeof name !== 'string' || name.length === 0) {
1748          throw new $TypeError('intrinsic name must be a non-empty string');
1749      }
1750      if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
1751          throw new $TypeError('"allowMissing" argument must be a boolean');
1752      }
1753  
1754      var parts = stringToPath(name);
1755      var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
1756  
1757      var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
1758      var intrinsicRealName = intrinsic.name;
1759      var value = intrinsic.value;
1760      var skipFurtherCaching = false;
1761  
1762      var alias = intrinsic.alias;
1763      if (alias) {
1764          intrinsicBaseName = alias[0];
1765          $spliceApply(parts, $concat([0, 1], alias));
1766      }
1767  
1768      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
1769          var part = parts[i];
1770          var first = $strSlice(part, 0, 1);
1771          var last = $strSlice(part, -1);
1772          if (
1773              (
1774                  (first === '"' || first === "'" || first === '`')
1775                  || (last === '"' || last === "'" || last === '`')
1776              )
1777              && first !== last
1778          ) {
1779              throw new $SyntaxError('property names with quotes must have matching quotes');
1780          }
1781          if (part === 'constructor' || !isOwn) {
1782              skipFurtherCaching = true;
1783          }
1784  
1785          intrinsicBaseName += '.' + part;
1786          intrinsicRealName = '%' + intrinsicBaseName + '%';
1787  
1788          if (hasOwn(INTRINSICS, intrinsicRealName)) {
1789              value = INTRINSICS[intrinsicRealName];
1790          } else if (value != null) {
1791              if (!(part in value)) {
1792                  if (!allowMissing) {
1793                      throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
1794                  }
1795                  return void undefined;
1796              }
1797              if ($gOPD && (i + 1) >= parts.length) {
1798                  var desc = $gOPD(value, part);
1799                  isOwn = !!desc;
1800  
1801                  // By convention, when a data property is converted to an accessor
1802                  // property to emulate a data property that does not suffer from
1803                  // the override mistake, that accessor's getter is marked with
1804                  // an `originalValue` property. Here, when we detect this, we
1805                  // uphold the illusion by pretending to see that original data
1806                  // property, i.e., returning the value rather than the getter
1807                  // itself.
1808                  if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
1809                      value = desc.get;
1810                  } else {
1811                      value = value[part];
1812                  }
1813              } else {
1814                  isOwn = hasOwn(value, part);
1815                  value = value[part];
1816              }
1817  
1818              if (isOwn && !skipFurtherCaching) {
1819                  INTRINSICS[intrinsicRealName] = value;
1820              }
1821          }
1822      }
1823      return value;
1824  };
1825  
1826  
1827  /***/ }),
1828  /* 54 */
1829  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1830  
1831  "use strict";
1832  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getDocument; });
1833  /**
1834   * Returns `element.ownerDocument || document`.
1835   */
1836  function getDocument(element) {
1837    return element ? element.ownerDocument || element : document;
1838  }
1839  
1840  
1841  
1842  
1843  /***/ }),
1844  /* 55 */
1845  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1846  
1847  "use strict";
1848  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _setPrototypeOf; });
1849  function _setPrototypeOf(o, p) {
1850    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
1851      o.__proto__ = p;
1852      return o;
1853    };
1854  
1855    return _setPrototypeOf(o, p);
1856  }
1857  
1858  /***/ }),
1859  /* 56 */
1860  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1861  
1862  "use strict";
1863  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; });
1864  function _typeof(obj) {
1865    "@babel/helpers - typeof";
1866  
1867    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
1868      _typeof = function _typeof(obj) {
1869        return typeof obj;
1870      };
1871    } else {
1872      _typeof = function _typeof(obj) {
1873        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
1874      };
1875    }
1876  
1877    return _typeof(obj);
1878  }
1879  
1880  /***/ }),
1881  /* 57 */,
1882  /* 58 */
1883  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1884  
1885  "use strict";
1886  
1887  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
1888  var defineProperty = __webpack_require__(5);
1889  
1890  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
1891  var objectWithoutProperties = __webpack_require__(13);
1892  
1893  // EXTERNAL MODULE: ./node_modules/classnames/index.js
1894  var classnames = __webpack_require__(10);
1895  var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
1896  
1897  // EXTERNAL MODULE: external ["wp","element"]
1898  var external_wp_element_ = __webpack_require__(0);
1899  
1900  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/visually-hidden/utils.js
1901  
1902  
1903  
1904  /**
1905   * @template {keyof JSX.IntrinsicElements | import('react').JSXElementConstructor<any>} T
1906   * @typedef OwnProps
1907   * @property {T} [as='div'] Component to render
1908   * @property {import('react').ReactNode | ((props: import('react').ComponentProps<T>) => JSX.Element) } [children] Children or render props function
1909   */
1910  
1911  /**
1912   * @template {keyof JSX.IntrinsicElements | import('react').JSXElementConstructor<any>} T
1913   * @typedef {OwnProps<T> & import('react').ComponentProps<T>} Props
1914   */
1915  
1916  /**
1917   * renderAsRenderProps is used to wrap a component and convert
1918   * the passed property "as" either a string or component, to the
1919   * rendered tag if a string, or component.
1920   *
1921   * See VisuallyHidden hidden for example.
1922   *
1923   * @template {keyof JSX.IntrinsicElements | import('react').JSXElementConstructor<any>} T
1924   * @param {Props<T>} props
1925   * @return {JSX.Element} The rendered element.
1926   */
1927  function renderAsRenderProps(_ref) {
1928    var _ref$as = _ref.as,
1929        Component = _ref$as === void 0 ? 'div' : _ref$as,
1930        props = Object(objectWithoutProperties["a" /* default */])(_ref, ["as"]);
1931  
1932    if (typeof props.children === 'function') {
1933      return props.children(props);
1934    }
1935  
1936    return Object(external_wp_element_["createElement"])(Component, props);
1937  }
1938  
1939  
1940  
1941  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/ui/context/with-next.js
1942  var with_next = __webpack_require__(526);
1943  
1944  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/visually-hidden/next.js
1945  /**
1946   * Internal dependencies
1947   */
1948  
1949  
1950  var VisuallyHidden =  false ? undefined : undefined;
1951  /**
1952   * There is nothing to adapt, the props are equal.
1953   *
1954   * @param {import('.').Props<any>} props
1955   * @return {import('../ui/visually-hidden/hook').Props} Adapted props
1956   */
1957  
1958  var adapter = function adapter(props) {
1959    return (
1960      /** @type {import('../ui/visually-hidden/hook').Props} */
1961      props
1962    );
1963  };
1964  /**
1965   * The generic type is too difficult to type here, default to any to circumvent that.
1966   *
1967   * @param {import('react').ForwardRefExoticComponent<import('.').Props<any>>} Current
1968   */
1969  
1970  
1971  function withNextComponent(Current) {
1972    return Object(with_next["a" /* withNext */])(Current, VisuallyHidden, 'WPComponentsVisuallyHidden', adapter);
1973  }
1974  
1975  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/visually-hidden/index.js
1976  
1977  
1978  
1979  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
1980  
1981  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
1982  
1983  /**
1984   * External dependencies
1985   */
1986  
1987  /**
1988   * WordPress dependencies
1989   */
1990  
1991  
1992  /**
1993   * Internal dependencies
1994   */
1995  
1996  
1997  
1998  /**
1999   * @template {keyof JSX.IntrinsicElements | import('react').JSXElementConstructor<any>} T
2000   * @typedef OwnProps
2001   * @property {T} [as='div'] Component to render, e.g. `"div"` or `MyComponent`.
2002   */
2003  
2004  /**
2005   * @template {keyof JSX.IntrinsicElements | import('react').JSXElementConstructor<any>} T
2006   * @typedef {OwnProps<T> & import('react').ComponentPropsWithRef<T>} Props
2007   */
2008  
2009  /**
2010   * VisuallyHidden component to render text out non-visually
2011   * for use in devices such as a screen reader.
2012   *
2013   * @template {keyof JSX.IntrinsicElements | import('react').JSXElementConstructor<any>} T T
2014   * @param {Props<T>} props
2015   * @param {import('react').Ref<any>} forwardedRef
2016   * @return {JSX.Element} Element
2017   */
2018  
2019  function visually_hidden_VisuallyHidden(_ref, forwardedRef) {
2020    var _ref$as = _ref.as,
2021        as = _ref$as === void 0 ? 'div' : _ref$as,
2022        className = _ref.className,
2023        props = Object(objectWithoutProperties["a" /* default */])(_ref, ["as", "className"]);
2024  
2025    return renderAsRenderProps(_objectSpread(_objectSpread({
2026      as: as,
2027      className: classnames_default()('components-visually-hidden', className)
2028    }, props), {}, {
2029      ref: forwardedRef
2030    }));
2031  }
2032  
2033  /* harmony default export */ var visually_hidden = __webpack_exports__["a"] = (withNextComponent(Object(external_wp_element_["forwardRef"])(visually_hidden_VisuallyHidden)));
2034  
2035  
2036  /***/ }),
2037  /* 59 */
2038  /***/ (function(module, exports) {
2039  
2040  function _typeof(obj) {
2041    "@babel/helpers - typeof";
2042  
2043    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
2044      module.exports = _typeof = function _typeof(obj) {
2045        return typeof obj;
2046      };
2047  
2048      module.exports["default"] = module.exports, module.exports.__esModule = true;
2049    } else {
2050      module.exports = _typeof = function _typeof(obj) {
2051        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
2052      };
2053  
2054      module.exports["default"] = module.exports, module.exports.__esModule = true;
2055    }
2056  
2057    return _typeof(obj);
2058  }
2059  
2060  module.exports = _typeof;
2061  module.exports["default"] = module.exports, module.exports.__esModule = true;
2062  
2063  /***/ }),
2064  /* 60 */
2065  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2066  
2067  "use strict";
2068  
2069  // EXPORTS
2070  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ createHook; });
2071  
2072  // EXTERNAL MODULE: external "React"
2073  var external_React_ = __webpack_require__(14);
2074  
2075  // EXTERNAL MODULE: ./node_modules/reakit-system/es/SystemContext.js
2076  var SystemContext = __webpack_require__(111);
2077  
2078  // CONCATENATED MODULE: ./node_modules/reakit-system/es/useToken.js
2079  
2080  
2081  
2082  /**
2083   * React custom hook that returns the value of any token defined in the
2084   * SystemContext. It's mainly used internally in [`useOptions`](#useoptions)
2085   * and [`useProps`](#useprops).
2086   *
2087   * @example
2088   * import { SystemProvider, useToken } from "reakit-system";
2089   *
2090   * const system = {
2091   *   token: "value",
2092   * };
2093   *
2094   * function Component(props) {
2095   *   const token = useToken("token", "default value");
2096   *   return <div {...props}>{token}</div>;
2097   * }
2098   *
2099   * function App() {
2100   *   return (
2101   *     <SystemProvider unstable_system={system}>
2102   *       <Component />
2103   *     </SystemProvider>
2104   *   );
2105   * }
2106   */
2107  
2108  function useToken(token, defaultValue) {
2109    Object(external_React_["useDebugValue"])(token);
2110    var context = Object(external_React_["useContext"])(SystemContext["a" /* SystemContext */]);
2111    return context[token] != null ? context[token] : defaultValue;
2112  }
2113  
2114  
2115  
2116  // CONCATENATED MODULE: ./node_modules/reakit-system/es/useProps.js
2117  
2118  
2119  
2120  
2121  /**
2122   * React custom hook that returns the props returned by a given
2123   * `use${name}Props` in the SystemContext.
2124   *
2125   * @example
2126   * import { SystemProvider, useProps } from "reakit-system";
2127   *
2128   * const system = {
2129   *   useAProps(options, htmlProps) {
2130   *     return {
2131   *       ...htmlProps,
2132   *       href: options.url,
2133   *     };
2134   *   },
2135   * };
2136   *
2137   * function A({ url, ...htmlProps }) {
2138   *   const props = useProps("A", { url }, htmlProps);
2139   *   return <a {...props} />;
2140   * }
2141   *
2142   * function App() {
2143   *   return (
2144   *     <SystemProvider unstable_system={system}>
2145   *       <A url="url">It will convert url into href in useAProps</A>
2146   *     </SystemProvider>
2147   *   );
2148   * }
2149   */
2150  
2151  function useProps(name, options, htmlProps) {
2152    if (options === void 0) {
2153      options = {};
2154    }
2155  
2156    if (htmlProps === void 0) {
2157      htmlProps = {};
2158    }
2159  
2160    var hookName = "use" + name + "Props";
2161    Object(external_React_["useDebugValue"])(hookName);
2162    var useHook = useToken(hookName);
2163  
2164    if (useHook) {
2165      return useHook(options, htmlProps);
2166    }
2167  
2168    return htmlProps;
2169  }
2170  
2171  
2172  
2173  // EXTERNAL MODULE: ./node_modules/reakit-system/es/_rollupPluginBabelHelpers-0c84a174.js
2174  var _rollupPluginBabelHelpers_0c84a174 = __webpack_require__(78);
2175  
2176  // CONCATENATED MODULE: ./node_modules/reakit-system/es/useOptions.js
2177  
2178  
2179  
2180  
2181  
2182  /**
2183   * React custom hook that returns the options returned by a given
2184   * `use${name}Options` in the SystemContext.
2185   *
2186   * @example
2187   * import React from "react";
2188   * import { SystemProvider, useOptions } from "reakit-system";
2189   *
2190   * const system = {
2191   *   useAOptions(options, htmlProps) {
2192   *     return {
2193   *       ...options,
2194   *       url: htmlProps.href,
2195   *     };
2196   *   },
2197   * };
2198   *
2199   * function A({ url, ...htmlProps }) {
2200   *   const options = useOptions("A", { url }, htmlProps);
2201   *   return <a href={options.url} {...htmlProps} />;
2202   * }
2203   *
2204   * function App() {
2205   *   return (
2206   *     <SystemProvider unstable_system={system}>
2207   *       <A href="url">
2208   *         It will convert href into url in useAOptions and then url into href in A
2209   *       </A>
2210   *     </SystemProvider>
2211   *   );
2212   * }
2213   */
2214  
2215  function useOptions(name, options, htmlProps) {
2216    if (options === void 0) {
2217      options = {};
2218    }
2219  
2220    if (htmlProps === void 0) {
2221      htmlProps = {};
2222    }
2223  
2224    var hookName = "use" + name + "Options";
2225    Object(external_React_["useDebugValue"])(hookName);
2226    var useHook = useToken(hookName);
2227  
2228    if (useHook) {
2229      return Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])(Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({}, options), useHook(options, htmlProps));
2230    }
2231  
2232    return options;
2233  }
2234  
2235  
2236  
2237  // EXTERNAL MODULE: ./node_modules/reakit-utils/es/shallowEqual.js
2238  var shallowEqual = __webpack_require__(69);
2239  
2240  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/toArray.js
2241  /**
2242   * Transforms `arg` into an array if it's not already.
2243   *
2244   * @example
2245   * import { toArray } from "reakit-utils";
2246   *
2247   * toArray("a"); // ["a"]
2248   * toArray(["a"]); // ["a"]
2249   */
2250  function toArray(arg) {
2251    if (Array.isArray(arg)) {
2252      return arg;
2253    }
2254  
2255    return typeof arg !== "undefined" ? [arg] : [];
2256  }
2257  
2258  
2259  
2260  // CONCATENATED MODULE: ./node_modules/reakit-system/es/createHook.js
2261  
2262  
2263  
2264  
2265  
2266  
2267  
2268  
2269  
2270  /**
2271   * Creates a React custom hook that will return component props.
2272   *
2273   * @example
2274   * import { createHook } from "reakit-system";
2275   *
2276   * const useA = createHook({
2277   *   name: "A",
2278   *   keys: ["url"], // custom props/options keys
2279   *   useProps(options, htmlProps) {
2280   *     return {
2281   *       ...htmlProps,
2282   *       href: options.url,
2283   *     };
2284   *   },
2285   * });
2286   *
2287   * function A({ url, ...htmlProps }) {
2288   *   const props = useA({ url }, htmlProps);
2289   *   return <a {...props} />;
2290   * }
2291   *
2292   * @param options
2293   */
2294  function createHook(options) {
2295    var _options$useState, _composedHooks$;
2296  
2297    var composedHooks = toArray(options.compose);
2298  
2299    var __useOptions = function __useOptions(hookOptions, htmlProps) {
2300      // Call the current hook's useOptions first
2301      if (options.useOptions) {
2302        hookOptions = options.useOptions(hookOptions, htmlProps);
2303      } // If there's name, call useOptions from the system context
2304  
2305  
2306      if (options.name) {
2307        hookOptions = useOptions(options.name, hookOptions, htmlProps);
2308      } // Run composed hooks useOptions
2309  
2310  
2311      if (options.compose) {
2312        for (var _iterator = Object(_rollupPluginBabelHelpers_0c84a174["c" /* b */])(composedHooks), _step; !(_step = _iterator()).done;) {
2313          var hook = _step.value;
2314          hookOptions = hook.__useOptions(hookOptions, htmlProps);
2315        }
2316      }
2317  
2318      return hookOptions;
2319    };
2320  
2321    var useHook = function useHook(hookOptions, htmlProps, unstable_ignoreUseOptions) {
2322      if (hookOptions === void 0) {
2323        hookOptions = {};
2324      }
2325  
2326      if (htmlProps === void 0) {
2327        htmlProps = {};
2328      }
2329  
2330      if (unstable_ignoreUseOptions === void 0) {
2331        unstable_ignoreUseOptions = false;
2332      }
2333  
2334      // This won't execute when useHook was called from within another useHook
2335      if (!unstable_ignoreUseOptions) {
2336        hookOptions = __useOptions(hookOptions, htmlProps);
2337      } // Call the current hook's useProps
2338  
2339  
2340      if (options.useProps) {
2341        htmlProps = options.useProps(hookOptions, htmlProps);
2342      } // If there's name, call useProps from the system context
2343  
2344  
2345      if (options.name) {
2346        htmlProps = useProps(options.name, hookOptions, htmlProps);
2347      }
2348  
2349      if (options.compose) {
2350        if (options.useComposeOptions) {
2351          hookOptions = options.useComposeOptions(hookOptions, htmlProps);
2352        }
2353  
2354        if (options.useComposeProps) {
2355          htmlProps = options.useComposeProps(hookOptions, htmlProps);
2356        } else {
2357          for (var _iterator2 = Object(_rollupPluginBabelHelpers_0c84a174["c" /* b */])(composedHooks), _step2; !(_step2 = _iterator2()).done;) {
2358            var hook = _step2.value;
2359            htmlProps = hook(hookOptions, htmlProps, true);
2360          }
2361        }
2362      } // Remove undefined values from htmlProps
2363  
2364  
2365      var finalHTMLProps = {};
2366      var definedHTMLProps = htmlProps || {};
2367  
2368      for (var prop in definedHTMLProps) {
2369        if (definedHTMLProps[prop] !== undefined) {
2370          finalHTMLProps[prop] = definedHTMLProps[prop];
2371        }
2372      }
2373  
2374      return finalHTMLProps;
2375    };
2376  
2377    useHook.__useOptions = __useOptions;
2378    var composedKeys = composedHooks.reduce(function (keys, hook) {
2379      keys.push.apply(keys, hook.__keys || []);
2380      return keys;
2381    }, []); // It's used by createComponent to split option props (keys) and html props
2382  
2383    useHook.__keys = [].concat(composedKeys, ((_options$useState = options.useState) === null || _options$useState === void 0 ? void 0 : _options$useState.__keys) || [], options.keys || []);
2384    useHook.unstable_propsAreEqual = options.propsAreEqual || ((_composedHooks$ = composedHooks[0]) === null || _composedHooks$ === void 0 ? void 0 : _composedHooks$.unstable_propsAreEqual) || shallowEqual["a" /* shallowEqual */];
2385  
2386    if (false) {}
2387  
2388    return useHook;
2389  }
2390  
2391  
2392  
2393  
2394  /***/ }),
2395  /* 61 */
2396  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2397  
2398  "use strict";
2399  
2400  // EXPORTS
2401  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ createComponent; });
2402  
2403  // EXTERNAL MODULE: external "React"
2404  var external_React_ = __webpack_require__(14);
2405  
2406  // EXTERNAL MODULE: ./node_modules/reakit-system/es/_rollupPluginBabelHelpers-0c84a174.js
2407  var _rollupPluginBabelHelpers_0c84a174 = __webpack_require__(78);
2408  
2409  // EXTERNAL MODULE: ./node_modules/reakit-system/es/useCreateElement.js
2410  var useCreateElement = __webpack_require__(117);
2411  
2412  // EXTERNAL MODULE: ./node_modules/reakit-utils/es/_rollupPluginBabelHelpers-1f0bf8c2.js
2413  var _rollupPluginBabelHelpers_1f0bf8c2 = __webpack_require__(85);
2414  
2415  // EXTERNAL MODULE: ./node_modules/reakit-utils/es/isObject.js
2416  var isObject = __webpack_require__(123);
2417  
2418  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/isPlainObject.js
2419  
2420  
2421  /**
2422   * Checks whether `arg` is a plain object or not.
2423   *
2424   * @returns {boolean}
2425   */
2426  
2427  function isPlainObject(arg) {
2428    var _proto$constructor;
2429  
2430    if (!Object(isObject["a" /* isObject */])(arg)) return false;
2431    var proto = Object.getPrototypeOf(arg);
2432    if (proto == null) return true;
2433    return ((_proto$constructor = proto.constructor) === null || _proto$constructor === void 0 ? void 0 : _proto$constructor.toString()) === Object.toString();
2434  }
2435  
2436  
2437  
2438  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/splitProps.js
2439  
2440  
2441  
2442  
2443  /**
2444   * Splits an object (`props`) into a tuple where the first item is an object
2445   * with the passed `keys`, and the second item is an object with these keys
2446   * omitted.
2447   *
2448   * @deprecated will be removed in version 2
2449   *
2450   * @example
2451   * import { splitProps } from "reakit-utils";
2452   *
2453   * splitProps({ a: "a", b: "b" }, ["a"]); // [{ a: "a" }, { b: "b" }]
2454   */
2455  
2456  function __deprecatedSplitProps(props, keys) {
2457    var propsKeys = Object.keys(props);
2458    var picked = {};
2459    var omitted = {};
2460  
2461    for (var _i = 0, _propsKeys = propsKeys; _i < _propsKeys.length; _i++) {
2462      var key = _propsKeys[_i];
2463  
2464      if (keys.indexOf(key) >= 0) {
2465        picked[key] = props[key];
2466      } else {
2467        omitted[key] = props[key];
2468      }
2469    }
2470  
2471    return [picked, omitted];
2472  }
2473  /**
2474   * Splits an object (`props`) into a tuple where the first item
2475   * is the `state` property, and the second item is the rest of the properties.
2476   *
2477   * It is also backward compatible with version 1. If `keys` are passed then
2478   * splits an object (`props`) into a tuple where the first item is an object
2479   * with the passed `keys`, and the second item is an object with these keys
2480   * omitted.
2481   *
2482   * @example
2483   * import { splitProps } from "reakit-utils";
2484   *
2485   * splitProps({ a: "a", b: "b" }, ["a"]); // [{ a: "a" }, { b: "b" }]
2486   *
2487   * @example
2488   * import { splitProps } from "reakit-utils";
2489   *
2490   * splitProps({ state: { a: "a" }, b: "b" }); // [{ a: "a" }, { b: "b" }]
2491   */
2492  
2493  
2494  function splitProps(props, keys) {
2495    if (keys === void 0) {
2496      keys = [];
2497    }
2498  
2499    if (!isPlainObject(props.state)) {
2500      return __deprecatedSplitProps(props, keys);
2501    }
2502  
2503    var _deprecatedSplitProp = __deprecatedSplitProps(props, [].concat(keys, ["state"])),
2504        picked = _deprecatedSplitProp[0],
2505        omitted = _deprecatedSplitProp[1];
2506  
2507    var state = picked.state,
2508        restPicked = Object(_rollupPluginBabelHelpers_1f0bf8c2["a" /* _ */])(picked, ["state"]);
2509  
2510    return [Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])({}, state), restPicked), omitted];
2511  }
2512  
2513  
2514  
2515  // EXTERNAL MODULE: ./node_modules/reakit-utils/es/shallowEqual.js
2516  var shallowEqual = __webpack_require__(69);
2517  
2518  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/normalizePropsAreEqual.js
2519  
2520  
2521  
2522  
2523  /**
2524   * This higher order functions take `propsAreEqual` function and
2525   * returns a new function which normalizes the props.
2526   *
2527   * Normalizing in our case is making sure the `propsAreEqual` works with
2528   * both version 1 (object spreading) and version 2 (state object) state passing.
2529   *
2530   * To achieve this, the returned function in case of a state object
2531   * will spread the state object in both `prev` and `next props.
2532   *
2533   * Other case it just returns the function as is which makes sure
2534   * that we are still backward compatible
2535   */
2536  function normalizePropsAreEqual(propsAreEqual) {
2537    if (propsAreEqual.name === "normalizePropsAreEqualInner") {
2538      return propsAreEqual;
2539    }
2540  
2541    return function normalizePropsAreEqualInner(prev, next) {
2542      if (!isPlainObject(prev.state) || !isPlainObject(next.state)) {
2543        return propsAreEqual(prev, next);
2544      }
2545  
2546      return propsAreEqual(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])({}, prev.state), prev), Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])({}, next.state), next));
2547    };
2548  }
2549  
2550  
2551  
2552  // CONCATENATED MODULE: ./node_modules/reakit-system/es/createComponent.js
2553  
2554  
2555  
2556  
2557  
2558  
2559  
2560  
2561  function forwardRef(component) {
2562    return /*#__PURE__*/Object(external_React_["forwardRef"])(component);
2563  }
2564  
2565  function memo(component, propsAreEqual) {
2566    return /*#__PURE__*/Object(external_React_["memo"])(component, propsAreEqual);
2567  }
2568  
2569  /**
2570   * Creates a React component.
2571   *
2572   * @example
2573   * import { createComponent } from "reakit-system";
2574   *
2575   * const A = createComponent({ as: "a" });
2576   *
2577   * @param options
2578   */
2579  function createComponent(_ref) {
2580    var type = _ref.as,
2581        useHook = _ref.useHook,
2582        shouldMemo = _ref.memo,
2583        _ref$propsAreEqual = _ref.propsAreEqual,
2584        propsAreEqual = _ref$propsAreEqual === void 0 ? useHook === null || useHook === void 0 ? void 0 : useHook.unstable_propsAreEqual : _ref$propsAreEqual,
2585        _ref$keys = _ref.keys,
2586        keys = _ref$keys === void 0 ? (useHook === null || useHook === void 0 ? void 0 : useHook.__keys) || [] : _ref$keys,
2587        _ref$useCreateElement = _ref.useCreateElement,
2588        useCreateElement$1 = _ref$useCreateElement === void 0 ? useCreateElement["a" /* useCreateElement */] : _ref$useCreateElement;
2589  
2590    var Comp = function Comp(_ref2, ref) {
2591      var _ref2$as = _ref2.as,
2592          as = _ref2$as === void 0 ? type : _ref2$as,
2593          props = Object(_rollupPluginBabelHelpers_0c84a174["b" /* a */])(_ref2, ["as"]);
2594  
2595      if (useHook) {
2596        var _as$render;
2597  
2598        var _splitProps = splitProps(props, keys),
2599            _options = _splitProps[0],
2600            htmlProps = _splitProps[1];
2601  
2602        var _useHook = useHook(_options, Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({
2603          ref: ref
2604        }, htmlProps)),
2605            wrapElement = _useHook.wrapElement,
2606            elementProps = Object(_rollupPluginBabelHelpers_0c84a174["b" /* a */])(_useHook, ["wrapElement"]); // @ts-ignore
2607  
2608  
2609        var asKeys = ((_as$render = as.render) === null || _as$render === void 0 ? void 0 : _as$render.__keys) || as.__keys;
2610        var asOptions = asKeys && splitProps(props, asKeys)[0];
2611        var allProps = asOptions ? Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])(Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({}, elementProps), asOptions) : elementProps;
2612  
2613        var _element = useCreateElement$1(as, allProps);
2614  
2615        if (wrapElement) {
2616          return wrapElement(_element);
2617        }
2618  
2619        return _element;
2620      }
2621  
2622      return useCreateElement$1(as, Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({
2623        ref: ref
2624      }, props));
2625    };
2626  
2627    if (false) {}
2628  
2629    Comp = forwardRef(Comp);
2630  
2631    if (shouldMemo) {
2632      Comp = memo(Comp, propsAreEqual && normalizePropsAreEqual(propsAreEqual));
2633    }
2634  
2635    Comp.__keys = keys;
2636    Comp.unstable_propsAreEqual = normalizePropsAreEqual(propsAreEqual || shallowEqual["a" /* shallowEqual */]);
2637    return Comp;
2638  }
2639  
2640  
2641  
2642  
2643  /***/ }),
2644  /* 62 */
2645  /***/ (function(module, exports, __webpack_require__) {
2646  
2647  var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.2
2648  // https://github.com/bgrins/TinyColor
2649  // Brian Grinstead, MIT License
2650  
2651  (function(Math) {
2652  
2653  var trimLeft = /^\s+/,
2654      trimRight = /\s+$/,
2655      tinyCounter = 0,
2656      mathRound = Math.round,
2657      mathMin = Math.min,
2658      mathMax = Math.max,
2659      mathRandom = Math.random;
2660  
2661  function tinycolor (color, opts) {
2662  
2663      color = (color) ? color : '';
2664      opts = opts || { };
2665  
2666      // If input is already a tinycolor, return itself
2667      if (color instanceof tinycolor) {
2668         return color;
2669      }
2670      // If we are called as a function, call using new instead
2671      if (!(this instanceof tinycolor)) {
2672          return new tinycolor(color, opts);
2673      }
2674  
2675      var rgb = inputToRGB(color);
2676      this._originalInput = color,
2677      this._r = rgb.r,
2678      this._g = rgb.g,
2679      this._b = rgb.b,
2680      this._a = rgb.a,
2681      this._roundA = mathRound(100*this._a) / 100,
2682      this._format = opts.format || rgb.format;
2683      this._gradientType = opts.gradientType;
2684  
2685      // Don't let the range of [0,255] come back in [0,1].
2686      // Potentially lose a little bit of precision here, but will fix issues where
2687      // .5 gets interpreted as half of the total, instead of half of 1
2688      // If it was supposed to be 128, this was already taken care of by `inputToRgb`
2689      if (this._r < 1) { this._r = mathRound(this._r); }
2690      if (this._g < 1) { this._g = mathRound(this._g); }
2691      if (this._b < 1) { this._b = mathRound(this._b); }
2692  
2693      this._ok = rgb.ok;
2694      this._tc_id = tinyCounter++;
2695  }
2696  
2697  tinycolor.prototype = {
2698      isDark: function() {
2699          return this.getBrightness() < 128;
2700      },
2701      isLight: function() {
2702          return !this.isDark();
2703      },
2704      isValid: function() {
2705          return this._ok;
2706      },
2707      getOriginalInput: function() {
2708        return this._originalInput;
2709      },
2710      getFormat: function() {
2711          return this._format;
2712      },
2713      getAlpha: function() {
2714          return this._a;
2715      },
2716      getBrightness: function() {
2717          //http://www.w3.org/TR/AERT#color-contrast
2718          var rgb = this.toRgb();
2719          return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
2720      },
2721      getLuminance: function() {
2722          //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
2723          var rgb = this.toRgb();
2724          var RsRGB, GsRGB, BsRGB, R, G, B;
2725          RsRGB = rgb.r/255;
2726          GsRGB = rgb.g/255;
2727          BsRGB = rgb.b/255;
2728  
2729          if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}
2730          if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}
2731          if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}
2732          return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
2733      },
2734      setAlpha: function(value) {
2735          this._a = boundAlpha(value);
2736          this._roundA = mathRound(100*this._a) / 100;
2737          return this;
2738      },
2739      toHsv: function() {
2740          var hsv = rgbToHsv(this._r, this._g, this._b);
2741          return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
2742      },
2743      toHsvString: function() {
2744          var hsv = rgbToHsv(this._r, this._g, this._b);
2745          var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
2746          return (this._a == 1) ?
2747            "hsv("  + h + ", " + s + "%, " + v + "%)" :
2748            "hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")";
2749      },
2750      toHsl: function() {
2751          var hsl = rgbToHsl(this._r, this._g, this._b);
2752          return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
2753      },
2754      toHslString: function() {
2755          var hsl = rgbToHsl(this._r, this._g, this._b);
2756          var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
2757          return (this._a == 1) ?
2758            "hsl("  + h + ", " + s + "%, " + l + "%)" :
2759            "hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")";
2760      },
2761      toHex: function(allow3Char) {
2762          return rgbToHex(this._r, this._g, this._b, allow3Char);
2763      },
2764      toHexString: function(allow3Char) {
2765          return '#' + this.toHex(allow3Char);
2766      },
2767      toHex8: function(allow4Char) {
2768          return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
2769      },
2770      toHex8String: function(allow4Char) {
2771          return '#' + this.toHex8(allow4Char);
2772      },
2773      toRgb: function() {
2774          return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
2775      },
2776      toRgbString: function() {
2777          return (this._a == 1) ?
2778            "rgb("  + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" :
2779            "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
2780      },
2781      toPercentageRgb: function() {
2782          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 };
2783      },
2784      toPercentageRgbString: function() {
2785          return (this._a == 1) ?
2786            "rgb("  + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" :
2787            "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
2788      },
2789      toName: function() {
2790          if (this._a === 0) {
2791              return "transparent";
2792          }
2793  
2794          if (this._a < 1) {
2795              return false;
2796          }
2797  
2798          return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
2799      },
2800      toFilter: function(secondColor) {
2801          var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);
2802          var secondHex8String = hex8String;
2803          var gradientType = this._gradientType ? "GradientType = 1, " : "";
2804  
2805          if (secondColor) {
2806              var s = tinycolor(secondColor);
2807              secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);
2808          }
2809  
2810          return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")";
2811      },
2812      toString: function(format) {
2813          var formatSet = !!format;
2814          format = format || this._format;
2815  
2816          var formattedString = false;
2817          var hasAlpha = this._a < 1 && this._a >= 0;
2818          var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
2819  
2820          if (needsAlphaFormat) {
2821              // Special case for "transparent", all other non-alpha formats
2822              // will return rgba when there is transparency.
2823              if (format === "name" && this._a === 0) {
2824                  return this.toName();
2825              }
2826              return this.toRgbString();
2827          }
2828          if (format === "rgb") {
2829              formattedString = this.toRgbString();
2830          }
2831          if (format === "prgb") {
2832              formattedString = this.toPercentageRgbString();
2833          }
2834          if (format === "hex" || format === "hex6") {
2835              formattedString = this.toHexString();
2836          }
2837          if (format === "hex3") {
2838              formattedString = this.toHexString(true);
2839          }
2840          if (format === "hex4") {
2841              formattedString = this.toHex8String(true);
2842          }
2843          if (format === "hex8") {
2844              formattedString = this.toHex8String();
2845          }
2846          if (format === "name") {
2847              formattedString = this.toName();
2848          }
2849          if (format === "hsl") {
2850              formattedString = this.toHslString();
2851          }
2852          if (format === "hsv") {
2853              formattedString = this.toHsvString();
2854          }
2855  
2856          return formattedString || this.toHexString();
2857      },
2858      clone: function() {
2859          return tinycolor(this.toString());
2860      },
2861  
2862      _applyModification: function(fn, args) {
2863          var color = fn.apply(null, [this].concat([].slice.call(args)));
2864          this._r = color._r;
2865          this._g = color._g;
2866          this._b = color._b;
2867          this.setAlpha(color._a);
2868          return this;
2869      },
2870      lighten: function() {
2871          return this._applyModification(lighten, arguments);
2872      },
2873      brighten: function() {
2874          return this._applyModification(brighten, arguments);
2875      },
2876      darken: function() {
2877          return this._applyModification(darken, arguments);
2878      },
2879      desaturate: function() {
2880          return this._applyModification(desaturate, arguments);
2881      },
2882      saturate: function() {
2883          return this._applyModification(saturate, arguments);
2884      },
2885      greyscale: function() {
2886          return this._applyModification(greyscale, arguments);
2887      },
2888      spin: function() {
2889          return this._applyModification(spin, arguments);
2890      },
2891  
2892      _applyCombination: function(fn, args) {
2893          return fn.apply(null, [this].concat([].slice.call(args)));
2894      },
2895      analogous: function() {
2896          return this._applyCombination(analogous, arguments);
2897      },
2898      complement: function() {
2899          return this._applyCombination(complement, arguments);
2900      },
2901      monochromatic: function() {
2902          return this._applyCombination(monochromatic, arguments);
2903      },
2904      splitcomplement: function() {
2905          return this._applyCombination(splitcomplement, arguments);
2906      },
2907      triad: function() {
2908          return this._applyCombination(triad, arguments);
2909      },
2910      tetrad: function() {
2911          return this._applyCombination(tetrad, arguments);
2912      }
2913  };
2914  
2915  // If input is an object, force 1 into "1.0" to handle ratios properly
2916  // String input requires "1.0" as input, so 1 will be treated as 1
2917  tinycolor.fromRatio = function(color, opts) {
2918      if (typeof color == "object") {
2919          var newColor = {};
2920          for (var i in color) {
2921              if (color.hasOwnProperty(i)) {
2922                  if (i === "a") {
2923                      newColor[i] = color[i];
2924                  }
2925                  else {
2926                      newColor[i] = convertToPercentage(color[i]);
2927                  }
2928              }
2929          }
2930          color = newColor;
2931      }
2932  
2933      return tinycolor(color, opts);
2934  };
2935  
2936  // Given a string or object, convert that input to RGB
2937  // Possible string inputs:
2938  //
2939  //     "red"
2940  //     "#f00" or "f00"
2941  //     "#ff0000" or "ff0000"
2942  //     "#ff000000" or "ff000000"
2943  //     "rgb 255 0 0" or "rgb (255, 0, 0)"
2944  //     "rgb 1.0 0 0" or "rgb (1, 0, 0)"
2945  //     "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
2946  //     "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
2947  //     "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
2948  //     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
2949  //     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
2950  //
2951  function inputToRGB(color) {
2952  
2953      var rgb = { r: 0, g: 0, b: 0 };
2954      var a = 1;
2955      var s = null;
2956      var v = null;
2957      var l = null;
2958      var ok = false;
2959      var format = false;
2960  
2961      if (typeof color == "string") {
2962          color = stringInputToObject(color);
2963      }
2964  
2965      if (typeof color == "object") {
2966          if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
2967              rgb = rgbToRgb(color.r, color.g, color.b);
2968              ok = true;
2969              format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
2970          }
2971          else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
2972              s = convertToPercentage(color.s);
2973              v = convertToPercentage(color.v);
2974              rgb = hsvToRgb(color.h, s, v);
2975              ok = true;
2976              format = "hsv";
2977          }
2978          else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
2979              s = convertToPercentage(color.s);
2980              l = convertToPercentage(color.l);
2981              rgb = hslToRgb(color.h, s, l);
2982              ok = true;
2983              format = "hsl";
2984          }
2985  
2986          if (color.hasOwnProperty("a")) {
2987              a = color.a;
2988          }
2989      }
2990  
2991      a = boundAlpha(a);
2992  
2993      return {
2994          ok: ok,
2995          format: color.format || format,
2996          r: mathMin(255, mathMax(rgb.r, 0)),
2997          g: mathMin(255, mathMax(rgb.g, 0)),
2998          b: mathMin(255, mathMax(rgb.b, 0)),
2999          a: a
3000      };
3001  }
3002  
3003  
3004  // Conversion Functions
3005  // --------------------
3006  
3007  // `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
3008  // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
3009  
3010  // `rgbToRgb`
3011  // Handle bounds / percentage checking to conform to CSS color spec
3012  // <http://www.w3.org/TR/css3-color/>
3013  // *Assumes:* r, g, b in [0, 255] or [0, 1]
3014  // *Returns:* { r, g, b } in [0, 255]
3015  function rgbToRgb(r, g, b){
3016      return {
3017          r: bound01(r, 255) * 255,
3018          g: bound01(g, 255) * 255,
3019          b: bound01(b, 255) * 255
3020      };
3021  }
3022  
3023  // `rgbToHsl`
3024  // Converts an RGB color value to HSL.
3025  // *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
3026  // *Returns:* { h, s, l } in [0,1]
3027  function rgbToHsl(r, g, b) {
3028  
3029      r = bound01(r, 255);
3030      g = bound01(g, 255);
3031      b = bound01(b, 255);
3032  
3033      var max = mathMax(r, g, b), min = mathMin(r, g, b);
3034      var h, s, l = (max + min) / 2;
3035  
3036      if(max == min) {
3037          h = s = 0; // achromatic
3038      }
3039      else {
3040          var d = max - min;
3041          s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
3042          switch(max) {
3043              case r: h = (g - b) / d + (g < b ? 6 : 0); break;
3044              case g: h = (b - r) / d + 2; break;
3045              case b: h = (r - g) / d + 4; break;
3046          }
3047  
3048          h /= 6;
3049      }
3050  
3051      return { h: h, s: s, l: l };
3052  }
3053  
3054  // `hslToRgb`
3055  // Converts an HSL color value to RGB.
3056  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
3057  // *Returns:* { r, g, b } in the set [0, 255]
3058  function hslToRgb(h, s, l) {
3059      var r, g, b;
3060  
3061      h = bound01(h, 360);
3062      s = bound01(s, 100);
3063      l = bound01(l, 100);
3064  
3065      function hue2rgb(p, q, t) {
3066          if(t < 0) t += 1;
3067          if(t > 1) t -= 1;
3068          if(t < 1/6) return p + (q - p) * 6 * t;
3069          if(t < 1/2) return q;
3070          if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
3071          return p;
3072      }
3073  
3074      if(s === 0) {
3075          r = g = b = l; // achromatic
3076      }
3077      else {
3078          var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
3079          var p = 2 * l - q;
3080          r = hue2rgb(p, q, h + 1/3);
3081          g = hue2rgb(p, q, h);
3082          b = hue2rgb(p, q, h - 1/3);
3083      }
3084  
3085      return { r: r * 255, g: g * 255, b: b * 255 };
3086  }
3087  
3088  // `rgbToHsv`
3089  // Converts an RGB color value to HSV
3090  // *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
3091  // *Returns:* { h, s, v } in [0,1]
3092  function rgbToHsv(r, g, b) {
3093  
3094      r = bound01(r, 255);
3095      g = bound01(g, 255);
3096      b = bound01(b, 255);
3097  
3098      var max = mathMax(r, g, b), min = mathMin(r, g, b);
3099      var h, s, v = max;
3100  
3101      var d = max - min;
3102      s = max === 0 ? 0 : d / max;
3103  
3104      if(max == min) {
3105          h = 0; // achromatic
3106      }
3107      else {
3108          switch(max) {
3109              case r: h = (g - b) / d + (g < b ? 6 : 0); break;
3110              case g: h = (b - r) / d + 2; break;
3111              case b: h = (r - g) / d + 4; break;
3112          }
3113          h /= 6;
3114      }
3115      return { h: h, s: s, v: v };
3116  }
3117  
3118  // `hsvToRgb`
3119  // Converts an HSV color value to RGB.
3120  // *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
3121  // *Returns:* { r, g, b } in the set [0, 255]
3122   function hsvToRgb(h, s, v) {
3123  
3124      h = bound01(h, 360) * 6;
3125      s = bound01(s, 100);
3126      v = bound01(v, 100);
3127  
3128      var i = Math.floor(h),
3129          f = h - i,
3130          p = v * (1 - s),
3131          q = v * (1 - f * s),
3132          t = v * (1 - (1 - f) * s),
3133          mod = i % 6,
3134          r = [v, q, p, p, t, v][mod],
3135          g = [t, v, v, q, p, p][mod],
3136          b = [p, p, t, v, v, q][mod];
3137  
3138      return { r: r * 255, g: g * 255, b: b * 255 };
3139  }
3140  
3141  // `rgbToHex`
3142  // Converts an RGB color to hex
3143  // Assumes r, g, and b are contained in the set [0, 255]
3144  // Returns a 3 or 6 character hex
3145  function rgbToHex(r, g, b, allow3Char) {
3146  
3147      var hex = [
3148          pad2(mathRound(r).toString(16)),
3149          pad2(mathRound(g).toString(16)),
3150          pad2(mathRound(b).toString(16))
3151      ];
3152  
3153      // Return a 3 character hex if possible
3154      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)) {
3155          return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
3156      }
3157  
3158      return hex.join("");
3159  }
3160  
3161  // `rgbaToHex`
3162  // Converts an RGBA color plus alpha transparency to hex
3163  // Assumes r, g, b are contained in the set [0, 255] and
3164  // a in [0, 1]. Returns a 4 or 8 character rgba hex
3165  function rgbaToHex(r, g, b, a, allow4Char) {
3166  
3167      var hex = [
3168          pad2(mathRound(r).toString(16)),
3169          pad2(mathRound(g).toString(16)),
3170          pad2(mathRound(b).toString(16)),
3171          pad2(convertDecimalToHex(a))
3172      ];
3173  
3174      // Return a 4 character hex if possible
3175      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)) {
3176          return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
3177      }
3178  
3179      return hex.join("");
3180  }
3181  
3182  // `rgbaToArgbHex`
3183  // Converts an RGBA color to an ARGB Hex8 string
3184  // Rarely used, but required for "toFilter()"
3185  function rgbaToArgbHex(r, g, b, a) {
3186  
3187      var hex = [
3188          pad2(convertDecimalToHex(a)),
3189          pad2(mathRound(r).toString(16)),
3190          pad2(mathRound(g).toString(16)),
3191          pad2(mathRound(b).toString(16))
3192      ];
3193  
3194      return hex.join("");
3195  }
3196  
3197  // `equals`
3198  // Can be called with any tinycolor input
3199  tinycolor.equals = function (color1, color2) {
3200      if (!color1 || !color2) { return false; }
3201      return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
3202  };
3203  
3204  tinycolor.random = function() {
3205      return tinycolor.fromRatio({
3206          r: mathRandom(),
3207          g: mathRandom(),
3208          b: mathRandom()
3209      });
3210  };
3211  
3212  
3213  // Modification Functions
3214  // ----------------------
3215  // Thanks to less.js for some of the basics here
3216  // <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
3217  
3218  function desaturate(color, amount) {
3219      amount = (amount === 0) ? 0 : (amount || 10);
3220      var hsl = tinycolor(color).toHsl();
3221      hsl.s -= amount / 100;
3222      hsl.s = clamp01(hsl.s);
3223      return tinycolor(hsl);
3224  }
3225  
3226  function saturate(color, amount) {
3227      amount = (amount === 0) ? 0 : (amount || 10);
3228      var hsl = tinycolor(color).toHsl();
3229      hsl.s += amount / 100;
3230      hsl.s = clamp01(hsl.s);
3231      return tinycolor(hsl);
3232  }
3233  
3234  function greyscale(color) {
3235      return tinycolor(color).desaturate(100);
3236  }
3237  
3238  function lighten (color, amount) {
3239      amount = (amount === 0) ? 0 : (amount || 10);
3240      var hsl = tinycolor(color).toHsl();
3241      hsl.l += amount / 100;
3242      hsl.l = clamp01(hsl.l);
3243      return tinycolor(hsl);
3244  }
3245  
3246  function brighten(color, amount) {
3247      amount = (amount === 0) ? 0 : (amount || 10);
3248      var rgb = tinycolor(color).toRgb();
3249      rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));
3250      rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));
3251      rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));
3252      return tinycolor(rgb);
3253  }
3254  
3255  function darken (color, amount) {
3256      amount = (amount === 0) ? 0 : (amount || 10);
3257      var hsl = tinycolor(color).toHsl();
3258      hsl.l -= amount / 100;
3259      hsl.l = clamp01(hsl.l);
3260      return tinycolor(hsl);
3261  }
3262  
3263  // Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
3264  // Values outside of this range will be wrapped into this range.
3265  function spin(color, amount) {
3266      var hsl = tinycolor(color).toHsl();
3267      var hue = (hsl.h + amount) % 360;
3268      hsl.h = hue < 0 ? 360 + hue : hue;
3269      return tinycolor(hsl);
3270  }
3271  
3272  // Combination Functions
3273  // ---------------------
3274  // Thanks to jQuery xColor for some of the ideas behind these
3275  // <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
3276  
3277  function complement(color) {
3278      var hsl = tinycolor(color).toHsl();
3279      hsl.h = (hsl.h + 180) % 360;
3280      return tinycolor(hsl);
3281  }
3282  
3283  function triad(color) {
3284      var hsl = tinycolor(color).toHsl();
3285      var h = hsl.h;
3286      return [
3287          tinycolor(color),
3288          tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
3289          tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })
3290      ];
3291  }
3292  
3293  function tetrad(color) {
3294      var hsl = tinycolor(color).toHsl();
3295      var h = hsl.h;
3296      return [
3297          tinycolor(color),
3298          tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
3299          tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
3300          tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })
3301      ];
3302  }
3303  
3304  function splitcomplement(color) {
3305      var hsl = tinycolor(color).toHsl();
3306      var h = hsl.h;
3307      return [
3308          tinycolor(color),
3309          tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),
3310          tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})
3311      ];
3312  }
3313  
3314  function analogous(color, results, slices) {
3315      results = results || 6;
3316      slices = slices || 30;
3317  
3318      var hsl = tinycolor(color).toHsl();
3319      var part = 360 / slices;
3320      var ret = [tinycolor(color)];
3321  
3322      for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
3323          hsl.h = (hsl.h + part) % 360;
3324          ret.push(tinycolor(hsl));
3325      }
3326      return ret;
3327  }
3328  
3329  function monochromatic(color, results) {
3330      results = results || 6;
3331      var hsv = tinycolor(color).toHsv();
3332      var h = hsv.h, s = hsv.s, v = hsv.v;
3333      var ret = [];
3334      var modification = 1 / results;
3335  
3336      while (results--) {
3337          ret.push(tinycolor({ h: h, s: s, v: v}));
3338          v = (v + modification) % 1;
3339      }
3340  
3341      return ret;
3342  }
3343  
3344  // Utility Functions
3345  // ---------------------
3346  
3347  tinycolor.mix = function(color1, color2, amount) {
3348      amount = (amount === 0) ? 0 : (amount || 50);
3349  
3350      var rgb1 = tinycolor(color1).toRgb();
3351      var rgb2 = tinycolor(color2).toRgb();
3352  
3353      var p = amount / 100;
3354  
3355      var rgba = {
3356          r: ((rgb2.r - rgb1.r) * p) + rgb1.r,
3357          g: ((rgb2.g - rgb1.g) * p) + rgb1.g,
3358          b: ((rgb2.b - rgb1.b) * p) + rgb1.b,
3359          a: ((rgb2.a - rgb1.a) * p) + rgb1.a
3360      };
3361  
3362      return tinycolor(rgba);
3363  };
3364  
3365  
3366  // Readability Functions
3367  // ---------------------
3368  // <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
3369  
3370  // `contrast`
3371  // Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
3372  tinycolor.readability = function(color1, color2) {
3373      var c1 = tinycolor(color1);
3374      var c2 = tinycolor(color2);
3375      return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);
3376  };
3377  
3378  // `isReadable`
3379  // Ensure that foreground and background color combinations meet WCAG2 guidelines.
3380  // The third argument is an optional Object.
3381  //      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
3382  //      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
3383  // If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
3384  
3385  // *Example*
3386  //    tinycolor.isReadable("#000", "#111") => false
3387  //    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
3388  tinycolor.isReadable = function(color1, color2, wcag2) {
3389      var readability = tinycolor.readability(color1, color2);
3390      var wcag2Parms, out;
3391  
3392      out = false;
3393  
3394      wcag2Parms = validateWCAG2Parms(wcag2);
3395      switch (wcag2Parms.level + wcag2Parms.size) {
3396          case "AAsmall":
3397          case "AAAlarge":
3398              out = readability >= 4.5;
3399              break;
3400          case "AAlarge":
3401              out = readability >= 3;
3402              break;
3403          case "AAAsmall":
3404              out = readability >= 7;
3405              break;
3406      }
3407      return out;
3408  
3409  };
3410  
3411  // `mostReadable`
3412  // Given a base color and a list of possible foreground or background
3413  // colors for that base, returns the most readable color.
3414  // Optionally returns Black or White if the most readable color is unreadable.
3415  // *Example*
3416  //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255"
3417  //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
3418  //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
3419  //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
3420  tinycolor.mostReadable = function(baseColor, colorList, args) {
3421      var bestColor = null;
3422      var bestScore = 0;
3423      var readability;
3424      var includeFallbackColors, level, size ;
3425      args = args || {};
3426      includeFallbackColors = args.includeFallbackColors ;
3427      level = args.level;
3428      size = args.size;
3429  
3430      for (var i= 0; i < colorList.length ; i++) {
3431          readability = tinycolor.readability(baseColor, colorList[i]);
3432          if (readability > bestScore) {
3433              bestScore = readability;
3434              bestColor = tinycolor(colorList[i]);
3435          }
3436      }
3437  
3438      if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) {
3439          return bestColor;
3440      }
3441      else {
3442          args.includeFallbackColors=false;
3443          return tinycolor.mostReadable(baseColor,["#fff", "#000"],args);
3444      }
3445  };
3446  
3447  
3448  // Big List of Colors
3449  // ------------------
3450  // <http://www.w3.org/TR/css3-color/#svg-color>
3451  var names = tinycolor.names = {
3452      aliceblue: "f0f8ff",
3453      antiquewhite: "faebd7",
3454      aqua: "0ff",
3455      aquamarine: "7fffd4",
3456      azure: "f0ffff",
3457      beige: "f5f5dc",
3458      bisque: "ffe4c4",
3459      black: "000",
3460      blanchedalmond: "ffebcd",
3461      blue: "00f",
3462      blueviolet: "8a2be2",
3463      brown: "a52a2a",
3464      burlywood: "deb887",
3465      burntsienna: "ea7e5d",
3466      cadetblue: "5f9ea0",
3467      chartreuse: "7fff00",
3468      chocolate: "d2691e",
3469      coral: "ff7f50",
3470      cornflowerblue: "6495ed",
3471      cornsilk: "fff8dc",
3472      crimson: "dc143c",
3473      cyan: "0ff",
3474      darkblue: "00008b",
3475      darkcyan: "008b8b",
3476      darkgoldenrod: "b8860b",
3477      darkgray: "a9a9a9",
3478      darkgreen: "006400",
3479      darkgrey: "a9a9a9",
3480      darkkhaki: "bdb76b",
3481      darkmagenta: "8b008b",
3482      darkolivegreen: "556b2f",
3483      darkorange: "ff8c00",
3484      darkorchid: "9932cc",
3485      darkred: "8b0000",
3486      darksalmon: "e9967a",
3487      darkseagreen: "8fbc8f",
3488      darkslateblue: "483d8b",
3489      darkslategray: "2f4f4f",
3490      darkslategrey: "2f4f4f",
3491      darkturquoise: "00ced1",
3492      darkviolet: "9400d3",
3493      deeppink: "ff1493",
3494      deepskyblue: "00bfff",
3495      dimgray: "696969",
3496      dimgrey: "696969",
3497      dodgerblue: "1e90ff",
3498      firebrick: "b22222",
3499      floralwhite: "fffaf0",
3500      forestgreen: "228b22",
3501      fuchsia: "f0f",
3502      gainsboro: "dcdcdc",
3503      ghostwhite: "f8f8ff",
3504      gold: "ffd700",
3505      goldenrod: "daa520",
3506      gray: "808080",
3507      green: "008000",
3508      greenyellow: "adff2f",
3509      grey: "808080",
3510      honeydew: "f0fff0",
3511      hotpink: "ff69b4",
3512      indianred: "cd5c5c",
3513      indigo: "4b0082",
3514      ivory: "fffff0",
3515      khaki: "f0e68c",
3516      lavender: "e6e6fa",
3517      lavenderblush: "fff0f5",
3518      lawngreen: "7cfc00",
3519      lemonchiffon: "fffacd",
3520      lightblue: "add8e6",
3521      lightcoral: "f08080",
3522      lightcyan: "e0ffff",
3523      lightgoldenrodyellow: "fafad2",
3524      lightgray: "d3d3d3",
3525      lightgreen: "90ee90",
3526      lightgrey: "d3d3d3",
3527      lightpink: "ffb6c1",
3528      lightsalmon: "ffa07a",
3529      lightseagreen: "20b2aa",
3530      lightskyblue: "87cefa",
3531      lightslategray: "789",
3532      lightslategrey: "789",
3533      lightsteelblue: "b0c4de",
3534      lightyellow: "ffffe0",
3535      lime: "0f0",
3536      limegreen: "32cd32",
3537      linen: "faf0e6",
3538      magenta: "f0f",
3539      maroon: "800000",
3540      mediumaquamarine: "66cdaa",
3541      mediumblue: "0000cd",
3542      mediumorchid: "ba55d3",
3543      mediumpurple: "9370db",
3544      mediumseagreen: "3cb371",
3545      mediumslateblue: "7b68ee",
3546      mediumspringgreen: "00fa9a",
3547      mediumturquoise: "48d1cc",
3548      mediumvioletred: "c71585",
3549      midnightblue: "191970",
3550      mintcream: "f5fffa",
3551      mistyrose: "ffe4e1",
3552      moccasin: "ffe4b5",
3553      navajowhite: "ffdead",
3554      navy: "000080",
3555      oldlace: "fdf5e6",
3556      olive: "808000",
3557      olivedrab: "6b8e23",
3558      orange: "ffa500",
3559      orangered: "ff4500",
3560      orchid: "da70d6",
3561      palegoldenrod: "eee8aa",
3562      palegreen: "98fb98",
3563      paleturquoise: "afeeee",
3564      palevioletred: "db7093",
3565      papayawhip: "ffefd5",
3566      peachpuff: "ffdab9",
3567      peru: "cd853f",
3568      pink: "ffc0cb",
3569      plum: "dda0dd",
3570      powderblue: "b0e0e6",
3571      purple: "800080",
3572      rebeccapurple: "663399",
3573      red: "f00",
3574      rosybrown: "bc8f8f",
3575      royalblue: "4169e1",
3576      saddlebrown: "8b4513",
3577      salmon: "fa8072",
3578      sandybrown: "f4a460",
3579      seagreen: "2e8b57",
3580      seashell: "fff5ee",
3581      sienna: "a0522d",
3582      silver: "c0c0c0",
3583      skyblue: "87ceeb",
3584      slateblue: "6a5acd",
3585      slategray: "708090",
3586      slategrey: "708090",
3587      snow: "fffafa",
3588      springgreen: "00ff7f",
3589      steelblue: "4682b4",
3590      tan: "d2b48c",
3591      teal: "008080",
3592      thistle: "d8bfd8",
3593      tomato: "ff6347",
3594      turquoise: "40e0d0",
3595      violet: "ee82ee",
3596      wheat: "f5deb3",
3597      white: "fff",
3598      whitesmoke: "f5f5f5",
3599      yellow: "ff0",
3600      yellowgreen: "9acd32"
3601  };
3602  
3603  // Make it easy to access colors via `hexNames[hex]`
3604  var hexNames = tinycolor.hexNames = flip(names);
3605  
3606  
3607  // Utilities
3608  // ---------
3609  
3610  // `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
3611  function flip(o) {
3612      var flipped = { };
3613      for (var i in o) {
3614          if (o.hasOwnProperty(i)) {
3615              flipped[o[i]] = i;
3616          }
3617      }
3618      return flipped;
3619  }
3620  
3621  // Return a valid alpha value [0,1] with all invalid values being set to 1
3622  function boundAlpha(a) {
3623      a = parseFloat(a);
3624  
3625      if (isNaN(a) || a < 0 || a > 1) {
3626          a = 1;
3627      }
3628  
3629      return a;
3630  }
3631  
3632  // Take input from [0, n] and return it as [0, 1]
3633  function bound01(n, max) {
3634      if (isOnePointZero(n)) { n = "100%"; }
3635  
3636      var processPercent = isPercentage(n);
3637      n = mathMin(max, mathMax(0, parseFloat(n)));
3638  
3639      // Automatically convert percentage into number
3640      if (processPercent) {
3641          n = parseInt(n * max, 10) / 100;
3642      }
3643  
3644      // Handle floating point rounding errors
3645      if ((Math.abs(n - max) < 0.000001)) {
3646          return 1;
3647      }
3648  
3649      // Convert into [0, 1] range if it isn't already
3650      return (n % max) / parseFloat(max);
3651  }
3652  
3653  // Force a number between 0 and 1
3654  function clamp01(val) {
3655      return mathMin(1, mathMax(0, val));
3656  }
3657  
3658  // Parse a base-16 hex value into a base-10 integer
3659  function parseIntFromHex(val) {
3660      return parseInt(val, 16);
3661  }
3662  
3663  // Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
3664  // <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
3665  function isOnePointZero(n) {
3666      return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
3667  }
3668  
3669  // Check to see if string passed in is a percentage
3670  function isPercentage(n) {
3671      return typeof n === "string" && n.indexOf('%') != -1;
3672  }
3673  
3674  // Force a hex value to have 2 characters
3675  function pad2(c) {
3676      return c.length == 1 ? '0' + c : '' + c;
3677  }
3678  
3679  // Replace a decimal with it's percentage value
3680  function convertToPercentage(n) {
3681      if (n <= 1) {
3682          n = (n * 100) + "%";
3683      }
3684  
3685      return n;
3686  }
3687  
3688  // Converts a decimal to a hex value
3689  function convertDecimalToHex(d) {
3690      return Math.round(parseFloat(d) * 255).toString(16);
3691  }
3692  // Converts a hex value to a decimal
3693  function convertHexToDecimal(h) {
3694      return (parseIntFromHex(h) / 255);
3695  }
3696  
3697  var matchers = (function() {
3698  
3699      // <http://www.w3.org/TR/css3-values/#integers>
3700      var CSS_INTEGER = "[-\\+]?\\d+%?";
3701  
3702      // <http://www.w3.org/TR/css3-values/#number-value>
3703      var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
3704  
3705      // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
3706      var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
3707  
3708      // Actual matching.
3709      // Parentheses and commas are optional, but not required.
3710      // Whitespace can take the place of commas or opening paren
3711      var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
3712      var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
3713  
3714      return {
3715          CSS_UNIT: new RegExp(CSS_UNIT),
3716          rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
3717          rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
3718          hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
3719          hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
3720          hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
3721          hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
3722          hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
3723          hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
3724          hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
3725          hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
3726      };
3727  })();
3728  
3729  // `isValidCSSUnit`
3730  // Take in a single string / number and check to see if it looks like a CSS unit
3731  // (see `matchers` above for definition).
3732  function isValidCSSUnit(color) {
3733      return !!matchers.CSS_UNIT.exec(color);
3734  }
3735  
3736  // `stringInputToObject`
3737  // Permissive string parsing.  Take in a number of formats, and output an object
3738  // based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
3739  function stringInputToObject(color) {
3740  
3741      color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
3742      var named = false;
3743      if (names[color]) {
3744          color = names[color];
3745          named = true;
3746      }
3747      else if (color == 'transparent') {
3748          return { r: 0, g: 0, b: 0, a: 0, format: "name" };
3749      }
3750  
3751      // Try to match string input using regular expressions.
3752      // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
3753      // Just return an object and let the conversion functions handle that.
3754      // This way the result will be the same whether the tinycolor is initialized with string or object.
3755      var match;
3756      if ((match = matchers.rgb.exec(color))) {
3757          return { r: match[1], g: match[2], b: match[3] };
3758      }
3759      if ((match = matchers.rgba.exec(color))) {
3760          return { r: match[1], g: match[2], b: match[3], a: match[4] };
3761      }
3762      if ((match = matchers.hsl.exec(color))) {
3763          return { h: match[1], s: match[2], l: match[3] };
3764      }
3765      if ((match = matchers.hsla.exec(color))) {
3766          return { h: match[1], s: match[2], l: match[3], a: match[4] };
3767      }
3768      if ((match = matchers.hsv.exec(color))) {
3769          return { h: match[1], s: match[2], v: match[3] };
3770      }
3771      if ((match = matchers.hsva.exec(color))) {
3772          return { h: match[1], s: match[2], v: match[3], a: match[4] };
3773      }
3774      if ((match = matchers.hex8.exec(color))) {
3775          return {
3776              r: parseIntFromHex(match[1]),
3777              g: parseIntFromHex(match[2]),
3778              b: parseIntFromHex(match[3]),
3779              a: convertHexToDecimal(match[4]),
3780              format: named ? "name" : "hex8"
3781          };
3782      }
3783      if ((match = matchers.hex6.exec(color))) {
3784          return {
3785              r: parseIntFromHex(match[1]),
3786              g: parseIntFromHex(match[2]),
3787              b: parseIntFromHex(match[3]),
3788              format: named ? "name" : "hex"
3789          };
3790      }
3791      if ((match = matchers.hex4.exec(color))) {
3792          return {
3793              r: parseIntFromHex(match[1] + '' + match[1]),
3794              g: parseIntFromHex(match[2] + '' + match[2]),
3795              b: parseIntFromHex(match[3] + '' + match[3]),
3796              a: convertHexToDecimal(match[4] + '' + match[4]),
3797              format: named ? "name" : "hex8"
3798          };
3799      }
3800      if ((match = matchers.hex3.exec(color))) {
3801          return {
3802              r: parseIntFromHex(match[1] + '' + match[1]),
3803              g: parseIntFromHex(match[2] + '' + match[2]),
3804              b: parseIntFromHex(match[3] + '' + match[3]),
3805              format: named ? "name" : "hex"
3806          };
3807      }
3808  
3809      return false;
3810  }
3811  
3812  function validateWCAG2Parms(parms) {
3813      // return valid WCAG2 parms for isReadable.
3814      // If input parms are invalid, return {"level":"AA", "size":"small"}
3815      var level, size;
3816      parms = parms || {"level":"AA", "size":"small"};
3817      level = (parms.level || "AA").toUpperCase();
3818      size = (parms.size || "small").toLowerCase();
3819      if (level !== "AA" && level !== "AAA") {
3820          level = "AA";
3821      }
3822      if (size !== "small" && size !== "large") {
3823          size = "small";
3824      }
3825      return {"level":level, "size":size};
3826  }
3827  
3828  // Node: Export function
3829  if ( true && module.exports) {
3830      module.exports = tinycolor;
3831  }
3832  // AMD/requirejs: Define the module
3833  else if (true) {
3834      !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {return tinycolor;}).call(exports, __webpack_require__, exports, module),
3835                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
3836  }
3837  // Browser: Expose to window
3838  else {}
3839  
3840  })(Math);
3841  
3842  
3843  /***/ }),
3844  /* 63 */,
3845  /* 64 */
3846  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3847  
3848  "use strict";
3849  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return findFirstEnabledItem; });
3850  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getCurrentId; });
3851  function findFirstEnabledItem(items, excludeId) {
3852    if (excludeId) {
3853      return items.find(function (item) {
3854        return !item.disabled && item.id !== excludeId;
3855      });
3856    }
3857  
3858    return items.find(function (item) {
3859      return !item.disabled;
3860    });
3861  }
3862  
3863  function getCurrentId(options, passedId) {
3864    var _findFirstEnabledItem;
3865  
3866    if (passedId || passedId === null) {
3867      return passedId;
3868    }
3869  
3870    if (options.currentId || options.currentId === null) {
3871      return options.currentId;
3872    }
3873  
3874    return (_findFirstEnabledItem = findFirstEnabledItem(options.items || [])) === null || _findFirstEnabledItem === void 0 ? void 0 : _findFirstEnabledItem.id;
3875  }
3876  
3877  
3878  
3879  
3880  /***/ }),
3881  /* 65 */
3882  /***/ (function(module, exports) {
3883  
3884  (function() { module.exports = window["wp"]["isShallowEqual"]; }());
3885  
3886  /***/ }),
3887  /* 66 */,
3888  /* 67 */
3889  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3890  
3891  "use strict";
3892  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getActiveElement; });
3893  /* harmony import */ var _getDocument_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(54);
3894  
3895  
3896  /**
3897   * Returns `element.ownerDocument.activeElement`.
3898   */
3899  
3900  function getActiveElement(element) {
3901    var _getDocument = Object(_getDocument_js__WEBPACK_IMPORTED_MODULE_0__[/* getDocument */ "a"])(element),
3902        activeElement = _getDocument.activeElement;
3903  
3904    if (!(activeElement !== null && activeElement !== void 0 && activeElement.nodeName)) {
3905      // In IE11, activeElement might be an empty object if we're interacting
3906      // with elements inside of an iframe.
3907      return null;
3908    }
3909  
3910    return activeElement;
3911  }
3912  
3913  
3914  
3915  
3916  /***/ }),
3917  /* 68 */
3918  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3919  
3920  "use strict";
3921  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isSelfTarget; });
3922  /**
3923   * Returns `true` if `event.target` and `event.currentTarget` are the same.
3924   */
3925  function isSelfTarget(event) {
3926    return event.target === event.currentTarget;
3927  }
3928  
3929  
3930  
3931  
3932  /***/ }),
3933  /* 69 */
3934  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3935  
3936  "use strict";
3937  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return shallowEqual; });
3938  /**
3939   * Compares two objects.
3940   *
3941   * @example
3942   * import { shallowEqual } from "reakit-utils";
3943   *
3944   * shallowEqual({ a: "a" }, {}); // false
3945   * shallowEqual({ a: "a" }, { b: "b" }); // false
3946   * shallowEqual({ a: "a" }, { a: "a" }); // true
3947   * shallowEqual({ a: "a" }, { a: "a", b: "b" }); // false
3948   */
3949  function shallowEqual(objA, objB) {
3950    if (objA === objB) return true;
3951    if (!objA) return false;
3952    if (!objB) return false;
3953    if (typeof objA !== "object") return false;
3954    if (typeof objB !== "object") return false;
3955    var aKeys = Object.keys(objA);
3956    var bKeys = Object.keys(objB);
3957    var length = aKeys.length;
3958    if (bKeys.length !== length) return false;
3959  
3960    for (var _i = 0, _aKeys = aKeys; _i < _aKeys.length; _i++) {
3961      var key = _aKeys[_i];
3962  
3963      if (objA[key] !== objB[key]) {
3964        return false;
3965      }
3966    }
3967  
3968    return true;
3969  }
3970  
3971  
3972  
3973  
3974  /***/ }),
3975  /* 70 */
3976  /***/ (function(module, exports) {
3977  
3978  (function() { module.exports = window["wp"]["date"]; }());
3979  
3980  /***/ }),
3981  /* 71 */
3982  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3983  
3984  "use strict";
3985  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useIsomorphicEffect; });
3986  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
3987  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
3988  /* harmony import */ var _canUseDOM_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(89);
3989  
3990  
3991  
3992  
3993  
3994  /**
3995   * `React.useLayoutEffect` that fallbacks to `React.useEffect` on server side
3996   * rendering.
3997   */
3998  
3999  var useIsomorphicEffect = !_canUseDOM_js__WEBPACK_IMPORTED_MODULE_1__[/* canUseDOM */ "a"] ? react__WEBPACK_IMPORTED_MODULE_0__["useEffect"] : react__WEBPACK_IMPORTED_MODULE_0__["useLayoutEffect"];
4000  
4001  
4002  
4003  
4004  /***/ }),
4005  /* 72 */,
4006  /* 73 */,
4007  /* 74 */
4008  /***/ (function(module, exports, __webpack_require__) {
4009  
4010  "use strict";
4011  
4012  
4013  Object.defineProperty(exports, "__esModule", {
4014    value: true
4015  });
4016  var DISPLAY_FORMAT = exports.DISPLAY_FORMAT = 'L';
4017  var ISO_FORMAT = exports.ISO_FORMAT = 'YYYY-MM-DD';
4018  var ISO_MONTH_FORMAT = exports.ISO_MONTH_FORMAT = 'YYYY-MM';
4019  
4020  var START_DATE = exports.START_DATE = 'startDate';
4021  var END_DATE = exports.END_DATE = 'endDate';
4022  
4023  var HORIZONTAL_ORIENTATION = exports.HORIZONTAL_ORIENTATION = 'horizontal';
4024  var VERTICAL_ORIENTATION = exports.VERTICAL_ORIENTATION = 'vertical';
4025  var VERTICAL_SCROLLABLE = exports.VERTICAL_SCROLLABLE = 'verticalScrollable';
4026  
4027  var ICON_BEFORE_POSITION = exports.ICON_BEFORE_POSITION = 'before';
4028  var ICON_AFTER_POSITION = exports.ICON_AFTER_POSITION = 'after';
4029  
4030  var INFO_POSITION_TOP = exports.INFO_POSITION_TOP = 'top';
4031  var INFO_POSITION_BOTTOM = exports.INFO_POSITION_BOTTOM = 'bottom';
4032  var INFO_POSITION_BEFORE = exports.INFO_POSITION_BEFORE = 'before';
4033  var INFO_POSITION_AFTER = exports.INFO_POSITION_AFTER = 'after';
4034  
4035  var ANCHOR_LEFT = exports.ANCHOR_LEFT = 'left';
4036  var ANCHOR_RIGHT = exports.ANCHOR_RIGHT = 'right';
4037  
4038  var OPEN_DOWN = exports.OPEN_DOWN = 'down';
4039  var OPEN_UP = exports.OPEN_UP = 'up';
4040  
4041  var DAY_SIZE = exports.DAY_SIZE = 39;
4042  var BLOCKED_MODIFIER = exports.BLOCKED_MODIFIER = 'blocked';
4043  var WEEKDAYS = exports.WEEKDAYS = [0, 1, 2, 3, 4, 5, 6];
4044  
4045  var FANG_WIDTH_PX = exports.FANG_WIDTH_PX = 20;
4046  var FANG_HEIGHT_PX = exports.FANG_HEIGHT_PX = 10;
4047  var DEFAULT_VERTICAL_SPACING = exports.DEFAULT_VERTICAL_SPACING = 22;
4048  
4049  var MODIFIER_KEY_NAMES = exports.MODIFIER_KEY_NAMES = new Set(['Shift', 'Control', 'Alt', 'Meta']);
4050  
4051  /***/ }),
4052  /* 75 */
4053  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4054  
4055  "use strict";
4056  /* unused harmony export Role */
4057  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useRole; });
4058  /* harmony import */ var _rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
4059  /* harmony import */ var reakit_system_createComponent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(61);
4060  /* harmony import */ var reakit_system_createHook__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(60);
4061  /* harmony import */ var reakit_utils_shallowEqual__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(69);
4062  
4063  
4064  
4065  
4066  
4067  // Automatically generated
4068  var ROLE_KEYS = ["unstable_system"];
4069  
4070  var useRole = Object(reakit_system_createHook__WEBPACK_IMPORTED_MODULE_2__[/* createHook */ "a"])({
4071    name: "Role",
4072    keys: ROLE_KEYS,
4073    propsAreEqual: function propsAreEqual(prev, next) {
4074      var prevSystem = prev.unstable_system,
4075          prevProps = Object(_rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__[/* _ */ "a"])(prev, ["unstable_system"]);
4076  
4077      var nextSystem = next.unstable_system,
4078          nextProps = Object(_rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__[/* _ */ "a"])(next, ["unstable_system"]);
4079  
4080      if (prevSystem !== nextSystem && !Object(reakit_utils_shallowEqual__WEBPACK_IMPORTED_MODULE_3__[/* shallowEqual */ "a"])(prevSystem, nextSystem)) {
4081        return false;
4082      }
4083  
4084      return Object(reakit_utils_shallowEqual__WEBPACK_IMPORTED_MODULE_3__[/* shallowEqual */ "a"])(prevProps, nextProps);
4085    }
4086  });
4087  var Role = Object(reakit_system_createComponent__WEBPACK_IMPORTED_MODULE_1__[/* createComponent */ "a"])({
4088    as: "div",
4089    useHook: useRole
4090  });
4091  
4092  
4093  
4094  
4095  /***/ }),
4096  /* 76 */,
4097  /* 77 */
4098  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4099  
4100  "use strict";
4101  /* harmony import */ var _babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
4102  /* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8);
4103  /* harmony import */ var _babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(13);
4104  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(0);
4105  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__);
4106  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(7);
4107  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_4__);
4108  /* harmony import */ var _dashicon__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(148);
4109  
4110  
4111  
4112  
4113  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
4114  
4115  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
4116  
4117  /**
4118   * WordPress dependencies
4119   */
4120  
4121  
4122  /**
4123   * Internal dependencies
4124   */
4125  
4126  
4127  
4128  function Icon(_ref) {
4129    var _ref$icon = _ref.icon,
4130        icon = _ref$icon === void 0 ? null : _ref$icon,
4131        size = _ref.size,
4132        additionalProps = Object(_babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(_ref, ["icon", "size"]);
4133  
4134    if ('string' === typeof icon) {
4135      return Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["createElement"])(_dashicon__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"], Object(_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])({
4136        icon: icon
4137      }, additionalProps));
4138    }
4139  
4140    if (icon && _dashicon__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"] === icon.type) {
4141      return Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["cloneElement"])(icon, _objectSpread({}, additionalProps));
4142    } // Icons should be 24x24 by default.
4143  
4144  
4145    var iconSize = size || 24;
4146  
4147    if ('function' === typeof icon) {
4148      if (icon.prototype instanceof _wordpress_element__WEBPACK_IMPORTED_MODULE_3__["Component"]) {
4149        return Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["createElement"])(icon, _objectSpread({
4150          size: iconSize
4151        }, additionalProps));
4152      }
4153  
4154      return icon(_objectSpread({
4155        size: iconSize
4156      }, additionalProps));
4157    }
4158  
4159    if (icon && (icon.type === 'svg' || icon.type === _wordpress_primitives__WEBPACK_IMPORTED_MODULE_4__["SVG"])) {
4160      var appliedProps = _objectSpread(_objectSpread({
4161        width: iconSize,
4162        height: iconSize
4163      }, icon.props), additionalProps);
4164  
4165      return Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_4__["SVG"], appliedProps);
4166    }
4167  
4168    if (Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["isValidElement"])(icon)) {
4169      return Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["cloneElement"])(icon, _objectSpread({
4170        size: iconSize
4171      }, additionalProps));
4172    }
4173  
4174    return icon;
4175  }
4176  
4177  /* harmony default export */ __webpack_exports__["a"] = (Icon);
4178  
4179  
4180  /***/ }),
4181  /* 78 */
4182  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4183  
4184  "use strict";
4185  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread2; });
4186  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return _objectWithoutPropertiesLoose; });
4187  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return _createForOfIteratorHelperLoose; });
4188  function _defineProperty(obj, key, value) {
4189    if (key in obj) {
4190      Object.defineProperty(obj, key, {
4191        value: value,
4192        enumerable: true,
4193        configurable: true,
4194        writable: true
4195      });
4196    } else {
4197      obj[key] = value;
4198    }
4199  
4200    return obj;
4201  }
4202  
4203  function ownKeys(object, enumerableOnly) {
4204    var keys = Object.keys(object);
4205  
4206    if (Object.getOwnPropertySymbols) {
4207      var symbols = Object.getOwnPropertySymbols(object);
4208      if (enumerableOnly) symbols = symbols.filter(function (sym) {
4209        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
4210      });
4211      keys.push.apply(keys, symbols);
4212    }
4213  
4214    return keys;
4215  }
4216  
4217  function _objectSpread2(target) {
4218    for (var i = 1; i < arguments.length; i++) {
4219      var source = arguments[i] != null ? arguments[i] : {};
4220  
4221      if (i % 2) {
4222        ownKeys(Object(source), true).forEach(function (key) {
4223          _defineProperty(target, key, source[key]);
4224        });
4225      } else if (Object.getOwnPropertyDescriptors) {
4226        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
4227      } else {
4228        ownKeys(Object(source)).forEach(function (key) {
4229          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
4230        });
4231      }
4232    }
4233  
4234    return target;
4235  }
4236  
4237  function _objectWithoutPropertiesLoose(source, excluded) {
4238    if (source == null) return {};
4239    var target = {};
4240    var sourceKeys = Object.keys(source);
4241    var key, i;
4242  
4243    for (i = 0; i < sourceKeys.length; i++) {
4244      key = sourceKeys[i];
4245      if (excluded.indexOf(key) >= 0) continue;
4246      target[key] = source[key];
4247    }
4248  
4249    return target;
4250  }
4251  
4252  function _unsupportedIterableToArray(o, minLen) {
4253    if (!o) return;
4254    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
4255    var n = Object.prototype.toString.call(o).slice(8, -1);
4256    if (n === "Object" && o.constructor) n = o.constructor.name;
4257    if (n === "Map" || n === "Set") return Array.from(o);
4258    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
4259  }
4260  
4261  function _arrayLikeToArray(arr, len) {
4262    if (len == null || len > arr.length) len = arr.length;
4263  
4264    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
4265  
4266    return arr2;
4267  }
4268  
4269  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
4270    var it;
4271  
4272    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
4273      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
4274        if (it) o = it;
4275        var i = 0;
4276        return function () {
4277          if (i >= o.length) return {
4278            done: true
4279          };
4280          return {
4281            done: false,
4282            value: o[i++]
4283          };
4284        };
4285      }
4286  
4287      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
4288    }
4289  
4290    it = o[Symbol.iterator]();
4291    return it.next.bind(it);
4292  }
4293  
4294  
4295  
4296  
4297  /***/ }),
4298  /* 79 */
4299  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4300  
4301  "use strict";
4302  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useForkRef; });
4303  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
4304  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
4305  
4306  
4307  // https://github.com/mui-org/material-ui/blob/2bcc874cf07b81202968f769cb9c2398c7c11311/packages/material-ui/src/utils/useForkRef.js
4308  
4309  function setRef(ref, value) {
4310    if (value === void 0) {
4311      value = null;
4312    }
4313  
4314    if (!ref) return;
4315  
4316    if (typeof ref === "function") {
4317      ref(value);
4318    } else {
4319      ref.current = value;
4320    }
4321  }
4322  /**
4323   * Merges up to two React Refs into a single memoized function React Ref so you
4324   * can pass it to an element.
4325   *
4326   * @example
4327   * import React from "react";
4328   * import { useForkRef } from "reakit-utils";
4329   *
4330   * const Component = React.forwardRef((props, ref) => {
4331   *   const internalRef = React.useRef();
4332   *   return <div {...props} ref={useForkRef(internalRef, ref)} />;
4333   * });
4334   */
4335  
4336  
4337  function useForkRef(refA, refB) {
4338    return Object(react__WEBPACK_IMPORTED_MODULE_0__["useMemo"])(function () {
4339      if (refA == null && refB == null) {
4340        return null;
4341      }
4342  
4343      return function (value) {
4344        setRef(refA, value);
4345        setRef(refB, value);
4346      };
4347    }, [refA, refB]);
4348  }
4349  
4350  
4351  
4352  
4353  /***/ }),
4354  /* 80 */
4355  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4356  
4357  "use strict";
4358  
4359  // UNUSED EXPORTS: TOOLTIP_DELAY
4360  
4361  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
4362  var slicedToArray = __webpack_require__(12);
4363  
4364  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
4365  var defineProperty = __webpack_require__(5);
4366  
4367  // EXTERNAL MODULE: external ["wp","element"]
4368  var external_wp_element_ = __webpack_require__(0);
4369  
4370  // EXTERNAL MODULE: external "lodash"
4371  var external_lodash_ = __webpack_require__(2);
4372  
4373  // EXTERNAL MODULE: external ["wp","compose"]
4374  var external_wp_compose_ = __webpack_require__(11);
4375  
4376  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/popover/index.js + 1 modules
4377  var popover = __webpack_require__(113);
4378  
4379  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/shortcut/index.js
4380  var build_module_shortcut = __webpack_require__(180);
4381  
4382  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
4383  var objectWithoutProperties = __webpack_require__(13);
4384  
4385  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/ui/context/with-next.js
4386  var with_next = __webpack_require__(526);
4387  
4388  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/tooltip/next.js
4389  
4390  
4391  
4392  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
4393  
4394  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
4395  
4396  /**
4397   * Internal dependencies
4398   */
4399  
4400  
4401  var Tooltip =  false ? undefined : undefined;
4402  
4403  var next_adapter = function adapter(_ref) {
4404    var text = _ref.text,
4405        props = Object(objectWithoutProperties["a" /* default */])(_ref, ["text"]);
4406  
4407    return _objectSpread(_objectSpread({}, props), {}, {
4408      content: text
4409    });
4410  };
4411  
4412  function withNextComponent(Component) {
4413    return Object(with_next["a" /* withNext */])(Component, Tooltip, 'WPComponentsTooltip', next_adapter);
4414  }
4415  
4416  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/tooltip/index.js
4417  
4418  
4419  
4420  
4421  function tooltip_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
4422  
4423  function tooltip_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { tooltip_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { tooltip_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
4424  
4425  /**
4426   * External dependencies
4427   */
4428  
4429  /**
4430   * WordPress dependencies
4431   */
4432  
4433  
4434  
4435  /**
4436   * Internal dependencies
4437   */
4438  
4439  
4440  
4441  
4442  /**
4443   * Time over children to wait before showing tooltip
4444   *
4445   * @type {number}
4446   */
4447  
4448  var TOOLTIP_DELAY = 700;
4449  var eventCatcher = Object(external_wp_element_["createElement"])("div", {
4450    className: "event-catcher"
4451  });
4452  
4453  var tooltip_getDisabledElement = function getDisabledElement(_ref) {
4454    var eventHandlers = _ref.eventHandlers,
4455        child = _ref.child,
4456        childrenWithPopover = _ref.childrenWithPopover;
4457    return Object(external_wp_element_["cloneElement"])(Object(external_wp_element_["createElement"])("span", {
4458      className: "disabled-element-wrapper"
4459    }, Object(external_wp_element_["cloneElement"])(eventCatcher, eventHandlers), Object(external_wp_element_["cloneElement"])(child, {
4460      children: childrenWithPopover
4461    }), ","), eventHandlers);
4462  };
4463  
4464  var tooltip_getRegularElement = function getRegularElement(_ref2) {
4465    var child = _ref2.child,
4466        eventHandlers = _ref2.eventHandlers,
4467        childrenWithPopover = _ref2.childrenWithPopover;
4468    return Object(external_wp_element_["cloneElement"])(child, tooltip_objectSpread(tooltip_objectSpread({}, eventHandlers), {}, {
4469      children: childrenWithPopover
4470    }));
4471  };
4472  
4473  var tooltip_addPopoverToGrandchildren = function addPopoverToGrandchildren(_ref3) {
4474    var grandchildren = _ref3.grandchildren,
4475        isOver = _ref3.isOver,
4476        position = _ref3.position,
4477        text = _ref3.text,
4478        shortcut = _ref3.shortcut;
4479    return Object(external_wp_element_["concatChildren"])(grandchildren, isOver && Object(external_wp_element_["createElement"])(popover["a" /* default */], {
4480      focusOnMount: false,
4481      position: position,
4482      className: "components-tooltip",
4483      "aria-hidden": "true",
4484      animate: false,
4485      noArrow: true
4486    }, text, Object(external_wp_element_["createElement"])(build_module_shortcut["a" /* default */], {
4487      className: "components-tooltip__shortcut",
4488      shortcut: shortcut
4489    })));
4490  };
4491  
4492  var tooltip_emitToChild = function emitToChild(children, eventName, event) {
4493    if (external_wp_element_["Children"].count(children) !== 1) {
4494      return;
4495    }
4496  
4497    var child = external_wp_element_["Children"].only(children);
4498  
4499    if (typeof child.props[eventName] === 'function') {
4500      child.props[eventName](event);
4501    }
4502  };
4503  
4504  function tooltip_Tooltip(_ref4) {
4505    var children = _ref4.children,
4506        position = _ref4.position,
4507        text = _ref4.text,
4508        shortcut = _ref4.shortcut;
4509  
4510    /**
4511     * Whether a mouse is currently pressed, used in determining whether
4512     * to handle a focus event as displaying the tooltip immediately.
4513     *
4514     * @type {boolean}
4515     */
4516    var _useState = Object(external_wp_element_["useState"])(false),
4517        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
4518        isMouseDown = _useState2[0],
4519        setIsMouseDown = _useState2[1];
4520  
4521    var _useState3 = Object(external_wp_element_["useState"])(false),
4522        _useState4 = Object(slicedToArray["a" /* default */])(_useState3, 2),
4523        isOver = _useState4[0],
4524        setIsOver = _useState4[1];
4525  
4526    var delayedSetIsOver = Object(external_wp_compose_["useDebounce"])(setIsOver, TOOLTIP_DELAY);
4527  
4528    var createMouseDown = function createMouseDown(event) {
4529      // Preserve original child callback behavior
4530      tooltip_emitToChild(children, 'onMouseDown', event); // On mouse down, the next `mouseup` should revert the value of the
4531      // instance property and remove its own event handler. The bind is
4532      // made on the document since the `mouseup` might not occur within
4533      // the bounds of the element.
4534  
4535      document.addEventListener('mouseup', cancelIsMouseDown);
4536      setIsMouseDown(true);
4537    };
4538  
4539    var createMouseUp = function createMouseUp(event) {
4540      tooltip_emitToChild(children, 'onMouseUp', event);
4541      document.removeEventListener('mouseup', cancelIsMouseDown);
4542      setIsMouseDown(false);
4543    };
4544  
4545    var createMouseEvent = function createMouseEvent(type) {
4546      if (type === 'mouseUp') return createMouseUp;
4547      if (type === 'mouseDown') return createMouseDown;
4548    };
4549    /**
4550     * Prebound `isInMouseDown` handler, created as a constant reference to
4551     * assure ability to remove in component unmount.
4552     *
4553     * @type {Function}
4554     */
4555  
4556  
4557    var cancelIsMouseDown = createMouseEvent('mouseUp');
4558  
4559    var createToggleIsOver = function createToggleIsOver(eventName, isDelayed) {
4560      return function (event) {
4561        // Preserve original child callback behavior
4562        tooltip_emitToChild(children, eventName, event); // Mouse events behave unreliably in React for disabled elements,
4563        // firing on mouseenter but not mouseleave.  Further, the default
4564        // behavior for disabled elements in some browsers is to ignore
4565        // mouse events. Don't bother trying to to handle them.
4566        //
4567        // See: https://github.com/facebook/react/issues/4251
4568  
4569        if (event.currentTarget.disabled) {
4570          return;
4571        } // A focus event will occur as a result of a mouse click, but it
4572        // should be disambiguated between interacting with the button and
4573        // using an explicit focus shift as a cue to display the tooltip.
4574  
4575  
4576        if ('focus' === event.type && isMouseDown) {
4577          return;
4578        } // Needed in case unsetting is over while delayed set pending, i.e.
4579        // quickly blur/mouseleave before delayedSetIsOver is called
4580  
4581  
4582        delayedSetIsOver.cancel();
4583  
4584        var _isOver = Object(external_lodash_["includes"])(['focus', 'mouseenter'], event.type);
4585  
4586        if (_isOver === isOver) {
4587          return;
4588        }
4589  
4590        if (isDelayed) {
4591          delayedSetIsOver(_isOver);
4592        } else {
4593          setIsOver(_isOver);
4594        }
4595      };
4596    };
4597  
4598    var clearOnUnmount = function clearOnUnmount() {
4599      delayedSetIsOver.cancel();
4600    };
4601  
4602    Object(external_wp_element_["useEffect"])(function () {
4603      return clearOnUnmount;
4604    }, []);
4605  
4606    if (external_wp_element_["Children"].count(children) !== 1) {
4607      if (false) {}
4608  
4609      return children;
4610    }
4611  
4612    var eventHandlers = {
4613      onMouseEnter: createToggleIsOver('onMouseEnter', true),
4614      onMouseLeave: createToggleIsOver('onMouseLeave'),
4615      onClick: createToggleIsOver('onClick'),
4616      onFocus: createToggleIsOver('onFocus'),
4617      onBlur: createToggleIsOver('onBlur'),
4618      onMouseDown: createMouseEvent('mouseDown')
4619    };
4620    var child = external_wp_element_["Children"].only(children);
4621    var _child$props = child.props,
4622        grandchildren = _child$props.children,
4623        disabled = _child$props.disabled;
4624    var getElementWithPopover = disabled ? tooltip_getDisabledElement : tooltip_getRegularElement;
4625    var popoverData = {
4626      isOver: isOver,
4627      position: position,
4628      text: text,
4629      shortcut: shortcut
4630    };
4631    var childrenWithPopover = tooltip_addPopoverToGrandchildren(tooltip_objectSpread({
4632      grandchildren: grandchildren
4633    }, popoverData));
4634    return getElementWithPopover({
4635      child: child,
4636      eventHandlers: eventHandlers,
4637      childrenWithPopover: childrenWithPopover
4638    });
4639  }
4640  
4641  /* harmony default export */ var tooltip = __webpack_exports__["a"] = (withNextComponent(tooltip_Tooltip));
4642  
4643  
4644  /***/ }),
4645  /* 81 */
4646  /***/ (function(module, exports, __webpack_require__) {
4647  
4648  "use strict";
4649  
4650  
4651  var ES5Type = __webpack_require__(331);
4652  
4653  // https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values
4654  
4655  module.exports = function Type(x) {
4656      if (typeof x === 'symbol') {
4657          return 'Symbol';
4658      }
4659      if (typeof x === 'bigint') {
4660          return 'BigInt';
4661      }
4662      return ES5Type(x);
4663  };
4664  
4665  
4666  /***/ }),
4667  /* 82 */
4668  /***/ (function(module, exports, __webpack_require__) {
4669  
4670  module.exports =  true ? __webpack_require__(380) : undefined;
4671  
4672  
4673  
4674  /***/ }),
4675  /* 83 */
4676  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4677  
4678  "use strict";
4679  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isUA; });
4680  /* harmony import */ var _canUseDOM_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(89);
4681  
4682  
4683  
4684  
4685  /**
4686   * Checks if a given string exists in the user agent string.
4687   */
4688  
4689  function isUA(string) {
4690    if (!_canUseDOM_js__WEBPACK_IMPORTED_MODULE_0__[/* canUseDOM */ "a"]) return false;
4691    return window.navigator.userAgent.indexOf(string) !== -1;
4692  }
4693  
4694  
4695  
4696  
4697  /***/ }),
4698  /* 84 */
4699  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4700  
4701  "use strict";
4702  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4703  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4704  /**
4705   * WordPress dependencies
4706   */
4707  
4708  var ToolbarContext = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createContext"])();
4709  /* harmony default export */ __webpack_exports__["a"] = (ToolbarContext);
4710  
4711  
4712  /***/ }),
4713  /* 85 */
4714  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4715  
4716  "use strict";
4717  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutPropertiesLoose; });
4718  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return _objectSpread2; });
4719  /* unused harmony export b */
4720  function _defineProperty(obj, key, value) {
4721    if (key in obj) {
4722      Object.defineProperty(obj, key, {
4723        value: value,
4724        enumerable: true,
4725        configurable: true,
4726        writable: true
4727      });
4728    } else {
4729      obj[key] = value;
4730    }
4731  
4732    return obj;
4733  }
4734  
4735  function ownKeys(object, enumerableOnly) {
4736    var keys = Object.keys(object);
4737  
4738    if (Object.getOwnPropertySymbols) {
4739      var symbols = Object.getOwnPropertySymbols(object);
4740      if (enumerableOnly) symbols = symbols.filter(function (sym) {
4741        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
4742      });
4743      keys.push.apply(keys, symbols);
4744    }
4745  
4746    return keys;
4747  }
4748  
4749  function _objectSpread2(target) {
4750    for (var i = 1; i < arguments.length; i++) {
4751      var source = arguments[i] != null ? arguments[i] : {};
4752  
4753      if (i % 2) {
4754        ownKeys(Object(source), true).forEach(function (key) {
4755          _defineProperty(target, key, source[key]);
4756        });
4757      } else if (Object.getOwnPropertyDescriptors) {
4758        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
4759      } else {
4760        ownKeys(Object(source)).forEach(function (key) {
4761          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
4762        });
4763      }
4764    }
4765  
4766    return target;
4767  }
4768  
4769  function _objectWithoutPropertiesLoose(source, excluded) {
4770    if (source == null) return {};
4771    var target = {};
4772    var sourceKeys = Object.keys(source);
4773    var key, i;
4774  
4775    for (i = 0; i < sourceKeys.length; i++) {
4776      key = sourceKeys[i];
4777      if (excluded.indexOf(key) >= 0) continue;
4778      target[key] = source[key];
4779    }
4780  
4781    return target;
4782  }
4783  
4784  function _unsupportedIterableToArray(o, minLen) {
4785    if (!o) return;
4786    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
4787    var n = Object.prototype.toString.call(o).slice(8, -1);
4788    if (n === "Object" && o.constructor) n = o.constructor.name;
4789    if (n === "Map" || n === "Set") return Array.from(o);
4790    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
4791  }
4792  
4793  function _arrayLikeToArray(arr, len) {
4794    if (len == null || len > arr.length) len = arr.length;
4795  
4796    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
4797  
4798    return arr2;
4799  }
4800  
4801  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
4802    var it;
4803  
4804    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
4805      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
4806        if (it) o = it;
4807        var i = 0;
4808        return function () {
4809          if (i >= o.length) return {
4810            done: true
4811          };
4812          return {
4813            done: false,
4814            value: o[i++]
4815          };
4816        };
4817      }
4818  
4819      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
4820    }
4821  
4822    it = o[Symbol.iterator]();
4823    return it.next.bind(it);
4824  }
4825  
4826  
4827  
4828  
4829  /***/ }),
4830  /* 86 */,
4831  /* 87 */
4832  /***/ (function(module, exports, __webpack_require__) {
4833  
4834  "use strict";
4835  
4836  
4837  var defineProperties = __webpack_require__(100);
4838  var callBind = __webpack_require__(163);
4839  
4840  var implementation = __webpack_require__(245);
4841  var getPolyfill = __webpack_require__(247);
4842  var shim = __webpack_require__(377);
4843  
4844  var polyfill = callBind.apply(getPolyfill());
4845  // eslint-disable-next-line no-unused-vars
4846  var bound = function assign(target, source1) {
4847      return polyfill(Object, arguments);
4848  };
4849  
4850  defineProperties(bound, {
4851      getPolyfill: getPolyfill,
4852      implementation: implementation,
4853      shim: shim
4854  });
4855  
4856  module.exports = bound;
4857  
4858  
4859  /***/ }),
4860  /* 88 */
4861  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4862  
4863  "use strict";
4864  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return unstable_IdContext; });
4865  /* unused harmony export unstable_IdProvider */
4866  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
4867  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
4868  
4869  
4870  var defaultPrefix = "id";
4871  function generateRandomString(prefix) {
4872    if (prefix === void 0) {
4873      prefix = defaultPrefix;
4874    }
4875  
4876    return "" + (prefix ? prefix + "-" : "") + Math.random().toString(32).substr(2, 6);
4877  }
4878  
4879  var unstable_IdContext = /*#__PURE__*/Object(react__WEBPACK_IMPORTED_MODULE_0__["createContext"])(generateRandomString);
4880  function unstable_IdProvider(_ref) {
4881    var children = _ref.children,
4882        _ref$prefix = _ref.prefix,
4883        prefix = _ref$prefix === void 0 ? defaultPrefix : _ref$prefix;
4884    var count = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(0);
4885    var generateId = Object(react__WEBPACK_IMPORTED_MODULE_0__["useCallback"])(function (localPrefix) {
4886      if (localPrefix === void 0) {
4887        localPrefix = prefix;
4888      }
4889  
4890      return "" + (localPrefix ? localPrefix + "-" : "") + ++count.current;
4891    }, [prefix]);
4892    return /*#__PURE__*/Object(react__WEBPACK_IMPORTED_MODULE_0__["createElement"])(unstable_IdContext.Provider, {
4893      value: generateId
4894    }, children);
4895  }
4896  
4897  
4898  
4899  
4900  /***/ }),
4901  /* 89 */
4902  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4903  
4904  "use strict";
4905  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return canUseDOM; });
4906  /* harmony import */ var _getWindow_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(110);
4907  
4908  
4909  
4910  function checkIsBrowser() {
4911    var _window = Object(_getWindow_js__WEBPACK_IMPORTED_MODULE_0__[/* getWindow */ "a"])();
4912  
4913    return Boolean(typeof _window !== "undefined" && _window.document && _window.document.createElement);
4914  }
4915  /**
4916   * It's `true` if it is running in a browser environment or `false` if it is not (SSR).
4917   *
4918   * @example
4919   * import { canUseDOM } from "reakit-utils";
4920   *
4921   * const title = canUseDOM ? document.title : "";
4922   */
4923  
4924  
4925  var canUseDOM = checkIsBrowser();
4926  
4927  
4928  
4929  
4930  /***/ }),
4931  /* 90 */,
4932  /* 91 */
4933  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4934  
4935  "use strict";
4936  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return hasUserFocus; });
4937  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return setUserFocus; });
4938  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return userFocus; });
4939  function userFocus(element) {
4940    element.userFocus = true;
4941    element.focus();
4942    element.userFocus = false;
4943  }
4944  function hasUserFocus(element) {
4945    return !!element.userFocus;
4946  }
4947  function setUserFocus(element, value) {
4948    element.userFocus = value;
4949  }
4950  
4951  
4952  
4953  
4954  /***/ }),
4955  /* 92 */
4956  /***/ (function(module, exports, __webpack_require__) {
4957  
4958  "use strict";
4959  
4960  
4961  var bind = __webpack_require__(122);
4962  
4963  module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
4964  
4965  
4966  /***/ }),
4967  /* 93 */
4968  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4969  
4970  "use strict";
4971  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return hasFocusWithin; });
4972  /* harmony import */ var _getActiveElement_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67);
4973  /* harmony import */ var _contains_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(176);
4974  
4975  
4976  
4977  
4978  /**
4979   * Checks if `element` has focus within. Elements that are referenced by
4980   * `aria-activedescendant` are also considered.
4981   *
4982   * @example
4983   * import { hasFocusWithin } from "reakit-utils";
4984   *
4985   * hasFocusWithin(document.getElementById("id"));
4986   */
4987  
4988  function hasFocusWithin(element) {
4989    var activeElement = Object(_getActiveElement_js__WEBPACK_IMPORTED_MODULE_0__[/* getActiveElement */ "a"])(element);
4990    if (!activeElement) return false;
4991    if (Object(_contains_js__WEBPACK_IMPORTED_MODULE_1__[/* contains */ "a"])(element, activeElement)) return true;
4992    var activeDescendant = activeElement.getAttribute("aria-activedescendant");
4993    if (!activeDescendant) return false;
4994    if (activeDescendant === element.id) return true;
4995    return !!element.querySelector("#" + activeDescendant);
4996  }
4997  
4998  
4999  
5000  
5001  /***/ }),
5002  /* 94 */
5003  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5004  
5005  "use strict";
5006  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isPortalEvent; });
5007  /* harmony import */ var _contains_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(176);
5008  
5009  
5010  /**
5011   * Returns `true` if `event` has been fired within a React Portal element.
5012   */
5013  
5014  function isPortalEvent(event) {
5015    return !Object(_contains_js__WEBPACK_IMPORTED_MODULE_0__[/* contains */ "a"])(event.currentTarget, event.target);
5016  }
5017  
5018  
5019  
5020  
5021  /***/ }),
5022  /* 95 */
5023  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5024  
5025  "use strict";
5026  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isButton; });
5027  var buttonInputTypes = ["button", "color", "file", "image", "reset", "submit"];
5028  /**
5029   * Checks whether `element` is a native HTML button element.
5030   *
5031   * @example
5032   * import { isButton } from "reakit-utils";
5033   *
5034   * isButton(document.querySelector("button")); // true
5035   * isButton(document.querySelector("input[type='button']")); // true
5036   * isButton(document.querySelector("div")); // false
5037   * isButton(document.querySelector("input[type='text']")); // false
5038   * isButton(document.querySelector("div[role='button']")); // false
5039   *
5040   * @returns {boolean}
5041   */
5042  
5043  function isButton(element) {
5044    if (element.tagName === "BUTTON") return true;
5045  
5046    if (element.tagName === "INPUT") {
5047      var input = element;
5048      return buttonInputTypes.indexOf(input.type) !== -1;
5049    }
5050  
5051    return false;
5052  }
5053  
5054  
5055  
5056  
5057  /***/ }),
5058  /* 96 */
5059  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5060  
5061  "use strict";
5062  /* unused harmony export Tabbable */
5063  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useTabbable; });
5064  /* harmony import */ var _rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
5065  /* harmony import */ var reakit_system_createComponent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(61);
5066  /* harmony import */ var reakit_system_createHook__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(60);
5067  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14);
5068  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_3__);
5069  /* harmony import */ var reakit_utils_useForkRef__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(79);
5070  /* harmony import */ var reakit_utils_isButton__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(95);
5071  /* harmony import */ var reakit_warning__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(109);
5072  /* harmony import */ var reakit_utils_useLiveRef__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(52);
5073  /* harmony import */ var reakit_utils_useIsomorphicEffect__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(71);
5074  /* harmony import */ var reakit_utils_hasFocusWithin__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(93);
5075  /* harmony import */ var reakit_utils_isPortalEvent__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(94);
5076  /* harmony import */ var reakit_utils_getActiveElement__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(67);
5077  /* harmony import */ var reakit_utils_dom__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(83);
5078  /* harmony import */ var reakit_utils_tabbable__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(101);
5079  /* harmony import */ var _Role_Role_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(75);
5080  
5081  
5082  
5083  
5084  
5085  
5086  
5087  
5088  
5089  
5090  
5091  
5092  
5093  
5094  
5095  
5096  
5097  // Automatically generated
5098  var TABBABLE_KEYS = ["disabled", "focusable"];
5099  
5100  var isSafariOrFirefoxOnMac = Object(reakit_utils_dom__WEBPACK_IMPORTED_MODULE_12__[/* isUA */ "a"])("Mac") && !Object(reakit_utils_dom__WEBPACK_IMPORTED_MODULE_12__[/* isUA */ "a"])("Chrome") && (Object(reakit_utils_dom__WEBPACK_IMPORTED_MODULE_12__[/* isUA */ "a"])("Safari") || Object(reakit_utils_dom__WEBPACK_IMPORTED_MODULE_12__[/* isUA */ "a"])("Firefox"));
5101  
5102  function focusIfNeeded(element) {
5103    if (!Object(reakit_utils_hasFocusWithin__WEBPACK_IMPORTED_MODULE_9__[/* hasFocusWithin */ "a"])(element)) {
5104      element.focus();
5105    }
5106  } // Safari and Firefox on MacOS don't focus on buttons on mouse down like other
5107  // browsers/platforms. Instead, they focus on the closest focusable ancestor
5108  // element, which is ultimately the body element. So we make sure to give focus
5109  // to the tabbable element on mouse down so it works consistently across
5110  // browsers.
5111  // istanbul ignore next
5112  
5113  
5114  function useFocusOnMouseDown() {
5115    if (!isSafariOrFirefoxOnMac) return undefined;
5116  
5117    var _React$useState = Object(react__WEBPACK_IMPORTED_MODULE_3__["useState"])(null),
5118        tabbable = _React$useState[0],
5119        scheduleFocus = _React$useState[1];
5120  
5121    Object(react__WEBPACK_IMPORTED_MODULE_3__["useEffect"])(function () {
5122      if (!tabbable) return;
5123      focusIfNeeded(tabbable);
5124      scheduleFocus(null);
5125    }, [tabbable]);
5126    var onMouseDown = Object(react__WEBPACK_IMPORTED_MODULE_3__["useCallback"])(function (event) {
5127      var element = event.currentTarget;
5128      if (Object(reakit_utils_isPortalEvent__WEBPACK_IMPORTED_MODULE_10__[/* isPortalEvent */ "a"])(event)) return;
5129      if (!Object(reakit_utils_isButton__WEBPACK_IMPORTED_MODULE_5__[/* isButton */ "a"])(element)) return;
5130      var activeElement = Object(reakit_utils_getActiveElement__WEBPACK_IMPORTED_MODULE_11__[/* getActiveElement */ "a"])(element);
5131      if (!activeElement) return;
5132      var activeElementIsBody = activeElement.tagName === "BODY";
5133      var focusableAncestor = Object(reakit_utils_tabbable__WEBPACK_IMPORTED_MODULE_13__[/* getClosestFocusable */ "a"])(element.parentElement);
5134  
5135      if (activeElement === focusableAncestor || activeElementIsBody && !focusableAncestor) {
5136        // When the active element is the focusable ancestor, it'll not emit
5137        // focus/blur events. After all, it's already focused. So we can't
5138        // listen to those events to focus this tabbable element.
5139        // When the active element is body and there's no focusable ancestor,
5140        // we also don't have any other event to listen to since body never
5141        // emits focus/blur events on itself.
5142        // In both of these cases, we have to schedule focus on this tabbable
5143        // element.
5144        scheduleFocus(element);
5145      } else if (focusableAncestor) {
5146        // Clicking (mouse down) on the tabbable element on Safari and Firefox
5147        // on MacOS will fire focus on the focusable ancestor element if
5148        // there's any and if it's not the current active element. So we wait
5149        // for this event to happen before moving focus to this element.
5150        // Instead of moving focus right away, we have to schedule it,
5151        // otherwise it's gonna prevent drag events from happening.
5152        var onFocus = function onFocus() {
5153          return scheduleFocus(element);
5154        };
5155  
5156        focusableAncestor.addEventListener("focusin", onFocus, {
5157          once: true
5158        });
5159      } else {
5160        // Finally, if there's no focsuable ancestor and there's another
5161        // element with focus, we wait for that element to get blurred before
5162        // focusing this one.
5163        var onBlur = function onBlur() {
5164          return focusIfNeeded(element);
5165        };
5166  
5167        activeElement.addEventListener("blur", onBlur, {
5168          once: true
5169        });
5170      }
5171    }, []);
5172    return onMouseDown;
5173  }
5174  
5175  function isNativeTabbable(element) {
5176    return element.tagName === "BUTTON" || element.tagName === "INPUT" || element.tagName === "SELECT" || element.tagName === "TEXTAREA" || element.tagName === "A";
5177  }
5178  
5179  function supportsDisabledAttribute(element) {
5180    return element.tagName === "BUTTON" || element.tagName === "INPUT" || element.tagName === "SELECT" || element.tagName === "TEXTAREA";
5181  }
5182  
5183  function getTabIndex(trulyDisabled, nativeTabbable, supportsDisabled, htmlTabIndex) {
5184    if (trulyDisabled) {
5185      if (nativeTabbable && !supportsDisabled) {
5186        // Anchor, audio and video tags don't support the `disabled` attribute.
5187        // We must pass tabIndex={-1} so they don't receive focus on tab.
5188        return -1;
5189      } // Elements that support the `disabled` attribute don't need tabIndex.
5190  
5191  
5192      return undefined;
5193    }
5194  
5195    if (nativeTabbable) {
5196      // If the element is enabled and it's natively tabbable, we don't need to
5197      // specify a tabIndex attribute unless it's explicitly set by the user.
5198      return htmlTabIndex;
5199    } // If the element is enabled and is not natively tabbable, we have to
5200    // fallback tabIndex={0}.
5201  
5202  
5203    return htmlTabIndex || 0;
5204  }
5205  
5206  function useDisableEvent(htmlEventRef, disabled) {
5207    return Object(react__WEBPACK_IMPORTED_MODULE_3__["useCallback"])(function (event) {
5208      var _htmlEventRef$current;
5209  
5210      (_htmlEventRef$current = htmlEventRef.current) === null || _htmlEventRef$current === void 0 ? void 0 : _htmlEventRef$current.call(htmlEventRef, event);
5211      if (event.defaultPrevented) return;
5212  
5213      if (disabled) {
5214        event.stopPropagation();
5215        event.preventDefault();
5216      }
5217    }, [htmlEventRef, disabled]);
5218  }
5219  
5220  var useTabbable = Object(reakit_system_createHook__WEBPACK_IMPORTED_MODULE_2__[/* createHook */ "a"])({
5221    name: "Tabbable",
5222    compose: _Role_Role_js__WEBPACK_IMPORTED_MODULE_14__[/* useRole */ "a"],
5223    keys: TABBABLE_KEYS,
5224    useOptions: function useOptions(options, _ref) {
5225      var disabled = _ref.disabled;
5226      return Object(_rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__[/* a */ "b"])({
5227        disabled: disabled
5228      }, options);
5229    },
5230    useProps: function useProps(options, _ref2) {
5231      var htmlRef = _ref2.ref,
5232          htmlTabIndex = _ref2.tabIndex,
5233          htmlOnClickCapture = _ref2.onClickCapture,
5234          htmlOnMouseDownCapture = _ref2.onMouseDownCapture,
5235          htmlOnMouseDown = _ref2.onMouseDown,
5236          htmlOnKeyPressCapture = _ref2.onKeyPressCapture,
5237          htmlStyle = _ref2.style,
5238          htmlProps = Object(_rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__[/* _ */ "a"])(_ref2, ["ref", "tabIndex", "onClickCapture", "onMouseDownCapture", "onMouseDown", "onKeyPressCapture", "style"]);
5239  
5240      var ref = Object(react__WEBPACK_IMPORTED_MODULE_3__["useRef"])(null);
5241      var onClickCaptureRef = Object(reakit_utils_useLiveRef__WEBPACK_IMPORTED_MODULE_7__[/* useLiveRef */ "a"])(htmlOnClickCapture);
5242      var onMouseDownCaptureRef = Object(reakit_utils_useLiveRef__WEBPACK_IMPORTED_MODULE_7__[/* useLiveRef */ "a"])(htmlOnMouseDownCapture);
5243      var onMouseDownRef = Object(reakit_utils_useLiveRef__WEBPACK_IMPORTED_MODULE_7__[/* useLiveRef */ "a"])(htmlOnMouseDown);
5244      var onKeyPressCaptureRef = Object(reakit_utils_useLiveRef__WEBPACK_IMPORTED_MODULE_7__[/* useLiveRef */ "a"])(htmlOnKeyPressCapture);
5245      var trulyDisabled = !!options.disabled && !options.focusable;
5246  
5247      var _React$useState2 = Object(react__WEBPACK_IMPORTED_MODULE_3__["useState"])(true),
5248          nativeTabbable = _React$useState2[0],
5249          setNativeTabbable = _React$useState2[1];
5250  
5251      var _React$useState3 = Object(react__WEBPACK_IMPORTED_MODULE_3__["useState"])(true),
5252          supportsDisabled = _React$useState3[0],
5253          setSupportsDisabled = _React$useState3[1];
5254  
5255      var style = options.disabled ? Object(_rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__[/* a */ "b"])({
5256        pointerEvents: "none"
5257      }, htmlStyle) : htmlStyle;
5258      var focusOnMouseDown = useFocusOnMouseDown();
5259      Object(reakit_utils_useIsomorphicEffect__WEBPACK_IMPORTED_MODULE_8__[/* useIsomorphicEffect */ "a"])(function () {
5260        var tabbable = ref.current;
5261  
5262        if (!tabbable) {
5263           false ? undefined : void 0;
5264          return;
5265        }
5266  
5267        if (!isNativeTabbable(tabbable)) {
5268          setNativeTabbable(false);
5269        }
5270  
5271        if (!supportsDisabledAttribute(tabbable)) {
5272          setSupportsDisabled(false);
5273        }
5274      }, []);
5275      var onClickCapture = useDisableEvent(onClickCaptureRef, options.disabled);
5276      var onMouseDownCapture = useDisableEvent(onMouseDownCaptureRef, options.disabled);
5277      var onKeyPressCapture = useDisableEvent(onKeyPressCaptureRef, options.disabled);
5278      var onMouseDown = Object(react__WEBPACK_IMPORTED_MODULE_3__["useCallback"])(function (event) {
5279        var _onMouseDownRef$curre;
5280  
5281        (_onMouseDownRef$curre = onMouseDownRef.current) === null || _onMouseDownRef$curre === void 0 ? void 0 : _onMouseDownRef$curre.call(onMouseDownRef, event);
5282        if (event.defaultPrevented) return;
5283        focusOnMouseDown === null || focusOnMouseDown === void 0 ? void 0 : focusOnMouseDown(event);
5284      }, [options.disabled, focusOnMouseDown]);
5285      return Object(_rollupPluginBabelHelpers_1f0bf8c2_js__WEBPACK_IMPORTED_MODULE_0__[/* a */ "b"])({
5286        ref: Object(reakit_utils_useForkRef__WEBPACK_IMPORTED_MODULE_4__[/* useForkRef */ "a"])(ref, htmlRef),
5287        style: style,
5288        tabIndex: getTabIndex(trulyDisabled, nativeTabbable, supportsDisabled, htmlTabIndex),
5289        disabled: trulyDisabled && supportsDisabled ? true : undefined,
5290        "aria-disabled": options.disabled ? true : undefined,
5291        onClickCapture: onClickCapture,
5292        onMouseDownCapture: onMouseDownCapture,
5293        onMouseDown: onMouseDown,
5294        onKeyPressCapture: onKeyPressCapture
5295      }, htmlProps);
5296    }
5297  });
5298  var Tabbable = Object(reakit_system_createComponent__WEBPACK_IMPORTED_MODULE_1__[/* createComponent */ "a"])({
5299    as: "div",
5300    useHook: useTabbable
5301  });
5302  
5303  
5304  
5305  
5306  /***/ }),
5307  /* 97 */
5308  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5309  
5310  "use strict";
5311  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return COMPOSITE_KEYS; });
5312  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return COMPOSITE_GROUP_KEYS; });
5313  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return COMPOSITE_ITEM_KEYS; });
5314  /* unused harmony export c */
5315  // Automatically generated
5316  var COMPOSITE_STATE_KEYS = ["baseId", "unstable_idCountRef", "setBaseId", "unstable_virtual", "rtl", "orientation", "items", "groups", "currentId", "loop", "wrap", "shift", "unstable_moves", "unstable_hasActiveWidget", "unstable_includesBaseElement", "registerItem", "unregisterItem", "registerGroup", "unregisterGroup", "move", "next", "previous", "up", "down", "first", "last", "sort", "unstable_setVirtual", "setRTL", "setOrientation", "setCurrentId", "setLoop", "setWrap", "setShift", "reset", "unstable_setIncludesBaseElement", "unstable_setHasActiveWidget"];
5317  var COMPOSITE_KEYS = COMPOSITE_STATE_KEYS;
5318  var COMPOSITE_GROUP_KEYS = COMPOSITE_KEYS;
5319  var COMPOSITE_ITEM_KEYS = COMPOSITE_GROUP_KEYS;
5320  var COMPOSITE_ITEM_WIDGET_KEYS = COMPOSITE_ITEM_KEYS;
5321  
5322  
5323  
5324  
5325  /***/ }),
5326  /* 98 */
5327  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5328  
5329  "use strict";
5330  
5331  // EXPORTS
5332  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ serialize_browser_esm_serializeStyles; });
5333  
5334  // CONCATENATED MODULE: ./node_modules/@emotion/hash/dist/hash.browser.esm.js
5335  /* eslint-disable */
5336  // Inspired by https://github.com/garycourt/murmurhash-js
5337  // Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
5338  function murmur2(str) {
5339    // 'm' and 'r' are mixing constants generated offline.
5340    // They're not really 'magic', they just happen to work well.
5341    // const m = 0x5bd1e995;
5342    // const r = 24;
5343    // Initialize the hash
5344    var h = 0; // Mix 4 bytes at a time into the hash
5345  
5346    var k,
5347        i = 0,
5348        len = str.length;
5349  
5350    for (; len >= 4; ++i, len -= 4) {
5351      k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
5352      k =
5353      /* Math.imul(k, m): */
5354      (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
5355      k ^=
5356      /* k >>> r: */
5357      k >>> 24;
5358      h =
5359      /* Math.imul(k, m): */
5360      (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
5361      /* Math.imul(h, m): */
5362      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
5363    } // Handle the last few bytes of the input array
5364  
5365  
5366    switch (len) {
5367      case 3:
5368        h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
5369  
5370      case 2:
5371        h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
5372  
5373      case 1:
5374        h ^= str.charCodeAt(i) & 0xff;
5375        h =
5376        /* Math.imul(h, m): */
5377        (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
5378    } // Do a few final mixes of the hash to ensure the last few
5379    // bytes are well-incorporated.
5380  
5381  
5382    h ^= h >>> 13;
5383    h =
5384    /* Math.imul(h, m): */
5385    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
5386    return ((h ^ h >>> 15) >>> 0).toString(36);
5387  }
5388  
5389  /* harmony default export */ var hash_browser_esm = (murmur2);
5390  
5391  // CONCATENATED MODULE: ./node_modules/@emotion/unitless/dist/unitless.browser.esm.js
5392  var unitlessKeys = {
5393    animationIterationCount: 1,
5394    borderImageOutset: 1,
5395    borderImageSlice: 1,
5396    borderImageWidth: 1,
5397    boxFlex: 1,
5398    boxFlexGroup: 1,
5399    boxOrdinalGroup: 1,
5400    columnCount: 1,
5401    columns: 1,
5402    flex: 1,
5403    flexGrow: 1,
5404    flexPositive: 1,
5405    flexShrink: 1,
5406    flexNegative: 1,
5407    flexOrder: 1,
5408    gridRow: 1,
5409    gridRowEnd: 1,
5410    gridRowSpan: 1,
5411    gridRowStart: 1,
5412    gridColumn: 1,
5413    gridColumnEnd: 1,
5414    gridColumnSpan: 1,
5415    gridColumnStart: 1,
5416    msGridRow: 1,
5417    msGridRowSpan: 1,
5418    msGridColumn: 1,
5419    msGridColumnSpan: 1,
5420    fontWeight: 1,
5421    lineHeight: 1,
5422    opacity: 1,
5423    order: 1,
5424    orphans: 1,
5425    tabSize: 1,
5426    widows: 1,
5427    zIndex: 1,
5428    zoom: 1,
5429    WebkitLineClamp: 1,
5430    // SVG-related properties
5431    fillOpacity: 1,
5432    floodOpacity: 1,
5433    stopOpacity: 1,
5434    strokeDasharray: 1,
5435    strokeDashoffset: 1,
5436    strokeMiterlimit: 1,
5437    strokeOpacity: 1,
5438    strokeWidth: 1
5439  };
5440  
5441  /* harmony default export */ var unitless_browser_esm = (unitlessKeys);
5442  
5443  // EXTERNAL MODULE: ./node_modules/@emotion/memoize/dist/memoize.browser.esm.js
5444  var memoize_browser_esm = __webpack_require__(177);
5445  
5446  // CONCATENATED MODULE: ./node_modules/@emotion/serialize/dist/serialize.browser.esm.js
5447  
5448  
5449  
5450  
5451  var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
5452  var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).";
5453  var hyphenateRegex = /[A-Z]|^ms/g;
5454  var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
5455  
5456  var isCustomProperty = function isCustomProperty(property) {
5457    return property.charCodeAt(1) === 45;
5458  };
5459  
5460  var isProcessableValue = function isProcessableValue(value) {
5461    return value != null && typeof value !== 'boolean';
5462  };
5463  
5464  var processStyleName = Object(memoize_browser_esm["a" /* default */])(function (styleName) {
5465    return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
5466  });
5467  
5468  var serialize_browser_esm_processStyleValue = function processStyleValue(key, value) {
5469    switch (key) {
5470      case 'animation':
5471      case 'animationName':
5472        {
5473          if (typeof value === 'string') {
5474            return value.replace(animationRegex, function (match, p1, p2) {
5475              cursor = {
5476                name: p1,
5477                styles: p2,
5478                next: cursor
5479              };
5480              return p1;
5481            });
5482          }
5483        }
5484    }
5485  
5486    if (unitless_browser_esm[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
5487      return value + 'px';
5488    }
5489  
5490    return value;
5491  };
5492  
5493  if (false) { var hyphenatedCache, hyphenPattern, msPattern, oldProcessStyleValue, contentValues, contentValuePattern; }
5494  
5495  var shouldWarnAboutInterpolatingClassNameFromCss = true;
5496  
5497  function handleInterpolation(mergedProps, registered, interpolation, couldBeSelectorInterpolation) {
5498    if (interpolation == null) {
5499      return '';
5500    }
5501  
5502    if (interpolation.__emotion_styles !== undefined) {
5503      if (false) {}
5504  
5505      return interpolation;
5506    }
5507  
5508    switch (typeof interpolation) {
5509      case 'boolean':
5510        {
5511          return '';
5512        }
5513  
5514      case 'object':
5515        {
5516          if (interpolation.anim === 1) {
5517            cursor = {
5518              name: interpolation.name,
5519              styles: interpolation.styles,
5520              next: cursor
5521            };
5522            return interpolation.name;
5523          }
5524  
5525          if (interpolation.styles !== undefined) {
5526            var next = interpolation.next;
5527  
5528            if (next !== undefined) {
5529              // not the most efficient thing ever but this is a pretty rare case
5530              // and there will be very few iterations of this generally
5531              while (next !== undefined) {
5532                cursor = {
5533                  name: next.name,
5534                  styles: next.styles,
5535                  next: cursor
5536                };
5537                next = next.next;
5538              }
5539            }
5540  
5541            var styles = interpolation.styles + ";";
5542  
5543            if (false) {}
5544  
5545            return styles;
5546          }
5547  
5548          return createStringFromObject(mergedProps, registered, interpolation);
5549        }
5550  
5551      case 'function':
5552        {
5553          if (mergedProps !== undefined) {
5554            var previousCursor = cursor;
5555            var result = interpolation(mergedProps);
5556            cursor = previousCursor;
5557            return handleInterpolation(mergedProps, registered, result, couldBeSelectorInterpolation);
5558          } else if (false) {}
5559  
5560          break;
5561        }
5562  
5563      case 'string':
5564        if (false) { var replaced, matched; }
5565  
5566        break;
5567    } // finalize string values (regular strings and functions interpolated into css calls)
5568  
5569  
5570    if (registered == null) {
5571      return interpolation;
5572    }
5573  
5574    var cached = registered[interpolation];
5575  
5576    if (false) {}
5577  
5578    return cached !== undefined && !couldBeSelectorInterpolation ? cached : interpolation;
5579  }
5580  
5581  function createStringFromObject(mergedProps, registered, obj) {
5582    var string = '';
5583  
5584    if (Array.isArray(obj)) {
5585      for (var i = 0; i < obj.length; i++) {
5586        string += handleInterpolation(mergedProps, registered, obj[i], false);
5587      }
5588    } else {
5589      for (var _key in obj) {
5590        var value = obj[_key];
5591  
5592        if (typeof value !== 'object') {
5593          if (registered != null && registered[value] !== undefined) {
5594            string += _key + "{" + registered[value] + "}";
5595          } else if (isProcessableValue(value)) {
5596            string += processStyleName(_key) + ":" + serialize_browser_esm_processStyleValue(_key, value) + ";";
5597          }
5598        } else {
5599          if (_key === 'NO_COMPONENT_SELECTOR' && "production" !== 'production') {
5600            throw new Error('Component selectors can only be used in conjunction with babel-plugin-emotion.');
5601          }
5602  
5603          if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
5604            for (var _i = 0; _i < value.length; _i++) {
5605              if (isProcessableValue(value[_i])) {
5606                string += processStyleName(_key) + ":" + serialize_browser_esm_processStyleValue(_key, value[_i]) + ";";
5607              }
5608            }
5609          } else {
5610            var interpolated = handleInterpolation(mergedProps, registered, value, false);
5611  
5612            switch (_key) {
5613              case 'animation':
5614              case 'animationName':
5615                {
5616                  string += processStyleName(_key) + ":" + interpolated + ";";
5617                  break;
5618                }
5619  
5620              default:
5621                {
5622                  if (false) {}
5623  
5624                  string += _key + "{" + interpolated + "}";
5625                }
5626            }
5627          }
5628        }
5629      }
5630    }
5631  
5632    return string;
5633  }
5634  
5635  var labelPattern = /label:\s*([^\s;\n{]+)\s*;/g;
5636  var sourceMapPattern;
5637  
5638  if (false) {} // this is the cursor for keyframes
5639  // keyframes are stored on the SerializedStyles object as a linked list
5640  
5641  
5642  var cursor;
5643  var serialize_browser_esm_serializeStyles = function serializeStyles(args, registered, mergedProps) {
5644    if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
5645      return args[0];
5646    }
5647  
5648    var stringMode = true;
5649    var styles = '';
5650    cursor = undefined;
5651    var strings = args[0];
5652  
5653    if (strings == null || strings.raw === undefined) {
5654      stringMode = false;
5655      styles += handleInterpolation(mergedProps, registered, strings, false);
5656    } else {
5657      if (false) {}
5658  
5659      styles += strings[0];
5660    } // we start at 1 since we've already handled the first arg
5661  
5662  
5663    for (var i = 1; i < args.length; i++) {
5664      styles += handleInterpolation(mergedProps, registered, args[i], styles.charCodeAt(styles.length - 1) === 46);
5665  
5666      if (stringMode) {
5667        if (false) {}
5668  
5669        styles += strings[i];
5670      }
5671    }
5672  
5673    var sourceMap;
5674  
5675    if (false) {} // using a global regex with .exec is stateful so lastIndex has to be reset each time
5676  
5677  
5678    labelPattern.lastIndex = 0;
5679    var identifierName = '';
5680    var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
5681  
5682    while ((match = labelPattern.exec(styles)) !== null) {
5683      identifierName += '-' + // $FlowFixMe we know it's not null
5684      match[1];
5685    }
5686  
5687    var name = hash_browser_esm(styles) + identifierName;
5688  
5689    if (false) {}
5690  
5691    return {
5692      name: name,
5693      styles: styles,
5694      next: cursor
5695    };
5696  };
5697  
5698  
5699  
5700  
5701  /***/ }),
5702  /* 99 */
5703  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5704  
5705  "use strict";
5706  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getRegisteredStyles; });
5707  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return insertStyles; });
5708  var isBrowser = "object" !== 'undefined';
5709  function getRegisteredStyles(registered, registeredStyles, classNames) {
5710    var rawClassName = '';
5711    classNames.split(' ').forEach(function (className) {
5712      if (registered[className] !== undefined) {
5713        registeredStyles.push(registered[className]);
5714      } else {
5715        rawClassName += className + " ";
5716      }
5717    });
5718    return rawClassName;
5719  }
5720  var insertStyles = function insertStyles(cache, serialized, isStringTag) {
5721    var className = cache.key + "-" + serialized.name;
5722  
5723    if ( // we only need to add the styles to the registered cache if the
5724    // class name could be used further down
5725    // the tree but if it's a string tag, we know it won't
5726    // so we don't have to add it to registered cache.
5727    // this improves memory usage since we can avoid storing the whole style string
5728    (isStringTag === false || // we need to always store it if we're in compat mode and
5729    // in node since emotion-server relies on whether a style is in
5730    // the registered cache to know whether a style is global or not
5731    // also, note that this check will be dead code eliminated in the browser
5732    isBrowser === false && cache.compat !== undefined) && cache.registered[className] === undefined) {
5733      cache.registered[className] = serialized.styles;
5734    }
5735  
5736    if (cache.inserted[serialized.name] === undefined) {
5737      var current = serialized;
5738  
5739      do {
5740        var maybeStyles = cache.insert("." + className, current, cache.sheet, true);
5741  
5742        current = current.next;
5743      } while (current !== undefined);
5744    }
5745  };
5746  
5747  
5748  
5749  
5750  /***/ }),
5751  /* 100 */
5752  /***/ (function(module, exports, __webpack_require__) {
5753  
5754  "use strict";
5755  
5756  
5757  var keys = __webpack_require__(221);
5758  var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
5759  
5760  var toStr = Object.prototype.toString;
5761  var concat = Array.prototype.concat;
5762  var origDefineProperty = Object.defineProperty;
5763  
5764  var isFunction = function (fn) {
5765      return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
5766  };
5767  
5768  var arePropertyDescriptorsSupported = function () {
5769      var obj = {};
5770      try {
5771          origDefineProperty(obj, 'x', { enumerable: false, value: obj });
5772          // eslint-disable-next-line no-unused-vars, no-restricted-syntax
5773          for (var _ in obj) { // jscs:ignore disallowUnusedVariables
5774              return false;
5775          }
5776          return obj.x === obj;
5777      } catch (e) { /* this is IE 8. */
5778          return false;
5779      }
5780  };
5781  var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
5782  
5783  var defineProperty = function (object, name, value, predicate) {
5784      if (name in object && (!isFunction(predicate) || !predicate())) {
5785          return;
5786      }
5787      if (supportsDescriptors) {
5788          origDefineProperty(object, name, {
5789              configurable: true,
5790              enumerable: false,
5791              value: value,
5792              writable: true
5793          });
5794      } else {
5795          object[name] = value;
5796      }
5797  };
5798  
5799  var defineProperties = function (object, map) {
5800      var predicates = arguments.length > 2 ? arguments[2] : {};
5801      var props = keys(map);
5802      if (hasSymbols) {
5803          props = concat.call(props, Object.getOwnPropertySymbols(map));
5804      }
5805      for (var i = 0; i < props.length; i += 1) {
5806          defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
5807      }
5808  };
5809  
5810  defineProperties.supportsDescriptors = !!supportsDescriptors;
5811  
5812  module.exports = defineProperties;
5813  
5814  
5815  /***/ }),
5816  /* 101 */
5817  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5818  
5819  "use strict";
5820  
5821  // EXPORTS
5822  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ getClosestFocusable; });
5823  
5824  // UNUSED EXPORTS: getAllFocusableIn, getAllTabbableIn, getFirstFocusableIn, getFirstTabbableIn, getLastTabbableIn, getNextTabbableIn, getPreviousTabbableIn, isFocusable, isTabbable
5825  
5826  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/matches.js
5827  /**
5828   * Ponyfill for `Element.prototype.matches`
5829   *
5830   * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/matches
5831   */
5832  function matches(element, selectors) {
5833    if ("matches" in element) {
5834      return element.matches(selectors);
5835    }
5836  
5837    if ("msMatchesSelector" in element) {
5838      return element.msMatchesSelector(selectors);
5839    }
5840  
5841    return element.webkitMatchesSelector(selectors);
5842  }
5843  
5844  
5845  
5846  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/closest.js
5847  
5848  
5849  /**
5850   * Ponyfill for `Element.prototype.closest`
5851   *
5852   * @example
5853   * import { closest } from "reakit-utils";
5854   *
5855   * closest(document.getElementById("id"), "div");
5856   * // same as
5857   * document.getElementById("id").closest("div");
5858   */
5859  function closest(element, selectors) {
5860    if ("closest" in element) return element.closest(selectors);
5861  
5862    do {
5863      if (matches(element, selectors)) return element;
5864      element = element.parentElement || element.parentNode;
5865    } while (element !== null && element.nodeType === 1);
5866  
5867    return null;
5868  }
5869  
5870  
5871  
5872  // EXTERNAL MODULE: ./node_modules/reakit-utils/es/getActiveElement.js
5873  var getActiveElement = __webpack_require__(67);
5874  
5875  // CONCATENATED MODULE: ./node_modules/reakit-utils/es/tabbable.js
5876  
5877  
5878  
5879  
5880  
5881  /** @module tabbable */
5882  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'])";
5883  
5884  function isVisible(element) {
5885    var htmlElement = element;
5886    return htmlElement.offsetWidth > 0 || htmlElement.offsetHeight > 0 || element.getClientRects().length > 0;
5887  }
5888  
5889  function hasNegativeTabIndex(element) {
5890    var tabIndex = parseInt(element.getAttribute("tabindex") || "0", 10);
5891    return tabIndex < 0;
5892  }
5893  /**
5894   * Checks whether `element` is focusable or not.
5895   *
5896   * @memberof tabbable
5897   *
5898   * @example
5899   * import { isFocusable } from "reakit-utils";
5900   *
5901   * isFocusable(document.querySelector("input")); // true
5902   * isFocusable(document.querySelector("input[tabindex='-1']")); // true
5903   * isFocusable(document.querySelector("input[hidden]")); // false
5904   * isFocusable(document.querySelector("input:disabled")); // false
5905   */
5906  
5907  
5908  function isFocusable(element) {
5909    return matches(element, selector) && isVisible(element);
5910  }
5911  /**
5912   * Checks whether `element` is tabbable or not.
5913   *
5914   * @memberof tabbable
5915   *
5916   * @example
5917   * import { isTabbable } from "reakit-utils";
5918   *
5919   * isTabbable(document.querySelector("input")); // true
5920   * isTabbable(document.querySelector("input[tabindex='-1']")); // false
5921   * isTabbable(document.querySelector("input[hidden]")); // false
5922   * isTabbable(document.querySelector("input:disabled")); // false
5923   */
5924  
5925  function isTabbable(element) {
5926    return isFocusable(element) && !hasNegativeTabIndex(element);
5927  }
5928  /**
5929   * Returns all the focusable elements in `container`.
5930   *
5931   * @memberof tabbable
5932   *
5933   * @param {Element} container
5934   *
5935   * @returns {Element[]}
5936   */
5937  
5938  function getAllFocusableIn(container) {
5939    var allFocusable = Array.from(container.querySelectorAll(selector));
5940    allFocusable.unshift(container);
5941    return allFocusable.filter(isFocusable);
5942  }
5943  /**
5944   * Returns the first focusable element in `container`.
5945   *
5946   * @memberof tabbable
5947   *
5948   * @param {Element} container
5949   *
5950   * @returns {Element|null}
5951   */
5952  
5953  function getFirstFocusableIn(container) {
5954    var _getAllFocusableIn = getAllFocusableIn(container),
5955        first = _getAllFocusableIn[0];
5956  
5957    return first || null;
5958  }
5959  /**
5960   * Returns all the tabbable elements in `container`, including the container
5961   * itself.
5962   *
5963   * @memberof tabbable
5964   *
5965   * @param {Element} container
5966   * @param fallbackToFocusable If `true`, it'll return focusable elements if there are no tabbable ones.
5967   *
5968   * @returns {Element[]}
5969   */
5970  
5971  function getAllTabbableIn(container, fallbackToFocusable) {
5972    var allFocusable = Array.from(container.querySelectorAll(selector));
5973    var allTabbable = allFocusable.filter(isTabbable);
5974  
5975    if (isTabbable(container)) {
5976      allTabbable.unshift(container);
5977    }
5978  
5979    if (!allTabbable.length && fallbackToFocusable) {
5980      return allFocusable;
5981    }
5982  
5983    return allTabbable;
5984  }
5985  /**
5986   * Returns the first tabbable element in `container`, including the container
5987   * itself if it's tabbable.
5988   *
5989   * @memberof tabbable
5990   *
5991   * @param {Element} container
5992   * @param fallbackToFocusable If `true`, it'll return the first focusable element if there are no tabbable ones.
5993   *
5994   * @returns {Element|null}
5995   */
5996  
5997  function getFirstTabbableIn(container, fallbackToFocusable) {
5998    var _getAllTabbableIn = getAllTabbableIn(container, fallbackToFocusable),
5999        first = _getAllTabbableIn[0];
6000  
6001    return first || null;
6002  }
6003  /**
6004   * Returns the last tabbable element in `container`, including the container
6005   * itself if it's tabbable.
6006   *
6007   * @memberof tabbable
6008   *
6009   * @param {Element} container
6010   * @param fallbackToFocusable If `true`, it'll return the last focusable element if there are no tabbable ones.
6011   *
6012   * @returns {Element|null}
6013   */
6014  
6015  function getLastTabbableIn(container, fallbackToFocusable) {
6016    var allTabbable = getAllTabbableIn(container, fallbackToFocusable);
6017    return allTabbable[allTabbable.length - 1] || null;
6018  }
6019  /**
6020   * Returns the next tabbable element in `container`.
6021   *
6022   * @memberof tabbable
6023   *
6024   * @param {Element} container
6025   * @param fallbackToFocusable If `true`, it'll return the next focusable element if there are no tabbable ones.
6026   *
6027   * @returns {Element|null}
6028   */
6029  
6030  function getNextTabbableIn(container, fallbackToFocusable) {
6031    var activeElement = Object(getActiveElement["a" /* getActiveElement */])(container);
6032    var allFocusable = getAllFocusableIn(container);
6033    var index = allFocusable.indexOf(activeElement);
6034    var slice = allFocusable.slice(index + 1);
6035    return slice.find(isTabbable) || allFocusable.find(isTabbable) || (fallbackToFocusable ? slice[0] : null);
6036  }
6037  /**
6038   * Returns the previous tabbable element in `container`.
6039   *
6040   * @memberof tabbable
6041   *
6042   * @param {Element} container
6043   * @param fallbackToFocusable If `true`, it'll return the previous focusable element if there are no tabbable ones.
6044   *
6045   * @returns {Element|null}
6046   */
6047  
6048  function getPreviousTabbableIn(container, fallbackToFocusable) {
6049    var activeElement = Object(getActiveElement["a" /* getActiveElement */])(container);
6050    var allFocusable = getAllFocusableIn(container).reverse();
6051    var index = allFocusable.indexOf(activeElement);
6052    var slice = allFocusable.slice(index + 1);
6053    return slice.find(isTabbable) || allFocusable.find(isTabbable) || (fallbackToFocusable ? slice[0] : null);
6054  }
6055  /**
6056   * Returns the closest focusable element.
6057   *
6058   * @memberof tabbable
6059   *
6060   * @param {Element} container
6061   *
6062   * @returns {Element|null}
6063   */
6064  
6065  function getClosestFocusable(element) {
6066    while (element && !isFocusable(element)) {
6067      element = closest(element, selector);
6068    }
6069  
6070    return element;
6071  }
6072  
6073  
6074  
6075  
6076  /***/ }),
6077  /* 102 */
6078  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6079  
6080  "use strict";
6081  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getAnimateClassName; });
6082  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Animate; });
6083  /* harmony import */ var _babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
6084  /* harmony import */ var _babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
6085  /* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
6086  /* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(classnames__WEBPACK_IMPORTED_MODULE_2__);
6087  
6088  
6089  
6090  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
6091  
6092  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
6093  
6094  /**
6095   * External dependencies
6096   */
6097  
6098  /**
6099   * @typedef {'top' | 'top left' | 'top right' | 'middle' | 'middle left' | 'middle right' | 'bottom' | 'bottom left' | 'bottom right'} AppearOrigin
6100   * @typedef {'left' | 'right'} SlideInOrigin
6101   * @typedef {{ type: 'appear'; origin?: AppearOrigin }} AppearOptions
6102   * @typedef {{ type: 'slide-in'; origin?: SlideInOrigin }} SlideInOptions
6103   * @typedef {{ type: 'loading'; }} LoadingOptions
6104   * @typedef {AppearOptions | SlideInOptions | LoadingOptions} GetAnimateOptions
6105   */
6106  
6107  /* eslint-disable jsdoc/valid-types */
6108  
6109  /**
6110   * @param {GetAnimateOptions['type']} type The animation type
6111   * @return {'top' | 'left'} Default origin
6112   */
6113  
6114  function getDefaultOrigin(type) {
6115    return type === 'appear' ? 'top' : 'left';
6116  }
6117  /* eslint-enable jsdoc/valid-types */
6118  
6119  /**
6120   * @param {GetAnimateOptions} options
6121   *
6122   * @return {string | void} ClassName that applies the animations
6123   */
6124  
6125  
6126  function getAnimateClassName(options) {
6127    if (options.type === 'loading') {
6128      return classnames__WEBPACK_IMPORTED_MODULE_2___default()('components-animate__loading');
6129    }
6130  
6131    var type = options.type,
6132        _options$origin = options.origin,
6133        origin = _options$origin === void 0 ? getDefaultOrigin(type) : _options$origin;
6134  
6135    if (type === 'appear') {
6136      var _classnames;
6137  
6138      var _origin$split = origin.split(' '),
6139          _origin$split2 = Object(_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(_origin$split, 2),
6140          yAxis = _origin$split2[0],
6141          _origin$split2$ = _origin$split2[1],
6142          xAxis = _origin$split2$ === void 0 ? 'center' : _origin$split2$;
6143  
6144      return classnames__WEBPACK_IMPORTED_MODULE_2___default()('components-animate__appear', (_classnames = {}, Object(_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_classnames, 'is-from-' + xAxis, xAxis !== 'center'), Object(_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_classnames, 'is-from-' + yAxis, yAxis !== 'middle'), _classnames));
6145    }
6146  
6147    if (type === 'slide-in') {
6148      return classnames__WEBPACK_IMPORTED_MODULE_2___default()('components-animate__slide-in', 'is-from-' + origin);
6149    }
6150  } // @ts-ignore Reason: Planned for deprecation
6151  
6152  function Animate(_ref) {
6153    var type = _ref.type,
6154        _ref$options = _ref.options,
6155        options = _ref$options === void 0 ? {} : _ref$options,
6156        children = _ref.children;
6157    return children({
6158      className: getAnimateClassName(_objectSpread({
6159        type: type
6160      }, options))
6161    });
6162  }
6163  
6164  
6165  /***/ }),
6166  /* 103 */
6167  /***/ (function(module, exports) {
6168  
6169  (function() { module.exports = window["wp"]["warning"]; }());
6170  
6171  /***/ }),
6172  /* 104 */,
6173  /* 105 */,
6174  /* 106 */
6175  /***/ (function(module, exports, __webpack_require__) {
6176  
6177  "use strict";
6178  
6179  
6180  Object.defineProperty(exports, "__esModule", {
6181    value: true
6182  });
6183  var calendarLabel = 'Calendar';
6184  var closeDatePicker = 'Close';
6185  var focusStartDate = 'Interact with the calendar and add the check-in date for your trip.';
6186  var clearDate = 'Clear Date';
6187  var clearDates = 'Clear Dates';
6188  var jumpToPrevMonth = 'Move backward to switch to the previous month.';
6189  var jumpToNextMonth = 'Move forward to switch to the next month.';
6190  var keyboardShortcuts = 'Keyboard Shortcuts';
6191  var showKeyboardShortcutsPanel = 'Open the keyboard shortcuts panel.';
6192  var hideKeyboardShortcutsPanel = 'Close the shortcuts panel.';
6193  var openThisPanel = 'Open this panel.';
6194  var enterKey = 'Enter key';
6195  var leftArrowRightArrow = 'Right and left arrow keys';
6196  var upArrowDownArrow = 'up and down arrow keys';
6197  var pageUpPageDown = 'page up and page down keys';
6198  var homeEnd = 'Home and end keys';
6199  var escape = 'Escape key';
6200  var questionMark = 'Question mark';
6201  var selectFocusedDate = 'Select the date in focus.';
6202  var moveFocusByOneDay = 'Move backward (left) and forward (right) by one day.';
6203  var moveFocusByOneWeek = 'Move backward (up) and forward (down) by one week.';
6204  var moveFocusByOneMonth = 'Switch months.';
6205  var moveFocustoStartAndEndOfWeek = 'Go to the first or last day of a week.';
6206  var returnFocusToInput = 'Return to the date input field.';
6207  var keyboardNavigationInstructions = 'Press the down arrow key to interact with the calendar and\n  select a date. Press the question mark key to get the keyboard shortcuts for changing dates.';
6208  
6209  var chooseAvailableStartDate = function chooseAvailableStartDate(_ref) {
6210    var date = _ref.date;
6211    return 'Choose ' + String(date) + ' as your check-in date. It\u2019s available.';
6212  };
6213  var chooseAvailableEndDate = function chooseAvailableEndDate(_ref2) {
6214    var date = _ref2.date;
6215    return 'Choose ' + String(date) + ' as your check-out date. It\u2019s available.';
6216  };
6217  var chooseAvailableDate = function chooseAvailableDate(_ref3) {
6218    var date = _ref3.date;
6219    return date;
6220  };
6221  var dateIsUnavailable = function dateIsUnavailable(_ref4) {
6222    var date = _ref4.date;
6223    return 'Not available. ' + String(date);
6224  };
6225  var dateIsSelected = function dateIsSelected(_ref5) {
6226    var date = _ref5.date;
6227    return 'Selected. ' + String(date);
6228  };
6229  
6230  exports['default'] = {
6231    calendarLabel: calendarLabel,
6232    closeDatePicker: closeDatePicker,
6233    focusStartDate: focusStartDate,
6234    clearDate: clearDate,
6235    clearDates: clearDates,
6236    jumpToPrevMonth: jumpToPrevMonth,
6237    jumpToNextMonth: jumpToNextMonth,
6238    keyboardShortcuts: keyboardShortcuts,
6239    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
6240    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
6241    openThisPanel: openThisPanel,
6242    enterKey: enterKey,
6243    leftArrowRightArrow: leftArrowRightArrow,
6244    upArrowDownArrow: upArrowDownArrow,
6245    pageUpPageDown: pageUpPageDown,
6246    homeEnd: homeEnd,
6247    escape: escape,
6248    questionMark: questionMark,
6249    selectFocusedDate: selectFocusedDate,
6250    moveFocusByOneDay: moveFocusByOneDay,
6251    moveFocusByOneWeek: moveFocusByOneWeek,
6252    moveFocusByOneMonth: moveFocusByOneMonth,
6253    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
6254    returnFocusToInput: returnFocusToInput,
6255    keyboardNavigationInstructions: keyboardNavigationInstructions,
6256  
6257    chooseAvailableStartDate: chooseAvailableStartDate,
6258    chooseAvailableEndDate: chooseAvailableEndDate,
6259    dateIsUnavailable: dateIsUnavailable,
6260    dateIsSelected: dateIsSelected
6261  };
6262  var DateRangePickerPhrases = exports.DateRangePickerPhrases = {
6263    calendarLabel: calendarLabel,
6264    closeDatePicker: closeDatePicker,
6265    clearDates: clearDates,
6266    focusStartDate: focusStartDate,
6267    jumpToPrevMonth: jumpToPrevMonth,
6268    jumpToNextMonth: jumpToNextMonth,
6269    keyboardShortcuts: keyboardShortcuts,
6270    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
6271    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
6272    openThisPanel: openThisPanel,
6273    enterKey: enterKey,
6274    leftArrowRightArrow: leftArrowRightArrow,
6275    upArrowDownArrow: upArrowDownArrow,
6276    pageUpPageDown: pageUpPageDown,
6277    homeEnd: homeEnd,
6278    escape: escape,
6279    questionMark: questionMark,
6280    selectFocusedDate: selectFocusedDate,
6281    moveFocusByOneDay: moveFocusByOneDay,
6282    moveFocusByOneWeek: moveFocusByOneWeek,
6283    moveFocusByOneMonth: moveFocusByOneMonth,
6284    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
6285    returnFocusToInput: returnFocusToInput,
6286    keyboardNavigationInstructions: keyboardNavigationInstructions,
6287    chooseAvailableStartDate: chooseAvailableStartDate,
6288    chooseAvailableEndDate: chooseAvailableEndDate,
6289    dateIsUnavailable: dateIsUnavailable,
6290    dateIsSelected: dateIsSelected
6291  };
6292  
6293  var DateRangePickerInputPhrases = exports.DateRangePickerInputPhrases = {
6294    focusStartDate: focusStartDate,
6295    clearDates: clearDates,
6296    keyboardNavigationInstructions: keyboardNavigationInstructions
6297  };
6298  
6299  var SingleDatePickerPhrases = exports.SingleDatePickerPhrases = {
6300    calendarLabel: calendarLabel,
6301    closeDatePicker: closeDatePicker,
6302    clearDate: clearDate,
6303    jumpToPrevMonth: jumpToPrevMonth,
6304    jumpToNextMonth: jumpToNextMonth,
6305    keyboardShortcuts: keyboardShortcuts,
6306    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
6307    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
6308    openThisPanel: openThisPanel,
6309    enterKey: enterKey,
6310    leftArrowRightArrow: leftArrowRightArrow,
6311    upArrowDownArrow: upArrowDownArrow,
6312    pageUpPageDown: pageUpPageDown,
6313    homeEnd: homeEnd,
6314    escape: escape,
6315    questionMark: questionMark,
6316    selectFocusedDate: selectFocusedDate,
6317    moveFocusByOneDay: moveFocusByOneDay,
6318    moveFocusByOneWeek: moveFocusByOneWeek,
6319    moveFocusByOneMonth: moveFocusByOneMonth,
6320    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
6321    returnFocusToInput: returnFocusToInput,
6322    keyboardNavigationInstructions: keyboardNavigationInstructions,
6323    chooseAvailableDate: chooseAvailableDate,
6324    dateIsUnavailable: dateIsUnavailable,
6325    dateIsSelected: dateIsSelected
6326  };
6327  
6328  var SingleDatePickerInputPhrases = exports.SingleDatePickerInputPhrases = {
6329    clearDate: clearDate,
6330    keyboardNavigationInstructions: keyboardNavigationInstructions
6331  };
6332  
6333  var DayPickerPhrases = exports.DayPickerPhrases = {
6334    calendarLabel: calendarLabel,
6335    jumpToPrevMonth: jumpToPrevMonth,
6336    jumpToNextMonth: jumpToNextMonth,
6337    keyboardShortcuts: keyboardShortcuts,
6338    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
6339    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
6340    openThisPanel: openThisPanel,
6341    enterKey: enterKey,
6342    leftArrowRightArrow: leftArrowRightArrow,
6343    upArrowDownArrow: upArrowDownArrow,
6344    pageUpPageDown: pageUpPageDown,
6345    homeEnd: homeEnd,
6346    escape: escape,
6347    questionMark: questionMark,
6348    selectFocusedDate: selectFocusedDate,
6349    moveFocusByOneDay: moveFocusByOneDay,
6350    moveFocusByOneWeek: moveFocusByOneWeek,
6351    moveFocusByOneMonth: moveFocusByOneMonth,
6352    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
6353    returnFocusToInput: returnFocusToInput,
6354    chooseAvailableStartDate: chooseAvailableStartDate,
6355    chooseAvailableEndDate: chooseAvailableEndDate,
6356    chooseAvailableDate: chooseAvailableDate,
6357    dateIsUnavailable: dateIsUnavailable,
6358    dateIsSelected: dateIsSelected
6359  };
6360  
6361  var DayPickerKeyboardShortcutsPhrases = exports.DayPickerKeyboardShortcutsPhrases = {
6362    keyboardShortcuts: keyboardShortcuts,
6363    showKeyboardShortcutsPanel: showKeyboardShortcutsPanel,
6364    hideKeyboardShortcutsPanel: hideKeyboardShortcutsPanel,
6365    openThisPanel: openThisPanel,
6366    enterKey: enterKey,
6367    leftArrowRightArrow: leftArrowRightArrow,
6368    upArrowDownArrow: upArrowDownArrow,
6369    pageUpPageDown: pageUpPageDown,
6370    homeEnd: homeEnd,
6371    escape: escape,
6372    questionMark: questionMark,
6373    selectFocusedDate: selectFocusedDate,
6374    moveFocusByOneDay: moveFocusByOneDay,
6375    moveFocusByOneWeek: moveFocusByOneWeek,
6376    moveFocusByOneMonth: moveFocusByOneMonth,
6377    moveFocustoStartAndEndOfWeek: moveFocustoStartAndEndOfWeek,
6378    returnFocusToInput: returnFocusToInput
6379  };
6380  
6381  var DayPickerNavigationPhrases = exports.DayPickerNavigationPhrases = {
6382    jumpToPrevMonth: jumpToPrevMonth,
6383    jumpToNextMonth: jumpToNextMonth
6384  };
6385  
6386  var CalendarDayPhrases = exports.CalendarDayPhrases = {
6387    chooseAvailableDate: chooseAvailableDate,
6388    dateIsUnavailable: dateIsUnavailable,
6389    dateIsSelected: dateIsSelected
6390  };
6391  
6392  /***/ }),
6393  /* 107 */
6394  /***/ (function(module, exports, __webpack_require__) {
6395  
6396  "use strict";
6397  
6398  
6399  Object.defineProperty(exports, "__esModule", {
6400    value: true
6401  });
6402  exports['default'] = getPhrasePropTypes;
6403  
6404  var _object = __webpack_require__(87);
6405  
6406  var _object2 = _interopRequireDefault(_object);
6407  
6408  var _propTypes = __webpack_require__(31);
6409  
6410  var _propTypes2 = _interopRequireDefault(_propTypes);
6411  
6412  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
6413  
6414  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
6415  
6416  function getPhrasePropTypes(defaultPhrases) {
6417    return Object.keys(defaultPhrases).reduce(function (phrases, key) {
6418      return (0, _object2['default'])({}, phrases, _defineProperty({}, key, _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func, _propTypes2['default'].node])));
6419    }, {});
6420  }
6421  
6422  /***/ }),
6423  /* 108 */
6424  /***/ (function(module, exports, __webpack_require__) {
6425  
6426  "use strict";
6427  
6428  
6429  Object.defineProperty(exports, "__esModule", {
6430    value: true
6431  });
6432  exports.withStylesPropTypes = exports.css = undefined;
6433  
6434  var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
6435  
6436  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
6437  
6438  exports.withStyles = withStyles;
6439  
6440  var _object = __webpack_require__(87);
6441  
6442  var _object2 = _interopRequireDefault(_object);
6443  
6444  var _react = __webpack_require__(14);
6445  
6446  var _react2 = _interopRequireDefault(_react);
6447  
6448  var _propTypes = __webpack_require__(31);
6449  
6450  var _propTypes2 = _interopRequireDefault(_propTypes);
6451  
6452  var _hoistNonReactStatics = __webpack_require__(387);
6453  
6454  var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
6455  
6456  var _constants = __webpack_require__(390);
6457  
6458  var _brcast = __webpack_require__(391);
6459  
6460  var _brcast2 = _interopRequireDefault(_brcast);
6461  
6462  var _ThemedStyleSheet = __webpack_require__(243);
6463  
6464  var _ThemedStyleSheet2 = _interopRequireDefault(_ThemedStyleSheet);
6465  
6466  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
6467  
6468  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
6469  
6470  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
6471  
6472  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
6473  
6474  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /* eslint react/forbid-foreign-prop-types: off */
6475  
6476  // Add some named exports to assist in upgrading and for convenience
6477  var css = exports.css = _ThemedStyleSheet2['default'].resolveLTR;
6478  var withStylesPropTypes = exports.withStylesPropTypes = {
6479    styles: _propTypes2['default'].object.isRequired, // eslint-disable-line react/forbid-prop-types
6480    theme: _propTypes2['default'].object.isRequired, // eslint-disable-line react/forbid-prop-types
6481    css: _propTypes2['default'].func.isRequired
6482  };
6483  
6484  var EMPTY_STYLES = {};
6485  var EMPTY_STYLES_FN = function EMPTY_STYLES_FN() {
6486    return EMPTY_STYLES;
6487  };
6488  
6489  var START_MARK = 'react-with-styles.createStyles.start';
6490  var END_MARK = 'react-with-styles.createStyles.end';
6491  
6492  function baseClass(pureComponent) {
6493    if (pureComponent) {
6494      if (!_react2['default'].PureComponent) {
6495        throw new ReferenceError('withStyles() pureComponent option requires React 15.3.0 or later');
6496      }
6497  
6498      return _react2['default'].PureComponent;
6499    }
6500  
6501    return _react2['default'].Component;
6502  }
6503  
6504  var contextTypes = _defineProperty({}, _constants.CHANNEL, _brcast2['default']);
6505  
6506  var defaultDirection = _constants.DIRECTIONS.LTR;
6507  
6508  function withStyles(styleFn) {
6509    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
6510        _ref$stylesPropName = _ref.stylesPropName,
6511        stylesPropName = _ref$stylesPropName === undefined ? 'styles' : _ref$stylesPropName,
6512        _ref$themePropName = _ref.themePropName,
6513        themePropName = _ref$themePropName === undefined ? 'theme' : _ref$themePropName,
6514        _ref$cssPropName = _ref.cssPropName,
6515        cssPropName = _ref$cssPropName === undefined ? 'css' : _ref$cssPropName,
6516        _ref$flushBefore = _ref.flushBefore,
6517        flushBefore = _ref$flushBefore === undefined ? false : _ref$flushBefore,
6518        _ref$pureComponent = _ref.pureComponent,
6519        pureComponent = _ref$pureComponent === undefined ? false : _ref$pureComponent;
6520  
6521    var styleDefLTR = void 0;
6522    var styleDefRTL = void 0;
6523    var currentThemeLTR = void 0;
6524    var currentThemeRTL = void 0;
6525    var BaseClass = baseClass(pureComponent);
6526  
6527    function getResolveMethod(direction) {
6528      return direction === _constants.DIRECTIONS.LTR ? _ThemedStyleSheet2['default'].resolveLTR : _ThemedStyleSheet2['default'].resolveRTL;
6529    }
6530  
6531    function getCurrentTheme(direction) {
6532      return direction === _constants.DIRECTIONS.LTR ? currentThemeLTR : currentThemeRTL;
6533    }
6534  
6535    function getStyleDef(direction, wrappedComponentName) {
6536      var currentTheme = getCurrentTheme(direction);
6537      var styleDef = direction === _constants.DIRECTIONS.LTR ? styleDefLTR : styleDefRTL;
6538  
6539      var registeredTheme = _ThemedStyleSheet2['default'].get();
6540  
6541      // Return the existing styles if they've already been defined
6542      // and if the theme used to create them corresponds to the theme
6543      // registered with ThemedStyleSheet
6544      if (styleDef && currentTheme === registeredTheme) {
6545        return styleDef;
6546      }
6547  
6548      if (false) {}
6549  
6550      var isRTL = direction === _constants.DIRECTIONS.RTL;
6551  
6552      if (isRTL) {
6553        styleDefRTL = styleFn ? _ThemedStyleSheet2['default'].createRTL(styleFn) : EMPTY_STYLES_FN;
6554  
6555        currentThemeRTL = registeredTheme;
6556        styleDef = styleDefRTL;
6557      } else {
6558        styleDefLTR = styleFn ? _ThemedStyleSheet2['default'].createLTR(styleFn) : EMPTY_STYLES_FN;
6559  
6560        currentThemeLTR = registeredTheme;
6561        styleDef = styleDefLTR;
6562      }
6563  
6564      if (false) { var measureName; }
6565  
6566      return styleDef;
6567    }
6568  
6569    function getState(direction, wrappedComponentName) {
6570      return {
6571        resolveMethod: getResolveMethod(direction),
6572        styleDef: getStyleDef(direction, wrappedComponentName)
6573      };
6574    }
6575  
6576    return function () {
6577      function withStylesHOC(WrappedComponent) {
6578        var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';
6579  
6580        // NOTE: Use a class here so components are ref-able if need be:
6581        // eslint-disable-next-line react/prefer-stateless-function
6582  
6583        var WithStyles = function (_BaseClass) {
6584          _inherits(WithStyles, _BaseClass);
6585  
6586          function WithStyles(props, context) {
6587            _classCallCheck(this, WithStyles);
6588  
6589            var _this = _possibleConstructorReturn(this, (WithStyles.__proto__ || Object.getPrototypeOf(WithStyles)).call(this, props, context));
6590  
6591            var direction = _this.context[_constants.CHANNEL] ? _this.context[_constants.CHANNEL].getState() : defaultDirection;
6592  
6593            _this.state = getState(direction, wrappedComponentName);
6594            return _this;
6595          }
6596  
6597          _createClass(WithStyles, [{
6598            key: 'componentDidMount',
6599            value: function () {
6600              function componentDidMount() {
6601                var _this2 = this;
6602  
6603                if (this.context[_constants.CHANNEL]) {
6604                  // subscribe to future direction changes
6605                  this.channelUnsubscribe = this.context[_constants.CHANNEL].subscribe(function (direction) {
6606                    _this2.setState(getState(direction, wrappedComponentName));
6607                  });
6608                }
6609              }
6610  
6611              return componentDidMount;
6612            }()
6613          }, {
6614            key: 'componentWillUnmount',
6615            value: function () {
6616              function componentWillUnmount() {
6617                if (this.channelUnsubscribe) {
6618                  this.channelUnsubscribe();
6619                }
6620              }
6621  
6622              return componentWillUnmount;
6623            }()
6624          }, {
6625            key: 'render',
6626            value: function () {
6627              function render() {
6628                var _ref2;
6629  
6630                // As some components will depend on previous styles in
6631                // the component tree, we provide the option of flushing the
6632                // buffered styles (i.e. to a style tag) **before** the rendering
6633                // cycle begins.
6634                //
6635                // The interfaces provide the optional "flush" method which
6636                // is run in turn by ThemedStyleSheet.flush.
6637                if (flushBefore) {
6638                  _ThemedStyleSheet2['default'].flush();
6639                }
6640  
6641                var _state = this.state,
6642                    resolveMethod = _state.resolveMethod,
6643                    styleDef = _state.styleDef;
6644  
6645  
6646                return _react2['default'].createElement(WrappedComponent, _extends({}, this.props, (_ref2 = {}, _defineProperty(_ref2, themePropName, _ThemedStyleSheet2['default'].get()), _defineProperty(_ref2, stylesPropName, styleDef()), _defineProperty(_ref2, cssPropName, resolveMethod), _ref2)));
6647              }
6648  
6649              return render;
6650            }()
6651          }]);
6652  
6653          return WithStyles;
6654        }(BaseClass);
6655  
6656        WithStyles.WrappedComponent = WrappedComponent;
6657        WithStyles.displayName = 'withStyles(' + String(wrappedComponentName) + ')';
6658        WithStyles.contextTypes = contextTypes;
6659        if (WrappedComponent.propTypes) {
6660          WithStyles.propTypes = (0, _object2['default'])({}, WrappedComponent.propTypes);
6661          delete WithStyles.propTypes[stylesPropName];
6662          delete WithStyles.propTypes[themePropName];
6663          delete WithStyles.propTypes[cssPropName];
6664        }
6665        if (WrappedComponent.defaultProps) {
6666          WithStyles.defaultProps = (0, _object2['default'])({}, WrappedComponent.defaultProps);
6667        }
6668  
6669        return (0, _hoistNonReactStatics2['default'])(WithStyles, WrappedComponent);
6670      }
6671  
6672      return withStylesHOC;
6673    }();
6674  }
6675  
6676  /***/ }),
6677  /* 109 */
6678  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6679  
6680  "use strict";
6681  
6682  // UNUSED EXPORTS: warning, useWarning
6683  
6684  // EXTERNAL MODULE: ./node_modules/reakit-warning/es/warning.js
6685  var warning = __webpack_require__(162);
6686  
6687  // EXTERNAL MODULE: external "React"
6688  var external_React_ = __webpack_require__(14);
6689  
6690  // EXTERNAL MODULE: ./node_modules/reakit-utils/es/isObject.js
6691  var isObject = __webpack_require__(123);
6692  
6693  // CONCATENATED MODULE: ./node_modules/reakit-warning/es/useWarning.js
6694  
6695  
6696  
6697  
6698  
6699  function isRefObject(ref) {
6700    return Object(isObject["a" /* isObject */])(ref) && "current" in ref;
6701  }
6702  /**
6703   * Logs `messages` to the console using `console.warn` based on a `condition`.
6704   * This should be used inside components.
6705   */
6706  
6707  
6708  function useWarning(condition) {
6709    for (var _len = arguments.length, messages = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
6710      messages[_key - 1] = arguments[_key];
6711    }
6712  
6713    if (false) {}
6714  }
6715  
6716  
6717  
6718  // CONCATENATED MODULE: ./node_modules/reakit-warning/es/index.js
6719  
6720  
6721  
6722  
6723  
6724  
6725  
6726  /***/ }),
6727  /* 110 */
6728  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6729  
6730  "use strict";
6731  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getWindow; });
6732  /* harmony import */ var _getDocument_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(54);
6733  
6734  
6735  // Thanks to Fluent UI for doing the [research on IE11 memery leak](https://github.com/microsoft/fluentui/pull/9010#issuecomment-490768427)
6736  
6737  var _window; // Note: Accessing "window" in IE11 is somewhat expensive, and calling "typeof window"
6738  // hits a memory leak, whereas aliasing it and calling "typeof _window" does not.
6739  // Caching the window value at the file scope lets us minimize the impact.
6740  
6741  
6742  try {
6743    _window = window;
6744  } catch (e) {
6745    /* no-op */
6746  }
6747  /**
6748   * Returns `element.ownerDocument.defaultView || window`.
6749   */
6750  
6751  
6752  function getWindow(element) {
6753    if (!element) {
6754      return _window;
6755    }
6756  
6757    return Object(_getDocument_js__WEBPACK_IMPORTED_MODULE_0__[/* getDocument */ "a"])(element).defaultView || _window;
6758  }
6759  
6760  
6761  
6762  
6763  /***/ }),
6764  /* 111 */
6765  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6766  
6767  "use strict";
6768  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SystemContext; });
6769  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
6770  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
6771  
6772  
6773  var SystemContext = /*#__PURE__*/Object(react__WEBPACK_IMPORTED_MODULE_0__["createContext"])({});
6774  
6775  
6776  
6777  
6778  /***/ }),
6779  /* 112 */
6780  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6781  
6782  "use strict";
6783  
6784  // EXPORTS
6785  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ slot_fill_Fill; });
6786  __webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ slot_fill_Slot; });
6787  __webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ Provider; });
6788  __webpack_require__.d(__webpack_exports__, "d", function() { return /* binding */ createSlotFill; });
6789  
6790  // UNUSED EXPORTS: useSlot
6791  
6792  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
6793  var esm_extends = __webpack_require__(8);
6794  
6795  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
6796  var objectWithoutProperties = __webpack_require__(13);
6797  
6798  // EXTERNAL MODULE: external ["wp","element"]
6799  var external_wp_element_ = __webpack_require__(0);
6800  
6801  // EXTERNAL MODULE: external "lodash"
6802  var external_lodash_ = __webpack_require__(2);
6803  
6804  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/context.js
6805  /**
6806   * WordPress dependencies
6807   */
6808  
6809  var SlotFillContext = Object(external_wp_element_["createContext"])({
6810    registerSlot: function registerSlot() {},
6811    unregisterSlot: function unregisterSlot() {},
6812    registerFill: function registerFill() {},
6813    unregisterFill: function unregisterFill() {},
6814    getSlot: function getSlot() {},
6815    getFills: function getFills() {},
6816    subscribe: function subscribe() {}
6817  });
6818  /* harmony default export */ var context = (SlotFillContext);
6819  
6820  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
6821  var slicedToArray = __webpack_require__(12);
6822  
6823  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/use-slot.js
6824  
6825  
6826  /**
6827   * WordPress dependencies
6828   */
6829  
6830  /**
6831   * Internal dependencies
6832   */
6833  
6834  
6835  /**
6836   * React hook returning the active slot given a name.
6837   *
6838   * @param {string} name Slot name.
6839   * @return {Object} Slot object.
6840   */
6841  
6842  var use_slot_useSlot = function useSlot(name) {
6843    var _useContext = Object(external_wp_element_["useContext"])(context),
6844        getSlot = _useContext.getSlot,
6845        subscribe = _useContext.subscribe;
6846  
6847    var _useState = Object(external_wp_element_["useState"])(getSlot(name)),
6848        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
6849        slot = _useState2[0],
6850        setSlot = _useState2[1];
6851  
6852    Object(external_wp_element_["useEffect"])(function () {
6853      setSlot(getSlot(name));
6854      var unsubscribe = subscribe(function () {
6855        setSlot(getSlot(name));
6856      });
6857      return unsubscribe;
6858    }, [name]);
6859    return slot;
6860  };
6861  
6862  /* harmony default export */ var use_slot = (use_slot_useSlot);
6863  
6864  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/fill.js
6865  
6866  
6867  
6868  /**
6869   * External dependencies
6870   */
6871  
6872  /**
6873   * WordPress dependencies
6874   */
6875  
6876  
6877  /**
6878   * Internal dependencies
6879   */
6880  
6881  
6882  
6883  
6884  function fill_FillComponent(_ref) {
6885    var name = _ref.name,
6886        children = _ref.children,
6887        registerFill = _ref.registerFill,
6888        unregisterFill = _ref.unregisterFill;
6889    var slot = use_slot(name);
6890    var ref = Object(external_wp_element_["useRef"])({
6891      name: name,
6892      children: children
6893    });
6894    Object(external_wp_element_["useLayoutEffect"])(function () {
6895      registerFill(name, ref.current);
6896      return function () {
6897        return unregisterFill(name, ref.current);
6898      };
6899    }, []);
6900    Object(external_wp_element_["useLayoutEffect"])(function () {
6901      ref.current.children = children;
6902  
6903      if (slot) {
6904        slot.forceUpdate();
6905      }
6906    }, [children]);
6907    Object(external_wp_element_["useLayoutEffect"])(function () {
6908      if (name === ref.current.name) {
6909        // ignore initial effect
6910        return;
6911      }
6912  
6913      unregisterFill(ref.current.name, ref.current);
6914      ref.current.name = name;
6915      registerFill(name, ref.current);
6916    }, [name]);
6917  
6918    if (!slot || !slot.node) {
6919      return null;
6920    } // If a function is passed as a child, provide it with the fillProps.
6921  
6922  
6923    if (Object(external_lodash_["isFunction"])(children)) {
6924      children = children(slot.props.fillProps);
6925    }
6926  
6927    return Object(external_wp_element_["createPortal"])(children, slot.node);
6928  }
6929  
6930  var fill_Fill = function Fill(props) {
6931    return Object(external_wp_element_["createElement"])(context.Consumer, null, function (_ref2) {
6932      var registerFill = _ref2.registerFill,
6933          unregisterFill = _ref2.unregisterFill;
6934      return Object(external_wp_element_["createElement"])(fill_FillComponent, Object(esm_extends["a" /* default */])({}, props, {
6935        registerFill: registerFill,
6936        unregisterFill: unregisterFill
6937      }));
6938    });
6939  };
6940  
6941  /* harmony default export */ var slot_fill_fill = (fill_Fill);
6942  
6943  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
6944  var classCallCheck = __webpack_require__(25);
6945  
6946  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
6947  var createClass = __webpack_require__(26);
6948  
6949  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
6950  var assertThisInitialized = __webpack_require__(18);
6951  
6952  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
6953  var getPrototypeOf = __webpack_require__(22);
6954  
6955  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/superPropBase.js
6956  
6957  function _superPropBase(object, property) {
6958    while (!Object.prototype.hasOwnProperty.call(object, property)) {
6959      object = Object(getPrototypeOf["a" /* default */])(object);
6960      if (object === null) break;
6961    }
6962  
6963    return object;
6964  }
6965  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/get.js
6966  
6967  function get_get(target, property, receiver) {
6968    if (typeof Reflect !== "undefined" && Reflect.get) {
6969      get_get = Reflect.get;
6970    } else {
6971      get_get = function _get(target, property, receiver) {
6972        var base = _superPropBase(target, property);
6973        if (!base) return;
6974        var desc = Object.getOwnPropertyDescriptor(base, property);
6975  
6976        if (desc.get) {
6977          return desc.get.call(receiver);
6978        }
6979  
6980        return desc.value;
6981      };
6982    }
6983  
6984    return get_get(target, property, receiver || target);
6985  }
6986  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
6987  var inherits = __webpack_require__(32);
6988  
6989  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
6990  var possibleConstructorReturn = __webpack_require__(34);
6991  
6992  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/slot.js
6993  
6994  
6995  
6996  
6997  
6998  
6999  
7000  
7001  
7002  
7003  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
7004  
7005  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
7006  
7007  /**
7008   * External dependencies
7009   */
7010  
7011  /**
7012   * WordPress dependencies
7013   */
7014  
7015  
7016  /**
7017   * Internal dependencies
7018   */
7019  
7020  
7021  
7022  var slot_SlotComponent = /*#__PURE__*/function (_Component) {
7023    Object(inherits["a" /* default */])(SlotComponent, _Component);
7024  
7025    var _super = _createSuper(SlotComponent);
7026  
7027    function SlotComponent() {
7028      var _this;
7029  
7030      Object(classCallCheck["a" /* default */])(this, SlotComponent);
7031  
7032      _this = _super.apply(this, arguments);
7033      _this.isUnmounted = false;
7034      _this.bindNode = _this.bindNode.bind(Object(assertThisInitialized["a" /* default */])(_this));
7035      return _this;
7036    }
7037  
7038    Object(createClass["a" /* default */])(SlotComponent, [{
7039      key: "componentDidMount",
7040      value: function componentDidMount() {
7041        var registerSlot = this.props.registerSlot;
7042        registerSlot(this.props.name, this);
7043      }
7044    }, {
7045      key: "componentWillUnmount",
7046      value: function componentWillUnmount() {
7047        var unregisterSlot = this.props.unregisterSlot;
7048        this.isUnmounted = true;
7049        unregisterSlot(this.props.name, this);
7050      }
7051    }, {
7052      key: "componentDidUpdate",
7053      value: function componentDidUpdate(prevProps) {
7054        var _this$props = this.props,
7055            name = _this$props.name,
7056            unregisterSlot = _this$props.unregisterSlot,
7057            registerSlot = _this$props.registerSlot;
7058  
7059        if (prevProps.name !== name) {
7060          unregisterSlot(prevProps.name);
7061          registerSlot(name, this);
7062        }
7063      }
7064    }, {
7065      key: "bindNode",
7066      value: function bindNode(node) {
7067        this.node = node;
7068      }
7069    }, {
7070      key: "forceUpdate",
7071      value: function forceUpdate() {
7072        if (this.isUnmounted) {
7073          return;
7074        }
7075  
7076        get_get(Object(getPrototypeOf["a" /* default */])(SlotComponent.prototype), "forceUpdate", this).call(this);
7077      }
7078    }, {
7079      key: "render",
7080      value: function render() {
7081        var _this$props2 = this.props,
7082            children = _this$props2.children,
7083            name = _this$props2.name,
7084            _this$props2$fillProp = _this$props2.fillProps,
7085            fillProps = _this$props2$fillProp === void 0 ? {} : _this$props2$fillProp,
7086            getFills = _this$props2.getFills;
7087        var fills = Object(external_lodash_["map"])(getFills(name, this), function (fill) {
7088          var fillChildren = Object(external_lodash_["isFunction"])(fill.children) ? fill.children(fillProps) : fill.children;
7089          return external_wp_element_["Children"].map(fillChildren, function (child, childIndex) {
7090            if (!child || Object(external_lodash_["isString"])(child)) {
7091              return child;
7092            }
7093  
7094            var childKey = child.key || childIndex;
7095            return Object(external_wp_element_["cloneElement"])(child, {
7096              key: childKey
7097            });
7098          });
7099        }).filter( // In some cases fills are rendered only when some conditions apply.
7100        // This ensures that we only use non-empty fills when rendering, i.e.,
7101        // it allows us to render wrappers only when the fills are actually present.
7102        Object(external_lodash_["negate"])(external_wp_element_["isEmptyElement"]));
7103        return Object(external_wp_element_["createElement"])(external_wp_element_["Fragment"], null, Object(external_lodash_["isFunction"])(children) ? children(fills) : fills);
7104      }
7105    }]);
7106  
7107    return SlotComponent;
7108  }(external_wp_element_["Component"]);
7109  
7110  var slot_Slot = function Slot(props) {
7111    return Object(external_wp_element_["createElement"])(context.Consumer, null, function (_ref) {
7112      var registerSlot = _ref.registerSlot,
7113          unregisterSlot = _ref.unregisterSlot,
7114          getFills = _ref.getFills;
7115      return Object(external_wp_element_["createElement"])(slot_SlotComponent, Object(esm_extends["a" /* default */])({}, props, {
7116        registerSlot: registerSlot,
7117        unregisterSlot: unregisterSlot,
7118        getFills: getFills
7119      }));
7120    });
7121  };
7122  
7123  /* harmony default export */ var slot_fill_slot = (slot_Slot);
7124  
7125  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/use-slot.js
7126  var bubbles_virtually_use_slot = __webpack_require__(169);
7127  
7128  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/fill.js
7129  
7130  
7131  /**
7132   * WordPress dependencies
7133   */
7134  
7135  /**
7136   * Internal dependencies
7137   */
7138  
7139  
7140  
7141  function useForceUpdate() {
7142    var _useState = Object(external_wp_element_["useState"])({}),
7143        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
7144        setState = _useState2[1];
7145  
7146    return function () {
7147      return setState({});
7148    };
7149  }
7150  
7151  function bubbles_virtually_fill_Fill(_ref) {
7152    var name = _ref.name,
7153        children = _ref.children;
7154    var slot = Object(bubbles_virtually_use_slot["a" /* default */])(name);
7155    var ref = Object(external_wp_element_["useRef"])({
7156      rerender: useForceUpdate()
7157    });
7158    Object(external_wp_element_["useEffect"])(function () {
7159      // We register fills so we can keep track of their existance.
7160      // Some Slot implementations need to know if there're already fills
7161      // registered so they can choose to render themselves or not.
7162      slot.registerFill(ref);
7163      return function () {
7164        slot.unregisterFill(ref);
7165      };
7166    }, [slot.registerFill, slot.unregisterFill]);
7167  
7168    if (!slot.ref || !slot.ref.current) {
7169      return null;
7170    }
7171  
7172    if (typeof children === 'function') {
7173      children = children(slot.fillProps);
7174    }
7175  
7176    return Object(external_wp_element_["createPortal"])(children, slot.ref.current);
7177  }
7178  
7179  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot-fill-context.js
7180  var slot_fill_context = __webpack_require__(133);
7181  
7182  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot.js
7183  
7184  
7185  
7186  
7187  /**
7188   * WordPress dependencies
7189   */
7190  
7191  /**
7192   * Internal dependencies
7193   */
7194  
7195  
7196  function bubbles_virtually_slot_Slot(_ref) {
7197    var name = _ref.name,
7198        _ref$fillProps = _ref.fillProps,
7199        fillProps = _ref$fillProps === void 0 ? {} : _ref$fillProps,
7200        _ref$as = _ref.as,
7201        Component = _ref$as === void 0 ? 'div' : _ref$as,
7202        props = Object(objectWithoutProperties["a" /* default */])(_ref, ["name", "fillProps", "as"]);
7203  
7204    var registry = Object(external_wp_element_["useContext"])(slot_fill_context["a" /* default */]);
7205    var ref = Object(external_wp_element_["useRef"])();
7206    Object(external_wp_element_["useLayoutEffect"])(function () {
7207      registry.registerSlot(name, ref, fillProps);
7208      return function () {
7209        registry.unregisterSlot(name, ref);
7210      }; // We are not including fillProps in the deps because we don't want to
7211      // unregister and register the slot whenever fillProps change, which would
7212      // cause the fill to be re-mounted. We are only considering the initial value
7213      // of fillProps.
7214    }, [registry.registerSlot, registry.unregisterSlot, name]); // fillProps may be an update that interacts with the layout, so we
7215    // useLayoutEffect
7216  
7217    Object(external_wp_element_["useLayoutEffect"])(function () {
7218      registry.updateSlot(name, fillProps);
7219    });
7220    return Object(external_wp_element_["createElement"])(Component, Object(esm_extends["a" /* default */])({
7221      ref: ref
7222    }, props));
7223  }
7224  
7225  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
7226  var esm_typeof = __webpack_require__(56);
7227  
7228  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
7229  var toConsumableArray = __webpack_require__(15);
7230  
7231  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
7232  var defineProperty = __webpack_require__(5);
7233  
7234  // EXTERNAL MODULE: external ["wp","isShallowEqual"]
7235  var external_wp_isShallowEqual_ = __webpack_require__(65);
7236  var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_);
7237  
7238  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot-fill-provider.js
7239  
7240  
7241  
7242  
7243  
7244  
7245  
7246  function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return Object(esm_typeof["a" /* default */])(key) === "symbol" ? key : String(key); }
7247  
7248  function _toPrimitive(input, hint) { if (Object(esm_typeof["a" /* default */])(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (Object(esm_typeof["a" /* default */])(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
7249  
7250  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
7251  
7252  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
7253  
7254  /**
7255   * WordPress dependencies
7256   */
7257  
7258  
7259  /**
7260   * Internal dependencies
7261   */
7262  
7263  
7264  
7265  function useSlotRegistry() {
7266    var _useState = Object(external_wp_element_["useState"])({}),
7267        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
7268        slots = _useState2[0],
7269        setSlots = _useState2[1];
7270  
7271    var _useState3 = Object(external_wp_element_["useState"])({}),
7272        _useState4 = Object(slicedToArray["a" /* default */])(_useState3, 2),
7273        fills = _useState4[0],
7274        setFills = _useState4[1];
7275  
7276    var registerSlot = Object(external_wp_element_["useCallback"])(function (name, ref, fillProps) {
7277      setSlots(function (prevSlots) {
7278        var slot = prevSlots[name] || {};
7279        return _objectSpread(_objectSpread({}, prevSlots), {}, Object(defineProperty["a" /* default */])({}, name, _objectSpread(_objectSpread({}, slot), {}, {
7280          ref: ref || slot.ref,
7281          fillProps: fillProps || slot.fillProps || {}
7282        })));
7283      });
7284    }, []);
7285    var unregisterSlot = Object(external_wp_element_["useCallback"])(function (name, ref) {
7286      setSlots(function (prevSlots) {
7287        var slot = prevSlots[name],
7288            nextSlots = Object(objectWithoutProperties["a" /* default */])(prevSlots, [name].map(_toPropertyKey)); // Make sure we're not unregistering a slot registered by another element
7289        // See https://github.com/WordPress/gutenberg/pull/19242#issuecomment-590295412
7290  
7291  
7292        if ((slot === null || slot === void 0 ? void 0 : slot.ref) === ref) {
7293          return nextSlots;
7294        }
7295  
7296        return prevSlots;
7297      });
7298    }, []);
7299    var updateSlot = Object(external_wp_element_["useCallback"])(function (name, fillProps) {
7300      var slot = slots[name];
7301  
7302      if (!slot) {
7303        return;
7304      }
7305  
7306      if (!external_wp_isShallowEqual_default()(slot.fillProps, fillProps)) {
7307        slot.fillProps = fillProps;
7308        var slotFills = fills[name];
7309  
7310        if (slotFills) {
7311          // Force update fills
7312          slotFills.map(function (fill) {
7313            return fill.current.rerender();
7314          });
7315        }
7316      }
7317    }, [slots, fills]);
7318    var registerFill = Object(external_wp_element_["useCallback"])(function (name, ref) {
7319      setFills(function (prevFills) {
7320        return _objectSpread(_objectSpread({}, prevFills), {}, Object(defineProperty["a" /* default */])({}, name, [].concat(Object(toConsumableArray["a" /* default */])(prevFills[name] || []), [ref])));
7321      });
7322    }, []);
7323    var unregisterFill = Object(external_wp_element_["useCallback"])(function (name, ref) {
7324      setFills(function (prevFills) {
7325        if (prevFills[name]) {
7326          return _objectSpread(_objectSpread({}, prevFills), {}, Object(defineProperty["a" /* default */])({}, name, prevFills[name].filter(function (fillRef) {
7327            return fillRef !== ref;
7328          })));
7329        }
7330  
7331        return prevFills;
7332      });
7333    }, []); // Memoizing the return value so it can be directly passed to Provider value
7334  
7335    var registry = Object(external_wp_element_["useMemo"])(function () {
7336      return {
7337        slots: slots,
7338        fills: fills,
7339        registerSlot: registerSlot,
7340        updateSlot: updateSlot,
7341        unregisterSlot: unregisterSlot,
7342        registerFill: registerFill,
7343        unregisterFill: unregisterFill
7344      };
7345    }, [slots, fills, registerSlot, updateSlot, unregisterSlot, registerFill, unregisterFill]);
7346    return registry;
7347  }
7348  
7349  function slot_fill_provider_SlotFillProvider(_ref) {
7350    var children = _ref.children;
7351    var registry = useSlotRegistry();
7352    return Object(external_wp_element_["createElement"])(slot_fill_context["a" /* default */].Provider, {
7353      value: registry
7354    }, children);
7355  }
7356  
7357  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/provider.js
7358  
7359  
7360  
7361  
7362  
7363  
7364  
7365  
7366  
7367  function provider_createSuper(Derived) { var hasNativeReflectConstruct = provider_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
7368  
7369  function provider_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
7370  
7371  /**
7372   * External dependencies
7373   */
7374  
7375  /**
7376   * WordPress dependencies
7377   */
7378  
7379  
7380  /**
7381   * Internal dependencies
7382   */
7383  
7384  
7385  
7386  var provider_SlotFillProvider = /*#__PURE__*/function (_Component) {
7387    Object(inherits["a" /* default */])(SlotFillProvider, _Component);
7388  
7389    var _super = provider_createSuper(SlotFillProvider);
7390  
7391    function SlotFillProvider() {
7392      var _this;
7393  
7394      Object(classCallCheck["a" /* default */])(this, SlotFillProvider);
7395  
7396      _this = _super.apply(this, arguments);
7397      _this.registerSlot = _this.registerSlot.bind(Object(assertThisInitialized["a" /* default */])(_this));
7398      _this.registerFill = _this.registerFill.bind(Object(assertThisInitialized["a" /* default */])(_this));
7399      _this.unregisterSlot = _this.unregisterSlot.bind(Object(assertThisInitialized["a" /* default */])(_this));
7400      _this.unregisterFill = _this.unregisterFill.bind(Object(assertThisInitialized["a" /* default */])(_this));
7401      _this.getSlot = _this.getSlot.bind(Object(assertThisInitialized["a" /* default */])(_this));
7402      _this.getFills = _this.getFills.bind(Object(assertThisInitialized["a" /* default */])(_this));
7403      _this.hasFills = _this.hasFills.bind(Object(assertThisInitialized["a" /* default */])(_this));
7404      _this.subscribe = _this.subscribe.bind(Object(assertThisInitialized["a" /* default */])(_this));
7405      _this.slots = {};
7406      _this.fills = {};
7407      _this.listeners = [];
7408      _this.contextValue = {
7409        registerSlot: _this.registerSlot,
7410        unregisterSlot: _this.unregisterSlot,
7411        registerFill: _this.registerFill,
7412        unregisterFill: _this.unregisterFill,
7413        getSlot: _this.getSlot,
7414        getFills: _this.getFills,
7415        hasFills: _this.hasFills,
7416        subscribe: _this.subscribe
7417      };
7418      return _this;
7419    }
7420  
7421    Object(createClass["a" /* default */])(SlotFillProvider, [{
7422      key: "registerSlot",
7423      value: function registerSlot(name, slot) {
7424        var previousSlot = this.slots[name];
7425        this.slots[name] = slot;
7426        this.triggerListeners(); // Sometimes the fills are registered after the initial render of slot
7427        // But before the registerSlot call, we need to rerender the slot
7428  
7429        this.forceUpdateSlot(name); // If a new instance of a slot is being mounted while another with the
7430        // same name exists, force its update _after_ the new slot has been
7431        // assigned into the instance, such that its own rendering of children
7432        // will be empty (the new Slot will subsume all fills for this name).
7433  
7434        if (previousSlot) {
7435          previousSlot.forceUpdate();
7436        }
7437      }
7438    }, {
7439      key: "registerFill",
7440      value: function registerFill(name, instance) {
7441        this.fills[name] = [].concat(Object(toConsumableArray["a" /* default */])(this.fills[name] || []), [instance]);
7442        this.forceUpdateSlot(name);
7443      }
7444    }, {
7445      key: "unregisterSlot",
7446      value: function unregisterSlot(name, instance) {
7447        // If a previous instance of a Slot by this name unmounts, do nothing,
7448        // as the slot and its fills should only be removed for the current
7449        // known instance.
7450        if (this.slots[name] !== instance) {
7451          return;
7452        }
7453  
7454        delete this.slots[name];
7455        this.triggerListeners();
7456      }
7457    }, {
7458      key: "unregisterFill",
7459      value: function unregisterFill(name, instance) {
7460        this.fills[name] = Object(external_lodash_["without"])(this.fills[name], instance);
7461        this.forceUpdateSlot(name);
7462      }
7463    }, {
7464      key: "getSlot",
7465      value: function getSlot(name) {
7466        return this.slots[name];
7467      }
7468    }, {
7469      key: "getFills",
7470      value: function getFills(name, slotInstance) {
7471        // Fills should only be returned for the current instance of the slot
7472        // in which they occupy.
7473        if (this.slots[name] !== slotInstance) {
7474          return [];
7475        }
7476  
7477        return this.fills[name];
7478      }
7479    }, {
7480      key: "hasFills",
7481      value: function hasFills(name) {
7482        return this.fills[name] && !!this.fills[name].length;
7483      }
7484    }, {
7485      key: "forceUpdateSlot",
7486      value: function forceUpdateSlot(name) {
7487        var slot = this.getSlot(name);
7488  
7489        if (slot) {
7490          slot.forceUpdate();
7491        }
7492      }
7493    }, {
7494      key: "triggerListeners",
7495      value: function triggerListeners() {
7496        this.listeners.forEach(function (listener) {
7497          return listener();
7498        });
7499      }
7500    }, {
7501      key: "subscribe",
7502      value: function subscribe(listener) {
7503        var _this2 = this;
7504  
7505        this.listeners.push(listener);
7506        return function () {
7507          _this2.listeners = Object(external_lodash_["without"])(_this2.listeners, listener);
7508        };
7509      }
7510    }, {
7511      key: "render",
7512      value: function render() {
7513        return Object(external_wp_element_["createElement"])(context.Provider, {
7514          value: this.contextValue
7515        }, this.props.children);
7516      }
7517    }]);
7518  
7519    return SlotFillProvider;
7520  }(external_wp_element_["Component"]);
7521  
7522  
7523  
7524  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/index.js
7525  
7526  
7527  
7528  
7529  /**
7530   * Internal dependencies
7531   */
7532  
7533  
7534  
7535  
7536  
7537  
7538  
7539  function slot_fill_Fill(props) {
7540    // We're adding both Fills here so they can register themselves before
7541    // their respective slot has been registered. Only the Fill that has a slot
7542    // will render. The other one will return null.
7543    return Object(external_wp_element_["createElement"])(external_wp_element_["Fragment"], null, Object(external_wp_element_["createElement"])(slot_fill_fill, props), Object(external_wp_element_["createElement"])(bubbles_virtually_fill_Fill, props));
7544  }
7545  function slot_fill_Slot(_ref) {
7546    var bubblesVirtually = _ref.bubblesVirtually,
7547        props = Object(objectWithoutProperties["a" /* default */])(_ref, ["bubblesVirtually"]);
7548  
7549    if (bubblesVirtually) {
7550      return Object(external_wp_element_["createElement"])(bubbles_virtually_slot_Slot, props);
7551    }
7552  
7553    return Object(external_wp_element_["createElement"])(slot_fill_slot, props);
7554  }
7555  function Provider(_ref2) {
7556    var children = _ref2.children,
7557        props = Object(objectWithoutProperties["a" /* default */])(_ref2, ["children"]);
7558  
7559    return Object(external_wp_element_["createElement"])(provider_SlotFillProvider, props, Object(external_wp_element_["createElement"])(slot_fill_provider_SlotFillProvider, null, children));
7560  }
7561  function createSlotFill(name) {
7562    var FillComponent = function FillComponent(props) {
7563      return Object(external_wp_element_["createElement"])(slot_fill_Fill, Object(esm_extends["a" /* default */])({
7564        name: name
7565      }, props));
7566    };
7567  
7568    FillComponent.displayName = name + 'Fill';
7569  
7570    var SlotComponent = function SlotComponent(props) {
7571      return Object(external_wp_element_["createElement"])(slot_fill_Slot, Object(esm_extends["a" /* default */])({
7572        name: name
7573      }, props));
7574    };
7575  
7576    SlotComponent.displayName = name + 'Slot';
7577    SlotComponent.__unstableName = name;
7578    return {
7579      Fill: FillComponent,
7580      Slot: SlotComponent
7581    };
7582  }
7583  
7584  
7585  
7586  /***/ }),
7587  /* 113 */
7588  /***/ (function(module, __webpack_exports__, __webpack_require__) {
7589  
7590  "use strict";
7591  
7592  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
7593  var esm_extends = __webpack_require__(8);
7594  
7595  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
7596  var slicedToArray = __webpack_require__(12);
7597  
7598  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
7599  var objectWithoutProperties = __webpack_require__(13);
7600  
7601  // EXTERNAL MODULE: external ["wp","element"]
7602  var external_wp_element_ = __webpack_require__(0);
7603  
7604  // EXTERNAL MODULE: ./node_modules/classnames/index.js
7605  var classnames = __webpack_require__(10);
7606  var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
7607  
7608  // EXTERNAL MODULE: external ["wp","dom"]
7609  var external_wp_dom_ = __webpack_require__(27);
7610  
7611  // EXTERNAL MODULE: external ["wp","keycodes"]
7612  var external_wp_keycodes_ = __webpack_require__(17);
7613  
7614  // EXTERNAL MODULE: external ["wp","deprecated"]
7615  var external_wp_deprecated_ = __webpack_require__(35);
7616  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
7617  
7618  // EXTERNAL MODULE: external ["wp","compose"]
7619  var external_wp_compose_ = __webpack_require__(11);
7620  
7621  // EXTERNAL MODULE: ./node_modules/@wordpress/icons/build-module/library/close.js
7622  var library_close = __webpack_require__(160);
7623  
7624  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
7625  var defineProperty = __webpack_require__(5);
7626  
7627  // EXTERNAL MODULE: external ["wp","i18n"]
7628  var external_wp_i18n_ = __webpack_require__(1);
7629  
7630  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/popover/utils.js
7631  
7632  
7633  
7634  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
7635  
7636  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
7637  
7638  /**
7639   * WordPress dependencies
7640   */
7641  
7642  /**
7643   * Module constants
7644   */
7645  
7646  var HEIGHT_OFFSET = 10; // used by the arrow and a bit of empty space
7647  
7648  /**
7649   * Utility used to compute the popover position over the xAxis
7650   *
7651   * @param {Object}  anchorRect            Anchor Rect.
7652   * @param {Object}  contentSize           Content Size.
7653   * @param {string}  xAxis                 Desired xAxis.
7654   * @param {string}  corner                Desired corner.
7655   * @param {boolean} stickyBoundaryElement The boundary element to use when
7656   *                                        switching between sticky and normal
7657   *                                        position.
7658   * @param {string}  chosenYAxis           yAxis to be used.
7659   * @param {Element} boundaryElement       Boundary element.
7660   * @param {boolean} forcePosition         Don't adjust position based on anchor.
7661   *
7662   * @return {Object} Popover xAxis position and constraints.
7663   */
7664  
7665  function computePopoverXAxisPosition(anchorRect, contentSize, xAxis, corner, stickyBoundaryElement, chosenYAxis, boundaryElement, forcePosition) {
7666    var width = contentSize.width; // Correct xAxis for RTL support
7667  
7668    if (xAxis === 'left' && Object(external_wp_i18n_["isRTL"])()) {
7669      xAxis = 'right';
7670    } else if (xAxis === 'right' && Object(external_wp_i18n_["isRTL"])()) {
7671      xAxis = 'left';
7672    }
7673  
7674    if (corner === 'left' && Object(external_wp_i18n_["isRTL"])()) {
7675      corner = 'right';
7676    } else if (corner === 'right' && Object(external_wp_i18n_["isRTL"])()) {
7677      corner = 'left';
7678    } // x axis alignment choices
7679  
7680  
7681    var anchorMidPoint = Math.round(anchorRect.left + anchorRect.width / 2);
7682    var centerAlignment = {
7683      popoverLeft: anchorMidPoint,
7684      contentWidth: (anchorMidPoint - width / 2 > 0 ? width / 2 : anchorMidPoint) + (anchorMidPoint + width / 2 > window.innerWidth ? window.innerWidth - anchorMidPoint : width / 2)
7685    };
7686    var leftAlignmentX = anchorRect.left;
7687  
7688    if (corner === 'right') {
7689      leftAlignmentX = anchorRect.right;
7690    } else if (chosenYAxis !== 'middle') {
7691      leftAlignmentX = anchorMidPoint;
7692    }
7693  
7694    var rightAlignmentX = anchorRect.right;
7695  
7696    if (corner === 'left') {
7697      rightAlignmentX = anchorRect.left;
7698    } else if (chosenYAxis !== 'middle') {
7699      rightAlignmentX = anchorMidPoint;
7700    }
7701  
7702    var leftAlignment = {
7703      popoverLeft: leftAlignmentX,
7704      contentWidth: leftAlignmentX - width > 0 ? width : leftAlignmentX
7705    };
7706    var rightAlignment = {
7707      popoverLeft: rightAlignmentX,
7708      contentWidth: rightAlignmentX + width > window.innerWidth ? window.innerWidth - rightAlignmentX : width
7709    }; // Choosing the x axis
7710  
7711    var chosenXAxis = xAxis;
7712    var contentWidth = null;
7713  
7714    if (!stickyBoundaryElement && !forcePosition) {
7715      if (xAxis === 'center' && centerAlignment.contentWidth === width) {
7716        chosenXAxis = 'center';
7717      } else if (xAxis === 'left' && leftAlignment.contentWidth === width) {
7718        chosenXAxis = 'left';
7719      } else if (xAxis === 'right' && rightAlignment.contentWidth === width) {
7720        chosenXAxis = 'right';
7721      } else {
7722        chosenXAxis = leftAlignment.contentWidth > rightAlignment.contentWidth ? 'left' : 'right';
7723        var chosenWidth = chosenXAxis === 'left' ? leftAlignment.contentWidth : rightAlignment.contentWidth; // Limit width of the content to the viewport width
7724  
7725        if (width > window.innerWidth) {
7726          contentWidth = window.innerWidth;
7727        } // If we can't find any alignment options that could fit
7728        // our content, then let's fallback to the center of the viewport.
7729  
7730  
7731        if (chosenWidth !== width) {
7732          chosenXAxis = 'center';
7733          centerAlignment.popoverLeft = window.innerWidth / 2;
7734        }
7735      }
7736    }
7737  
7738    var popoverLeft;
7739  
7740    if (chosenXAxis === 'center') {
7741      popoverLeft = centerAlignment.popoverLeft;
7742    } else if (chosenXAxis === 'left') {
7743      popoverLeft = leftAlignment.popoverLeft;
7744    } else {
7745      popoverLeft = rightAlignment.popoverLeft;
7746    }
7747  
7748    if (boundaryElement) {
7749      var boundaryRect = boundaryElement.getBoundingClientRect();
7750      popoverLeft = Math.min(popoverLeft, boundaryRect.right - width);
7751    }
7752  
7753    return {
7754      xAxis: chosenXAxis,
7755      popoverLeft: popoverLeft,
7756      contentWidth: contentWidth
7757    };
7758  }
7759  /**
7760   * Utility used to compute the popover position over the yAxis
7761   *
7762   * @param {Object}  anchorRect            Anchor Rect.
7763   * @param {Object}  contentSize           Content Size.
7764   * @param {string}  yAxis                 Desired yAxis.
7765   * @param {string}  corner                Desired corner.
7766   * @param {boolean} stickyBoundaryElement The boundary element to use when
7767   *                                        switching between sticky and normal
7768   *                                        position.
7769   * @param {Element} anchorRef             The anchor element.
7770   * @param {Element} relativeOffsetTop     If applicable, top offset of the
7771   *                                        relative positioned parent container.
7772   * @param {boolean} forcePosition         Don't adjust position based on anchor.
7773   *
7774   * @return {Object} Popover xAxis position and constraints.
7775   */
7776  
7777  function computePopoverYAxisPosition(anchorRect, contentSize, yAxis, corner, stickyBoundaryElement, anchorRef, relativeOffsetTop, forcePosition) {
7778    var height = contentSize.height;
7779  
7780    if (stickyBoundaryElement) {
7781      var stickyRect = stickyBoundaryElement.getBoundingClientRect();
7782      var stickyPosition = stickyRect.top + height - relativeOffsetTop;
7783  
7784      if (anchorRect.top <= stickyPosition) {
7785        return {
7786          yAxis: yAxis,
7787          popoverTop: Math.min(anchorRect.bottom, stickyPosition)
7788        };
7789      }
7790    } // y axis alignment choices
7791  
7792  
7793    var anchorMidPoint = anchorRect.top + anchorRect.height / 2;
7794  
7795    if (corner === 'bottom') {
7796      anchorMidPoint = anchorRect.bottom;
7797    } else if (corner === 'top') {
7798      anchorMidPoint = anchorRect.top;
7799    }
7800  
7801    var middleAlignment = {
7802      popoverTop: anchorMidPoint,
7803      contentHeight: (anchorMidPoint - height / 2 > 0 ? height / 2 : anchorMidPoint) + (anchorMidPoint + height / 2 > window.innerHeight ? window.innerHeight - anchorMidPoint : height / 2)
7804    };
7805    var topAlignment = {
7806      popoverTop: anchorRect.top,
7807      contentHeight: anchorRect.top - HEIGHT_OFFSET - height > 0 ? height : anchorRect.top - HEIGHT_OFFSET
7808    };
7809    var bottomAlignment = {
7810      popoverTop: anchorRect.bottom,
7811      contentHeight: anchorRect.bottom + HEIGHT_OFFSET + height > window.innerHeight ? window.innerHeight - HEIGHT_OFFSET - anchorRect.bottom : height
7812    }; // Choosing the y axis
7813  
7814    var chosenYAxis = yAxis;
7815    var contentHeight = null;
7816  
7817    if (!stickyBoundaryElement && !forcePosition) {
7818      if (yAxis === 'middle' && middleAlignment.contentHeight === height) {
7819        chosenYAxis = 'middle';
7820      } else if (yAxis === 'top' && topAlignment.contentHeight === height) {
7821        chosenYAxis = 'top';
7822      } else if (yAxis === 'bottom' && bottomAlignment.contentHeight === height) {
7823        chosenYAxis = 'bottom';
7824      } else {
7825        chosenYAxis = topAlignment.contentHeight > bottomAlignment.contentHeight ? 'top' : 'bottom';
7826        var chosenHeight = chosenYAxis === 'top' ? topAlignment.contentHeight : bottomAlignment.contentHeight;
7827        contentHeight = chosenHeight !== height ? chosenHeight : null;
7828      }
7829    }
7830  
7831    var popoverTop;
7832  
7833    if (chosenYAxis === 'middle') {
7834      popoverTop = middleAlignment.popoverTop;
7835    } else if (chosenYAxis === 'top') {
7836      popoverTop = topAlignment.popoverTop;
7837    } else {
7838      popoverTop = bottomAlignment.popoverTop;
7839    }
7840  
7841    return {
7842      yAxis: chosenYAxis,
7843      popoverTop: popoverTop,
7844      contentHeight: contentHeight
7845    };
7846  }
7847  /**
7848   * Utility used to compute the popover position and the content max width/height
7849   * for a popover given its anchor rect and its content size.
7850   *
7851   * @param {Object}  anchorRect            Anchor Rect.
7852   * @param {Object}  contentSize           Content Size.
7853   * @param {string}  position              Position.
7854   * @param {boolean} stickyBoundaryElement The boundary element to use when
7855   *                                        switching between sticky and normal
7856   *                                        position.
7857   * @param {Element} anchorRef             The anchor element.
7858   * @param {number}  relativeOffsetTop     If applicable, top offset of the
7859   *                                        relative positioned parent container.
7860   * @param {Element} boundaryElement       Boundary element.
7861   * @param {boolean} forcePosition         Don't adjust position based on anchor.
7862   *
7863   * @return {Object} Popover position and constraints.
7864   */
7865  
7866  function computePopoverPosition(anchorRect, contentSize) {
7867    var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'top';
7868    var stickyBoundaryElement = arguments.length > 3 ? arguments[3] : undefined;
7869    var anchorRef = arguments.length > 4 ? arguments[4] : undefined;
7870    var relativeOffsetTop = arguments.length > 5 ? arguments[5] : undefined;
7871    var boundaryElement = arguments.length > 6 ? arguments[6] : undefined;
7872    var forcePosition = arguments.length > 7 ? arguments[7] : undefined;
7873  
7874    var _position$split = position.split(' '),
7875        _position$split2 = Object(slicedToArray["a" /* default */])(_position$split, 3),
7876        yAxis = _position$split2[0],
7877        _position$split2$ = _position$split2[1],
7878        xAxis = _position$split2$ === void 0 ? 'center' : _position$split2$,
7879        corner = _position$split2[2];
7880  
7881    var yAxisPosition = computePopoverYAxisPosition(anchorRect, contentSize, yAxis, corner, stickyBoundaryElement, anchorRef, relativeOffsetTop, forcePosition);
7882    var xAxisPosition = computePopoverXAxisPosition(anchorRect, contentSize, xAxis, corner, stickyBoundaryElement, yAxisPosition.yAxis, boundaryElement, forcePosition);
7883    return _objectSpread(_objectSpread({}, xAxisPosition), yAxisPosition);
7884  }
7885  /**
7886   * Offsets the given rect by the position of the iframe that contains the element.
7887   * If the owner document is not in an iframe then it returns with the original rect.
7888   *
7889   * @param {DOMRect} rect bounds of the element
7890   * @param {Document} ownerDocument document of the element
7891   *
7892   * @return {DOMRect} offsetted bounds
7893   */
7894  
7895  function offsetIframe(rect, ownerDocument) {
7896    var defaultView = ownerDocument.defaultView;
7897    var frameElement = defaultView.frameElement;
7898  
7899    if (!frameElement) {
7900      return rect;
7901    }
7902  
7903    var iframeRect = frameElement.getBoundingClientRect();
7904    return new defaultView.DOMRect(rect.left + iframeRect.left, rect.top + iframeRect.top, rect.width, rect.height);
7905  }
7906  
7907  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/button/index.js + 1 modules
7908  var build_module_button = __webpack_require__(36);
7909  
7910  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/scroll-lock/index.js
7911  var scroll_lock = __webpack_require__(170);
7912  
7913  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/use-slot.js
7914  var use_slot = __webpack_require__(169);
7915  
7916  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/index.js + 10 modules
7917  var slot_fill = __webpack_require__(112);
7918  
7919  // EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/animate/index.js
7920  var build_module_animate = __webpack_require__(102);
7921  
7922  // CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/popover/index.js
7923  
7924  
7925  
7926  
7927  
7928  /**
7929   * External dependencies
7930   */
7931  
7932  /**
7933   * WordPress dependencies
7934   */
7935  
7936  
7937  
7938  
7939  
7940  
7941  
7942  /**
7943   * Internal dependencies
7944   */
7945  
7946  
7947  
7948  
7949  
7950  
7951  /**
7952   * Name of slot in which popover should fill.
7953   *
7954   * @type {string}
7955   */
7956  
7957  var SLOT_NAME = 'Popover';
7958  
7959  function computeAnchorRect(anchorRefFallback, anchorRect, getAnchorRect) {
7960    var anchorRef = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
7961    var shouldAnchorIncludePadding = arguments.length > 4 ? arguments[4] : undefined;
7962  
7963    if (anchorRect) {
7964      return anchorRect;
7965    }
7966  
7967    if (getAnchorRect) {
7968      if (!anchorRefFallback.current) {
7969        return;
7970      }
7971  
7972      return offsetIframe(getAnchorRect(anchorRefFallback.current), anchorRefFallback.current.ownerDocument);
7973    }
7974  
7975    if (anchorRef !== false) {
7976      if (!anchorRef || !window.Range || !window.Element || !window.DOMRect) {
7977        return;
7978      } // Duck-type to check if `anchorRef` is an instance of Range
7979      // `anchorRef instanceof window.Range` checks will break across document boundaries
7980      // such as in an iframe
7981  
7982  
7983      if (typeof (anchorRef === null || anchorRef === void 0 ? void 0 : anchorRef.cloneRange) === 'function') {
7984        return offsetIframe(Object(external_wp_dom_["getRectangleFromRange"])(anchorRef), anchorRef.endContainer.ownerDocument);
7985      } // Duck-type to check if `anchorRef` is an instance of Element
7986      // `anchorRef instanceof window.Element` checks will break across document boundaries
7987      // such as in an iframe
7988  
7989  
7990      if (typeof (anchorRef === null || anchorRef === void 0 ? void 0 : anchorRef.getBoundingClientRect) === 'function') {
7991        var _rect2 = offsetIframe(anchorRef.getBoundingClientRect(), anchorRef.ownerDocument);
7992  
7993        if (shouldAnchorIncludePadding) {
7994          return _rect2;
7995        }
7996  
7997        return withoutPadding(_rect2, anchorRef);
7998      }
7999  
8000      var top = anchorRef.top,
8001          bottom = anchorRef.bottom;
8002      var topRect = top.getBoundingClientRect();
8003      var bottomRect = bottom.getBoundingClientRect();
8004  
8005      var _rect = offsetIframe(new window.DOMRect(topRect.left, topRect.top, topRect.width, bottomRect.bottom - topRect.top), top.ownerDocument);
8006  
8007      if (shouldAnchorIncludePadding) {
8008        return _rect;
8009      }
8010  
8011      return withoutPadding(_rect, anchorRef);
8012    }
8013  
8014    if (!anchorRefFallback.current) {
8015      return;
8016    }
8017  
8018    var parentNode = anchorRefFallback.current.parentNode;
8019    var rect = parentNode.getBoundingClientRect();
8020  
8021    if (shouldAnchorIncludePadding) {
8022      return rect;
8023    }
8024  
8025    return withoutPadding(rect, parentNode);
8026  }
8027  
8028  function getComputedStyle(node) {
8029    return node.ownerDocument.defaultView.getComputedStyle(node);
8030  }
8031  
8032  function withoutPadding(rect, element) {
8033    var _getComputedStyle = getComputedStyle(element),
8034        paddingTop = _getComputedStyle.paddingTop,
8035        paddingBottom = _getComputedStyle.paddingBottom,
8036        paddingLeft = _getComputedStyle.paddingLeft,
8037        paddingRight = _getComputedStyle.paddingRight;
8038  
8039    var top = paddingTop ? parseInt(paddingTop, 10) : 0;
8040    var bottom = paddingBottom ? parseInt(paddingBottom, 10) : 0;
8041    var left = paddingLeft ? parseInt(paddingLeft, 10) : 0;
8042    var right = paddingRight ? parseInt(paddingRight, 10) : 0;
8043    return {
8044      x: rect.left + left,
8045      y: rect.top + top,
8046      width: rect.width - left - right,
8047      height: rect.height - top - bottom,
8048      left: rect.left + left,
8049      right: rect.right - right,
8050      top: rect.top + top,
8051      bottom: rect.bottom - bottom
8052    };
8053  }
8054  /**
8055   * Sets or removes an element attribute.
8056   *
8057   * @param {Element} element The element to modify.
8058   * @param {string}  name    The attribute name to set or remove.
8059   * @param {?string} value   The value to set. A falsy value will remove the
8060   *                          attribute.
8061   */
8062  
8063  
8064  function setAttribute(element, name, value) {
8065    if (!value) {
8066      if (element.hasAttribute(name)) {
8067        element.removeAttribute(name);
8068      }
8069    } else if (element.getAttribute(name) !== value) {
8070      element.setAttribute(name, value);
8071    }
8072  }
8073  /**
8074   * Sets or removes an element style property.
8075   *
8076   * @param {Element} element  The element to modify.
8077   * @param {string}  property The property to set or remove.
8078   * @param {?string} value    The value to set. A falsy value will remove the
8079   *                           property.
8080   */
8081  
8082  
8083  function setStyle(element, property) {
8084    var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
8085  
8086    if (element.style[property] !== value) {
8087      element.style[property] = value;
8088    }
8089  }
8090  /**
8091   * Sets or removes an element class.
8092   *
8093   * @param {Element} element The element to modify.
8094   * @param {string}  name    The class to set or remove.
8095   * @param {boolean} toggle  True to set the class, false to remove.
8096   */
8097  
8098  
8099  function setClass(element, name, toggle) {
8100    if (toggle) {
8101      if (!element.classList.contains(name)) {
8102        element.classList.add(name);
8103      }
8104    } else if (element.classList.contains(name)) {
8105      element.classList.remove(name);
8106    }
8107  }
8108  
8109  function getAnchorDocument(anchor) {
8110    if (!anchor) {
8111      return;
8112    }
8113  
8114    if (anchor.endContainer) {
8115      return anchor.endContainer.ownerDocument;
8116    }
8117  
8118    if (anchor.top) {
8119      return anchor.top.ownerDocument;
8120    }
8121  
8122    return anchor.ownerDocument;
8123  }
8124  
8125  var popover_Popover = function Popover(_ref) {
8126    var headerTitle = _ref.headerTitle,
8127        onClose = _ref.onClose,
8128        onKeyDown = _ref.onKeyDown,
8129        children = _ref.children,
8130        className = _ref.className,
8131        _ref$noArrow = _ref.noArrow,
8132        noArrow = _ref$noArrow === void 0 ? true : _ref$noArrow,
8133        isAlternate = _ref.isAlternate,
8134        _ref$position = _ref.position,
8135        position = _ref$position === void 0 ? 'bottom right' : _ref$position,
8136        range = _ref.range,
8137        _ref$focusOnMount = _ref.focusOnMount,
8138        focusOnMount = _ref$focusOnMount === void 0 ? 'firstElement' : _ref$focusOnMount,
8139        anchorRef = _ref.anchorRef,
8140        shouldAnchorIncludePadding = _ref.shouldAnchorIncludePadding,
8141        anchorRect = _ref.anchorRect,
8142        getAnchorRect = _ref.getAnchorRect,
8143        expandOnMobile = _ref.expandOnMobile,
8144        _ref$animate = _ref.animate,
8145        animate = _ref$animate === void 0 ? true : _ref$animate,
8146        onClickOutside = _ref.onClickOutside,
8147        onFocusOutside = _ref.onFocusOutside,
8148        __unstableStickyBoundaryElement = _ref.__unstableStickyBoundaryElement,
8149        _ref$__unstableSlotNa = _ref.__unstableSlotName,
8150        __unstableSlotName = _ref$__unstableSlotNa === void 0 ? SLOT_NAME : _ref$__unstableSlotNa,
8151        __unstableObserveElement = _ref.__unstableObserveElement,
8152        __unstableBoundaryParent = _ref.__unstableBoundaryParent,
8153        __unstableForcePosition = _ref.__unstableForcePosition,
8154        contentProps = Object(objectWithoutProperties["a" /* default */])(_ref, ["headerTitle", "onClose", "onKeyDown", "children", "className", "noArrow", "isAlternate", "position", "range", "focusOnMount", "anchorRef", "shouldAnchorIncludePadding", "anchorRect", "getAnchorRect", "expandOnMobile", "animate", "onClickOutside", "onFocusOutside", "__unstableStickyBoundaryElement", "__unstableSlotName", "__unstableObserveElement", "__unstableBoundaryParent", "__unstableForcePosition"]);
8155  
8156    var anchorRefFallback = Object(external_wp_element_["useRef"])(null);
8157    var contentRef = Object(external_wp_element_["useRef"])(null);
8158    var containerRef = Object(external_wp_element_["useRef"])();
8159    var isMobileViewport = Object(external_wp_compose_["useViewportMatch"])('medium', '<');
8160  
8161    var _useState = Object(external_wp_element_["useState"])(),
8162        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
8163        animateOrigin = _useState2[0],
8164        setAnimateOrigin = _useState2[1];
8165  
8166    var slot = Object(use_slot["a" /* default */])(__unstableSlotName);
8167    var isExpanded = expandOnMobile && isMobileViewport;
8168  
8169    var _useResizeObserver = Object(external_wp_compose_["useResizeObserver"])(),
8170        _useResizeObserver2 = Object(slicedToArray["a" /* default */])(_useResizeObserver, 2),
8171        containerResizeListener = _useResizeObserver2[0],
8172        contentSize = _useResizeObserver2[1];
8173  
8174    noArrow = isExpanded || noArrow;
8175    Object(external_wp_element_["useLayoutEffect"])(function () {
8176      if (isExpanded) {
8177        setClass(containerRef.current, 'is-without-arrow', noArrow);
8178        setClass(containerRef.current, 'is-alternate', isAlternate);
8179        setAttribute(containerRef.current, 'data-x-axis');
8180        setAttribute(containerRef.current, 'data-y-axis');
8181        setStyle(containerRef.current, 'top');
8182        setStyle(containerRef.current, 'left');
8183        setStyle(contentRef.current, 'maxHeight');
8184        setStyle(contentRef.current, 'maxWidth');
8185        return;
8186      }
8187  
8188      var refresh = function refresh() {
8189        if (!containerRef.current || !contentRef.current) {
8190          return;
8191        }
8192  
8193        var anchor = computeAnchorRect(anchorRefFallback, anchorRect, getAnchorRect, anchorRef, shouldAnchorIncludePadding);
8194  
8195        if (!anchor) {
8196          return;
8197        }
8198  
8199        var _containerRef$current = containerRef.current,
8200            offsetParent = _containerRef$current.offsetParent,
8201            ownerDocument = _containerRef$current.ownerDocument;
8202        var relativeOffsetTop = 0;