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


Generated: Fri Jul 3 01:00:03 2020 Cross-referenced by PHPXref 0.7.1