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


Generated: Tue May 18 01:00:05 2021 Cross-referenced by PHPXref 0.7.1