[Summary view] [Print] [Text view]

   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 = 431);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 0:
  91  /***/ (function(module, exports) {
  92  
  93  (function() { module.exports = this["wp"]["element"]; }());
  94  
  95  /***/ }),
  96  
  97  /***/ 105:
  98  /***/ (function(module, exports) {
  99  
 100  // shim for using process in browser
 101  var process = module.exports = {};
 102  
 103  // cached from whatever global is present so that test runners that stub it
 104  // don't break things.  But we need to wrap it in a try catch in case it is
 105  // wrapped in strict mode code which doesn't define any globals.  It's inside a
 106  // function because try/catches deoptimize in certain engines.
 107  
 108  var cachedSetTimeout;
 109  var cachedClearTimeout;
 110  
 111  function defaultSetTimout() {
 112      throw new Error('setTimeout has not been defined');
 113  }
 114  function defaultClearTimeout () {
 115      throw new Error('clearTimeout has not been defined');
 116  }
 117  (function () {
 118      try {
 119          if (typeof setTimeout === 'function') {
 120              cachedSetTimeout = setTimeout;
 121          } else {
 122              cachedSetTimeout = defaultSetTimout;
 123          }
 124      } catch (e) {
 125          cachedSetTimeout = defaultSetTimout;
 126      }
 127      try {
 128          if (typeof clearTimeout === 'function') {
 129              cachedClearTimeout = clearTimeout;
 130          } else {
 131              cachedClearTimeout = defaultClearTimeout;
 132          }
 133      } catch (e) {
 134          cachedClearTimeout = defaultClearTimeout;
 135      }
 136  } ())
 137  function runTimeout(fun) {
 138      if (cachedSetTimeout === setTimeout) {
 139          //normal enviroments in sane situations
 140          return setTimeout(fun, 0);
 141      }
 142      // if setTimeout wasn't available but was latter defined
 143      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
 144          cachedSetTimeout = setTimeout;
 145          return setTimeout(fun, 0);
 146      }
 147      try {
 148          // when when somebody has screwed with setTimeout but no I.E. maddness
 149          return cachedSetTimeout(fun, 0);
 150      } catch(e){
 151          try {
 152              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
 153              return cachedSetTimeout.call(null, fun, 0);
 154          } catch(e){
 155              // 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
 156              return cachedSetTimeout.call(this, fun, 0);
 157          }
 158      }
 159  
 160  
 161  }
 162  function runClearTimeout(marker) {
 163      if (cachedClearTimeout === clearTimeout) {
 164          //normal enviroments in sane situations
 165          return clearTimeout(marker);
 166      }
 167      // if clearTimeout wasn't available but was latter defined
 168      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
 169          cachedClearTimeout = clearTimeout;
 170          return clearTimeout(marker);
 171      }
 172      try {
 173          // when when somebody has screwed with setTimeout but no I.E. maddness
 174          return cachedClearTimeout(marker);
 175      } catch (e){
 176          try {
 177              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
 178              return cachedClearTimeout.call(null, marker);
 179          } catch (e){
 180              // 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.
 181              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
 182              return cachedClearTimeout.call(this, marker);
 183          }
 184      }
 185  
 186  
 187  
 188  }
 189  var queue = [];
 190  var draining = false;
 191  var currentQueue;
 192  var queueIndex = -1;
 193  
 194  function cleanUpNextTick() {
 195      if (!draining || !currentQueue) {
 196          return;
 197      }
 198      draining = false;
 199      if (currentQueue.length) {
 200          queue = currentQueue.concat(queue);
 201      } else {
 202          queueIndex = -1;
 203      }
 204      if (queue.length) {
 205          drainQueue();
 206      }
 207  }
 208  
 209  function drainQueue() {
 210      if (draining) {
 211          return;
 212      }
 213      var timeout = runTimeout(cleanUpNextTick);
 214      draining = true;
 215  
 216      var len = queue.length;
 217      while(len) {
 218          currentQueue = queue;
 219          queue = [];
 220          while (++queueIndex < len) {
 221              if (currentQueue) {
 222                  currentQueue[queueIndex].run();
 223              }
 224          }
 225          queueIndex = -1;
 226          len = queue.length;
 227      }
 228      currentQueue = null;
 229      draining = false;
 230      runClearTimeout(timeout);
 231  }
 232  
 233  process.nextTick = function (fun) {
 234      var args = new Array(arguments.length - 1);
 235      if (arguments.length > 1) {
 236          for (var i = 1; i < arguments.length; i++) {
 237              args[i - 1] = arguments[i];
 238          }
 239      }
 240      queue.push(new Item(fun, args));
 241      if (queue.length === 1 && !draining) {
 242          runTimeout(drainQueue);
 243      }
 244  };
 245  
 246  // v8 likes predictible objects
 247  function Item(fun, array) {
 248      this.fun = fun;
 249      this.array = array;
 250  }
 251  Item.prototype.run = function () {
 252      this.fun.apply(null, this.array);
 253  };
 254  process.title = 'browser';
 255  process.browser = true;
 256  process.env = {};
 257  process.argv = [];
 258  process.version = ''; // empty string to avoid regexp issues
 259  process.versions = {};
 260  
 261  function noop() {}
 262  
 263  process.on = noop;
 264  process.addListener = noop;
 265  process.once = noop;
 266  process.off = noop;
 267  process.removeListener = noop;
 268  process.removeAllListeners = noop;
 269  process.emit = noop;
 270  process.prependListener = noop;
 271  process.prependOnceListener = noop;
 272  
 273  process.listeners = function (name) { return [] }
 274  
 275  process.binding = function (name) {
 276      throw new Error('process.binding is not supported');
 277  };
 278  
 279  process.cwd = function () { return '/' };
 280  process.chdir = function (dir) {
 281      throw new Error('process.chdir is not supported');
 282  };
 283  process.umask = function() { return 0; };
 284  
 285  
 286  /***/ }),
 287  
 288  /***/ 112:
 289  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 290  
 291  "use strict";
 292  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useMediaQuery; });
 293  /* harmony import */ var _babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
 294  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0);
 295  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__);
 296  
 297  
 298  /**
 299   * WordPress dependencies
 300   */
 301  
 302  /**
 303   * Runs a media query and returns its value when it changes.
 304   *
 305   * @param {string} [query] Media Query.
 306   * @return {boolean} return value of the media query.
 307   */
 308  
 309  function useMediaQuery(query) {
 310    var _useState = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__["useState"])(false),
 311        _useState2 = Object(_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState, 2),
 312        match = _useState2[0],
 313        setMatch = _useState2[1];
 314  
 315    Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__["useEffect"])(function () {
 316      if (!query) {
 317        return;
 318      }
 319  
 320      var updateMatch = function updateMatch() {
 321        return setMatch(window.matchMedia(query).matches);
 322      };
 323  
 324      updateMatch();
 325      var list = window.matchMedia(query);
 326      list.addListener(updateMatch);
 327      return function () {
 328        list.removeListener(updateMatch);
 329      };
 330    }, [query]);
 331    return query && match;
 332  }
 333  
 334  
 335  /***/ }),
 336  
 337  /***/ 12:
 338  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 339  
 340  "use strict";
 341  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
 342  function _extends() {
 343    _extends = Object.assign || function (target) {
 344      for (var i = 1; i < arguments.length; i++) {
 345        var source = arguments[i];
 346  
 347        for (var key in source) {
 348          if (Object.prototype.hasOwnProperty.call(source, key)) {
 349            target[key] = source[key];
 350          }
 351        }
 352      }
 353  
 354      return target;
 355    };
 356  
 357    return _extends.apply(this, arguments);
 358  }
 359  
 360  /***/ }),
 361  
 362  /***/ 13:
 363  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 364  
 365  "use strict";
 366  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
 367  function _defineProperties(target, props) {
 368    for (var i = 0; i < props.length; i++) {
 369      var descriptor = props[i];
 370      descriptor.enumerable = descriptor.enumerable || false;
 371      descriptor.configurable = true;
 372      if ("value" in descriptor) descriptor.writable = true;
 373      Object.defineProperty(target, descriptor.key, descriptor);
 374    }
 375  }
 376  
 377  function _createClass(Constructor, protoProps, staticProps) {
 378    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 379    if (staticProps) _defineProperties(Constructor, staticProps);
 380    return Constructor;
 381  }
 382  
 383  /***/ }),
 384  
 385  /***/ 14:
 386  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 387  
 388  "use strict";
 389  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
 390  function _classCallCheck(instance, Constructor) {
 391    if (!(instance instanceof Constructor)) {
 392      throw new TypeError("Cannot call a class as a function");
 393    }
 394  }
 395  
 396  /***/ }),
 397  
 398  /***/ 15:
 399  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 400  
 401  "use strict";
 402  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
 403  /* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(34);
 404  /* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
 405  
 406  
 407  function _possibleConstructorReturn(self, call) {
 408    if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) {
 409      return call;
 410    }
 411  
 412    return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
 413  }
 414  
 415  /***/ }),
 416  
 417  /***/ 16:
 418  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 419  
 420  "use strict";
 421  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });
 422  function _getPrototypeOf(o) {
 423    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
 424      return o.__proto__ || Object.getPrototypeOf(o);
 425    };
 426    return _getPrototypeOf(o);
 427  }
 428  
 429  /***/ }),
 430  
 431  /***/ 17:
 432  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 433  
 434  "use strict";
 435  
 436  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
 437  function _setPrototypeOf(o, p) {
 438    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
 439      o.__proto__ = p;
 440      return o;
 441    };
 442  
 443    return _setPrototypeOf(o, p);
 444  }
 445  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
 446  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });
 447  
 448  function _inherits(subClass, superClass) {
 449    if (typeof superClass !== "function" && superClass !== null) {
 450      throw new TypeError("Super expression must either be null or a function");
 451    }
 452  
 453    subClass.prototype = Object.create(superClass && superClass.prototype, {
 454      constructor: {
 455        value: subClass,
 456        writable: true,
 457        configurable: true
 458      }
 459    });
 460    if (superClass) _setPrototypeOf(subClass, superClass);
 461  }
 462  
 463  /***/ }),
 464  
 465  /***/ 2:
 466  /***/ (function(module, exports) {
 467  
 468  (function() { module.exports = this["lodash"]; }());
 469  
 470  /***/ }),
 471  
 472  /***/ 20:
 473  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 474  
 475  "use strict";
 476  
 477  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
 478  var arrayWithHoles = __webpack_require__(38);
 479  
 480  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 481  function _iterableToArrayLimit(arr, i) {
 482    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
 483    var _arr = [];
 484    var _n = true;
 485    var _d = false;
 486    var _e = undefined;
 487  
 488    try {
 489      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 490        _arr.push(_s.value);
 491  
 492        if (i && _arr.length === i) break;
 493      }
 494    } catch (err) {
 495      _d = true;
 496      _e = err;
 497    } finally {
 498      try {
 499        if (!_n && _i["return"] != null) _i["return"]();
 500      } finally {
 501        if (_d) throw _e;
 502      }
 503    }
 504  
 505    return _arr;
 506  }
 507  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 508  var unsupportedIterableToArray = __webpack_require__(27);
 509  
 510  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 511  var nonIterableRest = __webpack_require__(39);
 512  
 513  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 514  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; });
 515  
 516  
 517  
 518  
 519  function _slicedToArray(arr, i) {
 520    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
 521  }
 522  
 523  /***/ }),
 524  
 525  /***/ 25:
 526  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 527  
 528  "use strict";
 529  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
 530  function _arrayLikeToArray(arr, len) {
 531    if (len == null || len > arr.length) len = arr.length;
 532  
 533    for (var i = 0, arr2 = new Array(len); i < len; i++) {
 534      arr2[i] = arr[i];
 535    }
 536  
 537    return arr2;
 538  }
 539  
 540  /***/ }),
 541  
 542  /***/ 252:
 543  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 544  
 545  "use strict";
 546  /* WEBPACK VAR INJECTION */(function(process) {/* harmony import */ var _use_media_query__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(112);
 547  /**
 548   * Internal dependencies
 549   */
 550  
 551  /**
 552   * Whether or not the user agent is Internet Explorer.
 553   *
 554   * @type {boolean}
 555   */
 556  
 557  var IS_IE = typeof window !== 'undefined' && window.navigator.userAgent.indexOf('Trident') >= 0;
 558  /**
 559   * Hook returning whether the user has a preference for reduced motion.
 560   *
 561   * @return {boolean} Reduced motion preference value.
 562   */
 563  
 564  var useReducedMotion = process.env.FORCE_REDUCED_MOTION || IS_IE ? function () {
 565    return true;
 566  } : function () {
 567    return Object(_use_media_query__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])('(prefers-reduced-motion: reduce)');
 568  };
 569  /* harmony default export */ __webpack_exports__["a"] = (useReducedMotion);
 570  
 571  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(105)))
 572  
 573  /***/ }),
 574  
 575  /***/ 27:
 576  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 577  
 578  "use strict";
 579  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
 580  /* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(25);
 581  
 582  function _unsupportedIterableToArray(o, minLen) {
 583    if (!o) return;
 584    if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
 585    var n = Object.prototype.toString.call(o).slice(8, -1);
 586    if (n === "Object" && o.constructor) n = o.constructor.name;
 587    if (n === "Map" || n === "Set") return Array.from(n);
 588    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
 589  }
 590  
 591  /***/ }),
 592  
 593  /***/ 271:
 594  /***/ (function(module, exports, __webpack_require__) {
 595  
 596  var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */
 597  /**
 598   * Copyright 2012-2017 Craig Campbell
 599   *
 600   * Licensed under the Apache License, Version 2.0 (the "License");
 601   * you may not use this file except in compliance with the License.
 602   * You may obtain a copy of the License at
 603   *
 604   * http://www.apache.org/licenses/LICENSE-2.0
 605   *
 606   * Unless required by applicable law or agreed to in writing, software
 607   * distributed under the License is distributed on an "AS IS" BASIS,
 608   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 609   * See the License for the specific language governing permissions and
 610   * limitations under the License.
 611   *
 612   * Mousetrap is a simple keyboard shortcut library for Javascript with
 613   * no external dependencies
 614   *
 615   * @version 1.6.5
 616   * @url craig.is/killing/mice
 617   */
 618  (function(window, document, undefined) {
 619  
 620      // Check if mousetrap is used inside browser, if not, return
 621      if (!window) {
 622          return;
 623      }
 624  
 625      /**
 626       * mapping of special keycodes to their corresponding keys
 627       *
 628       * everything in this dictionary cannot use keypress events
 629       * so it has to be here to map to the correct keycodes for
 630       * keyup/keydown events
 631       *
 632       * @type {Object}
 633       */
 634      var _MAP = {
 635          8: 'backspace',
 636          9: 'tab',
 637          13: 'enter',
 638          16: 'shift',
 639          17: 'ctrl',
 640          18: 'alt',
 641          20: 'capslock',
 642          27: 'esc',
 643          32: 'space',
 644          33: 'pageup',
 645          34: 'pagedown',
 646          35: 'end',
 647          36: 'home',
 648          37: 'left',
 649          38: 'up',
 650          39: 'right',
 651          40: 'down',
 652          45: 'ins',
 653          46: 'del',
 654          91: 'meta',
 655          93: 'meta',
 656          224: 'meta'
 657      };
 658  
 659      /**
 660       * mapping for special characters so they can support
 661       *
 662       * this dictionary is only used incase you want to bind a
 663       * keyup or keydown event to one of these keys
 664       *
 665       * @type {Object}
 666       */
 667      var _KEYCODE_MAP = {
 668          106: '*',
 669          107: '+',
 670          109: '-',
 671          110: '.',
 672          111 : '/',
 673          186: ';',
 674          187: '=',
 675          188: ',',
 676          189: '-',
 677          190: '.',
 678          191: '/',
 679          192: '`',
 680          219: '[',
 681          220: '\\',
 682          221: ']',
 683          222: '\''
 684      };
 685  
 686      /**
 687       * this is a mapping of keys that require shift on a US keypad
 688       * back to the non shift equivelents
 689       *
 690       * this is so you can use keyup events with these keys
 691       *
 692       * note that this will only work reliably on US keyboards
 693       *
 694       * @type {Object}
 695       */
 696      var _SHIFT_MAP = {
 697          '~': '`',
 698          '!': '1',
 699          '@': '2',
 700          '#': '3',
 701          '$': '4',
 702          '%': '5',
 703          '^': '6',
 704          '&': '7',
 705          '*': '8',
 706          '(': '9',
 707          ')': '0',
 708          '_': '-',
 709          '+': '=',
 710          ':': ';',
 711          '\"': '\'',
 712          '<': ',',
 713          '>': '.',
 714          '?': '/',
 715          '|': '\\'
 716      };
 717  
 718      /**
 719       * this is a list of special strings you can use to map
 720       * to modifier keys when you specify your keyboard shortcuts
 721       *
 722       * @type {Object}
 723       */
 724      var _SPECIAL_ALIASES = {
 725          'option': 'alt',
 726          'command': 'meta',
 727          'return': 'enter',
 728          'escape': 'esc',
 729          'plus': '+',
 730          'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'
 731      };
 732  
 733      /**
 734       * variable to store the flipped version of _MAP from above
 735       * needed to check if we should use keypress or not when no action
 736       * is specified
 737       *
 738       * @type {Object|undefined}
 739       */
 740      var _REVERSE_MAP;
 741  
 742      /**
 743       * loop through the f keys, f1 to f19 and add them to the map
 744       * programatically
 745       */
 746      for (var i = 1; i < 20; ++i) {
 747          _MAP[111 + i] = 'f' + i;
 748      }
 749  
 750      /**
 751       * loop through to map numbers on the numeric keypad
 752       */
 753      for (i = 0; i <= 9; ++i) {
 754  
 755          // This needs to use a string cause otherwise since 0 is falsey
 756          // mousetrap will never fire for numpad 0 pressed as part of a keydown
 757          // event.
 758          //
 759          // @see https://github.com/ccampbell/mousetrap/pull/258
 760          _MAP[i + 96] = i.toString();
 761      }
 762  
 763      /**
 764       * cross browser add event method
 765       *
 766       * @param {Element|HTMLDocument} object
 767       * @param {string} type
 768       * @param {Function} callback
 769       * @returns void
 770       */
 771      function _addEvent(object, type, callback) {
 772          if (object.addEventListener) {
 773              object.addEventListener(type, callback, false);
 774              return;
 775          }
 776  
 777          object.attachEvent('on' + type, callback);
 778      }
 779  
 780      /**
 781       * takes the event and returns the key character
 782       *
 783       * @param {Event} e
 784       * @return {string}
 785       */
 786      function _characterFromEvent(e) {
 787  
 788          // for keypress events we should return the character as is
 789          if (e.type == 'keypress') {
 790              var character = String.fromCharCode(e.which);
 791  
 792              // if the shift key is not pressed then it is safe to assume
 793              // that we want the character to be lowercase.  this means if
 794              // you accidentally have caps lock on then your key bindings
 795              // will continue to work
 796              //
 797              // the only side effect that might not be desired is if you
 798              // bind something like 'A' cause you want to trigger an
 799              // event when capital A is pressed caps lock will no longer
 800              // trigger the event.  shift+a will though.
 801              if (!e.shiftKey) {
 802                  character = character.toLowerCase();
 803              }
 804  
 805              return character;
 806          }
 807  
 808          // for non keypress events the special maps are needed
 809          if (_MAP[e.which]) {
 810              return _MAP[e.which];
 811          }
 812  
 813          if (_KEYCODE_MAP[e.which]) {
 814              return _KEYCODE_MAP[e.which];
 815          }
 816  
 817          // if it is not in the special map
 818  
 819          // with keydown and keyup events the character seems to always
 820          // come in as an uppercase character whether you are pressing shift
 821          // or not.  we should make sure it is always lowercase for comparisons
 822          return String.fromCharCode(e.which).toLowerCase();
 823      }
 824  
 825      /**
 826       * checks if two arrays are equal
 827       *
 828       * @param {Array} modifiers1
 829       * @param {Array} modifiers2
 830       * @returns {boolean}
 831       */
 832      function _modifiersMatch(modifiers1, modifiers2) {
 833          return modifiers1.sort().join(',') === modifiers2.sort().join(',');
 834      }
 835  
 836      /**
 837       * takes a key event and figures out what the modifiers are
 838       *
 839       * @param {Event} e
 840       * @returns {Array}
 841       */
 842      function _eventModifiers(e) {
 843          var modifiers = [];
 844  
 845          if (e.shiftKey) {
 846              modifiers.push('shift');
 847          }
 848  
 849          if (e.altKey) {
 850              modifiers.push('alt');
 851          }
 852  
 853          if (e.ctrlKey) {
 854              modifiers.push('ctrl');
 855          }
 856  
 857          if (e.metaKey) {
 858              modifiers.push('meta');
 859          }
 860  
 861          return modifiers;
 862      }
 863  
 864      /**
 865       * prevents default for this event
 866       *
 867       * @param {Event} e
 868       * @returns void
 869       */
 870      function _preventDefault(e) {
 871          if (e.preventDefault) {
 872              e.preventDefault();
 873              return;
 874          }
 875  
 876          e.returnValue = false;
 877      }
 878  
 879      /**
 880       * stops propogation for this event
 881       *
 882       * @param {Event} e
 883       * @returns void
 884       */
 885      function _stopPropagation(e) {
 886          if (e.stopPropagation) {
 887              e.stopPropagation();
 888              return;
 889          }
 890  
 891          e.cancelBubble = true;
 892      }
 893  
 894      /**
 895       * determines if the keycode specified is a modifier key or not
 896       *
 897       * @param {string} key
 898       * @returns {boolean}
 899       */
 900      function _isModifier(key) {
 901          return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';
 902      }
 903  
 904      /**
 905       * reverses the map lookup so that we can look for specific keys
 906       * to see what can and can't use keypress
 907       *
 908       * @return {Object}
 909       */
 910      function _getReverseMap() {
 911          if (!_REVERSE_MAP) {
 912              _REVERSE_MAP = {};
 913              for (var key in _MAP) {
 914  
 915                  // pull out the numeric keypad from here cause keypress should
 916                  // be able to detect the keys from the character
 917                  if (key > 95 && key < 112) {
 918                      continue;
 919                  }
 920  
 921                  if (_MAP.hasOwnProperty(key)) {
 922                      _REVERSE_MAP[_MAP[key]] = key;
 923                  }
 924              }
 925          }
 926          return _REVERSE_MAP;
 927      }
 928  
 929      /**
 930       * picks the best action based on the key combination
 931       *
 932       * @param {string} key - character for key
 933       * @param {Array} modifiers
 934       * @param {string=} action passed in
 935       */
 936      function _pickBestAction(key, modifiers, action) {
 937  
 938          // if no action was picked in we should try to pick the one
 939          // that we think would work best for this key
 940          if (!action) {
 941              action = _getReverseMap()[key] ? 'keydown' : 'keypress';
 942          }
 943  
 944          // modifier keys don't work as expected with keypress,
 945          // switch to keydown
 946          if (action == 'keypress' && modifiers.length) {
 947              action = 'keydown';
 948          }
 949  
 950          return action;
 951      }
 952  
 953      /**
 954       * Converts from a string key combination to an array
 955       *
 956       * @param  {string} combination like "command+shift+l"
 957       * @return {Array}
 958       */
 959      function _keysFromString(combination) {
 960          if (combination === '+') {
 961              return ['+'];
 962          }
 963  
 964          combination = combination.replace(/\+{2}/g, '+plus');
 965          return combination.split('+');
 966      }
 967  
 968      /**
 969       * Gets info for a specific key combination
 970       *
 971       * @param  {string} combination key combination ("command+s" or "a" or "*")
 972       * @param  {string=} action
 973       * @returns {Object}
 974       */
 975      function _getKeyInfo(combination, action) {
 976          var keys;
 977          var key;
 978          var i;
 979          var modifiers = [];
 980  
 981          // take the keys from this pattern and figure out what the actual
 982          // pattern is all about
 983          keys = _keysFromString(combination);
 984  
 985          for (i = 0; i < keys.length; ++i) {
 986              key = keys[i];
 987  
 988              // normalize key names
 989              if (_SPECIAL_ALIASES[key]) {
 990                  key = _SPECIAL_ALIASES[key];
 991              }
 992  
 993              // if this is not a keypress event then we should
 994              // be smart about using shift keys
 995              // this will only work for US keyboards however
 996              if (action && action != 'keypress' && _SHIFT_MAP[key]) {
 997                  key = _SHIFT_MAP[key];
 998                  modifiers.push('shift');
 999              }
1000  
1001              // if this key is a modifier then add it to the list of modifiers
1002              if (_isModifier(key)) {
1003                  modifiers.push(key);
1004              }
1005          }
1006  
1007          // depending on what the key combination is
1008          // we will try to pick the best event for it
1009          action = _pickBestAction(key, modifiers, action);
1010  
1011          return {
1012              key: key,
1013              modifiers: modifiers,
1014              action: action
1015          };
1016      }
1017  
1018      function _belongsTo(element, ancestor) {
1019          if (element === null || element === document) {
1020              return false;
1021          }
1022  
1023          if (element === ancestor) {
1024              return true;
1025          }
1026  
1027          return _belongsTo(element.parentNode, ancestor);
1028      }
1029  
1030      function Mousetrap(targetElement) {
1031          var self = this;
1032  
1033          targetElement = targetElement || document;
1034  
1035          if (!(self instanceof Mousetrap)) {
1036              return new Mousetrap(targetElement);
1037          }
1038  
1039          /**
1040           * element to attach key events to
1041           *
1042           * @type {Element}
1043           */
1044          self.target = targetElement;
1045  
1046          /**
1047           * a list of all the callbacks setup via Mousetrap.bind()
1048           *
1049           * @type {Object}
1050           */
1051          self._callbacks = {};
1052  
1053          /**
1054           * direct map of string combinations to callbacks used for trigger()
1055           *
1056           * @type {Object}
1057           */
1058          self._directMap = {};
1059  
1060          /**
1061           * keeps track of what level each sequence is at since multiple
1062           * sequences can start out with the same sequence
1063           *
1064           * @type {Object}
1065           */
1066          var _sequenceLevels = {};
1067  
1068          /**
1069           * variable to store the setTimeout call
1070           *
1071           * @type {null|number}
1072           */
1073          var _resetTimer;
1074  
1075          /**
1076           * temporary state where we will ignore the next keyup
1077           *
1078           * @type {boolean|string}
1079           */
1080          var _ignoreNextKeyup = false;
1081  
1082          /**
1083           * temporary state where we will ignore the next keypress
1084           *
1085           * @type {boolean}
1086           */
1087          var _ignoreNextKeypress = false;
1088  
1089          /**
1090           * are we currently inside of a sequence?
1091           * type of action ("keyup" or "keydown" or "keypress") or false
1092           *
1093           * @type {boolean|string}
1094           */
1095          var _nextExpectedAction = false;
1096  
1097          /**
1098           * resets all sequence counters except for the ones passed in
1099           *
1100           * @param {Object} doNotReset
1101           * @returns void
1102           */
1103          function _resetSequences(doNotReset) {
1104              doNotReset = doNotReset || {};
1105  
1106              var activeSequences = false,
1107                  key;
1108  
1109              for (key in _sequenceLevels) {
1110                  if (doNotReset[key]) {
1111                      activeSequences = true;
1112                      continue;
1113                  }
1114                  _sequenceLevels[key] = 0;
1115              }
1116  
1117              if (!activeSequences) {
1118                  _nextExpectedAction = false;
1119              }
1120          }
1121  
1122          /**
1123           * finds all callbacks that match based on the keycode, modifiers,
1124           * and action
1125           *
1126           * @param {string} character
1127           * @param {Array} modifiers
1128           * @param {Event|Object} e
1129           * @param {string=} sequenceName - name of the sequence we are looking for
1130           * @param {string=} combination
1131           * @param {number=} level
1132           * @returns {Array}
1133           */
1134          function _getMatches(character, modifiers, e, sequenceName, combination, level) {
1135              var i;
1136              var callback;
1137              var matches = [];
1138              var action = e.type;
1139  
1140              // if there are no events related to this keycode
1141              if (!self._callbacks[character]) {
1142                  return [];
1143              }
1144  
1145              // if a modifier key is coming up on its own we should allow it
1146              if (action == 'keyup' && _isModifier(character)) {
1147                  modifiers = [character];
1148              }
1149  
1150              // loop through all callbacks for the key that was pressed
1151              // and see if any of them match
1152              for (i = 0; i < self._callbacks[character].length; ++i) {
1153                  callback = self._callbacks[character][i];
1154  
1155                  // if a sequence name is not specified, but this is a sequence at
1156                  // the wrong level then move onto the next match
1157                  if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {
1158                      continue;
1159                  }
1160  
1161                  // if the action we are looking for doesn't match the action we got
1162                  // then we should keep going
1163                  if (action != callback.action) {
1164                      continue;
1165                  }
1166  
1167                  // if this is a keypress event and the meta key and control key
1168                  // are not pressed that means that we need to only look at the
1169                  // character, otherwise check the modifiers as well
1170                  //
1171                  // chrome will not fire a keypress if meta or control is down
1172                  // safari will fire a keypress if meta or meta+shift is down
1173                  // firefox will fire a keypress if meta or control is down
1174                  if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {
1175  
1176                      // when you bind a combination or sequence a second time it
1177                      // should overwrite the first one.  if a sequenceName or
1178                      // combination is specified in this call it does just that
1179                      //
1180                      // @todo make deleting its own method?
1181                      var deleteCombo = !sequenceName && callback.combo == combination;
1182                      var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;
1183                      if (deleteCombo || deleteSequence) {
1184                          self._callbacks[character].splice(i, 1);
1185                      }
1186  
1187                      matches.push(callback);
1188                  }
1189              }
1190  
1191              return matches;
1192          }
1193  
1194          /**
1195           * actually calls the callback function
1196           *
1197           * if your callback function returns false this will use the jquery
1198           * convention - prevent default and stop propogation on the event
1199           *
1200           * @param {Function} callback
1201           * @param {Event} e
1202           * @returns void
1203           */
1204          function _fireCallback(callback, e, combo, sequence) {
1205  
1206              // if this event should not happen stop here
1207              if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {
1208                  return;
1209              }
1210  
1211              if (callback(e, combo) === false) {
1212                  _preventDefault(e);
1213                  _stopPropagation(e);
1214              }
1215          }
1216  
1217          /**
1218           * handles a character key event
1219           *
1220           * @param {string} character
1221           * @param {Array} modifiers
1222           * @param {Event} e
1223           * @returns void
1224           */
1225          self._handleKey = function(character, modifiers, e) {
1226              var callbacks = _getMatches(character, modifiers, e);
1227              var i;
1228              var doNotReset = {};
1229              var maxLevel = 0;
1230              var processedSequenceCallback = false;
1231  
1232              // Calculate the maxLevel for sequences so we can only execute the longest callback sequence
1233              for (i = 0; i < callbacks.length; ++i) {
1234                  if (callbacks[i].seq) {
1235                      maxLevel = Math.max(maxLevel, callbacks[i].level);
1236                  }
1237              }
1238  
1239              // loop through matching callbacks for this key event
1240              for (i = 0; i < callbacks.length; ++i) {
1241  
1242                  // fire for all sequence callbacks
1243                  // this is because if for example you have multiple sequences
1244                  // bound such as "g i" and "g t" they both need to fire the
1245                  // callback for matching g cause otherwise you can only ever
1246                  // match the first one
1247                  if (callbacks[i].seq) {
1248  
1249                      // only fire callbacks for the maxLevel to prevent
1250                      // subsequences from also firing
1251                      //
1252                      // for example 'a option b' should not cause 'option b' to fire
1253                      // even though 'option b' is part of the other sequence
1254                      //
1255                      // any sequences that do not match here will be discarded
1256                      // below by the _resetSequences call
1257                      if (callbacks[i].level != maxLevel) {
1258                          continue;
1259                      }
1260  
1261                      processedSequenceCallback = true;
1262  
1263                      // keep a list of which sequences were matches for later
1264                      doNotReset[callbacks[i].seq] = 1;
1265                      _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);
1266                      continue;
1267                  }
1268  
1269                  // if there were no sequence matches but we are still here
1270                  // that means this is a regular match so we should fire that
1271                  if (!processedSequenceCallback) {
1272                      _fireCallback(callbacks[i].callback, e, callbacks[i].combo);
1273                  }
1274              }
1275  
1276              // if the key you pressed matches the type of sequence without
1277              // being a modifier (ie "keyup" or "keypress") then we should
1278              // reset all sequences that were not matched by this event
1279              //
1280              // this is so, for example, if you have the sequence "h a t" and you
1281              // type "h e a r t" it does not match.  in this case the "e" will
1282              // cause the sequence to reset
1283              //
1284              // modifier keys are ignored because you can have a sequence
1285              // that contains modifiers such as "enter ctrl+space" and in most
1286              // cases the modifier key will be pressed before the next key
1287              //
1288              // also if you have a sequence such as "ctrl+b a" then pressing the
1289              // "b" key will trigger a "keypress" and a "keydown"
1290              //
1291              // the "keydown" is expected when there is a modifier, but the
1292              // "keypress" ends up matching the _nextExpectedAction since it occurs
1293              // after and that causes the sequence to reset
1294              //
1295              // we ignore keypresses in a sequence that directly follow a keydown
1296              // for the same character
1297              var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;
1298              if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {
1299                  _resetSequences(doNotReset);
1300              }
1301  
1302              _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';
1303          };
1304  
1305          /**
1306           * handles a keydown event
1307           *
1308           * @param {Event} e
1309           * @returns void
1310           */
1311          function _handleKeyEvent(e) {
1312  
1313              // normalize e.which for key events
1314              // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion
1315              if (typeof e.which !== 'number') {
1316                  e.which = e.keyCode;
1317              }
1318  
1319              var character = _characterFromEvent(e);
1320  
1321              // no character found then stop
1322              if (!character) {
1323                  return;
1324              }
1325  
1326              // need to use === for the character check because the character can be 0
1327              if (e.type == 'keyup' && _ignoreNextKeyup === character) {
1328                  _ignoreNextKeyup = false;
1329                  return;
1330              }
1331  
1332              self.handleKey(character, _eventModifiers(e), e);
1333          }
1334  
1335          /**
1336           * called to set a 1 second timeout on the specified sequence
1337           *
1338           * this is so after each key press in the sequence you have 1 second
1339           * to press the next key before you have to start over
1340           *
1341           * @returns void
1342           */
1343          function _resetSequenceTimer() {
1344              clearTimeout(_resetTimer);
1345              _resetTimer = setTimeout(_resetSequences, 1000);
1346          }
1347  
1348          /**
1349           * binds a key sequence to an event
1350           *
1351           * @param {string} combo - combo specified in bind call
1352           * @param {Array} keys
1353           * @param {Function} callback
1354           * @param {string=} action
1355           * @returns void
1356           */
1357          function _bindSequence(combo, keys, callback, action) {
1358  
1359              // start off by adding a sequence level record for this combination
1360              // and setting the level to 0
1361              _sequenceLevels[combo] = 0;
1362  
1363              /**
1364               * callback to increase the sequence level for this sequence and reset
1365               * all other sequences that were active
1366               *
1367               * @param {string} nextAction
1368               * @returns {Function}
1369               */
1370              function _increaseSequence(nextAction) {
1371                  return function() {
1372                      _nextExpectedAction = nextAction;
1373                      ++_sequenceLevels[combo];
1374                      _resetSequenceTimer();
1375                  };
1376              }
1377  
1378              /**
1379               * wraps the specified callback inside of another function in order
1380               * to reset all sequence counters as soon as this sequence is done
1381               *
1382               * @param {Event} e
1383               * @returns void
1384               */
1385              function _callbackAndReset(e) {
1386                  _fireCallback(callback, e, combo);
1387  
1388                  // we should ignore the next key up if the action is key down
1389                  // or keypress.  this is so if you finish a sequence and
1390                  // release the key the final key will not trigger a keyup
1391                  if (action !== 'keyup') {
1392                      _ignoreNextKeyup = _characterFromEvent(e);
1393                  }
1394  
1395                  // weird race condition if a sequence ends with the key
1396                  // another sequence begins with
1397                  setTimeout(_resetSequences, 10);
1398              }
1399  
1400              // loop through keys one at a time and bind the appropriate callback
1401              // function.  for any key leading up to the final one it should
1402              // increase the sequence. after the final, it should reset all sequences
1403              //
1404              // if an action is specified in the original bind call then that will
1405              // be used throughout.  otherwise we will pass the action that the
1406              // next key in the sequence should match.  this allows a sequence
1407              // to mix and match keypress and keydown events depending on which
1408              // ones are better suited to the key provided
1409              for (var i = 0; i < keys.length; ++i) {
1410                  var isFinal = i + 1 === keys.length;
1411                  var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);
1412                  _bindSingle(keys[i], wrappedCallback, action, combo, i);
1413              }
1414          }
1415  
1416          /**
1417           * binds a single keyboard combination
1418           *
1419           * @param {string} combination
1420           * @param {Function} callback
1421           * @param {string=} action
1422           * @param {string=} sequenceName - name of sequence if part of sequence
1423           * @param {number=} level - what part of the sequence the command is
1424           * @returns void
1425           */
1426          function _bindSingle(combination, callback, action, sequenceName, level) {
1427  
1428              // store a direct mapped reference for use with Mousetrap.trigger
1429              self._directMap[combination + ':' + action] = callback;
1430  
1431              // make sure multiple spaces in a row become a single space
1432              combination = combination.replace(/\s+/g, ' ');
1433  
1434              var sequence = combination.split(' ');
1435              var info;
1436  
1437              // if this pattern is a sequence of keys then run through this method
1438              // to reprocess each pattern one key at a time
1439              if (sequence.length > 1) {
1440                  _bindSequence(combination, sequence, callback, action);
1441                  return;
1442              }
1443  
1444              info = _getKeyInfo(combination, action);
1445  
1446              // make sure to initialize array if this is the first time
1447              // a callback is added for this key
1448              self._callbacks[info.key] = self._callbacks[info.key] || [];
1449  
1450              // remove an existing match if there is one
1451              _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);
1452  
1453              // add this call back to the array
1454              // if it is a sequence put it at the beginning
1455              // if not put it at the end
1456              //
1457              // this is important because the way these are processed expects
1458              // the sequence ones to come first
1459              self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({
1460                  callback: callback,
1461                  modifiers: info.modifiers,
1462                  action: info.action,
1463                  seq: sequenceName,
1464                  level: level,
1465                  combo: combination
1466              });
1467          }
1468  
1469          /**
1470           * binds multiple combinations to the same callback
1471           *
1472           * @param {Array} combinations
1473           * @param {Function} callback
1474           * @param {string|undefined} action
1475           * @returns void
1476           */
1477          self._bindMultiple = function(combinations, callback, action) {
1478              for (var i = 0; i < combinations.length; ++i) {
1479                  _bindSingle(combinations[i], callback, action);
1480              }
1481          };
1482  
1483          // start!
1484          _addEvent(targetElement, 'keypress', _handleKeyEvent);
1485          _addEvent(targetElement, 'keydown', _handleKeyEvent);
1486          _addEvent(targetElement, 'keyup', _handleKeyEvent);
1487      }
1488  
1489      /**
1490       * binds an event to mousetrap
1491       *
1492       * can be a single key, a combination of keys separated with +,
1493       * an array of keys, or a sequence of keys separated by spaces
1494       *
1495       * be sure to list the modifier keys first to make sure that the
1496       * correct key ends up getting bound (the last key in the pattern)
1497       *
1498       * @param {string|Array} keys
1499       * @param {Function} callback
1500       * @param {string=} action - 'keypress', 'keydown', or 'keyup'
1501       * @returns void
1502       */
1503      Mousetrap.prototype.bind = function(keys, callback, action) {
1504          var self = this;
1505          keys = keys instanceof Array ? keys : [keys];
1506          self._bindMultiple.call(self, keys, callback, action);
1507          return self;
1508      };
1509  
1510      /**
1511       * unbinds an event to mousetrap
1512       *
1513       * the unbinding sets the callback function of the specified key combo
1514       * to an empty function and deletes the corresponding key in the
1515       * _directMap dict.
1516       *
1517       * TODO: actually remove this from the _callbacks dictionary instead
1518       * of binding an empty function
1519       *
1520       * the keycombo+action has to be exactly the same as
1521       * it was defined in the bind method
1522       *
1523       * @param {string|Array} keys
1524       * @param {string} action
1525       * @returns void
1526       */
1527      Mousetrap.prototype.unbind = function(keys, action) {
1528          var self = this;
1529          return self.bind.call(self, keys, function() {}, action);
1530      };
1531  
1532      /**
1533       * triggers an event that has already been bound
1534       *
1535       * @param {string} keys
1536       * @param {string=} action
1537       * @returns void
1538       */
1539      Mousetrap.prototype.trigger = function(keys, action) {
1540          var self = this;
1541          if (self._directMap[keys + ':' + action]) {
1542              self._directMap[keys + ':' + action]({}, keys);
1543          }
1544          return self;
1545      };
1546  
1547      /**
1548       * resets the library back to its initial state.  this is useful
1549       * if you want to clear out the current keyboard shortcuts and bind
1550       * new ones - for example if you switch to another page
1551       *
1552       * @returns void
1553       */
1554      Mousetrap.prototype.reset = function() {
1555          var self = this;
1556          self._callbacks = {};
1557          self._directMap = {};
1558          return self;
1559      };
1560  
1561      /**
1562       * should we stop this event before firing off callbacks
1563       *
1564       * @param {Event} e
1565       * @param {Element} element
1566       * @return {boolean}
1567       */
1568      Mousetrap.prototype.stopCallback = function(e, element) {
1569          var self = this;
1570  
1571          // if the element has the class "mousetrap" then no need to stop
1572          if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {
1573              return false;
1574          }
1575  
1576          if (_belongsTo(element, self.target)) {
1577              return false;
1578          }
1579  
1580          // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,
1581          // not the initial event target in the shadow tree. Note that not all events cross the
1582          // shadow boundary.
1583          // For shadow trees with `mode: 'open'`, the initial event target is the first element in
1584          // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event
1585          // target cannot be obtained.
1586          if ('composedPath' in e && typeof e.composedPath === 'function') {
1587              // For open shadow trees, update `element` so that the following check works.
1588              var initialEventTarget = e.composedPath()[0];
1589              if (initialEventTarget !== e.target) {
1590                  element = initialEventTarget;
1591              }
1592          }
1593  
1594          // stop for input, select, and textarea
1595          return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;
1596      };
1597  
1598      /**
1599       * exposes _handleKey publicly so it can be overwritten by extensions
1600       */
1601      Mousetrap.prototype.handleKey = function() {
1602          var self = this;
1603          return self._handleKey.apply(self, arguments);
1604      };
1605  
1606      /**
1607       * allow custom key mappings
1608       */
1609      Mousetrap.addKeycodes = function(object) {
1610          for (var key in object) {
1611              if (object.hasOwnProperty(key)) {
1612                  _MAP[key] = object[key];
1613              }
1614          }
1615          _REVERSE_MAP = null;
1616      };
1617  
1618      /**
1619       * Init the global mousetrap functions
1620       *
1621       * This method is needed to allow the global mousetrap functions to work
1622       * now that mousetrap is a constructor function.
1623       */
1624      Mousetrap.init = function() {
1625          var documentMousetrap = Mousetrap(document);
1626          for (var method in documentMousetrap) {
1627              if (method.charAt(0) !== '_') {
1628                  Mousetrap[method] = (function(method) {
1629                      return function() {
1630                          return documentMousetrap[method].apply(documentMousetrap, arguments);
1631                      };
1632                  } (method));
1633              }
1634          }
1635      };
1636  
1637      Mousetrap.init();
1638  
1639      // expose mousetrap to the global object
1640      window.Mousetrap = Mousetrap;
1641  
1642      // expose as a common js module
1643      if ( true && module.exports) {
1644          module.exports = Mousetrap;
1645      }
1646  
1647      // expose mousetrap as an AMD module
1648      if (true) {
1649          !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
1650              return Mousetrap;
1651          }).call(exports, __webpack_require__, exports, module),
1652                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
1653      }
1654  }) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);
1655  
1656  
1657  /***/ }),
1658  
1659  /***/ 34:
1660  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1661  
1662  "use strict";
1663  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; });
1664  function _typeof(obj) {
1665    "@babel/helpers - typeof";
1666  
1667    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
1668      _typeof = function _typeof(obj) {
1669        return typeof obj;
1670      };
1671    } else {
1672      _typeof = function _typeof(obj) {
1673        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
1674      };
1675    }
1676  
1677    return _typeof(obj);
1678  }
1679  
1680  /***/ }),
1681  
1682  /***/ 38:
1683  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1684  
1685  "use strict";
1686  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
1687  function _arrayWithHoles(arr) {
1688    if (Array.isArray(arr)) return arr;
1689  }
1690  
1691  /***/ }),
1692  
1693  /***/ 39:
1694  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1695  
1696  "use strict";
1697  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
1698  function _nonIterableRest() {
1699    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
1700  }
1701  
1702  /***/ }),
1703  
1704  /***/ 396:
1705  /***/ (function(module, exports) {
1706  
1707  /**
1708   * adds a bindGlobal method to Mousetrap that allows you to
1709   * bind specific keyboard shortcuts that will still work
1710   * inside a text input field
1711   *
1712   * usage:
1713   * Mousetrap.bindGlobal('ctrl+s', _saveChanges);
1714   */
1715  /* global Mousetrap:true */
1716  (function(Mousetrap) {
1717      if (! Mousetrap) {
1718          return;
1719      }
1720      var _globalCallbacks = {};
1721      var _originalStopCallback = Mousetrap.prototype.stopCallback;
1722  
1723      Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) {
1724          var self = this;
1725  
1726          if (self.paused) {
1727              return true;
1728          }
1729  
1730          if (_globalCallbacks[combo] || _globalCallbacks[sequence]) {
1731              return false;
1732          }
1733  
1734          return _originalStopCallback.call(self, e, element, combo);
1735      };
1736  
1737      Mousetrap.prototype.bindGlobal = function(keys, callback, action) {
1738          var self = this;
1739          self.bind(keys, callback, action);
1740  
1741          if (keys instanceof Array) {
1742              for (var i = 0; i < keys.length; i++) {
1743                  _globalCallbacks[keys[i]] = true;
1744              }
1745              return;
1746          }
1747  
1748          _globalCallbacks[keys] = true;
1749      };
1750  
1751      Mousetrap.init();
1752  }) (typeof Mousetrap !== "undefined" ? Mousetrap : undefined);
1753  
1754  
1755  /***/ }),
1756  
1757  /***/ 431:
1758  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1759  
1760  "use strict";
1761  __webpack_require__.r(__webpack_exports__);
1762  
1763  // EXTERNAL MODULE: external {"this":"lodash"}
1764  var external_this_lodash_ = __webpack_require__(2);
1765  
1766  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js
1767  /**
1768   * External dependencies
1769   */
1770  
1771  /**
1772   * Given a function mapping a component to an enhanced component and modifier
1773   * name, returns the enhanced component augmented with a generated displayName.
1774   *
1775   * @param {Function} mapComponentToEnhancedComponent Function mapping component
1776   *                                                   to enhanced component.
1777   * @param {string}   modifierName                    Seed name from which to
1778   *                                                   generated display name.
1779   *
1780   * @return {WPComponent} Component class with generated display name assigned.
1781   */
1782  
1783  function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) {
1784    return function (OriginalComponent) {
1785      var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent);
1786      var _OriginalComponent$di = OriginalComponent.displayName,
1787          displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di;
1788      EnhancedComponent.displayName = "".concat(Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")");
1789      return EnhancedComponent;
1790    };
1791  }
1792  
1793  /* harmony default export */ var create_higher_order_component = (createHigherOrderComponent);
1794  
1795  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js
1796  /**
1797   * External dependencies
1798   */
1799  
1800  /**
1801   * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function
1802   * composition, where each successive invocation is supplied the return value of the previous.
1803   *
1804   * @param {...Function} hocs The HOC functions to invoke.
1805   *
1806   * @return {Function} Returns the new composite function.
1807   */
1808  
1809  /* harmony default export */ var compose = (external_this_lodash_["flowRight"]);
1810  
1811  // EXTERNAL MODULE: external {"this":["wp","element"]}
1812  var external_this_wp_element_ = __webpack_require__(0);
1813  
1814  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js
1815  
1816  
1817  /**
1818   * Internal dependencies
1819   */
1820  
1821  /**
1822   * Higher-order component creator, creating a new component which renders if
1823   * the given condition is satisfied or with the given optional prop name.
1824   *
1825   * @param {Function} predicate Function to test condition.
1826   *
1827   * @return {Function} Higher-order component.
1828   */
1829  
1830  var if_condition_ifCondition = function ifCondition(predicate) {
1831    return create_higher_order_component(function (WrappedComponent) {
1832      return function (props) {
1833        if (!predicate(props)) {
1834          return null;
1835        }
1836  
1837        return Object(external_this_wp_element_["createElement"])(WrappedComponent, props);
1838      };
1839    }, 'ifCondition');
1840  };
1841  
1842  /* harmony default export */ var if_condition = (if_condition_ifCondition);
1843  
1844  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
1845  var classCallCheck = __webpack_require__(14);
1846  
1847  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
1848  var createClass = __webpack_require__(13);
1849  
1850  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
1851  var possibleConstructorReturn = __webpack_require__(15);
1852  
1853  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
1854  var getPrototypeOf = __webpack_require__(16);
1855  
1856  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules
1857  var inherits = __webpack_require__(17);
1858  
1859  // EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]}
1860  var external_this_wp_isShallowEqual_ = __webpack_require__(51);
1861  var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_);
1862  
1863  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js
1864  
1865  
1866  
1867  
1868  
1869  
1870  
1871  /**
1872   * WordPress dependencies
1873   */
1874  
1875  
1876  /**
1877   * Internal dependencies
1878   */
1879  
1880  
1881  /**
1882   * Given a component returns the enhanced component augmented with a component
1883   * only rerendering when its props/state change
1884   *
1885   * @param {Function} mapComponentToEnhancedComponent Function mapping component
1886   *                                                   to enhanced component.
1887   * @param {string}   modifierName                    Seed name from which to
1888   *                                                   generated display name.
1889   *
1890   * @return {WPComponent} Component class with generated display name assigned.
1891   */
1892  
1893  var pure = create_higher_order_component(function (Wrapped) {
1894    if (Wrapped.prototype instanceof external_this_wp_element_["Component"]) {
1895      return (
1896        /*#__PURE__*/
1897        function (_Wrapped) {
1898          Object(inherits["a" /* default */])(_class, _Wrapped);
1899  
1900          function _class() {
1901            Object(classCallCheck["a" /* default */])(this, _class);
1902  
1903            return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments));
1904          }
1905  
1906          Object(createClass["a" /* default */])(_class, [{
1907            key: "shouldComponentUpdate",
1908            value: function shouldComponentUpdate(nextProps, nextState) {
1909              return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state);
1910            }
1911          }]);
1912  
1913          return _class;
1914        }(Wrapped)
1915      );
1916    }
1917  
1918    return (
1919      /*#__PURE__*/
1920      function (_Component) {
1921        Object(inherits["a" /* default */])(_class2, _Component);
1922  
1923        function _class2() {
1924          Object(classCallCheck["a" /* default */])(this, _class2);
1925  
1926          return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class2).apply(this, arguments));
1927        }
1928  
1929        Object(createClass["a" /* default */])(_class2, [{
1930          key: "shouldComponentUpdate",
1931          value: function shouldComponentUpdate(nextProps) {
1932            return !external_this_wp_isShallowEqual_default()(nextProps, this.props);
1933          }
1934        }, {
1935          key: "render",
1936          value: function render() {
1937            return Object(external_this_wp_element_["createElement"])(Wrapped, this.props);
1938          }
1939        }]);
1940  
1941        return _class2;
1942      }(external_this_wp_element_["Component"])
1943    );
1944  }, 'pure');
1945  /* harmony default export */ var higher_order_pure = (pure);
1946  
1947  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
1948  var esm_extends = __webpack_require__(12);
1949  
1950  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
1951  var assertThisInitialized = __webpack_require__(7);
1952  
1953  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js
1954  
1955  
1956  
1957  /**
1958   * External dependencies
1959   */
1960  
1961  /**
1962   * Class responsible for orchestrating event handling on the global window,
1963   * binding a single event to be shared across all handling instances, and
1964   * removing the handler when no instances are listening for the event.
1965   */
1966  
1967  var listener_Listener =
1968  /*#__PURE__*/
1969  function () {
1970    function Listener() {
1971      Object(classCallCheck["a" /* default */])(this, Listener);
1972  
1973      this.listeners = {};
1974      this.handleEvent = this.handleEvent.bind(this);
1975    }
1976  
1977    Object(createClass["a" /* default */])(Listener, [{
1978      key: "add",
1979      value: function add(eventType, instance) {
1980        if (!this.listeners[eventType]) {
1981          // Adding first listener for this type, so bind event.
1982          window.addEventListener(eventType, this.handleEvent);
1983          this.listeners[eventType] = [];
1984        }
1985  
1986        this.listeners[eventType].push(instance);
1987      }
1988    }, {
1989      key: "remove",
1990      value: function remove(eventType, instance) {
1991        this.listeners[eventType] = Object(external_this_lodash_["without"])(this.listeners[eventType], instance);
1992  
1993        if (!this.listeners[eventType].length) {
1994          // Removing last listener for this type, so unbind event.
1995          window.removeEventListener(eventType, this.handleEvent);
1996          delete this.listeners[eventType];
1997        }
1998      }
1999    }, {
2000      key: "handleEvent",
2001      value: function handleEvent(event) {
2002        Object(external_this_lodash_["forEach"])(this.listeners[event.type], function (instance) {
2003          instance.handleEvent(event);
2004        });
2005      }
2006    }]);
2007  
2008    return Listener;
2009  }();
2010  
2011  /* harmony default export */ var listener = (listener_Listener);
2012  
2013  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js
2014  
2015  
2016  
2017  
2018  
2019  
2020  
2021  
2022  
2023  /**
2024   * External dependencies
2025   */
2026  
2027  /**
2028   * WordPress dependencies
2029   */
2030  
2031  
2032  /**
2033   * Internal dependencies
2034   */
2035  
2036  
2037  
2038  /**
2039   * Listener instance responsible for managing document event handling.
2040   *
2041   * @type {Listener}
2042   */
2043  
2044  var with_global_events_listener = new listener();
2045  /**
2046   * Higher-order component creator which, given an object of DOM event types and
2047   * values corresponding to a callback function name on the component, will
2048   * create or update a window event handler to invoke the callback when an event
2049   * occurs. On behalf of the consuming developer, the higher-order component
2050   * manages unbinding when the component unmounts, and binding at most a single
2051   * event handler for the entire application.
2052   *
2053   * @param {Object<string,string>} eventTypesToHandlers Object with keys of DOM
2054   *                                                     event type, the value a
2055   *                                                     name of the function on
2056   *                                                     the original component's
2057   *                                                     instance which handles
2058   *                                                     the event.
2059   *
2060   * @return {Function} Higher-order component.
2061   */
2062  
2063  function withGlobalEvents(eventTypesToHandlers) {
2064    return create_higher_order_component(function (WrappedComponent) {
2065      var Wrapper =
2066      /*#__PURE__*/
2067      function (_Component) {
2068        Object(inherits["a" /* default */])(Wrapper, _Component);
2069  
2070        function Wrapper() {
2071          var _this;
2072  
2073          Object(classCallCheck["a" /* default */])(this, Wrapper);
2074  
2075          _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Wrapper).apply(this, arguments));
2076          _this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(_this));
2077          _this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(_this));
2078          return _this;
2079        }
2080  
2081        Object(createClass["a" /* default */])(Wrapper, [{
2082          key: "componentDidMount",
2083          value: function componentDidMount() {
2084            var _this2 = this;
2085  
2086            Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
2087              with_global_events_listener.add(eventType, _this2);
2088            });
2089          }
2090        }, {
2091          key: "componentWillUnmount",
2092          value: function componentWillUnmount() {
2093            var _this3 = this;
2094  
2095            Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
2096              with_global_events_listener.remove(eventType, _this3);
2097            });
2098          }
2099        }, {
2100          key: "handleEvent",
2101          value: function handleEvent(event) {
2102            var handler = eventTypesToHandlers[event.type];
2103  
2104            if (typeof this.wrappedRef[handler] === 'function') {
2105              this.wrappedRef[handler](event);
2106            }
2107          }
2108        }, {
2109          key: "handleRef",
2110          value: function handleRef(el) {
2111            this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref`
2112            // will cause `this.props.forwardedRef` to be `null`, so we need this
2113            // check.
2114  
2115            if (this.props.forwardedRef) {
2116              this.props.forwardedRef(el);
2117            }
2118          }
2119        }, {
2120          key: "render",
2121          value: function render() {
2122            return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, {
2123              ref: this.handleRef
2124            }));
2125          }
2126        }]);
2127  
2128        return Wrapper;
2129      }(external_this_wp_element_["Component"]);
2130  
2131      return Object(external_this_wp_element_["forwardRef"])(function (props, ref) {
2132        return Object(external_this_wp_element_["createElement"])(Wrapper, {
2133          ownProps: props,
2134          forwardedRef: ref
2135        });
2136      });
2137    }, 'withGlobalEvents');
2138  }
2139  
2140  /* harmony default export */ var with_global_events = (withGlobalEvents);
2141  
2142  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js
2143  /**
2144   * WordPress dependencies
2145   */
2146  
2147  var instanceMap = new WeakMap();
2148  /**
2149   * Creates a new id for a given object.
2150   *
2151   * @param {Object} object Object reference to create an id for.
2152   */
2153  
2154  function createId(object) {
2155    var instances = instanceMap.get(object) || 0;
2156    instanceMap.set(object, instances + 1);
2157    return instances;
2158  }
2159  /**
2160   * Provides a unique instance ID.
2161   *
2162   * @param {Object} object Object reference to create an id for.
2163   */
2164  
2165  
2166  function useInstanceId(object) {
2167    return Object(external_this_wp_element_["useMemo"])(function () {
2168      return createId(object);
2169    }, [object]);
2170  }
2171  
2172  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js
2173  
2174  
2175  
2176  /**
2177   * Internal dependencies
2178   */
2179  
2180  
2181  /**
2182   * A Higher Order Component used to be provide a unique instance ID by
2183   * component.
2184   *
2185   * @param {WPComponent} WrappedComponent The wrapped component.
2186   *
2187   * @return {WPComponent} Component with an instanceId prop.
2188   */
2189  
2190  /* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) {
2191    return function (props) {
2192      var instanceId = useInstanceId(WrappedComponent);
2193      return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, props, {
2194        instanceId: instanceId
2195      }));
2196    };
2197  }, 'withInstanceId'));
2198  
2199  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js
2200  
2201  
2202  
2203  
2204  
2205  
2206  
2207  
2208  
2209  /**
2210   * External dependencies
2211   */
2212  
2213  /**
2214   * WordPress dependencies
2215   */
2216  
2217  
2218  /**
2219   * Internal dependencies
2220   */
2221  
2222  
2223  /**
2224   * A higher-order component used to provide and manage delayed function calls
2225   * that ought to be bound to a component's lifecycle.
2226   *
2227   * @param {WPComponent} OriginalComponent Component requiring setTimeout
2228   *
2229   * @return {WPComponent} Wrapped component.
2230   */
2231  
2232  var withSafeTimeout = create_higher_order_component(function (OriginalComponent) {
2233    return (
2234      /*#__PURE__*/
2235      function (_Component) {
2236        Object(inherits["a" /* default */])(WrappedComponent, _Component);
2237  
2238        function WrappedComponent() {
2239          var _this;
2240  
2241          Object(classCallCheck["a" /* default */])(this, WrappedComponent);
2242  
2243          _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments));
2244          _this.timeouts = [];
2245          _this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this));
2246          _this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this));
2247          return _this;
2248        }
2249  
2250        Object(createClass["a" /* default */])(WrappedComponent, [{
2251          key: "componentWillUnmount",
2252          value: function componentWillUnmount() {
2253            this.timeouts.forEach(clearTimeout);
2254          }
2255        }, {
2256          key: "setTimeout",
2257          value: function (_setTimeout) {
2258            function setTimeout(_x, _x2) {
2259              return _setTimeout.apply(this, arguments);
2260            }
2261  
2262            setTimeout.toString = function () {
2263              return _setTimeout.toString();
2264            };
2265  
2266            return setTimeout;
2267          }(function (fn, delay) {
2268            var _this2 = this;
2269  
2270            var id = setTimeout(function () {
2271              fn();
2272  
2273              _this2.clearTimeout(id);
2274            }, delay);
2275            this.timeouts.push(id);
2276            return id;
2277          })
2278        }, {
2279          key: "clearTimeout",
2280          value: function (_clearTimeout) {
2281            function clearTimeout(_x3) {
2282              return _clearTimeout.apply(this, arguments);
2283            }
2284  
2285            clearTimeout.toString = function () {
2286              return _clearTimeout.toString();
2287            };
2288  
2289            return clearTimeout;
2290          }(function (id) {
2291            clearTimeout(id);
2292            this.timeouts = Object(external_this_lodash_["without"])(this.timeouts, id);
2293          })
2294        }, {
2295          key: "render",
2296          value: function render() {
2297            return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, {
2298              setTimeout: this.setTimeout,
2299              clearTimeout: this.clearTimeout
2300            }));
2301          }
2302        }]);
2303  
2304        return WrappedComponent;
2305      }(external_this_wp_element_["Component"])
2306    );
2307  }, 'withSafeTimeout');
2308  /* harmony default export */ var with_safe_timeout = (withSafeTimeout);
2309  
2310  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js
2311  
2312  
2313  
2314  
2315  
2316  
2317  
2318  
2319  
2320  /**
2321   * WordPress dependencies
2322   */
2323  
2324  /**
2325   * Internal dependencies
2326   */
2327  
2328  
2329  /**
2330   * A Higher Order Component used to provide and manage internal component state
2331   * via props.
2332   *
2333   * @param {?Object} initialState Optional initial state of the component.
2334   *
2335   * @return {WPComponent} Wrapped component.
2336   */
2337  
2338  function withState() {
2339    var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2340    return create_higher_order_component(function (OriginalComponent) {
2341      return (
2342        /*#__PURE__*/
2343        function (_Component) {
2344          Object(inherits["a" /* default */])(WrappedComponent, _Component);
2345  
2346          function WrappedComponent() {
2347            var _this;
2348  
2349            Object(classCallCheck["a" /* default */])(this, WrappedComponent);
2350  
2351            _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments));
2352            _this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(_this));
2353            _this.state = initialState;
2354            return _this;
2355          }
2356  
2357          Object(createClass["a" /* default */])(WrappedComponent, [{
2358            key: "render",
2359            value: function render() {
2360              return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, {
2361                setState: this.setState
2362              }));
2363            }
2364          }]);
2365  
2366          return WrappedComponent;
2367        }(external_this_wp_element_["Component"])
2368      );
2369    }, 'withState');
2370  }
2371  
2372  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
2373  var slicedToArray = __webpack_require__(20);
2374  
2375  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js
2376  
2377  
2378  /**
2379   * WordPress dependencies
2380   */
2381  
2382  var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external_this_wp_element_["useLayoutEffect"] : external_this_wp_element_["useEffect"];
2383  function useDragging(_ref) {
2384    var onDragStart = _ref.onDragStart,
2385        onDragMove = _ref.onDragMove,
2386        onDragEnd = _ref.onDragEnd;
2387  
2388    var _useState = Object(external_this_wp_element_["useState"])(false),
2389        _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
2390        isDragging = _useState2[0],
2391        setIsDragging = _useState2[1];
2392  
2393    var eventsRef = Object(external_this_wp_element_["useRef"])({
2394      onDragStart: onDragStart,
2395      onDragMove: onDragMove,
2396      onDragEnd: onDragEnd
2397    });
2398    useIsomorphicLayoutEffect(function () {
2399      eventsRef.current.onDragStart = onDragStart;
2400      eventsRef.current.onDragMove = onDragMove;
2401      eventsRef.current.onDragEnd = onDragEnd;
2402    }, [onDragStart, onDragMove, onDragEnd]);
2403    var onMouseMove = Object(external_this_wp_element_["useCallback"])(function () {
2404      var _eventsRef$current;
2405  
2406      return eventsRef.current.onDragMove && (_eventsRef$current = eventsRef.current).onDragMove.apply(_eventsRef$current, arguments);
2407    }, []);
2408    var endDrag = Object(external_this_wp_element_["useCallback"])(function () {
2409      if (eventsRef.current.onDragEnd) {
2410        var _eventsRef$current2;
2411  
2412        (_eventsRef$current2 = eventsRef.current).onDragEnd.apply(_eventsRef$current2, arguments);
2413      }
2414  
2415      document.removeEventListener('mousemove', onMouseMove);
2416      document.removeEventListener('mouseup', endDrag);
2417      setIsDragging(false);
2418    }, []);
2419    var startDrag = Object(external_this_wp_element_["useCallback"])(function () {
2420      if (eventsRef.current.onDragStart) {
2421        var _eventsRef$current3;
2422  
2423        (_eventsRef$current3 = eventsRef.current).onDragStart.apply(_eventsRef$current3, arguments);
2424      }
2425  
2426      document.addEventListener('mousemove', onMouseMove);
2427      document.addEventListener('mouseup', endDrag);
2428      setIsDragging(true);
2429    }, []); // Remove the global events when unmounting if needed.
2430  
2431    Object(external_this_wp_element_["useEffect"])(function () {
2432      return function () {
2433        if (isDragging) {
2434          document.removeEventListener('mousemove', onMouseMove);
2435          document.removeEventListener('mouseup', endDrag);
2436        }
2437      };
2438    }, [isDragging]);
2439    return {
2440      startDrag: startDrag,
2441      endDrag: endDrag,
2442      isDragging: isDragging
2443    };
2444  }
2445  
2446  // EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js
2447  var mousetrap_mousetrap = __webpack_require__(271);
2448  var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap_mousetrap);
2449  
2450  // EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js
2451  var mousetrap_global_bind = __webpack_require__(396);
2452  
2453  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js
2454  /**
2455   * External dependencies
2456   */
2457  
2458  
2459  
2460  /**
2461   * WordPress dependencies
2462   */
2463  
2464  
2465  /**
2466   * A block selection object.
2467   *
2468   * @typedef {Object} WPKeyboardShortcutConfig
2469   *
2470   * @property {boolean} [bindGlobal]  Handle keyboard events anywhere including inside textarea/input fields.
2471   * @property {string}  [eventName]   Event name used to trigger the handler, defaults to keydown.
2472   * @property {boolean} [isDisabled]  Disables the keyboard handler if the value is true.
2473   * @property {Object}  [target]      React reference to the DOM element used to catch the keyboard event.
2474   */
2475  
2476  /**
2477   * Return true if platform is MacOS.
2478   *
2479   * @param {Object} _window   window object by default; used for DI testing.
2480   *
2481   * @return {boolean} True if MacOS; false otherwise.
2482   */
2483  
2484  function isAppleOS() {
2485    var _window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window;
2486  
2487    var platform = _window.navigator.platform;
2488    return platform.indexOf('Mac') !== -1 || Object(external_this_lodash_["includes"])(['iPad', 'iPhone'], platform);
2489  }
2490  /**
2491   * Attach a keyboard shortcut handler.
2492   *
2493   * @param {string[]|string}         shortcuts  Keyboard Shortcuts.
2494   * @param {Function}                callback   Shortcut callback.
2495   * @param {WPKeyboardShortcutConfig} options    Shortcut options.
2496   */
2497  
2498  
2499  function useKeyboardShortcut(shortcuts, callback) {
2500    var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
2501        _ref$bindGlobal = _ref.bindGlobal,
2502        bindGlobal = _ref$bindGlobal === void 0 ? false : _ref$bindGlobal,
2503        _ref$eventName = _ref.eventName,
2504        eventName = _ref$eventName === void 0 ? 'keydown' : _ref$eventName,
2505        _ref$isDisabled = _ref.isDisabled,
2506        isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled,
2507        target = _ref.target;
2508  
2509    Object(external_this_wp_element_["useEffect"])(function () {
2510      if (isDisabled) {
2511        return;
2512      }
2513  
2514      var mousetrap = new mousetrap_default.a(target ? target.current : document);
2515      Object(external_this_lodash_["castArray"])(shortcuts).forEach(function (shortcut) {
2516        var keys = shortcut.split('+'); // Determines whether a key is a modifier by the length of the string.
2517        // E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that
2518        // the modifiers are Shift and Cmd because they're not a single character.
2519  
2520        var modifiers = new Set(keys.filter(function (value) {
2521          return value.length > 1;
2522        }));
2523        var hasAlt = modifiers.has('alt');
2524        var hasShift = modifiers.has('shift'); // This should be better moved to the shortcut registration instead.
2525  
2526        if (isAppleOS() && (modifiers.size === 1 && hasAlt || modifiers.size === 2 && hasAlt && hasShift)) {
2527          throw new Error("Cannot bind ".concat(shortcut, ". Alt and Shift+Alt modifiers are reserved for character input."));
2528        }
2529  
2530        var bindFn = bindGlobal ? 'bindGlobal' : 'bind';
2531        mousetrap[bindFn](shortcut, callback, eventName);
2532      });
2533      return function () {
2534        mousetrap.reset();
2535      };
2536    }, [shortcuts, bindGlobal, eventName, callback, target, isDisabled]);
2537  }
2538  
2539  /* harmony default export */ var use_keyboard_shortcut = (useKeyboardShortcut);
2540  
2541  // EXTERNAL MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js
2542  var use_media_query = __webpack_require__(112);
2543  
2544  // EXTERNAL MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-reduced-motion/index.js
2545  var use_reduced_motion = __webpack_require__(252);
2546  
2547  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-viewport-match/index.js
2548  /**
2549   * WordPress dependencies
2550   */
2551  
2552  /**
2553   * Internal dependencies
2554   */
2555  
2556  
2557  /**
2558   * @typedef {"huge"|"wide"|"large"|"medium"|"small"|"mobile"} WPBreakpoint
2559   */
2560  
2561  /**
2562   * Hash of breakpoint names with pixel width at which it becomes effective.
2563   *
2564   * @see _breakpoints.scss
2565   *
2566   * @type {Object<WPBreakpoint,number>}
2567   */
2568  
2569  var BREAKPOINTS = {
2570    huge: 1440,
2571    wide: 1280,
2572    large: 960,
2573    medium: 782,
2574    small: 600,
2575    mobile: 480
2576  };
2577  /**
2578   * @typedef {">="|"<"} WPViewportOperator
2579   */
2580  
2581  /**
2582   * Object mapping media query operators to the condition to be used.
2583   *
2584   * @type {Object<WPViewportOperator,string>}
2585   */
2586  
2587  var CONDITIONS = {
2588    '>=': 'min-width',
2589    '<': 'max-width'
2590  };
2591  /**
2592   * Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values.
2593   *
2594   * @type {Object<WPViewportOperator,Function>}
2595   */
2596  
2597  var OPERATOR_EVALUATORS = {
2598    '>=': function _(breakpointValue, width) {
2599      return width >= breakpointValue;
2600    },
2601    '<': function _(breakpointValue, width) {
2602      return width < breakpointValue;
2603    }
2604  };
2605  var ViewportMatchWidthContext = Object(external_this_wp_element_["createContext"])(null);
2606  /**
2607   * Returns true if the viewport matches the given query, or false otherwise.
2608   *
2609   * @param {WPBreakpoint}       breakpoint      Breakpoint size name.
2610   * @param {WPViewportOperator} [operator=">="] Viewport operator.
2611   *
2612   * @example
2613   *
2614   * ```js
2615   * useViewportMatch( 'huge', <' );
2616   * useViewportMatch( 'medium' );
2617   * ```
2618   *
2619   * @return {boolean} Whether viewport matches query.
2620   */
2621  
2622  var use_viewport_match_useViewportMatch = function useViewportMatch(breakpoint) {
2623    var operator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '>=';
2624    var simulatedWidth = Object(external_this_wp_element_["useContext"])(ViewportMatchWidthContext);
2625    var mediaQuery = !simulatedWidth && "(".concat(CONDITIONS[operator], ": ").concat(BREAKPOINTS[breakpoint], "px)");
2626    var mediaQueryResult = Object(use_media_query["a" /* default */])(mediaQuery);
2627  
2628    if (simulatedWidth) {
2629      return OPERATOR_EVALUATORS[operator](BREAKPOINTS[breakpoint], simulatedWidth);
2630    }
2631  
2632    return mediaQueryResult;
2633  };
2634  
2635  use_viewport_match_useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider;
2636  /* harmony default export */ var use_viewport_match = (use_viewport_match_useViewportMatch);
2637  
2638  // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js
2639  /* concated harmony reexport createHigherOrderComponent */__webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return create_higher_order_component; });
2640  /* concated harmony reexport compose */__webpack_require__.d(__webpack_exports__, "compose", function() { return compose; });
2641  /* concated harmony reexport ifCondition */__webpack_require__.d(__webpack_exports__, "ifCondition", function() { return if_condition; });
2642  /* concated harmony reexport pure */__webpack_require__.d(__webpack_exports__, "pure", function() { return higher_order_pure; });
2643  /* concated harmony reexport withGlobalEvents */__webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return with_global_events; });
2644  /* concated harmony reexport withInstanceId */__webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return with_instance_id; });
2645  /* concated harmony reexport withSafeTimeout */__webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return with_safe_timeout; });
2646  /* concated harmony reexport withState */__webpack_require__.d(__webpack_exports__, "withState", function() { return withState; });
2647  /* concated harmony reexport __experimentalUseDragging */__webpack_require__.d(__webpack_exports__, "__experimentalUseDragging", function() { return useDragging; });
2648  /* concated harmony reexport useInstanceId */__webpack_require__.d(__webpack_exports__, "useInstanceId", function() { return useInstanceId; });
2649  /* concated harmony reexport useKeyboardShortcut */__webpack_require__.d(__webpack_exports__, "useKeyboardShortcut", function() { return use_keyboard_shortcut; });
2650  /* concated harmony reexport useMediaQuery */__webpack_require__.d(__webpack_exports__, "useMediaQuery", function() { return use_media_query["a" /* default */]; });
2651  /* concated harmony reexport useReducedMotion */__webpack_require__.d(__webpack_exports__, "useReducedMotion", function() { return use_reduced_motion["a" /* default */]; });
2652  /* concated harmony reexport useViewportMatch */__webpack_require__.d(__webpack_exports__, "useViewportMatch", function() { return use_viewport_match; });
2653  // Utils
2654   // Compose helper (aliased flowRight from Lodash)
2655  
2656   // Higher-order components
2657  
2658  
2659  
2660  
2661  
2662  
2663   // Hooks
2664  
2665  
2666  
2667  
2668  
2669  
2670  
2671  
2672  
2673  /***/ }),
2674  
2675  /***/ 51:
2676  /***/ (function(module, exports) {
2677  
2678  (function() { module.exports = this["wp"]["isShallowEqual"]; }());
2679  
2680  /***/ }),
2681  
2682  /***/ 7:
2683  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2684  
2685  "use strict";
2686  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
2687  function _assertThisInitialized(self) {
2688    if (self === void 0) {
2689      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
2690    }
2691  
2692    return self;
2693  }
2694  
2695  /***/ })
2696  
2697  /******/ });