[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

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

   1  this["wp"] = this["wp"] || {}; this["wp"]["compose"] =
   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 = 461);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 0:
  91  /***/ (function(module, exports) {
  92  
  93  (function() { module.exports = window["wp"]["element"]; }());
  94  
  95  /***/ }),
  96  
  97  /***/ 11:
  98  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  99  
 100  "use strict";
 101  
 102  // EXPORTS
 103  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; });
 104  
 105  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
 106  var arrayWithHoles = __webpack_require__(38);
 107  
 108  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 109  function _iterableToArrayLimit(arr, i) {
 110    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
 111    var _arr = [];
 112    var _n = true;
 113    var _d = false;
 114    var _e = undefined;
 115  
 116    try {
 117      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 118        _arr.push(_s.value);
 119  
 120        if (i && _arr.length === i) break;
 121      }
 122    } catch (err) {
 123      _d = true;
 124      _e = err;
 125    } finally {
 126      try {
 127        if (!_n && _i["return"] != null) _i["return"]();
 128      } finally {
 129        if (_d) throw _e;
 130      }
 131    }
 132  
 133    return _arr;
 134  }
 135  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 136  var unsupportedIterableToArray = __webpack_require__(31);
 137  
 138  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 139  var nonIterableRest = __webpack_require__(39);
 140  
 141  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 142  
 143  
 144  
 145  
 146  function _slicedToArray(arr, i) {
 147    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
 148  }
 149  
 150  /***/ }),
 151  
 152  /***/ 127:
 153  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 154  
 155  "use strict";
 156  /* unused harmony export useCallback */
 157  /* unused harmony export useCallbackOne */
 158  /* unused harmony export useMemo */
 159  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useMemoOne; });
 160  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
 161  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
 162  
 163  
 164  function areInputsEqual(newInputs, lastInputs) {
 165    if (newInputs.length !== lastInputs.length) {
 166      return false;
 167    }
 168  
 169    for (var i = 0; i < newInputs.length; i++) {
 170      if (newInputs[i] !== lastInputs[i]) {
 171        return false;
 172      }
 173    }
 174  
 175    return true;
 176  }
 177  
 178  function useMemoOne(getResult, inputs) {
 179    var initial = Object(react__WEBPACK_IMPORTED_MODULE_0__["useState"])(function () {
 180      return {
 181        inputs: inputs,
 182        result: getResult()
 183      };
 184    })[0];
 185    var isFirstRun = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(true);
 186    var committed = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(initial);
 187    var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));
 188    var cache = useCache ? committed.current : {
 189      inputs: inputs,
 190      result: getResult()
 191    };
 192    Object(react__WEBPACK_IMPORTED_MODULE_0__["useEffect"])(function () {
 193      isFirstRun.current = false;
 194      committed.current = cache;
 195    }, [cache]);
 196    return cache.result;
 197  }
 198  function useCallbackOne(callback, inputs) {
 199    return useMemoOne(function () {
 200      return callback;
 201    }, inputs);
 202  }
 203  var useMemo = useMemoOne;
 204  var useCallback = useCallbackOne;
 205  
 206  
 207  
 208  
 209  /***/ }),
 210  
 211  /***/ 14:
 212  /***/ (function(module, exports) {
 213  
 214  (function() { module.exports = window["React"]; }());
 215  
 216  /***/ }),
 217  
 218  /***/ 15:
 219  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 220  
 221  "use strict";
 222  
 223  // EXPORTS
 224  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; });
 225  
 226  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
 227  var arrayLikeToArray = __webpack_require__(24);
 228  
 229  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
 230  
 231  function _arrayWithoutHoles(arr) {
 232    if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
 233  }
 234  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 235  var iterableToArray = __webpack_require__(37);
 236  
 237  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 238  var unsupportedIterableToArray = __webpack_require__(31);
 239  
 240  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 241  function _nonIterableSpread() {
 242    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 243  }
 244  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 245  
 246  
 247  
 248  
 249  function _toConsumableArray(arr) {
 250    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 251  }
 252  
 253  /***/ }),
 254  
 255  /***/ 151:
 256  /***/ (function(module, exports, __webpack_require__) {
 257  
 258  var e=__webpack_require__(14),n={display:"block",opacity:0,position:"absolute",top:0,left:0,height:"100%",width:"100%",overflow:"hidden",pointerEvents:"none",zIndex:-1},t=function(t){var r=t.onResize,u=e.useRef();return function(n,t){var r=function(){return n.current&&n.current.contentDocument&&n.current.contentDocument.defaultView};function u(){t();var e=r();e&&e.addEventListener("resize",t)}e.useEffect((function(){return r()?u():n.current&&n.current.addEventListener&&n.current.addEventListener("load",u),function(){var e=r();e&&"function"==typeof e.removeEventListener&&e.removeEventListener("resize",t)}}),[])}(u,(function(){return r(u)})),e.createElement("iframe",{style:n,src:"about:blank",ref:u,"aria-hidden":!0,tabIndex:-1,frameBorder:0})},r=function(e){return{width:null!=e?e.offsetWidth:null,height:null!=e?e.offsetHeight:null}};module.exports=function(n){void 0===n&&(n=r);var u=e.useState(n(null)),o=u[0],i=u[1],c=e.useCallback((function(e){return i(n(e.current))}),[n]);return[e.useMemo((function(){return e.createElement(t,{onResize:c})}),[c]),o]};
 259  
 260  
 261  /***/ }),
 262  
 263  /***/ 152:
 264  /***/ (function(module, exports) {
 265  
 266  (function() { module.exports = window["wp"]["priorityQueue"]; }());
 267  
 268  /***/ }),
 269  
 270  /***/ 17:
 271  /***/ (function(module, exports) {
 272  
 273  (function() { module.exports = window["wp"]["keycodes"]; }());
 274  
 275  /***/ }),
 276  
 277  /***/ 18:
 278  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 279  
 280  "use strict";
 281  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
 282  function _assertThisInitialized(self) {
 283    if (self === void 0) {
 284      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 285    }
 286  
 287    return self;
 288  }
 289  
 290  /***/ }),
 291  
 292  /***/ 19:
 293  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 294  
 295  "use strict";
 296  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });
 297  function _getPrototypeOf(o) {
 298    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
 299      return o.__proto__ || Object.getPrototypeOf(o);
 300    };
 301    return _getPrototypeOf(o);
 302  }
 303  
 304  /***/ }),
 305  
 306  /***/ 2:
 307  /***/ (function(module, exports) {
 308  
 309  (function() { module.exports = window["lodash"]; }());
 310  
 311  /***/ }),
 312  
 313  /***/ 24:
 314  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 315  
 316  "use strict";
 317  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
 318  function _arrayLikeToArray(arr, len) {
 319    if (len == null || len > arr.length) len = arr.length;
 320  
 321    for (var i = 0, arr2 = new Array(len); i < len; i++) {
 322      arr2[i] = arr[i];
 323    }
 324  
 325    return arr2;
 326  }
 327  
 328  /***/ }),
 329  
 330  /***/ 25:
 331  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 332  
 333  "use strict";
 334  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
 335  function _classCallCheck(instance, Constructor) {
 336    if (!(instance instanceof Constructor)) {
 337      throw new TypeError("Cannot call a class as a function");
 338    }
 339  }
 340  
 341  /***/ }),
 342  
 343  /***/ 26:
 344  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 345  
 346  "use strict";
 347  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
 348  function _defineProperties(target, props) {
 349    for (var i = 0; i < props.length; i++) {
 350      var descriptor = props[i];
 351      descriptor.enumerable = descriptor.enumerable || false;
 352      descriptor.configurable = true;
 353      if ("value" in descriptor) descriptor.writable = true;
 354      Object.defineProperty(target, descriptor.key, descriptor);
 355    }
 356  }
 357  
 358  function _createClass(Constructor, protoProps, staticProps) {
 359    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 360    if (staticProps) _defineProperties(Constructor, staticProps);
 361    return Constructor;
 362  }
 363  
 364  /***/ }),
 365  
 366  /***/ 27:
 367  /***/ (function(module, exports) {
 368  
 369  (function() { module.exports = window["wp"]["dom"]; }());
 370  
 371  /***/ }),
 372  
 373  /***/ 28:
 374  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 375  
 376  "use strict";
 377  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });
 378  /* harmony import */ var _babel_runtime_helpers_esm_setPrototypeOf__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(52);
 379  
 380  function _inherits(subClass, superClass) {
 381    if (typeof superClass !== "function" && superClass !== null) {
 382      throw new TypeError("Super expression must either be null or a function");
 383    }
 384  
 385    subClass.prototype = Object.create(superClass && superClass.prototype, {
 386      constructor: {
 387        value: subClass,
 388        writable: true,
 389        configurable: true
 390      }
 391    });
 392    if (superClass) Object(_babel_runtime_helpers_esm_setPrototypeOf__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(subClass, superClass);
 393  }
 394  
 395  /***/ }),
 396  
 397  /***/ 289:
 398  /***/ (function(module, exports, __webpack_require__) {
 399  
 400  /*!
 401   * clipboard.js v2.0.6
 402   * https://clipboardjs.com/
 403   * 
 404   * Licensed MIT © Zeno Rocha
 405   */
 406  (function webpackUniversalModuleDefinition(root, factory) {
 407      if(true)
 408          module.exports = factory();
 409      else {}
 410  })(this, function() {
 411  return /******/ (function(modules) { // webpackBootstrap
 412  /******/     // The module cache
 413  /******/     var installedModules = {};
 414  /******/
 415  /******/     // The require function
 416  /******/ 	function __webpack_require__(moduleId) {
 417  /******/
 418  /******/         // Check if module is in cache
 419  /******/         if(installedModules[moduleId]) {
 420  /******/             return installedModules[moduleId].exports;
 421  /******/         }
 422  /******/         // Create a new module (and put it into the cache)
 423  /******/         var module = installedModules[moduleId] = {
 424  /******/             i: moduleId,
 425  /******/             l: false,
 426  /******/             exports: {}
 427  /******/         };
 428  /******/
 429  /******/         // Execute the module function
 430  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 431  /******/
 432  /******/         // Flag the module as loaded
 433  /******/         module.l = true;
 434  /******/
 435  /******/         // Return the exports of the module
 436  /******/         return module.exports;
 437  /******/     }
 438  /******/
 439  /******/
 440  /******/     // expose the modules object (__webpack_modules__)
 441  /******/     __webpack_require__.m = modules;
 442  /******/
 443  /******/     // expose the module cache
 444  /******/     __webpack_require__.c = installedModules;
 445  /******/
 446  /******/     // define getter function for harmony exports
 447  /******/     __webpack_require__.d = function(exports, name, getter) {
 448  /******/         if(!__webpack_require__.o(exports, name)) {
 449  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
 450  /******/         }
 451  /******/     };
 452  /******/
 453  /******/     // define __esModule on exports
 454  /******/     __webpack_require__.r = function(exports) {
 455  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
 456  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 457  /******/         }
 458  /******/         Object.defineProperty(exports, '__esModule', { value: true });
 459  /******/     };
 460  /******/
 461  /******/     // create a fake namespace object
 462  /******/     // mode & 1: value is a module id, require it
 463  /******/     // mode & 2: merge all properties of value into the ns
 464  /******/     // mode & 4: return value when already ns object
 465  /******/     // mode & 8|1: behave like require
 466  /******/     __webpack_require__.t = function(value, mode) {
 467  /******/         if(mode & 1) value = __webpack_require__(value);
 468  /******/         if(mode & 8) return value;
 469  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
 470  /******/         var ns = Object.create(null);
 471  /******/         __webpack_require__.r(ns);
 472  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
 473  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
 474  /******/         return ns;
 475  /******/     };
 476  /******/
 477  /******/     // getDefaultExport function for compatibility with non-harmony modules
 478  /******/     __webpack_require__.n = function(module) {
 479  /******/         var getter = module && module.__esModule ?
 480  /******/ 			function getDefault() { return module['default']; } :
 481  /******/ 			function getModuleExports() { return module; };
 482  /******/         __webpack_require__.d(getter, 'a', getter);
 483  /******/         return getter;
 484  /******/     };
 485  /******/
 486  /******/     // Object.prototype.hasOwnProperty.call
 487  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
 488  /******/
 489  /******/     // __webpack_public_path__
 490  /******/     __webpack_require__.p = "";
 491  /******/
 492  /******/
 493  /******/     // Load entry module and return exports
 494  /******/     return __webpack_require__(__webpack_require__.s = 6);
 495  /******/ })
 496  /************************************************************************/
 497  /******/ ([
 498  /* 0 */
 499  /***/ (function(module, exports) {
 500  
 501  function select(element) {
 502      var selectedText;
 503  
 504      if (element.nodeName === 'SELECT') {
 505          element.focus();
 506  
 507          selectedText = element.value;
 508      }
 509      else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
 510          var isReadOnly = element.hasAttribute('readonly');
 511  
 512          if (!isReadOnly) {
 513              element.setAttribute('readonly', '');
 514          }
 515  
 516          element.select();
 517          element.setSelectionRange(0, element.value.length);
 518  
 519          if (!isReadOnly) {
 520              element.removeAttribute('readonly');
 521          }
 522  
 523          selectedText = element.value;
 524      }
 525      else {
 526          if (element.hasAttribute('contenteditable')) {
 527              element.focus();
 528          }
 529  
 530          var selection = window.getSelection();
 531          var range = document.createRange();
 532  
 533          range.selectNodeContents(element);
 534          selection.removeAllRanges();
 535          selection.addRange(range);
 536  
 537          selectedText = selection.toString();
 538      }
 539  
 540      return selectedText;
 541  }
 542  
 543  module.exports = select;
 544  
 545  
 546  /***/ }),
 547  /* 1 */
 548  /***/ (function(module, exports) {
 549  
 550  function E () {
 551    // Keep this empty so it's easier to inherit from
 552    // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
 553  }
 554  
 555  E.prototype = {
 556    on: function (name, callback, ctx) {
 557      var e = this.e || (this.e = {});
 558  
 559      (e[name] || (e[name] = [])).push({
 560        fn: callback,
 561        ctx: ctx
 562      });
 563  
 564      return this;
 565    },
 566  
 567    once: function (name, callback, ctx) {
 568      var self = this;
 569      function listener () {
 570        self.off(name, listener);
 571        callback.apply(ctx, arguments);
 572      };
 573  
 574      listener._ = callback
 575      return this.on(name, listener, ctx);
 576    },
 577  
 578    emit: function (name) {
 579      var data = [].slice.call(arguments, 1);
 580      var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
 581      var i = 0;
 582      var len = evtArr.length;
 583  
 584      for (i; i < len; i++) {
 585        evtArr[i].fn.apply(evtArr[i].ctx, data);
 586      }
 587  
 588      return this;
 589    },
 590  
 591    off: function (name, callback) {
 592      var e = this.e || (this.e = {});
 593      var evts = e[name];
 594      var liveEvents = [];
 595  
 596      if (evts && callback) {
 597        for (var i = 0, len = evts.length; i < len; i++) {
 598          if (evts[i].fn !== callback && evts[i].fn._ !== callback)
 599            liveEvents.push(evts[i]);
 600        }
 601      }
 602  
 603      // Remove event from queue to prevent memory leak
 604      // Suggested by https://github.com/lazd
 605      // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
 606  
 607      (liveEvents.length)
 608        ? e[name] = liveEvents
 609        : delete e[name];
 610  
 611      return this;
 612    }
 613  };
 614  
 615  module.exports = E;
 616  module.exports.TinyEmitter = E;
 617  
 618  
 619  /***/ }),
 620  /* 2 */
 621  /***/ (function(module, exports, __webpack_require__) {
 622  
 623  var is = __webpack_require__(3);
 624  var delegate = __webpack_require__(4);
 625  
 626  /**
 627   * Validates all params and calls the right
 628   * listener function based on its target type.
 629   *
 630   * @param {String|HTMLElement|HTMLCollection|NodeList} target
 631   * @param {String} type
 632   * @param {Function} callback
 633   * @return {Object}
 634   */
 635  function listen(target, type, callback) {
 636      if (!target && !type && !callback) {
 637          throw new Error('Missing required arguments');
 638      }
 639  
 640      if (!is.string(type)) {
 641          throw new TypeError('Second argument must be a String');
 642      }
 643  
 644      if (!is.fn(callback)) {
 645          throw new TypeError('Third argument must be a Function');
 646      }
 647  
 648      if (is.node(target)) {
 649          return listenNode(target, type, callback);
 650      }
 651      else if (is.nodeList(target)) {
 652          return listenNodeList(target, type, callback);
 653      }
 654      else if (is.string(target)) {
 655          return listenSelector(target, type, callback);
 656      }
 657      else {
 658          throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
 659      }
 660  }
 661  
 662  /**
 663   * Adds an event listener to a HTML element
 664   * and returns a remove listener function.
 665   *
 666   * @param {HTMLElement} node
 667   * @param {String} type
 668   * @param {Function} callback
 669   * @return {Object}
 670   */
 671  function listenNode(node, type, callback) {
 672      node.addEventListener(type, callback);
 673  
 674      return {
 675          destroy: function() {
 676              node.removeEventListener(type, callback);
 677          }
 678      }
 679  }
 680  
 681  /**
 682   * Add an event listener to a list of HTML elements
 683   * and returns a remove listener function.
 684   *
 685   * @param {NodeList|HTMLCollection} nodeList
 686   * @param {String} type
 687   * @param {Function} callback
 688   * @return {Object}
 689   */
 690  function listenNodeList(nodeList, type, callback) {
 691      Array.prototype.forEach.call(nodeList, function(node) {
 692          node.addEventListener(type, callback);
 693      });
 694  
 695      return {
 696          destroy: function() {
 697              Array.prototype.forEach.call(nodeList, function(node) {
 698                  node.removeEventListener(type, callback);
 699              });
 700          }
 701      }
 702  }
 703  
 704  /**
 705   * Add an event listener to a selector
 706   * and returns a remove listener function.
 707   *
 708   * @param {String} selector
 709   * @param {String} type
 710   * @param {Function} callback
 711   * @return {Object}
 712   */
 713  function listenSelector(selector, type, callback) {
 714      return delegate(document.body, selector, type, callback);
 715  }
 716  
 717  module.exports = listen;
 718  
 719  
 720  /***/ }),
 721  /* 3 */
 722  /***/ (function(module, exports) {
 723  
 724  /**
 725   * Check if argument is a HTML element.
 726   *
 727   * @param {Object} value
 728   * @return {Boolean}
 729   */
 730  exports.node = function(value) {
 731      return value !== undefined
 732          && value instanceof HTMLElement
 733          && value.nodeType === 1;
 734  };
 735  
 736  /**
 737   * Check if argument is a list of HTML elements.
 738   *
 739   * @param {Object} value
 740   * @return {Boolean}
 741   */
 742  exports.nodeList = function(value) {
 743      var type = Object.prototype.toString.call(value);
 744  
 745      return value !== undefined
 746          && (type === '[object NodeList]' || type === '[object HTMLCollection]')
 747          && ('length' in value)
 748          && (value.length === 0 || exports.node(value[0]));
 749  };
 750  
 751  /**
 752   * Check if argument is a string.
 753   *
 754   * @param {Object} value
 755   * @return {Boolean}
 756   */
 757  exports.string = function(value) {
 758      return typeof value === 'string'
 759          || value instanceof String;
 760  };
 761  
 762  /**
 763   * Check if argument is a function.
 764   *
 765   * @param {Object} value
 766   * @return {Boolean}
 767   */
 768  exports.fn = function(value) {
 769      var type = Object.prototype.toString.call(value);
 770  
 771      return type === '[object Function]';
 772  };
 773  
 774  
 775  /***/ }),
 776  /* 4 */
 777  /***/ (function(module, exports, __webpack_require__) {
 778  
 779  var closest = __webpack_require__(5);
 780  
 781  /**
 782   * Delegates event to a selector.
 783   *
 784   * @param {Element} element
 785   * @param {String} selector
 786   * @param {String} type
 787   * @param {Function} callback
 788   * @param {Boolean} useCapture
 789   * @return {Object}
 790   */
 791  function _delegate(element, selector, type, callback, useCapture) {
 792      var listenerFn = listener.apply(this, arguments);
 793  
 794      element.addEventListener(type, listenerFn, useCapture);
 795  
 796      return {
 797          destroy: function() {
 798              element.removeEventListener(type, listenerFn, useCapture);
 799          }
 800      }
 801  }
 802  
 803  /**
 804   * Delegates event to a selector.
 805   *
 806   * @param {Element|String|Array} [elements]
 807   * @param {String} selector
 808   * @param {String} type
 809   * @param {Function} callback
 810   * @param {Boolean} useCapture
 811   * @return {Object}
 812   */
 813  function delegate(elements, selector, type, callback, useCapture) {
 814      // Handle the regular Element usage
 815      if (typeof elements.addEventListener === 'function') {
 816          return _delegate.apply(null, arguments);
 817      }
 818  
 819      // Handle Element-less usage, it defaults to global delegation
 820      if (typeof type === 'function') {
 821          // Use `document` as the first parameter, then apply arguments
 822          // This is a short way to .unshift `arguments` without running into deoptimizations
 823          return _delegate.bind(null, document).apply(null, arguments);
 824      }
 825  
 826      // Handle Selector-based usage
 827      if (typeof elements === 'string') {
 828          elements = document.querySelectorAll(elements);
 829      }
 830  
 831      // Handle Array-like based usage
 832      return Array.prototype.map.call(elements, function (element) {
 833          return _delegate(element, selector, type, callback, useCapture);
 834      });
 835  }
 836  
 837  /**
 838   * Finds closest match and invokes callback.
 839   *
 840   * @param {Element} element
 841   * @param {String} selector
 842   * @param {String} type
 843   * @param {Function} callback
 844   * @return {Function}
 845   */
 846  function listener(element, selector, type, callback) {
 847      return function(e) {
 848          e.delegateTarget = closest(e.target, selector);
 849  
 850          if (e.delegateTarget) {
 851              callback.call(element, e);
 852          }
 853      }
 854  }
 855  
 856  module.exports = delegate;
 857  
 858  
 859  /***/ }),
 860  /* 5 */
 861  /***/ (function(module, exports) {
 862  
 863  var DOCUMENT_NODE_TYPE = 9;
 864  
 865  /**
 866   * A polyfill for Element.matches()
 867   */
 868  if (typeof Element !== 'undefined' && !Element.prototype.matches) {
 869      var proto = Element.prototype;
 870  
 871      proto.matches = proto.matchesSelector ||
 872                      proto.mozMatchesSelector ||
 873                      proto.msMatchesSelector ||
 874                      proto.oMatchesSelector ||
 875                      proto.webkitMatchesSelector;
 876  }
 877  
 878  /**
 879   * Finds the closest parent that matches a selector.
 880   *
 881   * @param {Element} element
 882   * @param {String} selector
 883   * @return {Function}
 884   */
 885  function closest (element, selector) {
 886      while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
 887          if (typeof element.matches === 'function' &&
 888              element.matches(selector)) {
 889            return element;
 890          }
 891          element = element.parentNode;
 892      }
 893  }
 894  
 895  module.exports = closest;
 896  
 897  
 898  /***/ }),
 899  /* 6 */
 900  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 901  
 902  "use strict";
 903  __webpack_require__.r(__webpack_exports__);
 904  
 905  // EXTERNAL MODULE: ./node_modules/select/src/select.js
 906  var src_select = __webpack_require__(0);
 907  var select_default = /*#__PURE__*/__webpack_require__.n(src_select);
 908  
 909  // CONCATENATED MODULE: ./src/clipboard-action.js
 910  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 911  
 912  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; }; }();
 913  
 914  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 915  
 916  
 917  
 918  /**
 919   * Inner class which performs selection from either `text` or `target`
 920   * properties and then executes copy or cut operations.
 921   */
 922  
 923  var clipboard_action_ClipboardAction = function () {
 924      /**
 925       * @param {Object} options
 926       */
 927      function ClipboardAction(options) {
 928          _classCallCheck(this, ClipboardAction);
 929  
 930          this.resolveOptions(options);
 931          this.initSelection();
 932      }
 933  
 934      /**
 935       * Defines base properties passed from constructor.
 936       * @param {Object} options
 937       */
 938  
 939  
 940      _createClass(ClipboardAction, [{
 941          key: 'resolveOptions',
 942          value: function resolveOptions() {
 943              var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 944  
 945              this.action = options.action;
 946              this.container = options.container;
 947              this.emitter = options.emitter;
 948              this.target = options.target;
 949              this.text = options.text;
 950              this.trigger = options.trigger;
 951  
 952              this.selectedText = '';
 953          }
 954  
 955          /**
 956           * Decides which selection strategy is going to be applied based
 957           * on the existence of `text` and `target` properties.
 958           */
 959  
 960      }, {
 961          key: 'initSelection',
 962          value: function initSelection() {
 963              if (this.text) {
 964                  this.selectFake();
 965              } else if (this.target) {
 966                  this.selectTarget();
 967              }
 968          }
 969  
 970          /**
 971           * Creates a fake textarea element, sets its value from `text` property,
 972           * and makes a selection on it.
 973           */
 974  
 975      }, {
 976          key: 'selectFake',
 977          value: function selectFake() {
 978              var _this = this;
 979  
 980              var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
 981  
 982              this.removeFake();
 983  
 984              this.fakeHandlerCallback = function () {
 985                  return _this.removeFake();
 986              };
 987              this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;
 988  
 989              this.fakeElem = document.createElement('textarea');
 990              // Prevent zooming on iOS
 991              this.fakeElem.style.fontSize = '12pt';
 992              // Reset box model
 993              this.fakeElem.style.border = '0';
 994              this.fakeElem.style.padding = '0';
 995              this.fakeElem.style.margin = '0';
 996              // Move element out of screen horizontally
 997              this.fakeElem.style.position = 'absolute';
 998              this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
 999              // Move element to the same position vertically
1000              var yPosition = window.pageYOffset || document.documentElement.scrollTop;
1001              this.fakeElem.style.top = yPosition + 'px';
1002  
1003              this.fakeElem.setAttribute('readonly', '');
1004              this.fakeElem.value = this.text;
1005  
1006              this.container.appendChild(this.fakeElem);
1007  
1008              this.selectedText = select_default()(this.fakeElem);
1009              this.copyText();
1010          }
1011  
1012          /**
1013           * Only removes the fake element after another click event, that way
1014           * a user can hit `Ctrl+C` to copy because selection still exists.
1015           */
1016  
1017      }, {
1018          key: 'removeFake',
1019          value: function removeFake() {
1020              if (this.fakeHandler) {
1021                  this.container.removeEventListener('click', this.fakeHandlerCallback);
1022                  this.fakeHandler = null;
1023                  this.fakeHandlerCallback = null;
1024              }
1025  
1026              if (this.fakeElem) {
1027                  this.container.removeChild(this.fakeElem);
1028                  this.fakeElem = null;
1029              }
1030          }
1031  
1032          /**
1033           * Selects the content from element passed on `target` property.
1034           */
1035  
1036      }, {
1037          key: 'selectTarget',
1038          value: function selectTarget() {
1039              this.selectedText = select_default()(this.target);
1040              this.copyText();
1041          }
1042  
1043          /**
1044           * Executes the copy operation based on the current selection.
1045           */
1046  
1047      }, {
1048          key: 'copyText',
1049          value: function copyText() {
1050              var succeeded = void 0;
1051  
1052              try {
1053                  succeeded = document.execCommand(this.action);
1054              } catch (err) {
1055                  succeeded = false;
1056              }
1057  
1058              this.handleResult(succeeded);
1059          }
1060  
1061          /**
1062           * Fires an event based on the copy operation result.
1063           * @param {Boolean} succeeded
1064           */
1065  
1066      }, {
1067          key: 'handleResult',
1068          value: function handleResult(succeeded) {
1069              this.emitter.emit(succeeded ? 'success' : 'error', {
1070                  action: this.action,
1071                  text: this.selectedText,
1072                  trigger: this.trigger,
1073                  clearSelection: this.clearSelection.bind(this)
1074              });
1075          }
1076  
1077          /**
1078           * Moves focus away from `target` and back to the trigger, removes current selection.
1079           */
1080  
1081      }, {
1082          key: 'clearSelection',
1083          value: function clearSelection() {
1084              if (this.trigger) {
1085                  this.trigger.focus();
1086              }
1087              document.activeElement.blur();
1088              window.getSelection().removeAllRanges();
1089          }
1090  
1091          /**
1092           * Sets the `action` to be performed which can be either 'copy' or 'cut'.
1093           * @param {String} action
1094           */
1095  
1096      }, {
1097          key: 'destroy',
1098  
1099  
1100          /**
1101           * Destroy lifecycle.
1102           */
1103          value: function destroy() {
1104              this.removeFake();
1105          }
1106      }, {
1107          key: 'action',
1108          set: function set() {
1109              var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
1110  
1111              this._action = action;
1112  
1113              if (this._action !== 'copy' && this._action !== 'cut') {
1114                  throw new Error('Invalid "action" value, use either "copy" or "cut"');
1115              }
1116          }
1117  
1118          /**
1119           * Gets the `action` property.
1120           * @return {String}
1121           */
1122          ,
1123          get: function get() {
1124              return this._action;
1125          }
1126  
1127          /**
1128           * Sets the `target` property using an element
1129           * that will be have its content copied.
1130           * @param {Element} target
1131           */
1132  
1133      }, {
1134          key: 'target',
1135          set: function set(target) {
1136              if (target !== undefined) {
1137                  if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
1138                      if (this.action === 'copy' && target.hasAttribute('disabled')) {
1139                          throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
1140                      }
1141  
1142                      if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
1143                          throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
1144                      }
1145  
1146                      this._target = target;
1147                  } else {
1148                      throw new Error('Invalid "target" value, use a valid Element');
1149                  }
1150              }
1151          }
1152  
1153          /**
1154           * Gets the `target` property.
1155           * @return {String|HTMLElement}
1156           */
1157          ,
1158          get: function get() {
1159              return this._target;
1160          }
1161      }]);
1162  
1163      return ClipboardAction;
1164  }();
1165  
1166  /* harmony default export */ var clipboard_action = (clipboard_action_ClipboardAction);
1167  // EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js
1168  var tiny_emitter = __webpack_require__(1);
1169  var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);
1170  
1171  // EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
1172  var listen = __webpack_require__(2);
1173  var listen_default = /*#__PURE__*/__webpack_require__.n(listen);
1174  
1175  // CONCATENATED MODULE: ./src/clipboard.js
1176  var clipboard_typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
1177  
1178  var clipboard_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; }; }();
1179  
1180  function clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
1181  
1182  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; }
1183  
1184  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; }
1185  
1186  
1187  
1188  
1189  
1190  /**
1191   * Base class which takes one or more elements, adds event listeners to them,
1192   * and instantiates a new `ClipboardAction` on each click.
1193   */
1194  
1195  var clipboard_Clipboard = function (_Emitter) {
1196      _inherits(Clipboard, _Emitter);
1197  
1198      /**
1199       * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
1200       * @param {Object} options
1201       */
1202      function Clipboard(trigger, options) {
1203          clipboard_classCallCheck(this, Clipboard);
1204  
1205          var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));
1206  
1207          _this.resolveOptions(options);
1208          _this.listenClick(trigger);
1209          return _this;
1210      }
1211  
1212      /**
1213       * Defines if attributes would be resolved using internal setter functions
1214       * or custom functions that were passed in the constructor.
1215       * @param {Object} options
1216       */
1217  
1218  
1219      clipboard_createClass(Clipboard, [{
1220          key: 'resolveOptions',
1221          value: function resolveOptions() {
1222              var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1223  
1224              this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
1225              this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
1226              this.text = typeof options.text === 'function' ? options.text : this.defaultText;
1227              this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
1228          }
1229  
1230          /**
1231           * Adds a click event listener to the passed trigger.
1232           * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
1233           */
1234  
1235      }, {
1236          key: 'listenClick',
1237          value: function listenClick(trigger) {
1238              var _this2 = this;
1239  
1240              this.listener = listen_default()(trigger, 'click', function (e) {
1241                  return _this2.onClick(e);
1242              });
1243          }
1244  
1245          /**
1246           * Defines a new `ClipboardAction` on each click event.
1247           * @param {Event} e
1248           */
1249  
1250      }, {
1251          key: 'onClick',
1252          value: function onClick(e) {
1253              var trigger = e.delegateTarget || e.currentTarget;
1254  
1255              if (this.clipboardAction) {
1256                  this.clipboardAction = null;
1257              }
1258  
1259              this.clipboardAction = new clipboard_action({
1260                  action: this.action(trigger),
1261                  target: this.target(trigger),
1262                  text: this.text(trigger),
1263                  container: this.container,
1264                  trigger: trigger,
1265                  emitter: this
1266              });
1267          }
1268  
1269          /**
1270           * Default `action` lookup function.
1271           * @param {Element} trigger
1272           */
1273  
1274      }, {
1275          key: 'defaultAction',
1276          value: function defaultAction(trigger) {
1277              return getAttributeValue('action', trigger);
1278          }
1279  
1280          /**
1281           * Default `target` lookup function.
1282           * @param {Element} trigger
1283           */
1284  
1285      }, {
1286          key: 'defaultTarget',
1287          value: function defaultTarget(trigger) {
1288              var selector = getAttributeValue('target', trigger);
1289  
1290              if (selector) {
1291                  return document.querySelector(selector);
1292              }
1293          }
1294  
1295          /**
1296           * Returns the support of the given action, or all actions if no action is
1297           * given.
1298           * @param {String} [action]
1299           */
1300  
1301      }, {
1302          key: 'defaultText',
1303  
1304  
1305          /**
1306           * Default `text` lookup function.
1307           * @param {Element} trigger
1308           */
1309          value: function defaultText(trigger) {
1310              return getAttributeValue('text', trigger);
1311          }
1312  
1313          /**
1314           * Destroy lifecycle.
1315           */
1316  
1317      }, {
1318          key: 'destroy',
1319          value: function destroy() {
1320              this.listener.destroy();
1321  
1322              if (this.clipboardAction) {
1323                  this.clipboardAction.destroy();
1324                  this.clipboardAction = null;
1325              }
1326          }
1327      }], [{
1328          key: 'isSupported',
1329          value: function isSupported() {
1330              var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
1331  
1332              var actions = typeof action === 'string' ? [action] : action;
1333              var support = !!document.queryCommandSupported;
1334  
1335              actions.forEach(function (action) {
1336                  support = support && !!document.queryCommandSupported(action);
1337              });
1338  
1339              return support;
1340          }
1341      }]);
1342  
1343      return Clipboard;
1344  }(tiny_emitter_default.a);
1345  
1346  /**
1347   * Helper function to retrieve attribute value.
1348   * @param {String} suffix
1349   * @param {Element} element
1350   */
1351  
1352  
1353  function getAttributeValue(suffix, element) {
1354      var attribute = 'data-clipboard-' + suffix;
1355  
1356      if (!element.hasAttribute(attribute)) {
1357          return;
1358      }
1359  
1360      return element.getAttribute(attribute);
1361  }
1362  
1363  /* harmony default export */ var clipboard = __webpack_exports__["default"] = (clipboard_Clipboard);
1364  
1365  /***/ })
1366  /******/ ])["default"];
1367  });
1368  
1369  /***/ }),
1370  
1371  /***/ 29:
1372  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1373  
1374  "use strict";
1375  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
1376  /* harmony import */ var _babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(42);
1377  /* harmony import */ var _babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18);
1378  
1379  
1380  function _possibleConstructorReturn(self, call) {
1381    if (call && (Object(_babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) {
1382      return call;
1383    }
1384  
1385    return Object(_babel_runtime_helpers_esm_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
1386  }
1387  
1388  /***/ }),
1389  
1390  /***/ 290:
1391  /***/ (function(module, exports, __webpack_require__) {
1392  
1393  var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */
1394  /**
1395   * Copyright 2012-2017 Craig Campbell
1396   *
1397   * Licensed under the Apache License, Version 2.0 (the "License");
1398   * you may not use this file except in compliance with the License.
1399   * You may obtain a copy of the License at
1400   *
1401   * http://www.apache.org/licenses/LICENSE-2.0
1402   *
1403   * Unless required by applicable law or agreed to in writing, software
1404   * distributed under the License is distributed on an "AS IS" BASIS,
1405   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1406   * See the License for the specific language governing permissions and
1407   * limitations under the License.
1408   *
1409   * Mousetrap is a simple keyboard shortcut library for Javascript with
1410   * no external dependencies
1411   *
1412   * @version 1.6.5
1413   * @url craig.is/killing/mice
1414   */
1415  (function(window, document, undefined) {
1416  
1417      // Check if mousetrap is used inside browser, if not, return
1418      if (!window) {
1419          return;
1420      }
1421  
1422      /**
1423       * mapping of special keycodes to their corresponding keys
1424       *
1425       * everything in this dictionary cannot use keypress events
1426       * so it has to be here to map to the correct keycodes for
1427       * keyup/keydown events
1428       *
1429       * @type {Object}
1430       */
1431      var _MAP = {
1432          8: 'backspace',
1433          9: 'tab',
1434          13: 'enter',
1435          16: 'shift',
1436          17: 'ctrl',
1437          18: 'alt',
1438          20: 'capslock',
1439          27: 'esc',
1440          32: 'space',
1441          33: 'pageup',
1442          34: 'pagedown',
1443          35: 'end',
1444          36: 'home',
1445          37: 'left',
1446          38: 'up',
1447          39: 'right',
1448          40: 'down',
1449          45: 'ins',
1450          46: 'del',
1451          91: 'meta',
1452          93: 'meta',
1453          224: 'meta'
1454      };
1455  
1456      /**
1457       * mapping for special characters so they can support
1458       *
1459       * this dictionary is only used incase you want to bind a
1460       * keyup or keydown event to one of these keys
1461       *
1462       * @type {Object}
1463       */
1464      var _KEYCODE_MAP = {
1465          106: '*',
1466          107: '+',
1467          109: '-',
1468          110: '.',
1469          111 : '/',
1470          186: ';',
1471          187: '=',
1472          188: ',',
1473          189: '-',
1474          190: '.',
1475          191: '/',
1476          192: '`',
1477          219: '[',
1478          220: '\\',
1479          221: ']',
1480          222: '\''
1481      };
1482  
1483      /**
1484       * this is a mapping of keys that require shift on a US keypad
1485       * back to the non shift equivelents
1486       *
1487       * this is so you can use keyup events with these keys
1488       *
1489       * note that this will only work reliably on US keyboards
1490       *
1491       * @type {Object}
1492       */
1493      var _SHIFT_MAP = {
1494          '~': '`',
1495          '!': '1',
1496          '@': '2',
1497          '#': '3',
1498          '$': '4',
1499          '%': '5',
1500          '^': '6',
1501          '&': '7',
1502          '*': '8',
1503          '(': '9',
1504          ')': '0',
1505          '_': '-',
1506          '+': '=',
1507          ':': ';',
1508          '\"': '\'',
1509          '<': ',',
1510          '>': '.',
1511          '?': '/',
1512          '|': '\\'
1513      };
1514  
1515      /**
1516       * this is a list of special strings you can use to map
1517       * to modifier keys when you specify your keyboard shortcuts
1518       *
1519       * @type {Object}
1520       */
1521      var _SPECIAL_ALIASES = {
1522          'option': 'alt',
1523          'command': 'meta',
1524          'return': 'enter',
1525          'escape': 'esc',
1526          'plus': '+',
1527          'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'
1528      };
1529  
1530      /**
1531       * variable to store the flipped version of _MAP from above
1532       * needed to check if we should use keypress or not when no action
1533       * is specified
1534       *
1535       * @type {Object|undefined}
1536       */
1537      var _REVERSE_MAP;
1538  
1539      /**
1540       * loop through the f keys, f1 to f19 and add them to the map
1541       * programatically
1542       */
1543      for (var i = 1; i < 20; ++i) {
1544          _MAP[111 + i] = 'f' + i;
1545      }
1546  
1547      /**
1548       * loop through to map numbers on the numeric keypad
1549       */
1550      for (i = 0; i <= 9; ++i) {
1551  
1552          // This needs to use a string cause otherwise since 0 is falsey
1553          // mousetrap will never fire for numpad 0 pressed as part of a keydown
1554          // event.
1555          //
1556          // @see https://github.com/ccampbell/mousetrap/pull/258
1557          _MAP[i + 96] = i.toString();
1558      }
1559  
1560      /**
1561       * cross browser add event method
1562       *
1563       * @param {Element|HTMLDocument} object
1564       * @param {string} type
1565       * @param {Function} callback
1566       * @returns void
1567       */
1568      function _addEvent(object, type, callback) {
1569          if (object.addEventListener) {
1570              object.addEventListener(type, callback, false);
1571              return;
1572          }
1573  
1574          object.attachEvent('on' + type, callback);
1575      }
1576  
1577      /**
1578       * takes the event and returns the key character
1579       *
1580       * @param {Event} e
1581       * @return {string}
1582       */
1583      function _characterFromEvent(e) {
1584  
1585          // for keypress events we should return the character as is
1586          if (e.type == 'keypress') {
1587              var character = String.fromCharCode(e.which);
1588  
1589              // if the shift key is not pressed then it is safe to assume
1590              // that we want the character to be lowercase.  this means if
1591              // you accidentally have caps lock on then your key bindings
1592              // will continue to work
1593              //
1594              // the only side effect that might not be desired is if you
1595              // bind something like 'A' cause you want to trigger an
1596              // event when capital A is pressed caps lock will no longer
1597              // trigger the event.  shift+a will though.
1598              if (!e.shiftKey) {
1599                  character = character.toLowerCase();
1600              }
1601  
1602              return character;
1603          }
1604  
1605          // for non keypress events the special maps are needed
1606          if (_MAP[e.which]) {
1607              return _MAP[e.which];
1608          }
1609  
1610          if (_KEYCODE_MAP[e.which]) {
1611              return _KEYCODE_MAP[e.which];
1612          }
1613  
1614          // if it is not in the special map
1615  
1616          // with keydown and keyup events the character seems to always
1617          // come in as an uppercase character whether you are pressing shift
1618          // or not.  we should make sure it is always lowercase for comparisons
1619          return String.fromCharCode(e.which).toLowerCase();
1620      }
1621  
1622      /**
1623       * checks if two arrays are equal
1624       *
1625       * @param {Array} modifiers1
1626       * @param {Array} modifiers2
1627       * @returns {boolean}
1628       */
1629      function _modifiersMatch(modifiers1, modifiers2) {
1630          return modifiers1.sort().join(',') === modifiers2.sort().join(',');
1631      }
1632  
1633      /**
1634       * takes a key event and figures out what the modifiers are
1635       *
1636       * @param {Event} e
1637       * @returns {Array}
1638       */
1639      function _eventModifiers(e) {
1640          var modifiers = [];
1641  
1642          if (e.shiftKey) {
1643              modifiers.push('shift');
1644          }
1645  
1646          if (e.altKey) {
1647              modifiers.push('alt');
1648          }
1649  
1650          if (e.ctrlKey) {
1651              modifiers.push('ctrl');
1652          }
1653  
1654          if (e.metaKey) {
1655              modifiers.push('meta');
1656          }
1657  
1658          return modifiers;
1659      }
1660  
1661      /**
1662       * prevents default for this event
1663       *
1664       * @param {Event} e
1665       * @returns void
1666       */
1667      function _preventDefault(e) {
1668          if (e.preventDefault) {
1669              e.preventDefault();
1670              return;
1671          }
1672  
1673          e.returnValue = false;
1674      }
1675  
1676      /**
1677       * stops propogation for this event
1678       *
1679       * @param {Event} e
1680       * @returns void
1681       */
1682      function _stopPropagation(e) {
1683          if (e.stopPropagation) {
1684              e.stopPropagation();
1685              return;
1686          }
1687  
1688          e.cancelBubble = true;
1689      }
1690  
1691      /**
1692       * determines if the keycode specified is a modifier key or not
1693       *
1694       * @param {string} key
1695       * @returns {boolean}
1696       */
1697      function _isModifier(key) {
1698          return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';
1699      }
1700  
1701      /**
1702       * reverses the map lookup so that we can look for specific keys
1703       * to see what can and can't use keypress
1704       *
1705       * @return {Object}
1706       */
1707      function _getReverseMap() {
1708          if (!_REVERSE_MAP) {
1709              _REVERSE_MAP = {};
1710              for (var key in _MAP) {
1711  
1712                  // pull out the numeric keypad from here cause keypress should
1713                  // be able to detect the keys from the character
1714                  if (key > 95 && key < 112) {
1715                      continue;
1716                  }
1717  
1718                  if (_MAP.hasOwnProperty(key)) {
1719                      _REVERSE_MAP[_MAP[key]] = key;
1720                  }
1721              }
1722          }
1723          return _REVERSE_MAP;
1724      }
1725  
1726      /**
1727       * picks the best action based on the key combination
1728       *
1729       * @param {string} key - character for key
1730       * @param {Array} modifiers
1731       * @param {string=} action passed in
1732       */
1733      function _pickBestAction(key, modifiers, action) {
1734  
1735          // if no action was picked in we should try to pick the one
1736          // that we think would work best for this key
1737          if (!action) {
1738              action = _getReverseMap()[key] ? 'keydown' : 'keypress';
1739          }
1740  
1741          // modifier keys don't work as expected with keypress,
1742          // switch to keydown
1743          if (action == 'keypress' && modifiers.length) {
1744              action = 'keydown';
1745          }
1746  
1747          return action;
1748      }
1749  
1750      /**
1751       * Converts from a string key combination to an array
1752       *
1753       * @param  {string} combination like "command+shift+l"
1754       * @return {Array}
1755       */
1756      function _keysFromString(combination) {
1757          if (combination === '+') {
1758              return ['+'];
1759          }
1760  
1761          combination = combination.replace(/\+{2}/g, '+plus');
1762          return combination.split('+');
1763      }
1764  
1765      /**
1766       * Gets info for a specific key combination
1767       *
1768       * @param  {string} combination key combination ("command+s" or "a" or "*")
1769       * @param  {string=} action
1770       * @returns {Object}
1771       */
1772      function _getKeyInfo(combination, action) {
1773          var keys;
1774          var key;
1775          var i;
1776          var modifiers = [];
1777  
1778          // take the keys from this pattern and figure out what the actual
1779          // pattern is all about
1780          keys = _keysFromString(combination);
1781  
1782          for (i = 0; i < keys.length; ++i) {
1783              key = keys[i];
1784  
1785              // normalize key names
1786              if (_SPECIAL_ALIASES[key]) {
1787                  key = _SPECIAL_ALIASES[key];
1788              }
1789  
1790              // if this is not a keypress event then we should
1791              // be smart about using shift keys
1792              // this will only work for US keyboards however
1793              if (action && action != 'keypress' && _SHIFT_MAP[key]) {
1794                  key = _SHIFT_MAP[key];
1795                  modifiers.push('shift');
1796              }
1797  
1798              // if this key is a modifier then add it to the list of modifiers
1799              if (_isModifier(key)) {
1800                  modifiers.push(key);
1801              }
1802          }
1803  
1804          // depending on what the key combination is
1805          // we will try to pick the best event for it
1806          action = _pickBestAction(key, modifiers, action);
1807  
1808          return {
1809              key: key,
1810              modifiers: modifiers,
1811              action: action
1812          };
1813      }
1814  
1815      function _belongsTo(element, ancestor) {
1816          if (element === null || element === document) {
1817              return false;
1818          }
1819  
1820          if (element === ancestor) {
1821              return true;
1822          }
1823  
1824          return _belongsTo(element.parentNode, ancestor);
1825      }
1826  
1827      function Mousetrap(targetElement) {
1828          var self = this;
1829  
1830          targetElement = targetElement || document;
1831  
1832          if (!(self instanceof Mousetrap)) {
1833              return new Mousetrap(targetElement);
1834          }
1835  
1836          /**
1837           * element to attach key events to
1838           *
1839           * @type {Element}
1840           */
1841          self.target = targetElement;
1842  
1843          /**
1844           * a list of all the callbacks setup via Mousetrap.bind()
1845           *
1846           * @type {Object}
1847           */
1848          self._callbacks = {};
1849  
1850          /**
1851           * direct map of string combinations to callbacks used for trigger()
1852           *
1853           * @type {Object}
1854           */
1855          self._directMap = {};
1856  
1857          /**
1858           * keeps track of what level each sequence is at since multiple
1859           * sequences can start out with the same sequence
1860           *
1861           * @type {Object}
1862           */
1863          var _sequenceLevels = {};
1864  
1865          /**
1866           * variable to store the setTimeout call
1867           *
1868           * @type {null|number}
1869           */
1870          var _resetTimer;
1871  
1872          /**
1873           * temporary state where we will ignore the next keyup
1874           *
1875           * @type {boolean|string}
1876           */
1877          var _ignoreNextKeyup = false;
1878  
1879          /**
1880           * temporary state where we will ignore the next keypress
1881           *
1882           * @type {boolean}
1883           */
1884          var _ignoreNextKeypress = false;
1885  
1886          /**
1887           * are we currently inside of a sequence?
1888           * type of action ("keyup" or "keydown" or "keypress") or false
1889           *
1890           * @type {boolean|string}
1891           */
1892          var _nextExpectedAction = false;
1893  
1894          /**
1895           * resets all sequence counters except for the ones passed in
1896           *
1897           * @param {Object} doNotReset
1898           * @returns void
1899           */
1900          function _resetSequences(doNotReset) {
1901              doNotReset = doNotReset || {};
1902  
1903              var activeSequences = false,
1904                  key;
1905  
1906              for (key in _sequenceLevels) {
1907                  if (doNotReset[key]) {
1908                      activeSequences = true;
1909                      continue;
1910                  }
1911                  _sequenceLevels[key] = 0;
1912              }
1913  
1914              if (!activeSequences) {
1915                  _nextExpectedAction = false;
1916              }
1917          }
1918  
1919          /**
1920           * finds all callbacks that match based on the keycode, modifiers,
1921           * and action
1922           *
1923           * @param {string} character
1924           * @param {Array} modifiers
1925           * @param {Event|Object} e
1926           * @param {string=} sequenceName - name of the sequence we are looking for
1927           * @param {string=} combination
1928           * @param {number=} level
1929           * @returns {Array}
1930           */
1931          function _getMatches(character, modifiers, e, sequenceName, combination, level) {
1932              var i;
1933              var callback;
1934              var matches = [];
1935              var action = e.type;
1936  
1937              // if there are no events related to this keycode
1938              if (!self._callbacks[character]) {
1939                  return [];
1940              }
1941  
1942              // if a modifier key is coming up on its own we should allow it
1943              if (action == 'keyup' && _isModifier(character)) {
1944                  modifiers = [character];
1945              }
1946  
1947              // loop through all callbacks for the key that was pressed
1948              // and see if any of them match
1949              for (i = 0; i < self._callbacks[character].length; ++i) {
1950                  callback = self._callbacks[character][i];
1951  
1952                  // if a sequence name is not specified, but this is a sequence at
1953                  // the wrong level then move onto the next match
1954                  if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {
1955                      continue;
1956                  }
1957  
1958                  // if the action we are looking for doesn't match the action we got
1959                  // then we should keep going
1960                  if (action != callback.action) {
1961                      continue;
1962                  }
1963  
1964                  // if this is a keypress event and the meta key and control key
1965                  // are not pressed that means that we need to only look at the
1966                  // character, otherwise check the modifiers as well
1967                  //
1968                  // chrome will not fire a keypress if meta or control is down
1969                  // safari will fire a keypress if meta or meta+shift is down
1970                  // firefox will fire a keypress if meta or control is down
1971                  if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {
1972  
1973                      // when you bind a combination or sequence a second time it
1974                      // should overwrite the first one.  if a sequenceName or
1975                      // combination is specified in this call it does just that
1976                      //
1977                      // @todo make deleting its own method?
1978                      var deleteCombo = !sequenceName && callback.combo == combination;
1979                      var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;
1980                      if (deleteCombo || deleteSequence) {
1981                          self._callbacks[character].splice(i, 1);
1982                      }
1983  
1984                      matches.push(callback);
1985                  }
1986              }
1987  
1988              return matches;
1989          }
1990  
1991          /**
1992           * actually calls the callback function
1993           *
1994           * if your callback function returns false this will use the jquery
1995           * convention - prevent default and stop propogation on the event
1996           *
1997           * @param {Function} callback
1998           * @param {Event} e
1999           * @returns void
2000           */
2001          function _fireCallback(callback, e, combo, sequence) {
2002  
2003              // if this event should not happen stop here
2004              if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {
2005                  return;
2006              }
2007  
2008              if (callback(e, combo) === false) {
2009                  _preventDefault(e);
2010                  _stopPropagation(e);
2011              }
2012          }
2013  
2014          /**
2015           * handles a character key event
2016           *
2017           * @param {string} character
2018           * @param {Array} modifiers
2019           * @param {Event} e
2020           * @returns void
2021           */
2022          self._handleKey = function(character, modifiers, e) {
2023              var callbacks = _getMatches(character, modifiers, e);
2024              var i;
2025              var doNotReset = {};
2026              var maxLevel = 0;
2027              var processedSequenceCallback = false;
2028  
2029              // Calculate the maxLevel for sequences so we can only execute the longest callback sequence
2030              for (i = 0; i < callbacks.length; ++i) {
2031                  if (callbacks[i].seq) {
2032                      maxLevel = Math.max(maxLevel, callbacks[i].level);
2033                  }
2034              }
2035  
2036              // loop through matching callbacks for this key event
2037              for (i = 0; i < callbacks.length; ++i) {
2038  
2039                  // fire for all sequence callbacks
2040                  // this is because if for example you have multiple sequences
2041                  // bound such as "g i" and "g t" they both need to fire the
2042                  // callback for matching g cause otherwise you can only ever
2043                  // match the first one
2044                  if (callbacks[i].seq) {
2045  
2046                      // only fire callbacks for the maxLevel to prevent
2047                      // subsequences from also firing
2048                      //
2049                      // for example 'a option b' should not cause 'option b' to fire
2050                      // even though 'option b' is part of the other sequence
2051                      //
2052                      // any sequences that do not match here will be discarded
2053                      // below by the _resetSequences call
2054                      if (callbacks[i].level != maxLevel) {
2055                          continue;
2056                      }
2057  
2058                      processedSequenceCallback = true;
2059  
2060                      // keep a list of which sequences were matches for later
2061                      doNotReset[callbacks[i].seq] = 1;
2062                      _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);
2063                      continue;
2064                  }
2065  
2066                  // if there were no sequence matches but we are still here
2067                  // that means this is a regular match so we should fire that
2068                  if (!processedSequenceCallback) {
2069                      _fireCallback(callbacks[i].callback, e, callbacks[i].combo);
2070                  }
2071              }
2072  
2073              // if the key you pressed matches the type of sequence without
2074              // being a modifier (ie "keyup" or "keypress") then we should
2075              // reset all sequences that were not matched by this event
2076              //
2077              // this is so, for example, if you have the sequence "h a t" and you
2078              // type "h e a r t" it does not match.  in this case the "e" will
2079              // cause the sequence to reset
2080              //
2081              // modifier keys are ignored because you can have a sequence
2082              // that contains modifiers such as "enter ctrl+space" and in most
2083              // cases the modifier key will be pressed before the next key
2084              //
2085              // also if you have a sequence such as "ctrl+b a" then pressing the
2086              // "b" key will trigger a "keypress" and a "keydown"
2087              //
2088              // the "keydown" is expected when there is a modifier, but the
2089              // "keypress" ends up matching the _nextExpectedAction since it occurs
2090              // after and that causes the sequence to reset
2091              //
2092              // we ignore keypresses in a sequence that directly follow a keydown
2093              // for the same character
2094              var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;
2095              if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {
2096                  _resetSequences(doNotReset);
2097              }
2098  
2099              _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';
2100          };
2101  
2102          /**
2103           * handles a keydown event
2104           *
2105           * @param {Event} e
2106           * @returns void
2107           */
2108          function _handleKeyEvent(e) {
2109  
2110              // normalize e.which for key events
2111              // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion
2112              if (typeof e.which !== 'number') {
2113                  e.which = e.keyCode;
2114              }
2115  
2116              var character = _characterFromEvent(e);
2117  
2118              // no character found then stop
2119              if (!character) {
2120                  return;
2121              }
2122  
2123              // need to use === for the character check because the character can be 0
2124              if (e.type == 'keyup' && _ignoreNextKeyup === character) {
2125                  _ignoreNextKeyup = false;
2126                  return;
2127              }
2128  
2129              self.handleKey(character, _eventModifiers(e), e);
2130          }
2131  
2132          /**
2133           * called to set a 1 second timeout on the specified sequence
2134           *
2135           * this is so after each key press in the sequence you have 1 second
2136           * to press the next key before you have to start over
2137           *
2138           * @returns void
2139           */
2140          function _resetSequenceTimer() {
2141              clearTimeout(_resetTimer);
2142              _resetTimer = setTimeout(_resetSequences, 1000);
2143          }
2144  
2145          /**
2146           * binds a key sequence to an event
2147           *
2148           * @param {string} combo - combo specified in bind call
2149           * @param {Array} keys
2150           * @param {Function} callback
2151           * @param {string=} action
2152           * @returns void
2153           */
2154          function _bindSequence(combo, keys, callback, action) {
2155  
2156              // start off by adding a sequence level record for this combination
2157              // and setting the level to 0
2158              _sequenceLevels[combo] = 0;
2159  
2160              /**
2161               * callback to increase the sequence level for this sequence and reset
2162               * all other sequences that were active
2163               *
2164               * @param {string} nextAction
2165               * @returns {Function}
2166               */
2167              function _increaseSequence(nextAction) {
2168                  return function() {
2169                      _nextExpectedAction = nextAction;
2170                      ++_sequenceLevels[combo];
2171                      _resetSequenceTimer();
2172                  };
2173              }
2174  
2175              /**
2176               * wraps the specified callback inside of another function in order
2177               * to reset all sequence counters as soon as this sequence is done
2178               *
2179               * @param {Event} e
2180               * @returns void
2181               */
2182              function _callbackAndReset(e) {
2183                  _fireCallback(callback, e, combo);
2184  
2185                  // we should ignore the next key up if the action is key down
2186                  // or keypress.  this is so if you finish a sequence and
2187                  // release the key the final key will not trigger a keyup
2188                  if (action !== 'keyup') {
2189                      _ignoreNextKeyup = _characterFromEvent(e);
2190                  }
2191  
2192                  // weird race condition if a sequence ends with the key
2193                  // another sequence begins with
2194                  setTimeout(_resetSequences, 10);
2195              }
2196  
2197              // loop through keys one at a time and bind the appropriate callback
2198              // function.  for any key leading up to the final one it should
2199              // increase the sequence. after the final, it should reset all sequences
2200              //
2201              // if an action is specified in the original bind call then that will
2202              // be used throughout.  otherwise we will pass the action that the
2203              // next key in the sequence should match.  this allows a sequence
2204              // to mix and match keypress and keydown events depending on which
2205              // ones are better suited to the key provided
2206              for (var i = 0; i < keys.length; ++i) {
2207                  var isFinal = i + 1 === keys.length;
2208                  var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);
2209                  _bindSingle(keys[i], wrappedCallback, action, combo, i);
2210              }
2211          }
2212  
2213          /**
2214           * binds a single keyboard combination
2215           *
2216           * @param {string} combination
2217           * @param {Function} callback
2218           * @param {string=} action
2219           * @param {string=} sequenceName - name of sequence if part of sequence
2220           * @param {number=} level - what part of the sequence the command is
2221           * @returns void
2222           */
2223          function _bindSingle(combination, callback, action, sequenceName, level) {
2224  
2225              // store a direct mapped reference for use with Mousetrap.trigger
2226              self._directMap[combination + ':' + action] = callback;
2227  
2228              // make sure multiple spaces in a row become a single space
2229              combination = combination.replace(/\s+/g, ' ');
2230  
2231              var sequence = combination.split(' ');
2232              var info;
2233  
2234              // if this pattern is a sequence of keys then run through this method
2235              // to reprocess each pattern one key at a time
2236              if (sequence.length > 1) {
2237                  _bindSequence(combination, sequence, callback, action);
2238                  return;
2239              }
2240  
2241              info = _getKeyInfo(combination, action);
2242  
2243              // make sure to initialize array if this is the first time
2244              // a callback is added for this key
2245              self._callbacks[info.key] = self._callbacks[info.key] || [];
2246  
2247              // remove an existing match if there is one
2248              _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);
2249  
2250              // add this call back to the array
2251              // if it is a sequence put it at the beginning
2252              // if not put it at the end
2253              //
2254              // this is important because the way these are processed expects
2255              // the sequence ones to come first
2256              self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({
2257                  callback: callback,
2258                  modifiers: info.modifiers,
2259                  action: info.action,
2260                  seq: sequenceName,
2261                  level: level,
2262                  combo: combination
2263              });
2264          }
2265  
2266          /**
2267           * binds multiple combinations to the same callback
2268           *
2269           * @param {Array} combinations
2270           * @param {Function} callback
2271           * @param {string|undefined} action
2272           * @returns void
2273           */
2274          self._bindMultiple = function(combinations, callback, action) {
2275              for (var i = 0; i < combinations.length; ++i) {
2276                  _bindSingle(combinations[i], callback, action);
2277              }
2278          };
2279  
2280          // start!
2281          _addEvent(targetElement, 'keypress', _handleKeyEvent);
2282          _addEvent(targetElement, 'keydown', _handleKeyEvent);
2283          _addEvent(targetElement, 'keyup', _handleKeyEvent);
2284      }
2285  
2286      /**
2287       * binds an event to mousetrap
2288       *
2289       * can be a single key, a combination of keys separated with +,
2290       * an array of keys, or a sequence of keys separated by spaces
2291       *
2292       * be sure to list the modifier keys first to make sure that the
2293       * correct key ends up getting bound (the last key in the pattern)
2294       *
2295       * @param {string|Array} keys
2296       * @param {Function} callback
2297       * @param {string=} action - 'keypress', 'keydown', or 'keyup'
2298       * @returns void
2299       */
2300      Mousetrap.prototype.bind = function(keys, callback, action) {
2301          var self = this;
2302          keys = keys instanceof Array ? keys : [keys];
2303          self._bindMultiple.call(self, keys, callback, action);
2304          return self;
2305      };
2306  
2307      /**
2308       * unbinds an event to mousetrap
2309       *
2310       * the unbinding sets the callback function of the specified key combo
2311       * to an empty function and deletes the corresponding key in the
2312       * _directMap dict.
2313       *
2314       * TODO: actually remove this from the _callbacks dictionary instead
2315       * of binding an empty function
2316       *
2317       * the keycombo+action has to be exactly the same as
2318       * it was defined in the bind method
2319       *
2320       * @param {string|Array} keys
2321       * @param {string} action
2322       * @returns void
2323       */
2324      Mousetrap.prototype.unbind = function(keys, action) {
2325          var self = this;
2326          return self.bind.call(self, keys, function() {}, action);
2327      };
2328  
2329      /**
2330       * triggers an event that has already been bound
2331       *
2332       * @param {string} keys
2333       * @param {string=} action
2334       * @returns void
2335       */
2336      Mousetrap.prototype.trigger = function(keys, action) {
2337          var self = this;
2338          if (self._directMap[keys + ':' + action]) {
2339              self._directMap[keys + ':' + action]({}, keys);
2340          }
2341          return self;
2342      };
2343  
2344      /**
2345       * resets the library back to its initial state.  this is useful
2346       * if you want to clear out the current keyboard shortcuts and bind
2347       * new ones - for example if you switch to another page
2348       *
2349       * @returns void
2350       */
2351      Mousetrap.prototype.reset = function() {
2352          var self = this;
2353          self._callbacks = {};
2354          self._directMap = {};
2355          return self;
2356      };
2357  
2358      /**
2359       * should we stop this event before firing off callbacks
2360       *
2361       * @param {Event} e
2362       * @param {Element} element
2363       * @return {boolean}
2364       */
2365      Mousetrap.prototype.stopCallback = function(e, element) {
2366          var self = this;
2367  
2368          // if the element has the class "mousetrap" then no need to stop
2369          if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {
2370              return false;
2371          }
2372  
2373          if (_belongsTo(element, self.target)) {
2374              return false;
2375          }
2376  
2377          // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,
2378          // not the initial event target in the shadow tree. Note that not all events cross the
2379          // shadow boundary.
2380          // For shadow trees with `mode: 'open'`, the initial event target is the first element in
2381          // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event
2382          // target cannot be obtained.
2383          if ('composedPath' in e && typeof e.composedPath === 'function') {
2384              // For open shadow trees, update `element` so that the following check works.
2385              var initialEventTarget = e.composedPath()[0];
2386              if (initialEventTarget !== e.target) {
2387                  element = initialEventTarget;
2388              }
2389          }
2390  
2391          // stop for input, select, and textarea
2392          return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;
2393      };
2394  
2395      /**
2396       * exposes _handleKey publicly so it can be overwritten by extensions
2397       */
2398      Mousetrap.prototype.handleKey = function() {
2399          var self = this;
2400          return self._handleKey.apply(self, arguments);
2401      };
2402  
2403      /**
2404       * allow custom key mappings
2405       */
2406      Mousetrap.addKeycodes = function(object) {
2407          for (var key in object) {
2408              if (object.hasOwnProperty(key)) {
2409                  _MAP[key] = object[key];
2410              }
2411          }
2412          _REVERSE_MAP = null;
2413      };
2414  
2415      /**
2416       * Init the global mousetrap functions
2417       *
2418       * This method is needed to allow the global mousetrap functions to work
2419       * now that mousetrap is a constructor function.
2420       */
2421      Mousetrap.init = function() {
2422          var documentMousetrap = Mousetrap(document);
2423          for (var method in documentMousetrap) {
2424              if (method.charAt(0) !== '_') {
2425                  Mousetrap[method] = (function(method) {
2426                      return function() {
2427                          return documentMousetrap[method].apply(documentMousetrap, arguments);
2428                      };
2429                  } (method));
2430              }
2431          }
2432      };
2433  
2434      Mousetrap.init();
2435  
2436      // expose mousetrap to the global object
2437      window.Mousetrap = Mousetrap;
2438  
2439      // expose as a common js module
2440      if ( true && module.exports) {
2441          module.exports = Mousetrap;
2442      }
2443  
2444      // expose mousetrap as an AMD module
2445      if (true) {
2446          !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
2447              return Mousetrap;
2448          }).call(exports, __webpack_require__, exports, module),
2449                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
2450      }
2451  }) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);
2452  
2453  
2454  /***/ }),
2455  
2456  /***/ 31:
2457  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2458  
2459  "use strict";
2460  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
2461  /* harmony import */ var _babel_runtime_helpers_esm_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24);
2462  
2463  function _unsupportedIterableToArray(o, minLen) {
2464    if (!o) return;
2465    if (typeof o === "string") return Object(_babel_runtime_helpers_esm_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
2466    var n = Object.prototype.toString.call(o).slice(8, -1);
2467    if (n === "Object" && o.constructor) n = o.constructor.name;
2468    if (n === "Map" || n === "Set") return Array.from(o);
2469    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_babel_runtime_helpers_esm_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
2470  }
2471  
2472  /***/ }),
2473  
2474  /***/ 35:
2475  /***/ (function(module, exports) {
2476  
2477  (function() { module.exports = window["wp"]["deprecated"]; }());
2478  
2479  /***/ }),
2480  
2481  /***/ 37:
2482  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2483  
2484  "use strict";
2485  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
2486  function _iterableToArray(iter) {
2487    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
2488  }
2489  
2490  /***/ }),
2491  
2492  /***/ 38:
2493  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2494  
2495  "use strict";
2496  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
2497  function _arrayWithHoles(arr) {
2498    if (Array.isArray(arr)) return arr;
2499  }
2500  
2501  /***/ }),
2502  
2503  /***/ 39:
2504  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2505  
2506  "use strict";
2507  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
2508  function _nonIterableRest() {
2509    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
2510  }
2511  
2512  /***/ }),
2513  
2514  /***/ 42:
2515  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2516  
2517  "use strict";
2518  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; });
2519  function _typeof(obj) {
2520    "@babel/helpers - typeof";
2521  
2522    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
2523      _typeof = function _typeof(obj) {
2524        return typeof obj;
2525      };
2526    } else {
2527      _typeof = function _typeof(obj) {
2528        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
2529      };
2530    }
2531  
2532    return _typeof(obj);
2533  }
2534  
2535  /***/ }),
2536  
2537  /***/ 437:
2538  /***/ (function(module, exports) {
2539  
2540  /**
2541   * adds a bindGlobal method to Mousetrap that allows you to
2542   * bind specific keyboard shortcuts that will still work
2543   * inside a text input field
2544   *
2545   * usage:
2546   * Mousetrap.bindGlobal('ctrl+s', _saveChanges);
2547   */
2548  /* global Mousetrap:true */
2549  (function(Mousetrap) {
2550      if (! Mousetrap) {
2551          return;
2552      }
2553      var _globalCallbacks = {};
2554      var _originalStopCallback = Mousetrap.prototype.stopCallback;
2555  
2556      Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) {
2557          var self = this;
2558  
2559          if (self.paused) {
2560              return true;
2561          }
2562  
2563          if (_globalCallbacks[combo] || _globalCallbacks[sequence]) {
2564              return false;
2565          }
2566  
2567          return _originalStopCallback.call(self, e, element, combo);
2568      };
2569  
2570      Mousetrap.prototype.bindGlobal = function(keys, callback, action) {
2571          var self = this;
2572          self.bind(keys, callback, action);
2573  
2574          if (keys instanceof Array) {
2575              for (var i = 0; i < keys.length; i++) {
2576                  _globalCallbacks[keys[i]] = true;
2577              }
2578              return;
2579          }
2580  
2581          _globalCallbacks[keys] = true;
2582      };
2583  
2584      Mousetrap.init();
2585  }) (typeof Mousetrap !== "undefined" ? Mousetrap : undefined);
2586  
2587  
2588  /***/ }),
2589  
2590  /***/ 461:
2591  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2592  
2593  "use strict";
2594  // ESM COMPAT FLAG
2595  __webpack_require__.r(__webpack_exports__);
2596  
2597  // EXPORTS
2598  __webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return /* reexport */ create_higher_order_component; });
2599  __webpack_require__.d(__webpack_exports__, "compose", function() { return /* reexport */ compose; });
2600  __webpack_require__.d(__webpack_exports__, "ifCondition", function() { return /* reexport */ if_condition; });
2601  __webpack_require__.d(__webpack_exports__, "pure", function() { return /* reexport */ higher_order_pure; });
2602  __webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return /* reexport */ withGlobalEvents; });
2603  __webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return /* reexport */ with_instance_id; });
2604  __webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return /* reexport */ with_safe_timeout; });
2605  __webpack_require__.d(__webpack_exports__, "withState", function() { return /* reexport */ withState; });
2606  __webpack_require__.d(__webpack_exports__, "useConstrainedTabbing", function() { return /* reexport */ use_constrained_tabbing; });
2607  __webpack_require__.d(__webpack_exports__, "useCopyOnClick", function() { return /* reexport */ useCopyOnClick; });
2608  __webpack_require__.d(__webpack_exports__, "__experimentalUseDialog", function() { return /* reexport */ use_dialog; });
2609  __webpack_require__.d(__webpack_exports__, "__experimentalUseDragging", function() { return /* reexport */ useDragging; });
2610  __webpack_require__.d(__webpack_exports__, "useFocusOnMount", function() { return /* reexport */ useFocusOnMount; });
2611  __webpack_require__.d(__webpack_exports__, "__experimentalUseFocusOutside", function() { return /* reexport */ useFocusOutside; });
2612  __webpack_require__.d(__webpack_exports__, "useFocusReturn", function() { return /* reexport */ use_focus_return; });
2613  __webpack_require__.d(__webpack_exports__, "useInstanceId", function() { return /* reexport */ useInstanceId; });
2614  __webpack_require__.d(__webpack_exports__, "useIsomorphicLayoutEffect", function() { return /* reexport */ use_isomorphic_layout_effect; });
2615  __webpack_require__.d(__webpack_exports__, "useKeyboardShortcut", function() { return /* reexport */ use_keyboard_shortcut; });
2616  __webpack_require__.d(__webpack_exports__, "useMediaQuery", function() { return /* reexport */ useMediaQuery; });
2617  __webpack_require__.d(__webpack_exports__, "usePrevious", function() { return /* reexport */ usePrevious; });
2618  __webpack_require__.d(__webpack_exports__, "useReducedMotion", function() { return /* reexport */ use_reduced_motion; });
2619  __webpack_require__.d(__webpack_exports__, "useViewportMatch", function() { return /* reexport */ use_viewport_match; });
2620  __webpack_require__.d(__webpack_exports__, "useResizeObserver", function() { return /* reexport */ use_resize_observer; });
2621  __webpack_require__.d(__webpack_exports__, "useAsyncList", function() { return /* reexport */ use_async_list; });
2622  __webpack_require__.d(__webpack_exports__, "useWarnOnChange", function() { return /* reexport */ use_warn_on_change; });
2623  __webpack_require__.d(__webpack_exports__, "useDebounce", function() { return /* reexport */ useDebounce; });
2624  __webpack_require__.d(__webpack_exports__, "useThrottle", function() { return /* reexport */ useThrottle; });
2625  
2626  // EXTERNAL MODULE: external "lodash"
2627  var external_lodash_ = __webpack_require__(2);
2628  
2629  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js
2630  /**
2631   * External dependencies
2632   */
2633  
2634  /**
2635   * Given a function mapping a component to an enhanced component and modifier
2636   * name, returns the enhanced component augmented with a generated displayName.
2637   *
2638   * @param {Function} mapComponentToEnhancedComponent Function mapping component
2639   *                                                   to enhanced component.
2640   * @param {string}   modifierName                    Seed name from which to
2641   *                                                   generated display name.
2642   *
2643   * @return {WPComponent} Component class with generated display name assigned.
2644   */
2645  
2646  function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) {
2647    return function (OriginalComponent) {
2648      var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent);
2649      var _OriginalComponent$di = OriginalComponent.displayName,
2650          displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di;
2651      EnhancedComponent.displayName = "".concat(Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")");
2652      return EnhancedComponent;
2653    };
2654  }
2655  
2656  /* harmony default export */ var create_higher_order_component = (createHigherOrderComponent);
2657  
2658  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js
2659  /**
2660   * External dependencies
2661   */
2662  
2663  /**
2664   * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function
2665   * composition, where each successive invocation is supplied the return value of the previous.
2666   *
2667   * @param {...Function} hocs The HOC functions to invoke.
2668   *
2669   * @return {Function} Returns the new composite function.
2670   */
2671  
2672  /* harmony default export */ var compose = (external_lodash_["flowRight"]);
2673  
2674  // EXTERNAL MODULE: external ["wp","element"]
2675  var external_wp_element_ = __webpack_require__(0);
2676  
2677  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js
2678  
2679  
2680  /**
2681   * Internal dependencies
2682   */
2683  
2684  /**
2685   * Higher-order component creator, creating a new component which renders if
2686   * the given condition is satisfied or with the given optional prop name.
2687   *
2688   * @param {Function} predicate Function to test condition.
2689   *
2690   * @return {Function} Higher-order component.
2691   */
2692  
2693  var if_condition_ifCondition = function ifCondition(predicate) {
2694    return create_higher_order_component(function (WrappedComponent) {
2695      return function (props) {
2696        if (!predicate(props)) {
2697          return null;
2698        }
2699  
2700        return Object(external_wp_element_["createElement"])(WrappedComponent, props);
2701      };
2702    }, 'ifCondition');
2703  };
2704  
2705  /* harmony default export */ var if_condition = (if_condition_ifCondition);
2706  
2707  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
2708  var classCallCheck = __webpack_require__(25);
2709  
2710  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
2711  var createClass = __webpack_require__(26);
2712  
2713  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
2714  var inherits = __webpack_require__(28);
2715  
2716  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
2717  var possibleConstructorReturn = __webpack_require__(29);
2718  
2719  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
2720  var getPrototypeOf = __webpack_require__(19);
2721  
2722  // EXTERNAL MODULE: external ["wp","isShallowEqual"]
2723  var external_wp_isShallowEqual_ = __webpack_require__(63);
2724  var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_);
2725  
2726  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js
2727  
2728  
2729  
2730  
2731  
2732  
2733  
2734  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); }; }
2735  
2736  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
2737  
2738  /**
2739   * WordPress dependencies
2740   */
2741  
2742  
2743  /**
2744   * Internal dependencies
2745   */
2746  
2747  
2748  /**
2749   * Given a component returns the enhanced component augmented with a component
2750   * only rerendering when its props/state change
2751   *
2752   * @param {Function} mapComponentToEnhancedComponent Function mapping component
2753   *                                                   to enhanced component.
2754   * @param {string}   modifierName                    Seed name from which to
2755   *                                                   generated display name.
2756   *
2757   * @return {WPComponent} Component class with generated display name assigned.
2758   */
2759  
2760  var pure = create_higher_order_component(function (Wrapped) {
2761    if (Wrapped.prototype instanceof external_wp_element_["Component"]) {
2762      return /*#__PURE__*/function (_Wrapped) {
2763        Object(inherits["a" /* default */])(_class, _Wrapped);
2764  
2765        var _super = _createSuper(_class);
2766  
2767        function _class() {
2768          Object(classCallCheck["a" /* default */])(this, _class);
2769  
2770          return _super.apply(this, arguments);
2771        }
2772  
2773        Object(createClass["a" /* default */])(_class, [{
2774          key: "shouldComponentUpdate",
2775          value: function shouldComponentUpdate(nextProps, nextState) {
2776            return !external_wp_isShallowEqual_default()(nextProps, this.props) || !external_wp_isShallowEqual_default()(nextState, this.state);
2777          }
2778        }]);
2779  
2780        return _class;
2781      }(Wrapped);
2782    }
2783  
2784    return /*#__PURE__*/function (_Component) {
2785      Object(inherits["a" /* default */])(_class2, _Component);
2786  
2787      var _super2 = _createSuper(_class2);
2788  
2789      function _class2() {
2790        Object(classCallCheck["a" /* default */])(this, _class2);
2791  
2792        return _super2.apply(this, arguments);
2793      }
2794  
2795      Object(createClass["a" /* default */])(_class2, [{
2796        key: "shouldComponentUpdate",
2797        value: function shouldComponentUpdate(nextProps) {
2798          return !external_wp_isShallowEqual_default()(nextProps, this.props);
2799        }
2800      }, {
2801        key: "render",
2802        value: function render() {
2803          return Object(external_wp_element_["createElement"])(Wrapped, this.props);
2804        }
2805      }]);
2806  
2807      return _class2;
2808    }(external_wp_element_["Component"]);
2809  }, 'pure');
2810  /* harmony default export */ var higher_order_pure = (pure);
2811  
2812  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
2813  var esm_extends = __webpack_require__(8);
2814  
2815  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
2816  var assertThisInitialized = __webpack_require__(18);
2817  
2818  // EXTERNAL MODULE: external ["wp","deprecated"]
2819  var external_wp_deprecated_ = __webpack_require__(35);
2820  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
2821  
2822  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js
2823  
2824  
2825  
2826  /**
2827   * External dependencies
2828   */
2829  
2830  /**
2831   * Class responsible for orchestrating event handling on the global window,
2832   * binding a single event to be shared across all handling instances, and
2833   * removing the handler when no instances are listening for the event.
2834   */
2835  
2836  var listener_Listener = /*#__PURE__*/function () {
2837    function Listener() {
2838      Object(classCallCheck["a" /* default */])(this, Listener);
2839  
2840      this.listeners = {};
2841      this.handleEvent = this.handleEvent.bind(this);
2842    }
2843  
2844    Object(createClass["a" /* default */])(Listener, [{
2845      key: "add",
2846      value: function add(eventType, instance) {
2847        if (!this.listeners[eventType]) {
2848          // Adding first listener for this type, so bind event.
2849          window.addEventListener(eventType, this.handleEvent);
2850          this.listeners[eventType] = [];
2851        }
2852  
2853        this.listeners[eventType].push(instance);
2854      }
2855    }, {
2856      key: "remove",
2857      value: function remove(eventType, instance) {
2858        this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[eventType], instance);
2859  
2860        if (!this.listeners[eventType].length) {
2861          // Removing last listener for this type, so unbind event.
2862          window.removeEventListener(eventType, this.handleEvent);
2863          delete this.listeners[eventType];
2864        }
2865      }
2866    }, {
2867      key: "handleEvent",
2868      value: function handleEvent(event) {
2869        Object(external_lodash_["forEach"])(this.listeners[event.type], function (instance) {
2870          instance.handleEvent(event);
2871        });
2872      }
2873    }]);
2874  
2875    return Listener;
2876  }();
2877  
2878  /* harmony default export */ var listener = (listener_Listener);
2879  
2880  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js
2881  
2882  
2883  
2884  
2885  
2886  
2887  
2888  
2889  
2890  function with_global_events_createSuper(Derived) { var hasNativeReflectConstruct = with_global_events_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); }; }
2891  
2892  function with_global_events_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
2893  
2894  /**
2895   * External dependencies
2896   */
2897  
2898  /**
2899   * WordPress dependencies
2900   */
2901  
2902  
2903  
2904  /**
2905   * Internal dependencies
2906   */
2907  
2908  
2909  
2910  /**
2911   * Listener instance responsible for managing document event handling.
2912   *
2913   * @type {Listener}
2914   */
2915  
2916  var with_global_events_listener = new listener();
2917  /**
2918   * Higher-order component creator which, given an object of DOM event types and
2919   * values corresponding to a callback function name on the component, will
2920   * create or update a window event handler to invoke the callback when an event
2921   * occurs. On behalf of the consuming developer, the higher-order component
2922   * manages unbinding when the component unmounts, and binding at most a single
2923   * event handler for the entire application.
2924   *
2925   * @deprecated
2926   *
2927   * @param {Object<string,string>} eventTypesToHandlers Object with keys of DOM
2928   *                                                     event type, the value a
2929   *                                                     name of the function on
2930   *                                                     the original component's
2931   *                                                     instance which handles
2932   *                                                     the event.
2933   *
2934   * @return {Function} Higher-order component.
2935   */
2936  
2937  function withGlobalEvents(eventTypesToHandlers) {
2938    external_wp_deprecated_default()('wp.compose.withGlobalEvents', {
2939      alternative: 'useEffect'
2940    });
2941    return create_higher_order_component(function (WrappedComponent) {
2942      var Wrapper = /*#__PURE__*/function (_Component) {
2943        Object(inherits["a" /* default */])(Wrapper, _Component);
2944  
2945        var _super = with_global_events_createSuper(Wrapper);
2946  
2947        function Wrapper() {
2948          var _this;
2949  
2950          Object(classCallCheck["a" /* default */])(this, Wrapper);
2951  
2952          _this = _super.apply(this, arguments);
2953          _this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(_this));
2954          _this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(_this));
2955          return _this;
2956        }
2957  
2958        Object(createClass["a" /* default */])(Wrapper, [{
2959          key: "componentDidMount",
2960          value: function componentDidMount() {
2961            var _this2 = this;
2962  
2963            Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
2964              with_global_events_listener.add(eventType, _this2);
2965            });
2966          }
2967        }, {
2968          key: "componentWillUnmount",
2969          value: function componentWillUnmount() {
2970            var _this3 = this;
2971  
2972            Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
2973              with_global_events_listener.remove(eventType, _this3);
2974            });
2975          }
2976        }, {
2977          key: "handleEvent",
2978          value: function handleEvent(event) {
2979            var handler = eventTypesToHandlers[event.type];
2980  
2981            if (typeof this.wrappedRef[handler] === 'function') {
2982              this.wrappedRef[handler](event);
2983            }
2984          }
2985        }, {
2986          key: "handleRef",
2987          value: function handleRef(el) {
2988            this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref`
2989            // will cause `this.props.forwardedRef` to be `null`, so we need this
2990            // check.
2991  
2992            if (this.props.forwardedRef) {
2993              this.props.forwardedRef(el);
2994            }
2995          }
2996        }, {
2997          key: "render",
2998          value: function render() {
2999            return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, {
3000              ref: this.handleRef
3001            }));
3002          }
3003        }]);
3004  
3005        return Wrapper;
3006      }(external_wp_element_["Component"]);
3007  
3008      return Object(external_wp_element_["forwardRef"])(function (props, ref) {
3009        return Object(external_wp_element_["createElement"])(Wrapper, {
3010          ownProps: props,
3011          forwardedRef: ref
3012        });
3013      });
3014    }, 'withGlobalEvents');
3015  }
3016  
3017  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js
3018  /**
3019   * WordPress dependencies
3020   */
3021  
3022  var instanceMap = new WeakMap();
3023  /**
3024   * Creates a new id for a given object.
3025   *
3026   * @param {Object} object Object reference to create an id for.
3027   */
3028  
3029  function createId(object) {
3030    var instances = instanceMap.get(object) || 0;
3031    instanceMap.set(object, instances + 1);
3032    return instances;
3033  }
3034  /**
3035   * Provides a unique instance ID.
3036   *
3037   * @param {Object} object Object reference to create an id for.
3038   * @param {string} prefix Prefix for the unique id.
3039   */
3040  
3041  
3042  function useInstanceId(object, prefix) {
3043    return Object(external_wp_element_["useMemo"])(function () {
3044      var id = createId(object);
3045      return prefix ? "".concat(prefix, "-").concat(id) : id;
3046    }, [object]);
3047  }
3048  
3049  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js
3050  
3051  
3052  
3053  /**
3054   * Internal dependencies
3055   */
3056  
3057  
3058  /**
3059   * A Higher Order Component used to be provide a unique instance ID by
3060   * component.
3061   *
3062   * @param {WPComponent} WrappedComponent The wrapped component.
3063   *
3064   * @return {WPComponent} Component with an instanceId prop.
3065   */
3066  
3067  /* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) {
3068    return function (props) {
3069      var instanceId = useInstanceId(WrappedComponent);
3070      return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, props, {
3071        instanceId: instanceId
3072      }));
3073    };
3074  }, 'withInstanceId'));
3075  
3076  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js
3077  
3078  
3079  
3080  
3081  
3082  
3083  
3084  
3085  
3086  function with_safe_timeout_createSuper(Derived) { var hasNativeReflectConstruct = with_safe_timeout_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); }; }
3087  
3088  function with_safe_timeout_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
3089  
3090  /**
3091   * External dependencies
3092   */
3093  
3094  /**
3095   * WordPress dependencies
3096   */
3097  
3098  
3099  /**
3100   * Internal dependencies
3101   */
3102  
3103  
3104  /**
3105   * A higher-order component used to provide and manage delayed function calls
3106   * that ought to be bound to a component's lifecycle.
3107   *
3108   * @param {WPComponent} OriginalComponent Component requiring setTimeout
3109   *
3110   * @return {WPComponent} Wrapped component.
3111   */
3112  
3113  var withSafeTimeout = create_higher_order_component(function (OriginalComponent) {
3114    return /*#__PURE__*/function (_Component) {
3115      Object(inherits["a" /* default */])(WrappedComponent, _Component);
3116  
3117      var _super = with_safe_timeout_createSuper(WrappedComponent);
3118  
3119      function WrappedComponent() {
3120        var _this;
3121  
3122        Object(classCallCheck["a" /* default */])(this, WrappedComponent);
3123  
3124        _this = _super.apply(this, arguments);
3125        _this.timeouts = [];
3126        _this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this));
3127        _this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this));
3128        return _this;
3129      }
3130  
3131      Object(createClass["a" /* default */])(WrappedComponent, [{
3132        key: "componentWillUnmount",
3133        value: function componentWillUnmount() {
3134          this.timeouts.forEach(clearTimeout);
3135        }
3136      }, {
3137        key: "setTimeout",
3138        value: function (_setTimeout) {
3139          function setTimeout(_x, _x2) {
3140            return _setTimeout.apply(this, arguments);
3141          }
3142  
3143          setTimeout.toString = function () {
3144            return _setTimeout.toString();
3145          };
3146  
3147          return setTimeout;
3148        }(function (fn, delay) {
3149          var _this2 = this;
3150  
3151          var id = setTimeout(function () {
3152            fn();
3153  
3154            _this2.clearTimeout(id);
3155          }, delay);
3156          this.timeouts.push(id);
3157          return id;
3158        })
3159      }, {
3160        key: "clearTimeout",
3161        value: function (_clearTimeout) {
3162          function clearTimeout(_x3) {
3163            return _clearTimeout.apply(this, arguments);
3164          }
3165  
3166          clearTimeout.toString = function () {
3167            return _clearTimeout.toString();
3168          };
3169  
3170          return clearTimeout;
3171        }(function (id) {
3172          clearTimeout(id);
3173          this.timeouts = Object(external_lodash_["without"])(this.timeouts, id);
3174        })
3175      }, {
3176        key: "render",
3177        value: function render() {
3178          return Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, {
3179            setTimeout: this.setTimeout,
3180            clearTimeout: this.clearTimeout
3181          }));
3182        }
3183      }]);
3184  
3185      return WrappedComponent;
3186    }(external_wp_element_["Component"]);
3187  }, 'withSafeTimeout');
3188  /* harmony default export */ var with_safe_timeout = (withSafeTimeout);
3189  
3190  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js
3191  
3192  
3193  
3194  
3195  
3196  
3197  
3198  
3199  
3200  function with_state_createSuper(Derived) { var hasNativeReflectConstruct = with_state_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); }; }
3201  
3202  function with_state_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
3203  
3204  /**
3205   * WordPress dependencies
3206   */
3207  
3208  /**
3209   * Internal dependencies
3210   */
3211  
3212  
3213  /**
3214   * A Higher Order Component used to provide and manage internal component state
3215   * via props.
3216   *
3217   * @param {?Object} initialState Optional initial state of the component.
3218   *
3219   * @return {WPComponent} Wrapped component.
3220   */
3221  
3222  function withState() {
3223    var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
3224    return create_higher_order_component(function (OriginalComponent) {
3225      return /*#__PURE__*/function (_Component) {
3226        Object(inherits["a" /* default */])(WrappedComponent, _Component);
3227  
3228        var _super = with_state_createSuper(WrappedComponent);
3229  
3230        function WrappedComponent() {
3231          var _this;
3232  
3233          Object(classCallCheck["a" /* default */])(this, WrappedComponent);
3234  
3235          _this = _super.apply(this, arguments);
3236          _this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(_this));
3237          _this.state = initialState;
3238          return _this;
3239        }
3240  
3241        Object(createClass["a" /* default */])(WrappedComponent, [{
3242          key: "render",
3243          value: function render() {
3244            return Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, {
3245              setState: this.setState
3246            }));
3247          }
3248        }]);
3249  
3250        return WrappedComponent;
3251      }(external_wp_element_["Component"]);
3252    }, 'withState');
3253  }
3254  
3255  // EXTERNAL MODULE: external ["wp","keycodes"]
3256  var external_wp_keycodes_ = __webpack_require__(17);
3257  
3258  // EXTERNAL MODULE: external ["wp","dom"]
3259  var external_wp_dom_ = __webpack_require__(27);
3260  
3261  // EXTERNAL MODULE: ./node_modules/memize/index.js
3262  var memize = __webpack_require__(71);
3263  var memize_default = /*#__PURE__*/__webpack_require__.n(memize);
3264  
3265  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-callback-ref/index.js
3266  /**
3267   * External dependencies
3268   */
3269  
3270  /**
3271   * WordPress dependencies
3272   */
3273  
3274  
3275  
3276  function useCallbackRef(callback, deps) {
3277    return Object(external_wp_element_["useCallback"])(memize_default()(callback, {
3278      maxSize: 1
3279    }), deps);
3280  }
3281  
3282  /* harmony default export */ var use_callback_ref = (useCallbackRef);
3283  
3284  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-constrained-tabbing/index.js
3285  /**
3286   * WordPress dependencies
3287   */
3288  
3289  
3290  /**
3291   * Internal dependencies
3292   */
3293  
3294  
3295  /**
3296   * In Dialogs/modals, the tabbing must be constrained to the content of
3297   * the wrapper element. This hook adds the behavior to the returned ref.
3298   *
3299   * @return {Object|Function} Element Ref.
3300   *
3301   * @example
3302   * ```js
3303   * import { useConstrainedTabbing } from '@wordpress/compose';
3304   *
3305   * const ConstrainedTabbingExample = () => {
3306   *     const constrainedTabbingRef = useConstrainedTabbing()
3307   *     return (
3308   *         <div ref={ constrainedTabbingRef }>
3309   *             <Button />
3310   *             <Button />
3311   *         </div>
3312   *     );
3313   * }
3314   * ```
3315   */
3316  
3317  function useConstrainedTabbing() {
3318    var ref = use_callback_ref(function (node) {
3319      if (!node) {
3320        return;
3321      }
3322  
3323      node.addEventListener('keydown', function (event) {
3324        if (event.keyCode !== external_wp_keycodes_["TAB"]) {
3325          return;
3326        }
3327  
3328        var tabbables = external_wp_dom_["focus"].tabbable.find(node);
3329  
3330        if (!tabbables.length) {
3331          return;
3332        }
3333  
3334        var firstTabbable = tabbables[0];
3335        var lastTabbable = tabbables[tabbables.length - 1];
3336  
3337        if (event.shiftKey && event.target === firstTabbable) {
3338          event.preventDefault();
3339          lastTabbable.focus();
3340        } else if (!event.shiftKey && event.target === lastTabbable) {
3341          event.preventDefault();
3342          firstTabbable.focus();
3343          /*
3344           * When pressing Tab and none of the tabbables has focus, the keydown
3345           * event happens on the wrapper div: move focus on the first tabbable.
3346           */
3347        } else if (!tabbables.includes(event.target)) {
3348          event.preventDefault();
3349          firstTabbable.focus();
3350        }
3351      });
3352    }, []);
3353    return ref;
3354  }
3355  
3356  /* harmony default export */ var use_constrained_tabbing = (useConstrainedTabbing);
3357  
3358  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
3359  var slicedToArray = __webpack_require__(11);
3360  
3361  // EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js
3362  var dist_clipboard = __webpack_require__(289);
3363  var clipboard_default = /*#__PURE__*/__webpack_require__.n(dist_clipboard);
3364  
3365  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-on-click/index.js
3366  
3367  
3368  /**
3369   * External dependencies
3370   */
3371  
3372  /**
3373   * WordPress dependencies
3374   */
3375  
3376  
3377  /**
3378   * Copies the text to the clipboard when the element is clicked.
3379   *
3380   * @param {Object}          ref     Reference with the element.
3381   * @param {string|Function} text    The text to copy.
3382   * @param {number}          timeout Optional timeout to reset the returned
3383   *                                  state. 4 seconds by default.
3384   *
3385   * @return {boolean} Whether or not the text has been copied. Resets after the
3386   *                   timeout.
3387   */
3388  
3389  function useCopyOnClick(ref, _text) {
3390    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;
3391    var clipboard = Object(external_wp_element_["useRef"])();
3392  
3393    var _useState = Object(external_wp_element_["useState"])(false),
3394        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
3395        hasCopied = _useState2[0],
3396        setHasCopied = _useState2[1];
3397  
3398    Object(external_wp_element_["useEffect"])(function () {
3399      var timeoutId; // Clipboard listens to click events.
3400  
3401      clipboard.current = new clipboard_default.a(ref.current, {
3402        text: function text() {
3403          return typeof _text === 'function' ? _text() : _text;
3404        }
3405      });
3406      clipboard.current.on('success', function (_ref) {
3407        var clearSelection = _ref.clearSelection,
3408            trigger = _ref.trigger;
3409        // Clearing selection will move focus back to the triggering button,
3410        // ensuring that it is not reset to the body, and further that it is
3411        // kept within the rendered node.
3412        clearSelection(); // Handle ClipboardJS focus bug, see https://github.com/zenorocha/clipboard.js/issues/680
3413  
3414        if (trigger) {
3415          trigger.focus();
3416        }
3417  
3418        if (timeout) {
3419          setHasCopied(true);
3420          clearTimeout(timeoutId);
3421          timeoutId = setTimeout(function () {
3422            return setHasCopied(false);
3423          }, timeout);
3424        }
3425      });
3426      return function () {
3427        clipboard.current.destroy();
3428        clearTimeout(timeoutId);
3429      };
3430    }, [_text, timeout, setHasCopied]);
3431    return hasCopied;
3432  }
3433  
3434  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
3435  var defineProperty = __webpack_require__(5);
3436  
3437  // EXTERNAL MODULE: ./node_modules/react-merge-refs/dist/react-merge-refs.esm.js
3438  var react_merge_refs_esm = __webpack_require__(72);
3439  
3440  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-on-mount/index.js
3441  /**
3442   * WordPress dependencies
3443   */
3444  
3445  
3446  /**
3447   * Internal dependencies
3448   */
3449  
3450  
3451  /**
3452   * Hook used to focus the first tabbable element on mount.
3453   *
3454   * @param {boolean|string} focusOnMount Focus on mount mode.
3455   * @return {Function} Ref callback.
3456   *
3457   * @example
3458   * ```js
3459   * import { useFocusOnMount } from '@wordpress/compose';
3460   *
3461   * const WithFocusOnMount = () => {
3462   *     const ref = useFocusOnMount()
3463   *     return (
3464   *         <div ref={ ref }>
3465   *             <Button />
3466   *             <Button />
3467   *         </div>
3468   *     );
3469   * }
3470   * ```
3471   */
3472  
3473  function useFocusOnMount() {
3474    var focusOnMount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'firstElement';
3475    var focusOnMountRef = Object(external_wp_element_["useRef"])(focusOnMount);
3476    Object(external_wp_element_["useEffect"])(function () {
3477      focusOnMountRef.current = focusOnMount;
3478    }, [focusOnMount]);
3479    return use_callback_ref(function (node) {
3480      if (!node || focusOnMountRef.current === false) {
3481        return;
3482      }
3483  
3484      if (node.contains(node.ownerDocument.activeElement)) {
3485        return;
3486      }
3487  
3488      var target = node;
3489  
3490      if (focusOnMountRef.current === 'firstElement') {
3491        var firstTabbable = external_wp_dom_["focus"].tabbable.find(node)[0];
3492  
3493        if (firstTabbable) {
3494          target = firstTabbable;
3495        }
3496      }
3497  
3498      target.focus();
3499    }, []);
3500  }
3501  
3502  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-return/index.js
3503  /**
3504   * WordPress dependencies
3505   */
3506  
3507  /**
3508   * Internal dependencies
3509   */
3510  
3511  
3512  /**
3513   * When opening modals/sidebars/dialogs, the focus
3514   * must move to the opened area and return to the
3515   * previously focused element when closed.
3516   * The current hook implements the returning behavior.
3517   *
3518   * @param {Function?} onFocusReturn Overrides the default return behavior.
3519   * @return {Function} Element Ref.
3520   *
3521   * @example
3522   * ```js
3523   * import { useFocusReturn } from '@wordpress/compose';
3524   *
3525   * const WithFocusReturn = () => {
3526   *     const ref = useFocusReturn()
3527   *     return (
3528   *         <div ref={ ref }>
3529   *             <Button />
3530   *             <Button />
3531   *         </div>
3532   *     );
3533   * }
3534   * ```
3535   */
3536  
3537  function useFocusReturn(onFocusReturn) {
3538    var ref = Object(external_wp_element_["useRef"])();
3539    var focusedBeforeMount = Object(external_wp_element_["useRef"])();
3540    var onFocusReturnRef = Object(external_wp_element_["useRef"])(onFocusReturn);
3541    Object(external_wp_element_["useEffect"])(function () {
3542      onFocusReturnRef.current = onFocusReturn;
3543    }, [onFocusReturn]);
3544    return use_callback_ref(function (node) {
3545      if (node) {
3546        // Set ref to be used when unmounting.
3547        ref.current = node; // Only set when the node mounts.
3548  
3549        if (focusedBeforeMount.current) {
3550          return;
3551        }
3552  
3553        focusedBeforeMount.current = node.ownerDocument.activeElement;
3554      } else if (focusedBeforeMount.current) {
3555        var isFocused = ref.current.contains(ref.current.ownerDocument.activeElement);
3556  
3557        if (ref.current.isConnected && !isFocused) {
3558          return;
3559        } // Defer to the component's own explicit focus return behavior, if
3560        // specified. This allows for support that the `onFocusReturn`
3561        // decides to allow the default behavior to occur under some
3562        // conditions.
3563  
3564  
3565        if (onFocusReturnRef.current) {
3566          onFocusReturnRef.current();
3567        } else {
3568          focusedBeforeMount.current.focus();
3569        }
3570      }
3571    }, []);
3572  }
3573  
3574  /* harmony default export */ var use_focus_return = (useFocusReturn);
3575  
3576  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-outside/index.js
3577  /**
3578   * External dependencies
3579   */
3580  
3581  /**
3582   * WordPress dependencies
3583   */
3584  
3585  
3586  /**
3587   * Input types which are classified as button types, for use in considering
3588   * whether element is a (focus-normalized) button.
3589   *
3590   * @type {string[]}
3591   */
3592  
3593  var INPUT_BUTTON_TYPES = ['button', 'submit'];
3594  /**
3595   * @typedef {HTMLButtonElement | HTMLLinkElement | HTMLInputElement} FocusNormalizedButton
3596   */
3597  // Disable reason: Rule doesn't support predicate return types
3598  
3599  /* eslint-disable jsdoc/valid-types */
3600  
3601  /**
3602   * Returns true if the given element is a button element subject to focus
3603   * normalization, or false otherwise.
3604   *
3605   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
3606   *
3607   * @param {EventTarget} eventTarget The target from a mouse or touch event.
3608   *
3609   * @return {eventTarget is FocusNormalizedButton} Whether element is a button.
3610   */
3611  
3612  function isFocusNormalizedButton(eventTarget) {
3613    if (!(eventTarget instanceof window.HTMLElement)) {
3614      return false;
3615    }
3616  
3617    switch (eventTarget.nodeName) {
3618      case 'A':
3619      case 'BUTTON':
3620        return true;
3621  
3622      case 'INPUT':
3623        return Object(external_lodash_["includes"])(INPUT_BUTTON_TYPES,
3624        /** @type {HTMLInputElement} */
3625        eventTarget.type);
3626    }
3627  
3628    return false;
3629  }
3630  /* eslint-enable jsdoc/valid-types */
3631  
3632  /**
3633   * @typedef {import('react').SyntheticEvent} SyntheticEvent
3634   */
3635  
3636  /**
3637   * @callback EventCallback
3638   * @param {SyntheticEvent} event input related event.
3639   */
3640  
3641  /**
3642   * @typedef FocusOutsideReactElement
3643   * @property {EventCallback} handleFocusOutside callback for a focus outside event.
3644   */
3645  
3646  /**
3647   * @typedef {import('react').MutableRefObject<FocusOutsideReactElement | undefined>} FocusOutsideRef
3648   */
3649  
3650  /**
3651   * @typedef {Object} FocusOutsideReturnValue
3652   * @property {EventCallback} onFocus      An event handler for focus events.
3653   * @property {EventCallback} onBlur       An event handler for blur events.
3654   * @property {EventCallback} onMouseDown  An event handler for mouse down events.
3655   * @property {EventCallback} onMouseUp    An event handler for mouse up events.
3656   * @property {EventCallback} onTouchStart An event handler for touch start events.
3657   * @property {EventCallback} onTouchEnd   An event handler for touch end events.
3658   */
3659  
3660  /**
3661   * A react hook that can be used to check whether focus has moved outside the
3662   * element the event handlers are bound to.
3663   *
3664   * @param {EventCallback} onFocusOutside        A callback triggered when focus moves outside
3665   *                                              the element the event handlers are bound to.
3666   *
3667   * @return {FocusOutsideReturnValue} An object containing event handlers. Bind the event handlers
3668   *                                   to a wrapping element element to capture when focus moves
3669   *                                   outside that element.
3670   */
3671  
3672  
3673  function useFocusOutside(onFocusOutside) {
3674    var currentOnFocusOutside = Object(external_wp_element_["useRef"])(onFocusOutside);
3675    Object(external_wp_element_["useEffect"])(function () {
3676      currentOnFocusOutside.current = onFocusOutside;
3677    }, [onFocusOutside]);
3678    var preventBlurCheck = Object(external_wp_element_["useRef"])(false);
3679    /**
3680     * @type {import('react').MutableRefObject<number | undefined>}
3681     */
3682  
3683    var blurCheckTimeoutId = Object(external_wp_element_["useRef"])();
3684    /**
3685     * Cancel a blur check timeout.
3686     */
3687  
3688    var cancelBlurCheck = Object(external_wp_element_["useCallback"])(function () {
3689      clearTimeout(blurCheckTimeoutId.current);
3690    }, []); // Cancel blur checks on unmount.
3691  
3692    Object(external_wp_element_["useEffect"])(function () {
3693      return function () {
3694        return cancelBlurCheck();
3695      };
3696    }, []); // Cancel a blur check if the callback or ref is no longer provided.
3697  
3698    Object(external_wp_element_["useEffect"])(function () {
3699      if (!onFocusOutside) {
3700        cancelBlurCheck();
3701      }
3702    }, [onFocusOutside, cancelBlurCheck]);
3703    /**
3704     * Handles a mousedown or mouseup event to respectively assign and
3705     * unassign a flag for preventing blur check on button elements. Some
3706     * browsers, namely Firefox and Safari, do not emit a focus event on
3707     * button elements when clicked, while others do. The logic here
3708     * intends to normalize this as treating click on buttons as focus.
3709     *
3710     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
3711     *
3712     * @param {SyntheticEvent} event Event for mousedown or mouseup.
3713     */
3714  
3715    var normalizeButtonFocus = Object(external_wp_element_["useCallback"])(function (event) {
3716      var type = event.type,
3717          target = event.target;
3718      var isInteractionEnd = Object(external_lodash_["includes"])(['mouseup', 'touchend'], type);
3719  
3720      if (isInteractionEnd) {
3721        preventBlurCheck.current = false;
3722      } else if (isFocusNormalizedButton(target)) {
3723        preventBlurCheck.current = true;
3724      }
3725    }, []);
3726    /**
3727     * A callback triggered when a blur event occurs on the element the handler
3728     * is bound to.
3729     *
3730     * Calls the `onFocusOutside` callback in an immediate timeout if focus has
3731     * move outside the bound element and is still within the document.
3732     *
3733     * @param {SyntheticEvent} event Blur event.
3734     */
3735  
3736    var queueBlurCheck = Object(external_wp_element_["useCallback"])(function (event) {
3737      // React does not allow using an event reference asynchronously
3738      // due to recycling behavior, except when explicitly persisted.
3739      event.persist(); // Skip blur check if clicking button. See `normalizeButtonFocus`.
3740  
3741      if (preventBlurCheck.current) {
3742        return;
3743      }
3744  
3745      blurCheckTimeoutId.current = setTimeout(function () {
3746        // If document is not focused then focus should remain
3747        // inside the wrapped component and therefore we cancel
3748        // this blur event thereby leaving focus in place.
3749        // https://developer.mozilla.org/en-US/docs/Web/API/Document/hasFocus.
3750        if (!document.hasFocus()) {
3751          event.preventDefault();
3752          return;
3753        }
3754  
3755        if ('function' === typeof currentOnFocusOutside.current) {
3756          currentOnFocusOutside.current(event);
3757        }
3758      }, 0);
3759    }, []);
3760    return {
3761      onFocus: cancelBlurCheck,
3762      onMouseDown: normalizeButtonFocus,
3763      onMouseUp: normalizeButtonFocus,
3764      onTouchStart: normalizeButtonFocus,
3765      onTouchEnd: normalizeButtonFocus,
3766      onBlur: queueBlurCheck
3767    };
3768  }
3769  
3770  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dialog/index.js
3771  
3772  
3773  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; }
3774  
3775  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; }
3776  
3777  /**
3778   * External dependencies
3779   */
3780  
3781  /**
3782   * WordPress dependencies
3783   */
3784  
3785  
3786  
3787  /**
3788   * Internal dependencies
3789   */
3790  
3791  
3792  
3793  
3794  
3795  
3796  /**
3797   * Returns a ref and props to apply to a dialog wrapper to enable the following behaviors:
3798   *  - constrained tabbing.
3799   *  - focus on mount.
3800   *  - return focus on unmount.
3801   *  - focus outside.
3802   *
3803   * @param {Object} options Dialog Options.
3804   */
3805  
3806  function useDialog(options) {
3807    var onClose = Object(external_wp_element_["useRef"])();
3808    Object(external_wp_element_["useEffect"])(function () {
3809      onClose.current = options.onClose;
3810    }, [options.onClose]);
3811    var constrainedTabbingRef = use_constrained_tabbing();
3812    var focusOnMountRef = useFocusOnMount();
3813    var focusReturnRef = use_focus_return();
3814    var focusOutsideProps = useFocusOutside(options.onClose);
3815    var closeOnEscapeRef = use_callback_ref(function (node) {
3816      if (!node) {
3817        return;
3818      }
3819  
3820      node.addEventListener('keydown', function (event) {
3821        // Close on escape
3822        if (event.keyCode === external_wp_keycodes_["ESCAPE"] && onClose.current) {
3823          event.stopPropagation();
3824          onClose.current();
3825        }
3826      });
3827    }, []);
3828    return [Object(react_merge_refs_esm["a" /* default */])([constrainedTabbingRef, focusReturnRef, focusOnMountRef, closeOnEscapeRef]), _objectSpread(_objectSpread({}, focusOutsideProps), {}, {
3829      tabIndex: '-1'
3830    })];
3831  }
3832  
3833  /* harmony default export */ var use_dialog = (useDialog);
3834  
3835  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-isomorphic-layout-effect/index.js
3836  /**
3837   * WordPress dependencies
3838   */
3839  
3840  /**
3841   * Preferred over direct usage of `useLayoutEffect` when supporting
3842   * server rendered components (SSR) because currently React
3843   * throws a warning when using useLayoutEffect in that environment.
3844   */
3845  
3846  var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external_wp_element_["useLayoutEffect"] : external_wp_element_["useEffect"];
3847  /* harmony default export */ var use_isomorphic_layout_effect = (useIsomorphicLayoutEffect);
3848  
3849  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js
3850  
3851  
3852  /**
3853   * WordPress dependencies
3854   */
3855  
3856  /**
3857   * Internal dependencies
3858   */
3859  
3860  
3861  function useDragging(_ref) {
3862    var onDragStart = _ref.onDragStart,
3863        onDragMove = _ref.onDragMove,
3864        onDragEnd = _ref.onDragEnd;
3865  
3866    var _useState = Object(external_wp_element_["useState"])(false),
3867        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
3868        isDragging = _useState2[0],
3869        setIsDragging = _useState2[1];
3870  
3871    var eventsRef = Object(external_wp_element_["useRef"])({
3872      onDragStart: onDragStart,
3873      onDragMove: onDragMove,
3874      onDragEnd: onDragEnd
3875    });
3876    use_isomorphic_layout_effect(function () {
3877      eventsRef.current.onDragStart = onDragStart;
3878      eventsRef.current.onDragMove = onDragMove;
3879      eventsRef.current.onDragEnd = onDragEnd;
3880    }, [onDragStart, onDragMove, onDragEnd]);
3881    var onMouseMove = Object(external_wp_element_["useCallback"])(function () {
3882      var _eventsRef$current;
3883  
3884      return eventsRef.current.onDragMove && (_eventsRef$current = eventsRef.current).onDragMove.apply(_eventsRef$current, arguments);
3885    }, []);
3886    var endDrag = Object(external_wp_element_["useCallback"])(function () {
3887      if (eventsRef.current.onDragEnd) {
3888        var _eventsRef$current2;
3889  
3890        (_eventsRef$current2 = eventsRef.current).onDragEnd.apply(_eventsRef$current2, arguments);
3891      }
3892  
3893      document.removeEventListener('mousemove', onMouseMove);
3894      document.removeEventListener('mouseup', endDrag);
3895      setIsDragging(false);
3896    }, []);
3897    var startDrag = Object(external_wp_element_["useCallback"])(function () {
3898      if (eventsRef.current.onDragStart) {
3899        var _eventsRef$current3;
3900  
3901        (_eventsRef$current3 = eventsRef.current).onDragStart.apply(_eventsRef$current3, arguments);
3902      }
3903  
3904      document.addEventListener('mousemove', onMouseMove);
3905      document.addEventListener('mouseup', endDrag);
3906      setIsDragging(true);
3907    }, []); // Remove the global events when unmounting if needed.
3908  
3909    Object(external_wp_element_["useEffect"])(function () {
3910      return function () {
3911        if (isDragging) {
3912          document.removeEventListener('mousemove', onMouseMove);
3913          document.removeEventListener('mouseup', endDrag);
3914        }
3915      };
3916    }, [isDragging]);
3917    return {
3918      startDrag: startDrag,
3919      endDrag: endDrag,
3920      isDragging: isDragging
3921    };
3922  }
3923  
3924  // EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js
3925  var mousetrap_mousetrap = __webpack_require__(290);
3926  var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap_mousetrap);
3927  
3928  // EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js
3929  var mousetrap_global_bind = __webpack_require__(437);
3930  
3931  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js
3932  /**
3933   * External dependencies
3934   */
3935  
3936  
3937  
3938  /**
3939   * WordPress dependencies
3940   */
3941  
3942  
3943  /**
3944   * A block selection object.
3945   *
3946   * @typedef {Object} WPKeyboardShortcutConfig
3947   *
3948   * @property {boolean} [bindGlobal]  Handle keyboard events anywhere including inside textarea/input fields.
3949   * @property {string}  [eventName]   Event name used to trigger the handler, defaults to keydown.
3950   * @property {boolean} [isDisabled]  Disables the keyboard handler if the value is true.
3951   * @property {Object}  [target]      React reference to the DOM element used to catch the keyboard event.
3952   */
3953  
3954  /**
3955   * Return true if platform is MacOS.
3956   *
3957   * @param {Object} _window   window object by default; used for DI testing.
3958   *
3959   * @return {boolean} True if MacOS; false otherwise.
3960   */
3961  
3962  function isAppleOS() {
3963    var _window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window;
3964  
3965    var platform = _window.navigator.platform;
3966    return platform.indexOf('Mac') !== -1 || Object(external_lodash_["includes"])(['iPad', 'iPhone'], platform);
3967  }
3968  /**
3969   * Attach a keyboard shortcut handler.
3970   *
3971   * @param {string[]|string}         shortcuts  Keyboard Shortcuts.
3972   * @param {Function}                callback   Shortcut callback.
3973   * @param {WPKeyboardShortcutConfig} options    Shortcut options.
3974   */
3975  
3976  
3977  function useKeyboardShortcut(shortcuts, callback) {
3978    var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
3979        _ref$bindGlobal = _ref.bindGlobal,
3980        bindGlobal = _ref$bindGlobal === void 0 ? false : _ref$bindGlobal,
3981        _ref$eventName = _ref.eventName,
3982        eventName = _ref$eventName === void 0 ? 'keydown' : _ref$eventName,
3983        _ref$isDisabled = _ref.isDisabled,
3984        isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled,
3985        target = _ref.target;
3986  
3987    var currentCallback = Object(external_wp_element_["useRef"])(callback);
3988    Object(external_wp_element_["useEffect"])(function () {
3989      currentCallback.current = callback;
3990    }, [callback]);
3991    Object(external_wp_element_["useEffect"])(function () {
3992      if (isDisabled) {
3993        return;
3994      }
3995  
3996      var mousetrap = new mousetrap_default.a(target ? target.current : document);
3997      Object(external_lodash_["castArray"])(shortcuts).forEach(function (shortcut) {
3998        var keys = shortcut.split('+'); // Determines whether a key is a modifier by the length of the string.
3999        // E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that
4000        // the modifiers are Shift and Cmd because they're not a single character.
4001  
4002        var modifiers = new Set(keys.filter(function (value) {
4003          return value.length > 1;
4004        }));
4005        var hasAlt = modifiers.has('alt');
4006        var hasShift = modifiers.has('shift'); // This should be better moved to the shortcut registration instead.
4007  
4008        if (isAppleOS() && (modifiers.size === 1 && hasAlt || modifiers.size === 2 && hasAlt && hasShift)) {
4009          throw new Error("Cannot bind ".concat(shortcut, ". Alt and Shift+Alt modifiers are reserved for character input."));
4010        }
4011  
4012        var bindFn = bindGlobal ? 'bindGlobal' : 'bind';
4013        mousetrap[bindFn](shortcut, function () {
4014          return currentCallback.current.apply(currentCallback, arguments);
4015        }, eventName);
4016      });
4017      return function () {
4018        mousetrap.reset();
4019      };
4020    }, [shortcuts, bindGlobal, eventName, target, isDisabled]);
4021  }
4022  
4023  /* harmony default export */ var use_keyboard_shortcut = (useKeyboardShortcut);
4024  
4025  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js
4026  
4027  
4028  /**
4029   * WordPress dependencies
4030   */
4031  
4032  /**
4033   * Runs a media query and returns its value when it changes.
4034   *
4035   * @param {string} [query] Media Query.
4036   * @return {boolean} return value of the media query.
4037   */
4038  
4039  function useMediaQuery(query) {
4040    var _useState = Object(external_wp_element_["useState"])(function () {
4041      return !!(query && typeof window !== 'undefined' && window.matchMedia(query).matches);
4042    }),
4043        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
4044        match = _useState2[0],
4045        setMatch = _useState2[1];
4046  
4047    Object(external_wp_element_["useEffect"])(function () {
4048      if (!query) {
4049        return;
4050      }
4051  
4052      var updateMatch = function updateMatch() {
4053        return setMatch(window.matchMedia(query).matches);
4054      };
4055  
4056      updateMatch();
4057      var list = window.matchMedia(query);
4058      list.addListener(updateMatch);
4059      return function () {
4060        list.removeListener(updateMatch);
4061      };
4062    }, [query]);
4063    return query && match;
4064  }
4065  
4066  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-previous/index.js
4067  /**
4068   * WordPress dependencies
4069   */
4070  
4071  /**
4072   * Use something's value from the previous render.
4073   * Based on https://usehooks.com/usePrevious/.
4074   *
4075   * @template T
4076   *
4077   * @param {T} value The value to track.
4078   *
4079   * @return {T|undefined} The value from the previous render.
4080   */
4081  
4082  function usePrevious(value) {
4083    // Disable reason: without an explicit type detail, the type of ref will be
4084    // inferred based on the initial useRef argument, which is undefined.
4085    // https://github.com/WordPress/gutenberg/pull/22597#issuecomment-633588366
4086  
4087    /* eslint-disable jsdoc/no-undefined-types */
4088    var ref = Object(external_wp_element_["useRef"])(
4089    /** @type {T|undefined} */
4090    undefined);
4091    /* eslint-enable jsdoc/no-undefined-types */
4092    // Store current value in ref.
4093  
4094    Object(external_wp_element_["useEffect"])(function () {
4095      ref.current = value;
4096    }, [value]); // Re-run when value changes.
4097    // Return previous value (happens before update in useEffect above).
4098  
4099    return ref.current;
4100  }
4101  
4102  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-reduced-motion/index.js
4103  /**
4104   * Internal dependencies
4105   */
4106  
4107  /**
4108   * Whether or not the user agent is Internet Explorer.
4109   *
4110   * @type {boolean}
4111   */
4112  
4113  var IS_IE = typeof window !== 'undefined' && window.navigator.userAgent.indexOf('Trident') >= 0;
4114  /**
4115   * Hook returning whether the user has a preference for reduced motion.
4116   *
4117   * @return {boolean} Reduced motion preference value.
4118   */
4119  
4120  var useReducedMotion = undefined || IS_IE ? function () {
4121    return true;
4122  } : function () {
4123    return useMediaQuery('(prefers-reduced-motion: reduce)');
4124  };
4125  /* harmony default export */ var use_reduced_motion = (useReducedMotion);
4126  
4127  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-viewport-match/index.js
4128  /**
4129   * WordPress dependencies
4130   */
4131  
4132  /**
4133   * Internal dependencies
4134   */
4135  
4136  
4137  /**
4138   * @typedef {"huge"|"wide"|"large"|"medium"|"small"|"mobile"} WPBreakpoint
4139   */
4140  
4141  /**
4142   * Hash of breakpoint names with pixel width at which it becomes effective.
4143   *
4144   * @see _breakpoints.scss
4145   *
4146   * @type {Object<WPBreakpoint,number>}
4147   */
4148  
4149  var BREAKPOINTS = {
4150    huge: 1440,
4151    wide: 1280,
4152    large: 960,
4153    medium: 782,
4154    small: 600,
4155    mobile: 480
4156  };
4157  /**
4158   * @typedef {">="|"<"} WPViewportOperator
4159   */
4160  
4161  /**
4162   * Object mapping media query operators to the condition to be used.
4163   *
4164   * @type {Object<WPViewportOperator,string>}
4165   */
4166  
4167  var CONDITIONS = {
4168    '>=': 'min-width',
4169    '<': 'max-width'
4170  };
4171  /**
4172   * Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values.
4173   *
4174   * @type {Object<WPViewportOperator,Function>}
4175   */
4176  
4177  var OPERATOR_EVALUATORS = {
4178    '>=': function _(breakpointValue, width) {
4179      return width >= breakpointValue;
4180    },
4181    '<': function _(breakpointValue, width) {
4182      return width < breakpointValue;
4183    }
4184  };
4185  var ViewportMatchWidthContext = Object(external_wp_element_["createContext"])(null);
4186  /**
4187   * Returns true if the viewport matches the given query, or false otherwise.
4188   *
4189   * @param {WPBreakpoint}       breakpoint      Breakpoint size name.
4190   * @param {WPViewportOperator} [operator=">="] Viewport operator.
4191   *
4192   * @example
4193   *
4194   * ```js
4195   * useViewportMatch( 'huge', '<' );
4196   * useViewportMatch( 'medium' );
4197   * ```
4198   *
4199   * @return {boolean} Whether viewport matches query.
4200   */
4201  
4202  var use_viewport_match_useViewportMatch = function useViewportMatch(breakpoint) {
4203    var operator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '>=';
4204    var simulatedWidth = Object(external_wp_element_["useContext"])(ViewportMatchWidthContext);
4205    var mediaQuery = !simulatedWidth && "(".concat(CONDITIONS[operator], ": ").concat(BREAKPOINTS[breakpoint], "px)");
4206    var mediaQueryResult = useMediaQuery(mediaQuery);
4207  
4208    if (simulatedWidth) {
4209      return OPERATOR_EVALUATORS[operator](BREAKPOINTS[breakpoint], simulatedWidth);
4210    }
4211  
4212    return mediaQueryResult;
4213  };
4214  
4215  use_viewport_match_useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider;
4216  /* harmony default export */ var use_viewport_match = (use_viewport_match_useViewportMatch);
4217  
4218  // EXTERNAL MODULE: ./node_modules/react-resize-aware/dist/index.js
4219  var dist = __webpack_require__(151);
4220  var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
4221  
4222  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/index.js
4223  /**
4224   * External dependencies
4225   */
4226  
4227  /**
4228   * Hook which allows to listen the resize event of any target element when it changes sizes.
4229   * _Note: `useResizeObserver` will report `null` until after first render_
4230   *
4231   * @return {Array} An array of {Element} `resizeListener` and {?Object} `sizes` with properties `width` and `height`
4232   *
4233   * @example
4234   *
4235   * ```js
4236   * const App = () => {
4237   *     const [ resizeListener, sizes ] = useResizeObserver();
4238   *
4239   *     return (
4240   *         <div>
4241   *             { resizeListener }
4242   *             Your content here
4243   *         </div>
4244   *     );
4245   * };
4246   * ```
4247   *
4248   */
4249  
4250  /* harmony default export */ var use_resize_observer = (dist_default.a);
4251  
4252  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
4253  var toConsumableArray = __webpack_require__(15);
4254  
4255  // EXTERNAL MODULE: external ["wp","priorityQueue"]
4256  var external_wp_priorityQueue_ = __webpack_require__(152);
4257  
4258  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-async-list/index.js
4259  
4260  
4261  
4262  /**
4263   * WordPress dependencies
4264   */
4265  
4266  
4267  /**
4268   * Returns the first items from list that are present on state.
4269   *
4270   * @param {Array} list  New array.
4271   * @param {Array} state Current state.
4272   * @return {Array} First items present iin state.
4273   */
4274  
4275  function getFirstItemsPresentInState(list, state) {
4276    var firstItems = [];
4277  
4278    for (var i = 0; i < list.length; i++) {
4279      var item = list[i];
4280  
4281      if (!state.includes(item)) {
4282        break;
4283      }
4284  
4285      firstItems.push(item);
4286    }
4287  
4288    return firstItems;
4289  }
4290  /**
4291   * Reducer keeping track of a list of appended items.
4292   *
4293   * @param {Array}  state  Current state
4294   * @param {Object} action Action
4295   *
4296   * @return {Array} update state.
4297   */
4298  
4299  
4300  function listReducer(state, action) {
4301    if (action.type === 'reset') {
4302      return action.list;
4303    }
4304  
4305    if (action.type === 'append') {
4306      return [].concat(Object(toConsumableArray["a" /* default */])(state), [action.item]);
4307    }
4308  
4309    return state;
4310  }
4311  /**
4312   * React hook returns an array which items get asynchronously appended from a source array.
4313   * This behavior is useful if we want to render a list of items asynchronously for performance reasons.
4314   *
4315   * @param {Array} list Source array.
4316   * @return {Array} Async array.
4317   */
4318  
4319  
4320  function useAsyncList(list) {
4321    var _useReducer = Object(external_wp_element_["useReducer"])(listReducer, []),
4322        _useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2),
4323        current = _useReducer2[0],
4324        dispatch = _useReducer2[1];
4325  
4326    Object(external_wp_element_["useEffect"])(function () {
4327      // On reset, we keep the first items that were previously rendered.
4328      var firstItems = getFirstItemsPresentInState(list, current);
4329      dispatch({
4330        type: 'reset',
4331        list: firstItems
4332      });
4333      var asyncQueue = Object(external_wp_priorityQueue_["createQueue"])();
4334  
4335      var append = function append(index) {
4336        return function () {
4337          if (list.length <= index) {
4338            return;
4339          }
4340  
4341          dispatch({
4342            type: 'append',
4343            item: list[index]
4344          });
4345          asyncQueue.add({}, append(index + 1));
4346        };
4347      };
4348  
4349      asyncQueue.add({}, append(firstItems.length));
4350      return function () {
4351        return asyncQueue.reset();
4352      };
4353    }, [list]);
4354    return current;
4355  }
4356  
4357  /* harmony default export */ var use_async_list = (useAsyncList);
4358  
4359  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-warn-on-change/index.js
4360  
4361  
4362  /**
4363   * Internal dependencies
4364   */
4365  
4366  /**
4367   * Hook that performs a shallow comparison between the preview value of an object
4368   * and the new one, if there's a difference, it prints it to the console.
4369   * this is useful in performance related work, to check why a component re-renders.
4370   *
4371   *  @example
4372   *
4373   * ```jsx
4374   * function MyComponent(props) {
4375   *    useWarnOnChange(props);
4376   *
4377   *    return "Something";
4378   * }
4379   * ```
4380   *
4381   * @param {Object} object Object which changes to compare.
4382   * @param {string} prefix Just a prefix to show when console logging.
4383   */
4384  
4385  function useWarnOnChange(object) {
4386    var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Change detection';
4387    var previousValues = usePrevious(object);
4388    Object.entries(previousValues !== null && previousValues !== void 0 ? previousValues : []).forEach(function (_ref) {
4389      var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2),
4390          key = _ref2[0],
4391          value = _ref2[1];
4392  
4393      if (value !== object[key]) {
4394        // eslint-disable-next-line no-console
4395        console.warn("".concat(prefix, ": ").concat(key, " key changed:"), value, object[key]);
4396      }
4397    });
4398  }
4399  
4400  /* harmony default export */ var use_warn_on_change = (useWarnOnChange);
4401  
4402  // EXTERNAL MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js
4403  var use_memo_one_esm = __webpack_require__(127);
4404  
4405  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-debounce/index.js
4406  /**
4407   * External dependencies
4408   */
4409  
4410  
4411  /**
4412   * WordPress dependencies
4413   */
4414  
4415  
4416  /**
4417   * Debounces a function with Lodash's `debounce`. A new debounced function will
4418   * be returned and any scheduled calls cancelled if any of the arguments change,
4419   * including the function to debounce, so please wrap functions created on
4420   * render in components in `useCallback`.
4421   *
4422   * @param {...any} args Arguments passed to Lodash's `debounce`.
4423   *
4424   * @return {Function} Debounced function.
4425   */
4426  
4427  function useDebounce() {
4428    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
4429      args[_key] = arguments[_key];
4430    }
4431  
4432    var debounced = Object(use_memo_one_esm["a" /* useMemoOne */])(function () {
4433      return external_lodash_["debounce"].apply(void 0, args);
4434    }, args);
4435    Object(external_wp_element_["useEffect"])(function () {
4436      return function () {
4437        return debounced.cancel();
4438      };
4439    }, [debounced]);
4440    return debounced;
4441  }
4442  
4443  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-throttle/index.js
4444  /**
4445   * External dependencies
4446   */
4447  
4448  
4449  /**
4450   * WordPress dependencies
4451   */
4452  
4453  
4454  /**
4455   * Throttles a function with Lodash's `throttle`. A new throttled function will
4456   * be returned and any scheduled calls cancelled if any of the arguments change,
4457   * including the function to throttle, so please wrap functions created on
4458   * render in components in `useCallback`.
4459   *
4460   * @param {...any} args Arguments passed to Lodash's `throttle`.
4461   *
4462   * @return {Function} Throttled function.
4463   */
4464  
4465  function useThrottle() {
4466    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
4467      args[_key] = arguments[_key];
4468    }
4469  
4470    var throttled = Object(use_memo_one_esm["a" /* useMemoOne */])(function () {
4471      return external_lodash_["throttle"].apply(void 0, args);
4472    }, args);
4473    Object(external_wp_element_["useEffect"])(function () {
4474      return function () {
4475        return throttled.cancel();
4476      };
4477    }, [throttled]);
4478    return throttled;
4479  }
4480  
4481  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js
4482  // Utils
4483   // Compose helper (aliased flowRight from Lodash)
4484  
4485   // Higher-order components
4486  
4487  
4488  
4489  
4490  
4491  
4492   // Hooks
4493  
4494  
4495  
4496  
4497  
4498  
4499  
4500  
4501  
4502  
4503  
4504  
4505  
4506  
4507  
4508  
4509  
4510  
4511  
4512  
4513  
4514  
4515  /***/ }),
4516  
4517  /***/ 5:
4518  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4519  
4520  "use strict";
4521  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });
4522  function _defineProperty(obj, key, value) {
4523    if (key in obj) {
4524      Object.defineProperty(obj, key, {
4525        value: value,
4526        enumerable: true,
4527        configurable: true,
4528        writable: true
4529      });
4530    } else {
4531      obj[key] = value;
4532    }
4533  
4534    return obj;
4535  }
4536  
4537  /***/ }),
4538  
4539  /***/ 52:
4540  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4541  
4542  "use strict";
4543  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _setPrototypeOf; });
4544  function _setPrototypeOf(o, p) {
4545    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
4546      o.__proto__ = p;
4547      return o;
4548    };
4549  
4550    return _setPrototypeOf(o, p);
4551  }
4552  
4553  /***/ }),
4554  
4555  /***/ 63:
4556  /***/ (function(module, exports) {
4557  
4558  (function() { module.exports = window["wp"]["isShallowEqual"]; }());
4559  
4560  /***/ }),
4561  
4562  /***/ 71:
4563  /***/ (function(module, exports, __webpack_require__) {
4564  
4565  /**
4566   * Memize options object.
4567   *
4568   * @typedef MemizeOptions
4569   *
4570   * @property {number} [maxSize] Maximum size of the cache.
4571   */
4572  
4573  /**
4574   * Internal cache entry.
4575   *
4576   * @typedef MemizeCacheNode
4577   *
4578   * @property {?MemizeCacheNode|undefined} [prev] Previous node.
4579   * @property {?MemizeCacheNode|undefined} [next] Next node.
4580   * @property {Array<*>}                   args   Function arguments for cache
4581   *                                               entry.
4582   * @property {*}                          val    Function result.
4583   */
4584  
4585  /**
4586   * Properties of the enhanced function for controlling cache.
4587   *
4588   * @typedef MemizeMemoizedFunction
4589   *
4590   * @property {()=>void} clear Clear the cache.
4591   */
4592  
4593  /**
4594   * Accepts a function to be memoized, and returns a new memoized function, with
4595   * optional options.
4596   *
4597   * @template {Function} F
4598   *
4599   * @param {F}             fn        Function to memoize.
4600   * @param {MemizeOptions} [options] Options object.
4601   *
4602   * @return {F & MemizeMemoizedFunction} Memoized function.
4603   */
4604  function memize( fn, options ) {
4605      var size = 0;
4606  
4607      /** @type {?MemizeCacheNode|undefined} */
4608      var head;
4609  
4610      /** @type {?MemizeCacheNode|undefined} */
4611      var tail;
4612  
4613      options = options || {};
4614  
4615  	function memoized( /* ...args */ ) {
4616          var node = head,
4617              len = arguments.length,
4618              args, i;
4619  
4620          searchCache: while ( node ) {
4621              // Perform a shallow equality test to confirm that whether the node
4622              // under test is a candidate for the arguments passed. Two arrays
4623              // are shallowly equal if their length matches and each entry is
4624              // strictly equal between the two sets. Avoid abstracting to a
4625              // function which could incur an arguments leaking deoptimization.
4626  
4627              // Check whether node arguments match arguments length
4628              if ( node.args.length !== arguments.length ) {
4629                  node = node.next;
4630                  continue;
4631              }
4632  
4633              // Check whether node arguments match arguments values
4634              for ( i = 0; i < len; i++ ) {
4635                  if ( node.args[ i ] !== arguments[ i ] ) {
4636                      node = node.next;
4637                      continue searchCache;
4638                  }
4639              }
4640  
4641              // At this point we can assume we've found a match
4642  
4643              // Surface matched node to head if not already
4644              if ( node !== head ) {
4645                  // As tail, shift to previous. Must only shift if not also
4646                  // head, since if both head and tail, there is no previous.
4647                  if ( node === tail ) {
4648                      tail = node.prev;
4649                  }
4650  
4651                  // Adjust siblings to point to each other. If node was tail,
4652                  // this also handles new tail's empty `next` assignment.
4653                  /** @type {MemizeCacheNode} */ ( node.prev ).next = node.next;
4654                  if ( node.next ) {
4655                      node.next.prev = node.prev;
4656                  }
4657  
4658                  node.next = head;
4659                  node.prev = null;
4660                  /** @type {MemizeCacheNode} */ ( head ).prev = node;
4661                  head = node;
4662              }
4663  
4664              // Return immediately
4665              return node.val;
4666          }
4667  
4668          // No cached value found. Continue to insertion phase:
4669  
4670          // Create a copy of arguments (avoid leaking deoptimization)
4671          args = new Array( len );
4672          for ( i = 0; i < len; i++ ) {
4673              args[ i ] = arguments[ i ];
4674          }
4675  
4676          node = {
4677              args: args,
4678  
4679              // Generate the result from original function
4680              val: fn.apply( null, args ),
4681          };
4682  
4683          // Don't need to check whether node is already head, since it would
4684          // have been returned above already if it was
4685  
4686          // Shift existing head down list
4687          if ( head ) {
4688              head.prev = node;
4689              node.next = head;
4690          } else {
4691              // If no head, follows that there's no tail (at initial or reset)
4692              tail = node;
4693          }
4694  
4695          // Trim tail if we're reached max size and are pending cache insertion
4696          if ( size === /** @type {MemizeOptions} */ ( options ).maxSize ) {
4697              tail = /** @type {MemizeCacheNode} */ ( tail ).prev;
4698              /** @type {MemizeCacheNode} */ ( tail ).next = null;
4699          } else {
4700              size++;
4701          }
4702  
4703          head = node;
4704  
4705          return node.val;
4706      }
4707  
4708      memoized.clear = function() {
4709          head = null;
4710          tail = null;
4711          size = 0;
4712      };
4713  
4714      if ( false ) {}
4715  
4716      // Ignore reason: There's not a clear solution to create an intersection of
4717      // the function with additional properties, where the goal is to retain the
4718      // function signature of the incoming argument and add control properties
4719      // on the return value.
4720  
4721      // @ts-ignore
4722      return memoized;
4723  }
4724  
4725  module.exports = memize;
4726  
4727  
4728  /***/ }),
4729  
4730  /***/ 72:
4731  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4732  
4733  "use strict";
4734  function mergeRefs(refs) {
4735    return function (value) {
4736      refs.forEach(function (ref) {
4737        if (typeof ref === "function") {
4738          ref(value);
4739        } else if (ref != null) {
4740          ref.current = value;
4741        }
4742      });
4743    };
4744  }
4745  
4746  /* harmony default export */ __webpack_exports__["a"] = (mergeRefs);
4747  
4748  
4749  /***/ }),
4750  
4751  /***/ 8:
4752  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4753  
4754  "use strict";
4755  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
4756  function _extends() {
4757    _extends = Object.assign || function (target) {
4758      for (var i = 1; i < arguments.length; i++) {
4759        var source = arguments[i];
4760  
4761        for (var key in source) {
4762          if (Object.prototype.hasOwnProperty.call(source, key)) {
4763            target[key] = source[key];
4764          }
4765        }
4766      }
4767  
4768      return target;
4769    };
4770  
4771    return _extends.apply(this, arguments);
4772  }
4773  
4774  /***/ })
4775  
4776  /******/ });


Generated: Thu Feb 25 01:00:09 2021 Cross-referenced by PHPXref 0.7.1