{"version":3,"file":"./build/compose/index.min.js","mappings":"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","sources":["webpack://wp/./node_modules/clipboard/dist/clipboard.js","webpack://wp/./node_modules/mousetrap/mousetrap.js","webpack://wp/./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js","webpack://wp/./node_modules/react-resize-aware/src/ResizeListener.js","webpack://wp/./node_modules/react-resize-aware/src/useOnResize.js","webpack://wp/./node_modules/react-resize-aware/src/useResizeAware.js","webpack://wp/external window \"React\"","webpack://wp/webpack/bootstrap","webpack://wp/webpack/runtime/compat get default export","webpack://wp/webpack/runtime/define property getters","webpack://wp/webpack/runtime/hasOwnProperty shorthand","webpack://wp/webpack/runtime/make namespace object","webpack://wp/external window \"lodash\"","webpack://wp/./packages/compose/build-module/utils/create-higher-order-component/@wordpress/compose/src/utils/create-higher-order-component/index.ts","webpack://wp/./packages/compose/build-module/higher-order/@wordpress/compose/src/higher-order/compose.ts","webpack://wp/external window [\"wp\",\"element\"]","webpack://wp/./packages/compose/build-module/higher-order/if-condition/@wordpress/compose/src/higher-order/if-condition/index.tsx","webpack://wp/external window [\"wp\",\"isShallowEqual\"]","webpack://wp/./packages/compose/build-module/higher-order/pure/@wordpress/compose/src/higher-order/pure/index.tsx","webpack://wp/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://wp/external window [\"wp\",\"deprecated\"]","webpack://wp/./packages/compose/build-module/higher-order/with-global-events/@wordpress/compose/src/higher-order/with-global-events/index.js","webpack://wp/./packages/compose/build-module/higher-order/with-global-events/@wordpress/compose/src/higher-order/with-global-events/listener.js","webpack://wp/./packages/compose/build-module/hooks/use-instance-id/@wordpress/compose/src/hooks/use-instance-id/index.js","webpack://wp/./packages/compose/build-module/higher-order/with-instance-id/@wordpress/compose/src/higher-order/with-instance-id/index.tsx","webpack://wp/./packages/compose/build-module/higher-order/with-safe-timeout/@wordpress/compose/src/higher-order/with-safe-timeout/index.tsx","webpack://wp/./packages/compose/build-module/higher-order/with-state/@wordpress/compose/src/higher-order/with-state/index.js","webpack://wp/external window [\"wp\",\"keycodes\"]","webpack://wp/external window [\"wp\",\"dom\"]","webpack://wp/./packages/compose/build-module/hooks/use-ref-effect/@wordpress/compose/src/hooks/use-ref-effect/index.ts","webpack://wp/./packages/compose/build-module/hooks/use-constrained-tabbing/@wordpress/compose/src/hooks/use-constrained-tabbing/index.js","webpack://wp/./packages/compose/build-module/hooks/use-copy-on-click/@wordpress/compose/src/hooks/use-copy-on-click/index.js","webpack://wp/./packages/compose/build-module/hooks/use-copy-to-clipboard/@wordpress/compose/src/hooks/use-copy-to-clipboard/index.js","webpack://wp/./packages/compose/build-module/hooks/use-focus-on-mount/@wordpress/compose/src/hooks/use-focus-on-mount/index.js","webpack://wp/./packages/compose/build-module/hooks/use-focus-return/@wordpress/compose/src/hooks/use-focus-return/index.js","webpack://wp/./packages/compose/build-module/hooks/use-focus-outside/@wordpress/compose/src/hooks/use-focus-outside/index.js","webpack://wp/./packages/compose/build-module/hooks/use-merge-refs/@wordpress/compose/src/hooks/use-merge-refs/index.js","webpack://wp/./packages/compose/build-module/hooks/use-dialog/@wordpress/compose/src/hooks/use-dialog/index.js","webpack://wp/./packages/compose/build-module/hooks/use-disabled/@wordpress/compose/src/hooks/use-disabled/index.js","webpack://wp/./packages/compose/build-module/hooks/use-isomorphic-layout-effect/@wordpress/compose/src/hooks/use-isomorphic-layout-effect/index.js","webpack://wp/./packages/compose/build-module/hooks/use-dragging/@wordpress/compose/src/hooks/use-dragging/index.js","webpack://wp/./packages/compose/build-module/hooks/use-keyboard-shortcut/@wordpress/compose/src/hooks/use-keyboard-shortcut/index.js","webpack://wp/./packages/compose/build-module/hooks/use-media-query/@wordpress/compose/src/hooks/use-media-query/index.js","webpack://wp/./packages/compose/build-module/hooks/use-previous/@wordpress/compose/src/hooks/use-previous/index.ts","webpack://wp/./packages/compose/build-module/hooks/use-reduced-motion/@wordpress/compose/src/hooks/use-reduced-motion/index.js","webpack://wp/./packages/compose/build-module/hooks/use-viewport-match/@wordpress/compose/src/hooks/use-viewport-match/index.js","webpack://wp/./packages/compose/build-module/hooks/use-resize-observer/@wordpress/compose/src/hooks/use-resize-observer/index.js","webpack://wp/external window [\"wp\",\"priorityQueue\"]","webpack://wp/./packages/compose/build-module/hooks/use-async-list/@wordpress/compose/src/hooks/use-async-list/index.ts","webpack://wp/./packages/compose/build-module/hooks/use-warn-on-change/@wordpress/compose/src/hooks/use-warn-on-change/index.js","webpack://wp/./node_modules/use-memo-one/dist/use-memo-one.esm.js","webpack://wp/./packages/compose/build-module/hooks/use-debounce/@wordpress/compose/src/hooks/use-debounce/index.js","webpack://wp/./packages/compose/build-module/hooks/use-throttle/@wordpress/compose/src/hooks/use-throttle/index.js","webpack://wp/./packages/compose/build-module/hooks/use-drop-zone/@wordpress/compose/src/hooks/use-drop-zone/index.js","webpack://wp/./packages/compose/build-module/hooks/use-focusable-iframe/@wordpress/compose/src/hooks/use-focusable-iframe/index.js","webpack://wp/./packages/compose/build-module/hooks/use-fixed-window-list/@wordpress/compose/src/hooks/use-fixed-window-list/index.js"],"sourcesContent":["/*!\n * clipboard.js v2.0.8\n * https://clipboardjs.com/\n *\n * Licensed MIT © Zeno Rocha\n */\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ClipboardJS\"] = factory();\n\telse\n\t\troot[\"ClipboardJS\"] = factory();\n})(this, function() {\nreturn /******/ (function() { // webpackBootstrap\n/******/ \tvar __webpack_modules__ = ({\n\n/***/ 134:\n/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n\n// EXPORTS\n__webpack_require__.d(__webpack_exports__, {\n  \"default\": function() { return /* binding */ clipboard; }\n});\n\n// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js\nvar tiny_emitter = __webpack_require__(279);\nvar tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);\n// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js\nvar listen = __webpack_require__(370);\nvar listen_default = /*#__PURE__*/__webpack_require__.n(listen);\n// EXTERNAL MODULE: ./node_modules/select/src/select.js\nvar src_select = __webpack_require__(817);\nvar select_default = /*#__PURE__*/__webpack_require__.n(src_select);\n;// CONCATENATED MODULE: ./src/clipboard-action.js\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n\n/**\n * Inner class which performs selection from either `text` or `target`\n * properties and then executes copy or cut operations.\n */\n\nvar ClipboardAction = /*#__PURE__*/function () {\n  /**\n   * @param {Object} options\n   */\n  function ClipboardAction(options) {\n    _classCallCheck(this, ClipboardAction);\n\n    this.resolveOptions(options);\n    this.initSelection();\n  }\n  /**\n   * Defines base properties passed from constructor.\n   * @param {Object} options\n   */\n\n\n  _createClass(ClipboardAction, [{\n    key: \"resolveOptions\",\n    value: function resolveOptions() {\n      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      this.action = options.action;\n      this.container = options.container;\n      this.emitter = options.emitter;\n      this.target = options.target;\n      this.text = options.text;\n      this.trigger = options.trigger;\n      this.selectedText = '';\n    }\n    /**\n     * Decides which selection strategy is going to be applied based\n     * on the existence of `text` and `target` properties.\n     */\n\n  }, {\n    key: \"initSelection\",\n    value: function initSelection() {\n      if (this.text) {\n        this.selectFake();\n      } else if (this.target) {\n        this.selectTarget();\n      }\n    }\n    /**\n     * Creates a fake textarea element, sets its value from `text` property,\n     */\n\n  }, {\n    key: \"createFakeElement\",\n    value: function createFakeElement() {\n      var isRTL = document.documentElement.getAttribute('dir') === 'rtl';\n      this.fakeElem = document.createElement('textarea'); // Prevent zooming on iOS\n\n      this.fakeElem.style.fontSize = '12pt'; // Reset box model\n\n      this.fakeElem.style.border = '0';\n      this.fakeElem.style.padding = '0';\n      this.fakeElem.style.margin = '0'; // Move element out of screen horizontally\n\n      this.fakeElem.style.position = 'absolute';\n      this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically\n\n      var yPosition = window.pageYOffset || document.documentElement.scrollTop;\n      this.fakeElem.style.top = \"\".concat(yPosition, \"px\");\n      this.fakeElem.setAttribute('readonly', '');\n      this.fakeElem.value = this.text;\n      return this.fakeElem;\n    }\n    /**\n     * Get's the value of fakeElem,\n     * and makes a selection on it.\n     */\n\n  }, {\n    key: \"selectFake\",\n    value: function selectFake() {\n      var _this = this;\n\n      var fakeElem = this.createFakeElement();\n\n      this.fakeHandlerCallback = function () {\n        return _this.removeFake();\n      };\n\n      this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;\n      this.container.appendChild(fakeElem);\n      this.selectedText = select_default()(fakeElem);\n      this.copyText();\n      this.removeFake();\n    }\n    /**\n     * Only removes the fake element after another click event, that way\n     * a user can hit `Ctrl+C` to copy because selection still exists.\n     */\n\n  }, {\n    key: \"removeFake\",\n    value: function removeFake() {\n      if (this.fakeHandler) {\n        this.container.removeEventListener('click', this.fakeHandlerCallback);\n        this.fakeHandler = null;\n        this.fakeHandlerCallback = null;\n      }\n\n      if (this.fakeElem) {\n        this.container.removeChild(this.fakeElem);\n        this.fakeElem = null;\n      }\n    }\n    /**\n     * Selects the content from element passed on `target` property.\n     */\n\n  }, {\n    key: \"selectTarget\",\n    value: function selectTarget() {\n      this.selectedText = select_default()(this.target);\n      this.copyText();\n    }\n    /**\n     * Executes the copy operation based on the current selection.\n     */\n\n  }, {\n    key: \"copyText\",\n    value: function copyText() {\n      var succeeded;\n\n      try {\n        succeeded = document.execCommand(this.action);\n      } catch (err) {\n        succeeded = false;\n      }\n\n      this.handleResult(succeeded);\n    }\n    /**\n     * Fires an event based on the copy operation result.\n     * @param {Boolean} succeeded\n     */\n\n  }, {\n    key: \"handleResult\",\n    value: function handleResult(succeeded) {\n      this.emitter.emit(succeeded ? 'success' : 'error', {\n        action: this.action,\n        text: this.selectedText,\n        trigger: this.trigger,\n        clearSelection: this.clearSelection.bind(this)\n      });\n    }\n    /**\n     * Moves focus away from `target` and back to the trigger, removes current selection.\n     */\n\n  }, {\n    key: \"clearSelection\",\n    value: function clearSelection() {\n      if (this.trigger) {\n        this.trigger.focus();\n      }\n\n      document.activeElement.blur();\n      window.getSelection().removeAllRanges();\n    }\n    /**\n     * Sets the `action` to be performed which can be either 'copy' or 'cut'.\n     * @param {String} action\n     */\n\n  }, {\n    key: \"destroy\",\n\n    /**\n     * Destroy lifecycle.\n     */\n    value: function destroy() {\n      this.removeFake();\n    }\n  }, {\n    key: \"action\",\n    set: function set() {\n      var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';\n      this._action = action;\n\n      if (this._action !== 'copy' && this._action !== 'cut') {\n        throw new Error('Invalid \"action\" value, use either \"copy\" or \"cut\"');\n      }\n    }\n    /**\n     * Gets the `action` property.\n     * @return {String}\n     */\n    ,\n    get: function get() {\n      return this._action;\n    }\n    /**\n     * Sets the `target` property using an element\n     * that will be have its content copied.\n     * @param {Element} target\n     */\n\n  }, {\n    key: \"target\",\n    set: function set(target) {\n      if (target !== undefined) {\n        if (target && _typeof(target) === 'object' && target.nodeType === 1) {\n          if (this.action === 'copy' && target.hasAttribute('disabled')) {\n            throw new Error('Invalid \"target\" attribute. Please use \"readonly\" instead of \"disabled\" attribute');\n          }\n\n          if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {\n            throw new Error('Invalid \"target\" attribute. You can\\'t cut text from elements with \"readonly\" or \"disabled\" attributes');\n          }\n\n          this._target = target;\n        } else {\n          throw new Error('Invalid \"target\" value, use a valid Element');\n        }\n      }\n    }\n    /**\n     * Gets the `target` property.\n     * @return {String|HTMLElement}\n     */\n    ,\n    get: function get() {\n      return this._target;\n    }\n  }]);\n\n  return ClipboardAction;\n}();\n\n/* harmony default export */ var clipboard_action = (ClipboardAction);\n;// CONCATENATED MODULE: ./src/clipboard.js\nfunction clipboard_typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { clipboard_typeof = function _typeof(obj) { return typeof obj; }; } else { clipboard_typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return clipboard_typeof(obj); }\n\nfunction clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction clipboard_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction clipboard_createClass(Constructor, protoProps, staticProps) { if (protoProps) clipboard_defineProperties(Constructor.prototype, protoProps); if (staticProps) clipboard_defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n\n\n\n/**\n * Helper function to retrieve attribute value.\n * @param {String} suffix\n * @param {Element} element\n */\n\nfunction getAttributeValue(suffix, element) {\n  var attribute = \"data-clipboard-\".concat(suffix);\n\n  if (!element.hasAttribute(attribute)) {\n    return;\n  }\n\n  return element.getAttribute(attribute);\n}\n/**\n * Base class which takes one or more elements, adds event listeners to them,\n * and instantiates a new `ClipboardAction` on each click.\n */\n\n\nvar Clipboard = /*#__PURE__*/function (_Emitter) {\n  _inherits(Clipboard, _Emitter);\n\n  var _super = _createSuper(Clipboard);\n\n  /**\n   * @param {String|HTMLElement|HTMLCollection|NodeList} trigger\n   * @param {Object} options\n   */\n  function Clipboard(trigger, options) {\n    var _this;\n\n    clipboard_classCallCheck(this, Clipboard);\n\n    _this = _super.call(this);\n\n    _this.resolveOptions(options);\n\n    _this.listenClick(trigger);\n\n    return _this;\n  }\n  /**\n   * Defines if attributes would be resolved using internal setter functions\n   * or custom functions that were passed in the constructor.\n   * @param {Object} options\n   */\n\n\n  clipboard_createClass(Clipboard, [{\n    key: \"resolveOptions\",\n    value: function resolveOptions() {\n      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      this.action = typeof options.action === 'function' ? options.action : this.defaultAction;\n      this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;\n      this.text = typeof options.text === 'function' ? options.text : this.defaultText;\n      this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;\n    }\n    /**\n     * Adds a click event listener to the passed trigger.\n     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger\n     */\n\n  }, {\n    key: \"listenClick\",\n    value: function listenClick(trigger) {\n      var _this2 = this;\n\n      this.listener = listen_default()(trigger, 'click', function (e) {\n        return _this2.onClick(e);\n      });\n    }\n    /**\n     * Defines a new `ClipboardAction` on each click event.\n     * @param {Event} e\n     */\n\n  }, {\n    key: \"onClick\",\n    value: function onClick(e) {\n      var trigger = e.delegateTarget || e.currentTarget;\n\n      if (this.clipboardAction) {\n        this.clipboardAction = null;\n      }\n\n      this.clipboardAction = new clipboard_action({\n        action: this.action(trigger),\n        target: this.target(trigger),\n        text: this.text(trigger),\n        container: this.container,\n        trigger: trigger,\n        emitter: this\n      });\n    }\n    /**\n     * Default `action` lookup function.\n     * @param {Element} trigger\n     */\n\n  }, {\n    key: \"defaultAction\",\n    value: function defaultAction(trigger) {\n      return getAttributeValue('action', trigger);\n    }\n    /**\n     * Default `target` lookup function.\n     * @param {Element} trigger\n     */\n\n  }, {\n    key: \"defaultTarget\",\n    value: function defaultTarget(trigger) {\n      var selector = getAttributeValue('target', trigger);\n\n      if (selector) {\n        return document.querySelector(selector);\n      }\n    }\n    /**\n     * Returns the support of the given action, or all actions if no action is\n     * given.\n     * @param {String} [action]\n     */\n\n  }, {\n    key: \"defaultText\",\n\n    /**\n     * Default `text` lookup function.\n     * @param {Element} trigger\n     */\n    value: function defaultText(trigger) {\n      return getAttributeValue('text', trigger);\n    }\n    /**\n     * Destroy lifecycle.\n     */\n\n  }, {\n    key: \"destroy\",\n    value: function destroy() {\n      this.listener.destroy();\n\n      if (this.clipboardAction) {\n        this.clipboardAction.destroy();\n        this.clipboardAction = null;\n      }\n    }\n  }], [{\n    key: \"isSupported\",\n    value: function isSupported() {\n      var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];\n      var actions = typeof action === 'string' ? [action] : action;\n      var support = !!document.queryCommandSupported;\n      actions.forEach(function (action) {\n        support = support && !!document.queryCommandSupported(action);\n      });\n      return support;\n    }\n  }]);\n\n  return Clipboard;\n}((tiny_emitter_default()));\n\n/* harmony default export */ var clipboard = (Clipboard);\n\n/***/ }),\n\n/***/ 828:\n/***/ (function(module) {\n\nvar DOCUMENT_NODE_TYPE = 9;\n\n/**\n * A polyfill for Element.matches()\n */\nif (typeof Element !== 'undefined' && !Element.prototype.matches) {\n    var proto = Element.prototype;\n\n    proto.matches = proto.matchesSelector ||\n                    proto.mozMatchesSelector ||\n                    proto.msMatchesSelector ||\n                    proto.oMatchesSelector ||\n                    proto.webkitMatchesSelector;\n}\n\n/**\n * Finds the closest parent that matches a selector.\n *\n * @param {Element} element\n * @param {String} selector\n * @return {Function}\n */\nfunction closest (element, selector) {\n    while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {\n        if (typeof element.matches === 'function' &&\n            element.matches(selector)) {\n          return element;\n        }\n        element = element.parentNode;\n    }\n}\n\nmodule.exports = closest;\n\n\n/***/ }),\n\n/***/ 438:\n/***/ (function(module, __unused_webpack_exports, __webpack_require__) {\n\nvar closest = __webpack_require__(828);\n\n/**\n * Delegates event to a selector.\n *\n * @param {Element} element\n * @param {String} selector\n * @param {String} type\n * @param {Function} callback\n * @param {Boolean} useCapture\n * @return {Object}\n */\nfunction _delegate(element, selector, type, callback, useCapture) {\n    var listenerFn = listener.apply(this, arguments);\n\n    element.addEventListener(type, listenerFn, useCapture);\n\n    return {\n        destroy: function() {\n            element.removeEventListener(type, listenerFn, useCapture);\n        }\n    }\n}\n\n/**\n * Delegates event to a selector.\n *\n * @param {Element|String|Array} [elements]\n * @param {String} selector\n * @param {String} type\n * @param {Function} callback\n * @param {Boolean} useCapture\n * @return {Object}\n */\nfunction delegate(elements, selector, type, callback, useCapture) {\n    // Handle the regular Element usage\n    if (typeof elements.addEventListener === 'function') {\n        return _delegate.apply(null, arguments);\n    }\n\n    // Handle Element-less usage, it defaults to global delegation\n    if (typeof type === 'function') {\n        // Use `document` as the first parameter, then apply arguments\n        // This is a short way to .unshift `arguments` without running into deoptimizations\n        return _delegate.bind(null, document).apply(null, arguments);\n    }\n\n    // Handle Selector-based usage\n    if (typeof elements === 'string') {\n        elements = document.querySelectorAll(elements);\n    }\n\n    // Handle Array-like based usage\n    return Array.prototype.map.call(elements, function (element) {\n        return _delegate(element, selector, type, callback, useCapture);\n    });\n}\n\n/**\n * Finds closest match and invokes callback.\n *\n * @param {Element} element\n * @param {String} selector\n * @param {String} type\n * @param {Function} callback\n * @return {Function}\n */\nfunction listener(element, selector, type, callback) {\n    return function(e) {\n        e.delegateTarget = closest(e.target, selector);\n\n        if (e.delegateTarget) {\n            callback.call(element, e);\n        }\n    }\n}\n\nmodule.exports = delegate;\n\n\n/***/ }),\n\n/***/ 879:\n/***/ (function(__unused_webpack_module, exports) {\n\n/**\n * Check if argument is a HTML element.\n *\n * @param {Object} value\n * @return {Boolean}\n */\nexports.node = function(value) {\n    return value !== undefined\n        && value instanceof HTMLElement\n        && value.nodeType === 1;\n};\n\n/**\n * Check if argument is a list of HTML elements.\n *\n * @param {Object} value\n * @return {Boolean}\n */\nexports.nodeList = function(value) {\n    var type = Object.prototype.toString.call(value);\n\n    return value !== undefined\n        && (type === '[object NodeList]' || type === '[object HTMLCollection]')\n        && ('length' in value)\n        && (value.length === 0 || exports.node(value[0]));\n};\n\n/**\n * Check if argument is a string.\n *\n * @param {Object} value\n * @return {Boolean}\n */\nexports.string = function(value) {\n    return typeof value === 'string'\n        || value instanceof String;\n};\n\n/**\n * Check if argument is a function.\n *\n * @param {Object} value\n * @return {Boolean}\n */\nexports.fn = function(value) {\n    var type = Object.prototype.toString.call(value);\n\n    return type === '[object Function]';\n};\n\n\n/***/ }),\n\n/***/ 370:\n/***/ (function(module, __unused_webpack_exports, __webpack_require__) {\n\nvar is = __webpack_require__(879);\nvar delegate = __webpack_require__(438);\n\n/**\n * Validates all params and calls the right\n * listener function based on its target type.\n *\n * @param {String|HTMLElement|HTMLCollection|NodeList} target\n * @param {String} type\n * @param {Function} callback\n * @return {Object}\n */\nfunction listen(target, type, callback) {\n    if (!target && !type && !callback) {\n        throw new Error('Missing required arguments');\n    }\n\n    if (!is.string(type)) {\n        throw new TypeError('Second argument must be a String');\n    }\n\n    if (!is.fn(callback)) {\n        throw new TypeError('Third argument must be a Function');\n    }\n\n    if (is.node(target)) {\n        return listenNode(target, type, callback);\n    }\n    else if (is.nodeList(target)) {\n        return listenNodeList(target, type, callback);\n    }\n    else if (is.string(target)) {\n        return listenSelector(target, type, callback);\n    }\n    else {\n        throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');\n    }\n}\n\n/**\n * Adds an event listener to a HTML element\n * and returns a remove listener function.\n *\n * @param {HTMLElement} node\n * @param {String} type\n * @param {Function} callback\n * @return {Object}\n */\nfunction listenNode(node, type, callback) {\n    node.addEventListener(type, callback);\n\n    return {\n        destroy: function() {\n            node.removeEventListener(type, callback);\n        }\n    }\n}\n\n/**\n * Add an event listener to a list of HTML elements\n * and returns a remove listener function.\n *\n * @param {NodeList|HTMLCollection} nodeList\n * @param {String} type\n * @param {Function} callback\n * @return {Object}\n */\nfunction listenNodeList(nodeList, type, callback) {\n    Array.prototype.forEach.call(nodeList, function(node) {\n        node.addEventListener(type, callback);\n    });\n\n    return {\n        destroy: function() {\n            Array.prototype.forEach.call(nodeList, function(node) {\n                node.removeEventListener(type, callback);\n            });\n        }\n    }\n}\n\n/**\n * Add an event listener to a selector\n * and returns a remove listener function.\n *\n * @param {String} selector\n * @param {String} type\n * @param {Function} callback\n * @return {Object}\n */\nfunction listenSelector(selector, type, callback) {\n    return delegate(document.body, selector, type, callback);\n}\n\nmodule.exports = listen;\n\n\n/***/ }),\n\n/***/ 817:\n/***/ (function(module) {\n\nfunction select(element) {\n    var selectedText;\n\n    if (element.nodeName === 'SELECT') {\n        element.focus();\n\n        selectedText = element.value;\n    }\n    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {\n        var isReadOnly = element.hasAttribute('readonly');\n\n        if (!isReadOnly) {\n            element.setAttribute('readonly', '');\n        }\n\n        element.select();\n        element.setSelectionRange(0, element.value.length);\n\n        if (!isReadOnly) {\n            element.removeAttribute('readonly');\n        }\n\n        selectedText = element.value;\n    }\n    else {\n        if (element.hasAttribute('contenteditable')) {\n            element.focus();\n        }\n\n        var selection = window.getSelection();\n        var range = document.createRange();\n\n        range.selectNodeContents(element);\n        selection.removeAllRanges();\n        selection.addRange(range);\n\n        selectedText = selection.toString();\n    }\n\n    return selectedText;\n}\n\nmodule.exports = select;\n\n\n/***/ }),\n\n/***/ 279:\n/***/ (function(module) {\n\nfunction E () {\n  // Keep this empty so it's easier to inherit from\n  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)\n}\n\nE.prototype = {\n  on: function (name, callback, ctx) {\n    var e = this.e || (this.e = {});\n\n    (e[name] || (e[name] = [])).push({\n      fn: callback,\n      ctx: ctx\n    });\n\n    return this;\n  },\n\n  once: function (name, callback, ctx) {\n    var self = this;\n    function listener () {\n      self.off(name, listener);\n      callback.apply(ctx, arguments);\n    };\n\n    listener._ = callback\n    return this.on(name, listener, ctx);\n  },\n\n  emit: function (name) {\n    var data = [].slice.call(arguments, 1);\n    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();\n    var i = 0;\n    var len = evtArr.length;\n\n    for (i; i < len; i++) {\n      evtArr[i].fn.apply(evtArr[i].ctx, data);\n    }\n\n    return this;\n  },\n\n  off: function (name, callback) {\n    var e = this.e || (this.e = {});\n    var evts = e[name];\n    var liveEvents = [];\n\n    if (evts && callback) {\n      for (var i = 0, len = evts.length; i < len; i++) {\n        if (evts[i].fn !== callback && evts[i].fn._ !== callback)\n          liveEvents.push(evts[i]);\n      }\n    }\n\n    // Remove event from queue to prevent memory leak\n    // Suggested by https://github.com/lazd\n    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910\n\n    (liveEvents.length)\n      ? e[name] = liveEvents\n      : delete e[name];\n\n    return this;\n  }\n};\n\nmodule.exports = E;\nmodule.exports.TinyEmitter = E;\n\n\n/***/ })\n\n/******/ \t});\n/************************************************************************/\n/******/ \t// The module cache\n/******/ \tvar __webpack_module_cache__ = {};\n/******/ \t\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(__webpack_module_cache__[moduleId]) {\n/******/ \t\t\treturn __webpack_module_cache__[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = __webpack_module_cache__[moduleId] = {\n/******/ \t\t\t// no module.id needed\n/******/ \t\t\t// no module.loaded needed\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/ \t\n/******/ \t\t// Execute the module function\n/******/ \t\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n/******/ \t\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/ \t\n/************************************************************************/\n/******/ \t/* webpack/runtime/compat get default export */\n/******/ \t!function() {\n/******/ \t\t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t\t__webpack_require__.n = function(module) {\n/******/ \t\t\tvar getter = module && module.__esModule ?\n/******/ \t\t\t\tfunction() { return module['default']; } :\n/******/ \t\t\t\tfunction() { return module; };\n/******/ \t\t\t__webpack_require__.d(getter, { a: getter });\n/******/ \t\t\treturn getter;\n/******/ \t\t};\n/******/ \t}();\n/******/ \t\n/******/ \t/* webpack/runtime/define property getters */\n/******/ \t!function() {\n/******/ \t\t// define getter functions for harmony exports\n/******/ \t\t__webpack_require__.d = function(exports, definition) {\n/******/ \t\t\tfor(var key in definition) {\n/******/ \t\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n/******/ \t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n/******/ \t\t\t\t}\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t}();\n/******/ \t\n/******/ \t/* webpack/runtime/hasOwnProperty shorthand */\n/******/ \t!function() {\n/******/ \t\t__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }\n/******/ \t}();\n/******/ \t\n/************************************************************************/\n/******/ \t// module exports must be returned from runtime so entry inlining is disabled\n/******/ \t// startup\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(134);\n/******/ })()\n.default;\n});","/*global define:false */\n/**\n * Copyright 2012-2017 Craig Campbell\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * Mousetrap is a simple keyboard shortcut library for Javascript with\n * no external dependencies\n *\n * @version 1.6.5\n * @url craig.is/killing/mice\n */\n(function(window, document, undefined) {\n\n    // Check if mousetrap is used inside browser, if not, return\n    if (!window) {\n        return;\n    }\n\n    /**\n     * mapping of special keycodes to their corresponding keys\n     *\n     * everything in this dictionary cannot use keypress events\n     * so it has to be here to map to the correct keycodes for\n     * keyup/keydown events\n     *\n     * @type {Object}\n     */\n    var _MAP = {\n        8: 'backspace',\n        9: 'tab',\n        13: 'enter',\n        16: 'shift',\n        17: 'ctrl',\n        18: 'alt',\n        20: 'capslock',\n        27: 'esc',\n        32: 'space',\n        33: 'pageup',\n        34: 'pagedown',\n        35: 'end',\n        36: 'home',\n        37: 'left',\n        38: 'up',\n        39: 'right',\n        40: 'down',\n        45: 'ins',\n        46: 'del',\n        91: 'meta',\n        93: 'meta',\n        224: 'meta'\n    };\n\n    /**\n     * mapping for special characters so they can support\n     *\n     * this dictionary is only used incase you want to bind a\n     * keyup or keydown event to one of these keys\n     *\n     * @type {Object}\n     */\n    var _KEYCODE_MAP = {\n        106: '*',\n        107: '+',\n        109: '-',\n        110: '.',\n        111 : '/',\n        186: ';',\n        187: '=',\n        188: ',',\n        189: '-',\n        190: '.',\n        191: '/',\n        192: '`',\n        219: '[',\n        220: '\\\\',\n        221: ']',\n        222: '\\''\n    };\n\n    /**\n     * this is a mapping of keys that require shift on a US keypad\n     * back to the non shift equivelents\n     *\n     * this is so you can use keyup events with these keys\n     *\n     * note that this will only work reliably on US keyboards\n     *\n     * @type {Object}\n     */\n    var _SHIFT_MAP = {\n        '~': '`',\n        '!': '1',\n        '@': '2',\n        '#': '3',\n        '$': '4',\n        '%': '5',\n        '^': '6',\n        '&': '7',\n        '*': '8',\n        '(': '9',\n        ')': '0',\n        '_': '-',\n        '+': '=',\n        ':': ';',\n        '\\\"': '\\'',\n        '<': ',',\n        '>': '.',\n        '?': '/',\n        '|': '\\\\'\n    };\n\n    /**\n     * this is a list of special strings you can use to map\n     * to modifier keys when you specify your keyboard shortcuts\n     *\n     * @type {Object}\n     */\n    var _SPECIAL_ALIASES = {\n        'option': 'alt',\n        'command': 'meta',\n        'return': 'enter',\n        'escape': 'esc',\n        'plus': '+',\n        'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'\n    };\n\n    /**\n     * variable to store the flipped version of _MAP from above\n     * needed to check if we should use keypress or not when no action\n     * is specified\n     *\n     * @type {Object|undefined}\n     */\n    var _REVERSE_MAP;\n\n    /**\n     * loop through the f keys, f1 to f19 and add them to the map\n     * programatically\n     */\n    for (var i = 1; i < 20; ++i) {\n        _MAP[111 + i] = 'f' + i;\n    }\n\n    /**\n     * loop through to map numbers on the numeric keypad\n     */\n    for (i = 0; i <= 9; ++i) {\n\n        // This needs to use a string cause otherwise since 0 is falsey\n        // mousetrap will never fire for numpad 0 pressed as part of a keydown\n        // event.\n        //\n        // @see https://github.com/ccampbell/mousetrap/pull/258\n        _MAP[i + 96] = i.toString();\n    }\n\n    /**\n     * cross browser add event method\n     *\n     * @param {Element|HTMLDocument} object\n     * @param {string} type\n     * @param {Function} callback\n     * @returns void\n     */\n    function _addEvent(object, type, callback) {\n        if (object.addEventListener) {\n            object.addEventListener(type, callback, false);\n            return;\n        }\n\n        object.attachEvent('on' + type, callback);\n    }\n\n    /**\n     * takes the event and returns the key character\n     *\n     * @param {Event} e\n     * @return {string}\n     */\n    function _characterFromEvent(e) {\n\n        // for keypress events we should return the character as is\n        if (e.type == 'keypress') {\n            var character = String.fromCharCode(e.which);\n\n            // if the shift key is not pressed then it is safe to assume\n            // that we want the character to be lowercase.  this means if\n            // you accidentally have caps lock on then your key bindings\n            // will continue to work\n            //\n            // the only side effect that might not be desired is if you\n            // bind something like 'A' cause you want to trigger an\n            // event when capital A is pressed caps lock will no longer\n            // trigger the event.  shift+a will though.\n            if (!e.shiftKey) {\n                character = character.toLowerCase();\n            }\n\n            return character;\n        }\n\n        // for non keypress events the special maps are needed\n        if (_MAP[e.which]) {\n            return _MAP[e.which];\n        }\n\n        if (_KEYCODE_MAP[e.which]) {\n            return _KEYCODE_MAP[e.which];\n        }\n\n        // if it is not in the special map\n\n        // with keydown and keyup events the character seems to always\n        // come in as an uppercase character whether you are pressing shift\n        // or not.  we should make sure it is always lowercase for comparisons\n        return String.fromCharCode(e.which).toLowerCase();\n    }\n\n    /**\n     * checks if two arrays are equal\n     *\n     * @param {Array} modifiers1\n     * @param {Array} modifiers2\n     * @returns {boolean}\n     */\n    function _modifiersMatch(modifiers1, modifiers2) {\n        return modifiers1.sort().join(',') === modifiers2.sort().join(',');\n    }\n\n    /**\n     * takes a key event and figures out what the modifiers are\n     *\n     * @param {Event} e\n     * @returns {Array}\n     */\n    function _eventModifiers(e) {\n        var modifiers = [];\n\n        if (e.shiftKey) {\n            modifiers.push('shift');\n        }\n\n        if (e.altKey) {\n            modifiers.push('alt');\n        }\n\n        if (e.ctrlKey) {\n            modifiers.push('ctrl');\n        }\n\n        if (e.metaKey) {\n            modifiers.push('meta');\n        }\n\n        return modifiers;\n    }\n\n    /**\n     * prevents default for this event\n     *\n     * @param {Event} e\n     * @returns void\n     */\n    function _preventDefault(e) {\n        if (e.preventDefault) {\n            e.preventDefault();\n            return;\n        }\n\n        e.returnValue = false;\n    }\n\n    /**\n     * stops propogation for this event\n     *\n     * @param {Event} e\n     * @returns void\n     */\n    function _stopPropagation(e) {\n        if (e.stopPropagation) {\n            e.stopPropagation();\n            return;\n        }\n\n        e.cancelBubble = true;\n    }\n\n    /**\n     * determines if the keycode specified is a modifier key or not\n     *\n     * @param {string} key\n     * @returns {boolean}\n     */\n    function _isModifier(key) {\n        return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';\n    }\n\n    /**\n     * reverses the map lookup so that we can look for specific keys\n     * to see what can and can't use keypress\n     *\n     * @return {Object}\n     */\n    function _getReverseMap() {\n        if (!_REVERSE_MAP) {\n            _REVERSE_MAP = {};\n            for (var key in _MAP) {\n\n                // pull out the numeric keypad from here cause keypress should\n                // be able to detect the keys from the character\n                if (key > 95 && key < 112) {\n                    continue;\n                }\n\n                if (_MAP.hasOwnProperty(key)) {\n                    _REVERSE_MAP[_MAP[key]] = key;\n                }\n            }\n        }\n        return _REVERSE_MAP;\n    }\n\n    /**\n     * picks the best action based on the key combination\n     *\n     * @param {string} key - character for key\n     * @param {Array} modifiers\n     * @param {string=} action passed in\n     */\n    function _pickBestAction(key, modifiers, action) {\n\n        // if no action was picked in we should try to pick the one\n        // that we think would work best for this key\n        if (!action) {\n            action = _getReverseMap()[key] ? 'keydown' : 'keypress';\n        }\n\n        // modifier keys don't work as expected with keypress,\n        // switch to keydown\n        if (action == 'keypress' && modifiers.length) {\n            action = 'keydown';\n        }\n\n        return action;\n    }\n\n    /**\n     * Converts from a string key combination to an array\n     *\n     * @param  {string} combination like \"command+shift+l\"\n     * @return {Array}\n     */\n    function _keysFromString(combination) {\n        if (combination === '+') {\n            return ['+'];\n        }\n\n        combination = combination.replace(/\\+{2}/g, '+plus');\n        return combination.split('+');\n    }\n\n    /**\n     * Gets info for a specific key combination\n     *\n     * @param  {string} combination key combination (\"command+s\" or \"a\" or \"*\")\n     * @param  {string=} action\n     * @returns {Object}\n     */\n    function _getKeyInfo(combination, action) {\n        var keys;\n        var key;\n        var i;\n        var modifiers = [];\n\n        // take the keys from this pattern and figure out what the actual\n        // pattern is all about\n        keys = _keysFromString(combination);\n\n        for (i = 0; i < keys.length; ++i) {\n            key = keys[i];\n\n            // normalize key names\n            if (_SPECIAL_ALIASES[key]) {\n                key = _SPECIAL_ALIASES[key];\n            }\n\n            // if this is not a keypress event then we should\n            // be smart about using shift keys\n            // this will only work for US keyboards however\n            if (action && action != 'keypress' && _SHIFT_MAP[key]) {\n                key = _SHIFT_MAP[key];\n                modifiers.push('shift');\n            }\n\n            // if this key is a modifier then add it to the list of modifiers\n            if (_isModifier(key)) {\n                modifiers.push(key);\n            }\n        }\n\n        // depending on what the key combination is\n        // we will try to pick the best event for it\n        action = _pickBestAction(key, modifiers, action);\n\n        return {\n            key: key,\n            modifiers: modifiers,\n            action: action\n        };\n    }\n\n    function _belongsTo(element, ancestor) {\n        if (element === null || element === document) {\n            return false;\n        }\n\n        if (element === ancestor) {\n            return true;\n        }\n\n        return _belongsTo(element.parentNode, ancestor);\n    }\n\n    function Mousetrap(targetElement) {\n        var self = this;\n\n        targetElement = targetElement || document;\n\n        if (!(self instanceof Mousetrap)) {\n            return new Mousetrap(targetElement);\n        }\n\n        /**\n         * element to attach key events to\n         *\n         * @type {Element}\n         */\n        self.target = targetElement;\n\n        /**\n         * a list of all the callbacks setup via Mousetrap.bind()\n         *\n         * @type {Object}\n         */\n        self._callbacks = {};\n\n        /**\n         * direct map of string combinations to callbacks used for trigger()\n         *\n         * @type {Object}\n         */\n        self._directMap = {};\n\n        /**\n         * keeps track of what level each sequence is at since multiple\n         * sequences can start out with the same sequence\n         *\n         * @type {Object}\n         */\n        var _sequenceLevels = {};\n\n        /**\n         * variable to store the setTimeout call\n         *\n         * @type {null|number}\n         */\n        var _resetTimer;\n\n        /**\n         * temporary state where we will ignore the next keyup\n         *\n         * @type {boolean|string}\n         */\n        var _ignoreNextKeyup = false;\n\n        /**\n         * temporary state where we will ignore the next keypress\n         *\n         * @type {boolean}\n         */\n        var _ignoreNextKeypress = false;\n\n        /**\n         * are we currently inside of a sequence?\n         * type of action (\"keyup\" or \"keydown\" or \"keypress\") or false\n         *\n         * @type {boolean|string}\n         */\n        var _nextExpectedAction = false;\n\n        /**\n         * resets all sequence counters except for the ones passed in\n         *\n         * @param {Object} doNotReset\n         * @returns void\n         */\n        function _resetSequences(doNotReset) {\n            doNotReset = doNotReset || {};\n\n            var activeSequences = false,\n                key;\n\n            for (key in _sequenceLevels) {\n                if (doNotReset[key]) {\n                    activeSequences = true;\n                    continue;\n                }\n                _sequenceLevels[key] = 0;\n            }\n\n            if (!activeSequences) {\n                _nextExpectedAction = false;\n            }\n        }\n\n        /**\n         * finds all callbacks that match based on the keycode, modifiers,\n         * and action\n         *\n         * @param {string} character\n         * @param {Array} modifiers\n         * @param {Event|Object} e\n         * @param {string=} sequenceName - name of the sequence we are looking for\n         * @param {string=} combination\n         * @param {number=} level\n         * @returns {Array}\n         */\n        function _getMatches(character, modifiers, e, sequenceName, combination, level) {\n            var i;\n            var callback;\n            var matches = [];\n            var action = e.type;\n\n            // if there are no events related to this keycode\n            if (!self._callbacks[character]) {\n                return [];\n            }\n\n            // if a modifier key is coming up on its own we should allow it\n            if (action == 'keyup' && _isModifier(character)) {\n                modifiers = [character];\n            }\n\n            // loop through all callbacks for the key that was pressed\n            // and see if any of them match\n            for (i = 0; i < self._callbacks[character].length; ++i) {\n                callback = self._callbacks[character][i];\n\n                // if a sequence name is not specified, but this is a sequence at\n                // the wrong level then move onto the next match\n                if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {\n                    continue;\n                }\n\n                // if the action we are looking for doesn't match the action we got\n                // then we should keep going\n                if (action != callback.action) {\n                    continue;\n                }\n\n                // if this is a keypress event and the meta key and control key\n                // are not pressed that means that we need to only look at the\n                // character, otherwise check the modifiers as well\n                //\n                // chrome will not fire a keypress if meta or control is down\n                // safari will fire a keypress if meta or meta+shift is down\n                // firefox will fire a keypress if meta or control is down\n                if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {\n\n                    // when you bind a combination or sequence a second time it\n                    // should overwrite the first one.  if a sequenceName or\n                    // combination is specified in this call it does just that\n                    //\n                    // @todo make deleting its own method?\n                    var deleteCombo = !sequenceName && callback.combo == combination;\n                    var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;\n                    if (deleteCombo || deleteSequence) {\n                        self._callbacks[character].splice(i, 1);\n                    }\n\n                    matches.push(callback);\n                }\n            }\n\n            return matches;\n        }\n\n        /**\n         * actually calls the callback function\n         *\n         * if your callback function returns false this will use the jquery\n         * convention - prevent default and stop propogation on the event\n         *\n         * @param {Function} callback\n         * @param {Event} e\n         * @returns void\n         */\n        function _fireCallback(callback, e, combo, sequence) {\n\n            // if this event should not happen stop here\n            if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {\n                return;\n            }\n\n            if (callback(e, combo) === false) {\n                _preventDefault(e);\n                _stopPropagation(e);\n            }\n        }\n\n        /**\n         * handles a character key event\n         *\n         * @param {string} character\n         * @param {Array} modifiers\n         * @param {Event} e\n         * @returns void\n         */\n        self._handleKey = function(character, modifiers, e) {\n            var callbacks = _getMatches(character, modifiers, e);\n            var i;\n            var doNotReset = {};\n            var maxLevel = 0;\n            var processedSequenceCallback = false;\n\n            // Calculate the maxLevel for sequences so we can only execute the longest callback sequence\n            for (i = 0; i < callbacks.length; ++i) {\n                if (callbacks[i].seq) {\n                    maxLevel = Math.max(maxLevel, callbacks[i].level);\n                }\n            }\n\n            // loop through matching callbacks for this key event\n            for (i = 0; i < callbacks.length; ++i) {\n\n                // fire for all sequence callbacks\n                // this is because if for example you have multiple sequences\n                // bound such as \"g i\" and \"g t\" they both need to fire the\n                // callback for matching g cause otherwise you can only ever\n                // match the first one\n                if (callbacks[i].seq) {\n\n                    // only fire callbacks for the maxLevel to prevent\n                    // subsequences from also firing\n                    //\n                    // for example 'a option b' should not cause 'option b' to fire\n                    // even though 'option b' is part of the other sequence\n                    //\n                    // any sequences that do not match here will be discarded\n                    // below by the _resetSequences call\n                    if (callbacks[i].level != maxLevel) {\n                        continue;\n                    }\n\n                    processedSequenceCallback = true;\n\n                    // keep a list of which sequences were matches for later\n                    doNotReset[callbacks[i].seq] = 1;\n                    _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);\n                    continue;\n                }\n\n                // if there were no sequence matches but we are still here\n                // that means this is a regular match so we should fire that\n                if (!processedSequenceCallback) {\n                    _fireCallback(callbacks[i].callback, e, callbacks[i].combo);\n                }\n            }\n\n            // if the key you pressed matches the type of sequence without\n            // being a modifier (ie \"keyup\" or \"keypress\") then we should\n            // reset all sequences that were not matched by this event\n            //\n            // this is so, for example, if you have the sequence \"h a t\" and you\n            // type \"h e a r t\" it does not match.  in this case the \"e\" will\n            // cause the sequence to reset\n            //\n            // modifier keys are ignored because you can have a sequence\n            // that contains modifiers such as \"enter ctrl+space\" and in most\n            // cases the modifier key will be pressed before the next key\n            //\n            // also if you have a sequence such as \"ctrl+b a\" then pressing the\n            // \"b\" key will trigger a \"keypress\" and a \"keydown\"\n            //\n            // the \"keydown\" is expected when there is a modifier, but the\n            // \"keypress\" ends up matching the _nextExpectedAction since it occurs\n            // after and that causes the sequence to reset\n            //\n            // we ignore keypresses in a sequence that directly follow a keydown\n            // for the same character\n            var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;\n            if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {\n                _resetSequences(doNotReset);\n            }\n\n            _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';\n        };\n\n        /**\n         * handles a keydown event\n         *\n         * @param {Event} e\n         * @returns void\n         */\n        function _handleKeyEvent(e) {\n\n            // normalize e.which for key events\n            // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion\n            if (typeof e.which !== 'number') {\n                e.which = e.keyCode;\n            }\n\n            var character = _characterFromEvent(e);\n\n            // no character found then stop\n            if (!character) {\n                return;\n            }\n\n            // need to use === for the character check because the character can be 0\n            if (e.type == 'keyup' && _ignoreNextKeyup === character) {\n                _ignoreNextKeyup = false;\n                return;\n            }\n\n            self.handleKey(character, _eventModifiers(e), e);\n        }\n\n        /**\n         * called to set a 1 second timeout on the specified sequence\n         *\n         * this is so after each key press in the sequence you have 1 second\n         * to press the next key before you have to start over\n         *\n         * @returns void\n         */\n        function _resetSequenceTimer() {\n            clearTimeout(_resetTimer);\n            _resetTimer = setTimeout(_resetSequences, 1000);\n        }\n\n        /**\n         * binds a key sequence to an event\n         *\n         * @param {string} combo - combo specified in bind call\n         * @param {Array} keys\n         * @param {Function} callback\n         * @param {string=} action\n         * @returns void\n         */\n        function _bindSequence(combo, keys, callback, action) {\n\n            // start off by adding a sequence level record for this combination\n            // and setting the level to 0\n            _sequenceLevels[combo] = 0;\n\n            /**\n             * callback to increase the sequence level for this sequence and reset\n             * all other sequences that were active\n             *\n             * @param {string} nextAction\n             * @returns {Function}\n             */\n            function _increaseSequence(nextAction) {\n                return function() {\n                    _nextExpectedAction = nextAction;\n                    ++_sequenceLevels[combo];\n                    _resetSequenceTimer();\n                };\n            }\n\n            /**\n             * wraps the specified callback inside of another function in order\n             * to reset all sequence counters as soon as this sequence is done\n             *\n             * @param {Event} e\n             * @returns void\n             */\n            function _callbackAndReset(e) {\n                _fireCallback(callback, e, combo);\n\n                // we should ignore the next key up if the action is key down\n                // or keypress.  this is so if you finish a sequence and\n                // release the key the final key will not trigger a keyup\n                if (action !== 'keyup') {\n                    _ignoreNextKeyup = _characterFromEvent(e);\n                }\n\n                // weird race condition if a sequence ends with the key\n                // another sequence begins with\n                setTimeout(_resetSequences, 10);\n            }\n\n            // loop through keys one at a time and bind the appropriate callback\n            // function.  for any key leading up to the final one it should\n            // increase the sequence. after the final, it should reset all sequences\n            //\n            // if an action is specified in the original bind call then that will\n            // be used throughout.  otherwise we will pass the action that the\n            // next key in the sequence should match.  this allows a sequence\n            // to mix and match keypress and keydown events depending on which\n            // ones are better suited to the key provided\n            for (var i = 0; i < keys.length; ++i) {\n                var isFinal = i + 1 === keys.length;\n                var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);\n                _bindSingle(keys[i], wrappedCallback, action, combo, i);\n            }\n        }\n\n        /**\n         * binds a single keyboard combination\n         *\n         * @param {string} combination\n         * @param {Function} callback\n         * @param {string=} action\n         * @param {string=} sequenceName - name of sequence if part of sequence\n         * @param {number=} level - what part of the sequence the command is\n         * @returns void\n         */\n        function _bindSingle(combination, callback, action, sequenceName, level) {\n\n            // store a direct mapped reference for use with Mousetrap.trigger\n            self._directMap[combination + ':' + action] = callback;\n\n            // make sure multiple spaces in a row become a single space\n            combination = combination.replace(/\\s+/g, ' ');\n\n            var sequence = combination.split(' ');\n            var info;\n\n            // if this pattern is a sequence of keys then run through this method\n            // to reprocess each pattern one key at a time\n            if (sequence.length > 1) {\n                _bindSequence(combination, sequence, callback, action);\n                return;\n            }\n\n            info = _getKeyInfo(combination, action);\n\n            // make sure to initialize array if this is the first time\n            // a callback is added for this key\n            self._callbacks[info.key] = self._callbacks[info.key] || [];\n\n            // remove an existing match if there is one\n            _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);\n\n            // add this call back to the array\n            // if it is a sequence put it at the beginning\n            // if not put it at the end\n            //\n            // this is important because the way these are processed expects\n            // the sequence ones to come first\n            self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({\n                callback: callback,\n                modifiers: info.modifiers,\n                action: info.action,\n                seq: sequenceName,\n                level: level,\n                combo: combination\n            });\n        }\n\n        /**\n         * binds multiple combinations to the same callback\n         *\n         * @param {Array} combinations\n         * @param {Function} callback\n         * @param {string|undefined} action\n         * @returns void\n         */\n        self._bindMultiple = function(combinations, callback, action) {\n            for (var i = 0; i < combinations.length; ++i) {\n                _bindSingle(combinations[i], callback, action);\n            }\n        };\n\n        // start!\n        _addEvent(targetElement, 'keypress', _handleKeyEvent);\n        _addEvent(targetElement, 'keydown', _handleKeyEvent);\n        _addEvent(targetElement, 'keyup', _handleKeyEvent);\n    }\n\n    /**\n     * binds an event to mousetrap\n     *\n     * can be a single key, a combination of keys separated with +,\n     * an array of keys, or a sequence of keys separated by spaces\n     *\n     * be sure to list the modifier keys first to make sure that the\n     * correct key ends up getting bound (the last key in the pattern)\n     *\n     * @param {string|Array} keys\n     * @param {Function} callback\n     * @param {string=} action - 'keypress', 'keydown', or 'keyup'\n     * @returns void\n     */\n    Mousetrap.prototype.bind = function(keys, callback, action) {\n        var self = this;\n        keys = keys instanceof Array ? keys : [keys];\n        self._bindMultiple.call(self, keys, callback, action);\n        return self;\n    };\n\n    /**\n     * unbinds an event to mousetrap\n     *\n     * the unbinding sets the callback function of the specified key combo\n     * to an empty function and deletes the corresponding key in the\n     * _directMap dict.\n     *\n     * TODO: actually remove this from the _callbacks dictionary instead\n     * of binding an empty function\n     *\n     * the keycombo+action has to be exactly the same as\n     * it was defined in the bind method\n     *\n     * @param {string|Array} keys\n     * @param {string} action\n     * @returns void\n     */\n    Mousetrap.prototype.unbind = function(keys, action) {\n        var self = this;\n        return self.bind.call(self, keys, function() {}, action);\n    };\n\n    /**\n     * triggers an event that has already been bound\n     *\n     * @param {string} keys\n     * @param {string=} action\n     * @returns void\n     */\n    Mousetrap.prototype.trigger = function(keys, action) {\n        var self = this;\n        if (self._directMap[keys + ':' + action]) {\n            self._directMap[keys + ':' + action]({}, keys);\n        }\n        return self;\n    };\n\n    /**\n     * resets the library back to its initial state.  this is useful\n     * if you want to clear out the current keyboard shortcuts and bind\n     * new ones - for example if you switch to another page\n     *\n     * @returns void\n     */\n    Mousetrap.prototype.reset = function() {\n        var self = this;\n        self._callbacks = {};\n        self._directMap = {};\n        return self;\n    };\n\n    /**\n     * should we stop this event before firing off callbacks\n     *\n     * @param {Event} e\n     * @param {Element} element\n     * @return {boolean}\n     */\n    Mousetrap.prototype.stopCallback = function(e, element) {\n        var self = this;\n\n        // if the element has the class \"mousetrap\" then no need to stop\n        if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {\n            return false;\n        }\n\n        if (_belongsTo(element, self.target)) {\n            return false;\n        }\n\n        // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,\n        // not the initial event target in the shadow tree. Note that not all events cross the\n        // shadow boundary.\n        // For shadow trees with `mode: 'open'`, the initial event target is the first element in\n        // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event\n        // target cannot be obtained.\n        if ('composedPath' in e && typeof e.composedPath === 'function') {\n            // For open shadow trees, update `element` so that the following check works.\n            var initialEventTarget = e.composedPath()[0];\n            if (initialEventTarget !== e.target) {\n                element = initialEventTarget;\n            }\n        }\n\n        // stop for input, select, and textarea\n        return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;\n    };\n\n    /**\n     * exposes _handleKey publicly so it can be overwritten by extensions\n     */\n    Mousetrap.prototype.handleKey = function() {\n        var self = this;\n        return self._handleKey.apply(self, arguments);\n    };\n\n    /**\n     * allow custom key mappings\n     */\n    Mousetrap.addKeycodes = function(object) {\n        for (var key in object) {\n            if (object.hasOwnProperty(key)) {\n                _MAP[key] = object[key];\n            }\n        }\n        _REVERSE_MAP = null;\n    };\n\n    /**\n     * Init the global mousetrap functions\n     *\n     * This method is needed to allow the global mousetrap functions to work\n     * now that mousetrap is a constructor function.\n     */\n    Mousetrap.init = function() {\n        var documentMousetrap = Mousetrap(document);\n        for (var method in documentMousetrap) {\n            if (method.charAt(0) !== '_') {\n                Mousetrap[method] = (function(method) {\n                    return function() {\n                        return documentMousetrap[method].apply(documentMousetrap, arguments);\n                    };\n                } (method));\n            }\n        }\n    };\n\n    Mousetrap.init();\n\n    // expose mousetrap to the global object\n    window.Mousetrap = Mousetrap;\n\n    // expose as a common js module\n    if (typeof module !== 'undefined' && module.exports) {\n        module.exports = Mousetrap;\n    }\n\n    // expose mousetrap as an AMD module\n    if (typeof define === 'function' && define.amd) {\n        define(function() {\n            return Mousetrap;\n        });\n    }\n}) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);\n","/**\n * adds a bindGlobal method to Mousetrap that allows you to\n * bind specific keyboard shortcuts that will still work\n * inside a text input field\n *\n * usage:\n * Mousetrap.bindGlobal('ctrl+s', _saveChanges);\n */\n/* global Mousetrap:true */\n(function(Mousetrap) {\n    if (! Mousetrap) {\n        return;\n    }\n    var _globalCallbacks = {};\n    var _originalStopCallback = Mousetrap.prototype.stopCallback;\n\n    Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) {\n        var self = this;\n\n        if (self.paused) {\n            return true;\n        }\n\n        if (_globalCallbacks[combo] || _globalCallbacks[sequence]) {\n            return false;\n        }\n\n        return _originalStopCallback.call(self, e, element, combo);\n    };\n\n    Mousetrap.prototype.bindGlobal = function(keys, callback, action) {\n        var self = this;\n        self.bind(keys, callback, action);\n\n        if (keys instanceof Array) {\n            for (var i = 0; i < keys.length; i++) {\n                _globalCallbacks[keys[i]] = true;\n            }\n            return;\n        }\n\n        _globalCallbacks[keys] = true;\n    };\n\n    Mousetrap.init();\n}) (typeof Mousetrap !== \"undefined\" ? Mousetrap : undefined);\n","// @flow\nimport * as React from 'react';\nimport useOnResize from './useOnResize';\n\nconst style = {\n  display: 'block',\n  opacity: 0,\n  position: 'absolute',\n  top: 0,\n  left: 0,\n  height: '100%',\n  width: '100%',\n  overflow: 'hidden',\n  pointerEvents: 'none',\n  zIndex: -1,\n};\n\n// This automatically attaches to itself the resize event listener\n// and adds onResize as callback\nexport default ({\n  onResize,\n}: {\n  onResize: (React.ElementRef<any>) => void,\n}) => {\n  const ref = React.useRef();\n  useOnResize(ref, () => onResize(ref));\n\n  return (\n    <iframe\n      style={style}\n      src=\"about:blank\"\n      ref={ref}\n      aria-hidden={true}\n      tabIndex={-1}\n      frameBorder={0}\n    />\n  );\n};\n","// @flow\nimport * as React from 'react';\n\n// This is just an utility to cleanly attach a `resize` event listener\n// to a target HTMLObjectElement or HTMLIFrameElement\n// The real Hook is `useResizeAware.js`\nexport default (ref: React.ElementRef<any>, onResize: () => void) => {\n  const getTarget = () => ref.current && ref.current.contentDocument && ref.current.contentDocument.defaultView;\n  function run() {\n    // trigger onResize event on mount to provide initial sizes\n    onResize();\n    var target = getTarget();\n    target && target.addEventListener('resize', onResize);\n  }\n  React.useEffect(() => {\n    if (getTarget()) {\n      run();\n    }\n    else if (ref.current && ref.current.addEventListener) {\n      ref.current.addEventListener('load', run)\n    }\n\n    // clean event listener on unmount\n    return () => {\n      // Ensure the target exists and is in fact an event listener\n      // this fixes an issue where contentDocument.defaultView is not a real window object\n      // as can be the case when used with React portals\n      const target = getTarget();\n      const isListener =\n        target && typeof target.removeEventListener === 'function';\n\n      isListener && target.removeEventListener('resize', onResize);\n    };\n  }, []);\n};\n","// @flow\nimport * as React from 'react';\nimport ResizeListener from './ResizeListener';\n\nconst defaultReporter = (target: ?HTMLElement) => ({\n  width: target != null ? target.offsetWidth : null,\n  height: target != null ? target.offsetHeight : null,\n});\n\nexport default function useResizeAware(\n  reporter: typeof defaultReporter = defaultReporter\n) {\n  const [sizes, setSizes] = React.useState(reporter(null));\n  const onResize = React.useCallback(ref => setSizes(reporter(ref.current)), [\n    reporter,\n  ]);\n  const resizeListenerNode = React.useMemo(\n    () => <ResizeListener onResize={onResize} />,\n    [onResize]\n  );\n\n  return [resizeListenerNode, sizes];\n}\n","module.exports = window[\"React\"];","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"lodash\"];","/**\n * External dependencies\n */\nimport { camelCase, upperFirst } from 'lodash';\nimport type { ComponentType } from 'react';\n\n/**\n * Higher order components can cause props to be obviated. For example a HOC that\n * injects i18n props will obviate the need for the i18n props to be passed to the component.\n *\n * If a HOC does not obviate the need for any specific props then we default to `{}` which\n * essentially subtracts 0 from the original props of the passed in component. An example\n * of this is the `pure` HOC which does not change the API surface of the component but\n * simply modifies the internals.\n */\nexport type HigherOrderComponent< HOCProps extends Record< string, any > > = <\n\tInnerProps extends HOCProps\n>(\n\tInner: ComponentType< InnerProps >\n) => {} extends HOCProps\n\t? ComponentType< InnerProps >\n\t: ComponentType< Omit< InnerProps, keyof HOCProps > >;\n\n/**\n * Given a function mapping a component to an enhanced component and modifier\n * name, returns the enhanced component augmented with a generated displayName.\n *\n * @param  mapComponent Function mapping component to enhanced component.\n * @param  modifierName Seed name from which to generated display name.\n *\n * @return Component class with generated display name assigned.\n */\nfunction createHigherOrderComponent<\n\tHOCProps extends Record< string, any > = {}\n>( mapComponent: HigherOrderComponent< HOCProps >, modifierName: string ) {\n\treturn < InnerProps extends HOCProps >(\n\t\tInner: ComponentType< InnerProps >\n\t) => {\n\t\tconst Outer = mapComponent( Inner );\n\t\tconst displayName = Inner.displayName || Inner.name || 'Component';\n\t\tOuter.displayName = `${ upperFirst(\n\t\t\tcamelCase( modifierName )\n\t\t) }(${ displayName })`;\n\t\treturn Outer;\n\t};\n}\n\nexport default createHigherOrderComponent;\n","/**\n * External dependencies\n */\nimport { flowRight as compose } from 'lodash';\n\n/**\n * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function\n * composition, where each successive invocation is supplied the return value of the previous.\n *\n * This is just a re-export of `lodash`'s `flowRight` function.\n *\n * @see https://docs-lodash.com/v4/flow-right/\n */\nexport default compose;\n","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"element\"];","/**\n * Internal dependencies\n */\nimport createHigherOrderComponent from '../../utils/create-higher-order-component';\n\n/**\n * Higher-order component creator, creating a new component which renders if\n * the given condition is satisfied or with the given optional prop name.\n *\n * @example\n * ```ts\n * type Props = { foo: string };\n * const Component = ( props: Props ) => <div>{ props.foo }</div>;\n * const ConditionalComponent = ifCondition( ( props: Props ) => props.foo.length !== 0 )( Component );\n * <ConditionalComponent foo=\"\" />; // => null\n * <ConditionalComponent foo=\"bar\" />; // => <div>bar</div>;\n * ```\n *\n * @param  predicate Function to test condition.\n *\n * @return Higher-order component.\n */\nconst ifCondition = < TProps extends Record< string, any > >(\n\tpredicate: ( props: TProps ) => boolean\n) =>\n\tcreateHigherOrderComponent< {} >(\n\t\t( WrappedComponent ) => ( props ) => {\n\t\t\tif ( ! predicate( props as TProps ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\treturn <WrappedComponent { ...props } />;\n\t\t},\n\t\t'ifCondition'\n\t);\n\nexport default ifCondition;\n","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"isShallowEqual\"];","/**\n * WordPress dependencies\n */\nimport isShallowEqual from '@wordpress/is-shallow-equal';\nimport { Component } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport createHigherOrderComponent from '../../utils/create-higher-order-component';\n\n/**\n * External dependencies\n */\nimport type { ComponentType, ComponentClass } from 'react';\n\n/**\n * Given a component returns the enhanced component augmented with a component\n * only re-rendering when its props/state change\n */\nconst pure = createHigherOrderComponent(\n\t< TProps extends Record< string, any > >(\n\t\tWrapped: ComponentType< TProps >\n\t) => {\n\t\tif ( Wrapped.prototype instanceof Component ) {\n\t\t\treturn class extends ( Wrapped as ComponentClass< TProps > ) {\n\t\t\t\tshouldComponentUpdate( nextProps: TProps, nextState: any ) {\n\t\t\t\t\treturn (\n\t\t\t\t\t\t! isShallowEqual( nextProps, this.props ) ||\n\t\t\t\t\t\t! isShallowEqual( nextState, this.state )\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\t\treturn class extends Component< TProps > {\n\t\t\tshouldComponentUpdate( nextProps: TProps ) {\n\t\t\t\treturn ! isShallowEqual( nextProps, this.props );\n\t\t\t}\n\n\t\t\trender() {\n\t\t\t\treturn <Wrapped { ...this.props } />;\n\t\t\t}\n\t\t};\n\t},\n\t'pure'\n);\n\nexport default pure;\n","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"deprecated\"];","/**\n * External dependencies\n */\nimport { forEach } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { Component, forwardRef } from '@wordpress/element';\nimport deprecated from '@wordpress/deprecated';\n\n/**\n * Internal dependencies\n */\nimport createHigherOrderComponent from '../../utils/create-higher-order-component';\nimport Listener from './listener';\n\n/**\n * Listener instance responsible for managing document event handling.\n */\nconst listener = new Listener();\n\n/* eslint-disable jsdoc/no-undefined-types */\n/**\n * Higher-order component creator which, given an object of DOM event types and\n * values corresponding to a callback function name on the component, will\n * create or update a window event handler to invoke the callback when an event\n * occurs. On behalf of the consuming developer, the higher-order component\n * manages unbinding when the component unmounts, and binding at most a single\n * event handler for the entire application.\n *\n * @deprecated\n *\n * @param {Record<keyof GlobalEventHandlersEventMap, string>} eventTypesToHandlers Object with keys of DOM\n *                                                                                 event type, the value a\n *                                                                                 name of the function on\n *                                                                                 the original component's\n *                                                                                 instance which handles\n *                                                                                 the event.\n *\n * @return {any} Higher-order component.\n */\nexport default function withGlobalEvents( eventTypesToHandlers ) {\n\tdeprecated( 'wp.compose.withGlobalEvents', {\n\t\tsince: '5.7',\n\t\talternative: 'useEffect',\n\t} );\n\n\t// @ts-ignore We don't need to fix the type-related issues because this is deprecated.\n\treturn createHigherOrderComponent( ( WrappedComponent ) => {\n\t\tclass Wrapper extends Component {\n\t\t\tconstructor( /** @type {any} */ props ) {\n\t\t\t\tsuper( props );\n\n\t\t\t\tthis.handleEvent = this.handleEvent.bind( this );\n\t\t\t\tthis.handleRef = this.handleRef.bind( this );\n\t\t\t}\n\n\t\t\tcomponentDidMount() {\n\t\t\t\tforEach( eventTypesToHandlers, ( _, eventType ) => {\n\t\t\t\t\tlistener.add( eventType, this );\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\tcomponentWillUnmount() {\n\t\t\t\tforEach( eventTypesToHandlers, ( _, eventType ) => {\n\t\t\t\t\tlistener.remove( eventType, this );\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thandleEvent( /** @type {any} */ event ) {\n\t\t\t\tconst handler =\n\t\t\t\t\teventTypesToHandlers[\n\t\t\t\t\t\t/** @type {keyof GlobalEventHandlersEventMap} */ ( event.type )\n\t\t\t\t\t\t/* eslint-enable jsdoc/no-undefined-types */\n\t\t\t\t\t];\n\t\t\t\tif ( typeof this.wrappedRef[ handler ] === 'function' ) {\n\t\t\t\t\tthis.wrappedRef[ handler ]( event );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\thandleRef( /** @type {any} */ el ) {\n\t\t\t\tthis.wrappedRef = el;\n\t\t\t\t// Any component using `withGlobalEvents` that is not setting a `ref`\n\t\t\t\t// will cause `this.props.forwardedRef` to be `null`, so we need this\n\t\t\t\t// check.\n\t\t\t\tif ( this.props.forwardedRef ) {\n\t\t\t\t\tthis.props.forwardedRef( el );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\trender() {\n\t\t\t\treturn (\n\t\t\t\t\t<WrappedComponent\n\t\t\t\t\t\t{ ...this.props.ownProps }\n\t\t\t\t\t\tref={ this.handleRef }\n\t\t\t\t\t/>\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\treturn forwardRef( ( props, ref ) => {\n\t\t\treturn <Wrapper ownProps={ props } forwardedRef={ ref } />;\n\t\t} );\n\t}, 'withGlobalEvents' );\n}\n","/**\n * External dependencies\n */\nimport { forEach, without } from 'lodash';\n\n/**\n * Class responsible for orchestrating event handling on the global window,\n * binding a single event to be shared across all handling instances, and\n * removing the handler when no instances are listening for the event.\n */\nclass Listener {\n\tconstructor() {\n\t\t/** @type {any} */\n\t\tthis.listeners = {};\n\n\t\tthis.handleEvent = this.handleEvent.bind( this );\n\t}\n\n\tadd( /** @type {any} */ eventType, /** @type {any} */ instance ) {\n\t\tif ( ! this.listeners[ eventType ] ) {\n\t\t\t// Adding first listener for this type, so bind event.\n\t\t\twindow.addEventListener( eventType, this.handleEvent );\n\t\t\tthis.listeners[ eventType ] = [];\n\t\t}\n\n\t\tthis.listeners[ eventType ].push( instance );\n\t}\n\n\tremove( /** @type {any} */ eventType, /** @type {any} */ instance ) {\n\t\tthis.listeners[ eventType ] = without(\n\t\t\tthis.listeners[ eventType ],\n\t\t\tinstance\n\t\t);\n\n\t\tif ( ! this.listeners[ eventType ].length ) {\n\t\t\t// Removing last listener for this type, so unbind event.\n\t\t\twindow.removeEventListener( eventType, this.handleEvent );\n\t\t\tdelete this.listeners[ eventType ];\n\t\t}\n\t}\n\n\thandleEvent( /** @type {any} */ event ) {\n\t\tforEach( this.listeners[ event.type ], ( instance ) => {\n\t\t\tinstance.handleEvent( event );\n\t\t} );\n\t}\n}\n\nexport default Listener;\n","// Disable reason: Object and object are distinctly different types in TypeScript and we mean the lowercase object in thise case\n// but eslint wants to force us to use `Object`. See https://stackoverflow.com/questions/49464634/difference-between-object-and-object-in-typescript\n/* eslint-disable jsdoc/check-types */\n/**\n * WordPress dependencies\n */\nimport { useMemo } from '@wordpress/element';\n\n/**\n * @type {WeakMap<object, number>}\n */\nconst instanceMap = new WeakMap();\n\n/**\n * Creates a new id for a given object.\n *\n * @param {object} object Object reference to create an id for.\n * @return {number} The instance id (index).\n */\nfunction createId( object ) {\n\tconst instances = instanceMap.get( object ) || 0;\n\tinstanceMap.set( object, instances + 1 );\n\treturn instances;\n}\n\n/**\n * Provides a unique instance ID.\n *\n * @param {object}          object           Object reference to create an id for.\n * @param {string}          [prefix]         Prefix for the unique id.\n * @param {string | number} [preferredId=''] Default ID to use.\n * @return {string | number} The unique instance id.\n */\nexport default function useInstanceId( object, prefix, preferredId = '' ) {\n\treturn useMemo( () => {\n\t\tif ( preferredId ) return preferredId;\n\t\tconst id = createId( object );\n\n\t\treturn prefix ? `${ prefix }-${ id }` : id;\n\t}, [ object ] );\n}\n/* eslint-enable jsdoc/check-types */\n","/**\n * Internal dependencies\n */\nimport createHigherOrderComponent from '../../utils/create-higher-order-component';\nimport useInstanceId from '../../hooks/use-instance-id';\n\n/**\n * A Higher Order Component used to be provide a unique instance ID by\n * component.\n */\nconst withInstanceId = createHigherOrderComponent< {\n\tinstanceId: string | number;\n} >( ( WrappedComponent ) => {\n\treturn ( props ) => {\n\t\tconst instanceId = useInstanceId( WrappedComponent );\n\t\t// @ts-ignore\n\t\treturn <WrappedComponent { ...props } instanceId={ instanceId } />;\n\t};\n}, 'withInstanceId' );\n\nexport default withInstanceId;\n","/**\n * External dependencies\n */\nimport { without } from 'lodash';\nimport type { ComponentType } from 'react';\n\n/**\n * WordPress dependencies\n */\nimport { Component } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport createHigherOrderComponent from '../../utils/create-higher-order-component';\n\n/**\n * We cannot use the `Window['setTimeout']` and `Window['clearTimeout']`\n * types here because those functions include functionality that is not handled\n * by this component, like the ability to pass extra arguments.\n *\n * In the case of this component, we only handle the simplest case where\n * `setTimeout` only accepts a function (not a string) and an optional delay.\n */\ntype TimeoutProps = {\n\tsetTimeout: ( fn: () => void, delay: number ) => number;\n\tclearTimeout: ( id: number ) => void;\n};\n\n/**\n * A higher-order component used to provide and manage delayed function calls\n * that ought to be bound to a component's lifecycle.\n */\nconst withSafeTimeout = createHigherOrderComponent< TimeoutProps >(\n\t< TProps extends TimeoutProps >(\n\t\tOriginalComponent: ComponentType< TProps >\n\t) => {\n\t\treturn class WrappedComponent extends Component<\n\t\t\tOmit< TProps, keyof TimeoutProps >\n\t\t> {\n\t\t\ttimeouts: number[];\n\n\t\t\tconstructor( props: Omit< TProps, keyof TimeoutProps > ) {\n\t\t\t\tsuper( props );\n\t\t\t\tthis.timeouts = [];\n\t\t\t\tthis.setTimeout = this.setTimeout.bind( this );\n\t\t\t\tthis.clearTimeout = this.clearTimeout.bind( this );\n\t\t\t}\n\n\t\t\tcomponentWillUnmount() {\n\t\t\t\tthis.timeouts.forEach( clearTimeout );\n\t\t\t}\n\n\t\t\tsetTimeout( fn: ( ...args: any[] ) => void, delay: number ) {\n\t\t\t\tconst id = setTimeout( () => {\n\t\t\t\t\tfn();\n\t\t\t\t\tthis.clearTimeout( id );\n\t\t\t\t}, delay );\n\t\t\t\tthis.timeouts.push( id );\n\t\t\t\treturn id;\n\t\t\t}\n\n\t\t\tclearTimeout( id: number ) {\n\t\t\t\tclearTimeout( id );\n\t\t\t\tthis.timeouts = without( this.timeouts, id );\n\t\t\t}\n\n\t\t\trender() {\n\t\t\t\tconst props = {\n\t\t\t\t\t...this.props,\n\t\t\t\t\tsetTimeout: this.setTimeout,\n\t\t\t\t\tclearTimeout: this.clearTimeout,\n\t\t\t\t} as TProps;\n\n\t\t\t\treturn <OriginalComponent { ...props } />;\n\t\t\t}\n\t\t};\n\t},\n\t'withSafeTimeout'\n);\n\nexport default withSafeTimeout;\n","/**\n * WordPress dependencies\n */\nimport { Component } from '@wordpress/element';\nimport deprecated from '@wordpress/deprecated';\n\n/**\n * Internal dependencies\n */\nimport createHigherOrderComponent from '../../utils/create-higher-order-component';\n\n/**\n * A Higher Order Component used to provide and manage internal component state\n * via props.\n *\n * @deprecated Use `useState` instead.\n *\n * @param {any} initialState Optional initial state of the component.\n *\n * @return {any} A higher order component wrapper accepting a component that takes the state props + its own props + `setState` and returning a component that only accepts the own props.\n */\nexport default function withState( initialState = {} ) {\n\tdeprecated( 'wp.compose.withState', {\n\t\tsince: '5.8',\n\t\talternative: 'wp.element.useState',\n\t} );\n\n\treturn createHigherOrderComponent( ( OriginalComponent ) => {\n\t\treturn class WrappedComponent extends Component {\n\t\t\tconstructor( /** @type {any} */ props ) {\n\t\t\t\tsuper( props );\n\n\t\t\t\tthis.setState = this.setState.bind( this );\n\n\t\t\t\tthis.state = initialState;\n\t\t\t}\n\n\t\t\trender() {\n\t\t\t\treturn (\n\t\t\t\t\t<OriginalComponent\n\t\t\t\t\t\t{ ...this.props }\n\t\t\t\t\t\t{ ...this.state }\n\t\t\t\t\t\tsetState={ this.setState }\n\t\t\t\t\t/>\n\t\t\t\t);\n\t\t\t}\n\t\t};\n\t}, 'withState' );\n}\n","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"keycodes\"];","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"dom\"];","/**\n * External dependencies\n */\nimport type { DependencyList, RefCallback } from 'react';\n\n/**\n * WordPress dependencies\n */\nimport { useCallback, useRef } from '@wordpress/element';\n\n/**\n * Effect-like ref callback. Just like with `useEffect`, this allows you to\n * return a cleanup function to be run if the ref changes or one of the\n * dependencies changes. The ref is provided as an argument to the callback\n * functions. The main difference between this and `useEffect` is that\n * the `useEffect` callback is not called when the ref changes, but this is.\n * Pass the returned ref callback as the component's ref and merge multiple refs\n * with `useMergeRefs`.\n *\n * It's worth noting that if the dependencies array is empty, there's not\n * strictly a need to clean up event handlers for example, because the node is\n * to be removed. It *is* necessary if you add dependencies because the ref\n * callback will be called multiple times for the same node.\n *\n * @param  callback     Callback with ref as argument.\n * @param  dependencies Dependencies of the callback.\n *\n * @return Ref callback.\n */\nexport default function useRefEffect< TElement = Node >(\n\tcallback: ( node: TElement ) => ( () => void ) | undefined,\n\tdependencies: DependencyList\n): RefCallback< TElement | null > {\n\tconst cleanup = useRef< ( () => void ) | undefined >();\n\treturn useCallback( ( node: TElement | null ) => {\n\t\tif ( node ) {\n\t\t\tcleanup.current = callback( node );\n\t\t} else if ( cleanup.current ) {\n\t\t\tcleanup.current();\n\t\t}\n\t}, dependencies );\n}\n","/**\n * WordPress dependencies\n */\nimport { TAB } from '@wordpress/keycodes';\nimport { focus } from '@wordpress/dom';\n\n/**\n * Internal dependencies\n */\nimport useRefEffect from '../use-ref-effect';\n\n/**\n * In Dialogs/modals, the tabbing must be constrained to the content of\n * the wrapper element. This hook adds the behavior to the returned ref.\n *\n * @return {import('react').RefCallback<Element>} Element Ref.\n *\n * @example\n * ```js\n * import { useConstrainedTabbing } from '@wordpress/compose';\n *\n * const ConstrainedTabbingExample = () => {\n *     const constrainedTabbingRef = useConstrainedTabbing()\n *     return (\n *         <div ref={ constrainedTabbingRef }>\n *             <Button />\n *             <Button />\n *         </div>\n *     );\n * }\n * ```\n */\nfunction useConstrainedTabbing() {\n\treturn useRefEffect( ( /** @type {HTMLElement} */ node ) => {\n\t\t/** @type {number|undefined} */\n\t\tlet timeoutId;\n\n\t\tfunction onKeyDown( /** @type {KeyboardEvent} */ event ) {\n\t\t\tconst { keyCode, shiftKey, target } = event;\n\n\t\t\tif ( keyCode !== TAB ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst action = shiftKey ? 'findPrevious' : 'findNext';\n\t\t\tconst nextElement =\n\t\t\t\tfocus.tabbable[ action ](\n\t\t\t\t\t/** @type {HTMLElement} */ ( target )\n\t\t\t\t) || null;\n\n\t\t\t// If the element that is about to receive focus is outside the\n\t\t\t// area, move focus to a div and insert it at the start or end of\n\t\t\t// the area, depending on the direction. Without preventing default\n\t\t\t// behaviour, the browser will then move focus to the next element.\n\t\t\tif ( node.contains( nextElement ) ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst domAction = shiftKey ? 'append' : 'prepend';\n\t\t\tconst { ownerDocument } = node;\n\t\t\tconst trap = ownerDocument.createElement( 'div' );\n\n\t\t\ttrap.tabIndex = -1;\n\t\t\tnode[ domAction ]( trap );\n\t\t\ttrap.focus();\n\t\t\t// Remove after the browser moves focus to the next element.\n\t\t\ttimeoutId = setTimeout( () => node.removeChild( trap ) );\n\t\t}\n\n\t\tnode.addEventListener( 'keydown', onKeyDown );\n\t\treturn () => {\n\t\t\tnode.removeEventListener( 'keydown', onKeyDown );\n\t\t\tclearTimeout( timeoutId );\n\t\t};\n\t}, [] );\n}\n\nexport default useConstrainedTabbing;\n","/**\n * External dependencies\n */\nimport Clipboard from 'clipboard';\n\n/**\n * WordPress dependencies\n */\nimport { useRef, useEffect, useState } from '@wordpress/element';\nimport deprecated from '@wordpress/deprecated';\n\n/* eslint-disable jsdoc/no-undefined-types */\n/**\n * Copies the text to the clipboard when the element is clicked.\n *\n * @deprecated\n *\n * @param {import('react').RefObject<string | Element | NodeListOf<Element>>} ref       Reference with the element.\n * @param {string|Function}                                                   text      The text to copy.\n * @param {number}                                                            [timeout] Optional timeout to reset the returned\n *                                                                                      state. 4 seconds by default.\n *\n * @return {boolean} Whether or not the text has been copied. Resets after the\n *                   timeout.\n */\nexport default function useCopyOnClick( ref, text, timeout = 4000 ) {\n\t/* eslint-enable jsdoc/no-undefined-types */\n\tdeprecated( 'wp.compose.useCopyOnClick', {\n\t\tsince: '5.8',\n\t\talternative: 'wp.compose.useCopyToClipboard',\n\t} );\n\n\t/** @type {import('react').MutableRefObject<Clipboard | undefined>} */\n\tconst clipboard = useRef();\n\tconst [ hasCopied, setHasCopied ] = useState( false );\n\n\tuseEffect( () => {\n\t\t/** @type {number | undefined} */\n\t\tlet timeoutId;\n\n\t\tif ( ! ref.current ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Clipboard listens to click events.\n\t\tclipboard.current = new Clipboard( ref.current, {\n\t\t\ttext: () => ( typeof text === 'function' ? text() : text ),\n\t\t} );\n\n\t\tclipboard.current.on( 'success', ( { clearSelection, trigger } ) => {\n\t\t\t// Clearing selection will move focus back to the triggering button,\n\t\t\t// ensuring that it is not reset to the body, and further that it is\n\t\t\t// kept within the rendered node.\n\t\t\tclearSelection();\n\n\t\t\t// Handle ClipboardJS focus bug, see https://github.com/zenorocha/clipboard.js/issues/680\n\t\t\tif ( trigger ) {\n\t\t\t\t/** @type {HTMLElement} */ ( trigger ).focus();\n\t\t\t}\n\n\t\t\tif ( timeout ) {\n\t\t\t\tsetHasCopied( true );\n\t\t\t\tclearTimeout( timeoutId );\n\t\t\t\ttimeoutId = setTimeout( () => setHasCopied( false ), timeout );\n\t\t\t}\n\t\t} );\n\n\t\treturn () => {\n\t\t\tif ( clipboard.current ) {\n\t\t\t\tclipboard.current.destroy();\n\t\t\t}\n\t\t\tclearTimeout( timeoutId );\n\t\t};\n\t}, [ text, timeout, setHasCopied ] );\n\n\treturn hasCopied;\n}\n","/**\n * External dependencies\n */\nimport Clipboard from 'clipboard';\n\n/**\n * WordPress dependencies\n */\nimport { useRef } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport useRefEffect from '../use-ref-effect';\n\n/**\n * @template T\n * @param {T} value\n * @return {import('react').RefObject<T>} The updated ref\n */\nfunction useUpdatedRef( value ) {\n\tconst ref = useRef( value );\n\tref.current = value;\n\treturn ref;\n}\n\n/**\n * Copies the given text to the clipboard when the element is clicked.\n *\n * @template {HTMLElement} TElementType\n * @param {string | (() => string)} text      The text to copy. Use a function if not\n *                                            already available and expensive to compute.\n * @param {Function}                onSuccess Called when to text is copied.\n *\n * @return {import('react').Ref<TElementType>} A ref to assign to the target element.\n */\nexport default function useCopyToClipboard( text, onSuccess ) {\n\t// Store the dependencies as refs and continuesly update them so they're\n\t// fresh when the callback is called.\n\tconst textRef = useUpdatedRef( text );\n\tconst onSuccessRef = useUpdatedRef( onSuccess );\n\treturn useRefEffect( ( node ) => {\n\t\t// Clipboard listens to click events.\n\t\tconst clipboard = new Clipboard( node, {\n\t\t\ttext() {\n\t\t\t\treturn typeof textRef.current === 'function'\n\t\t\t\t\t? textRef.current()\n\t\t\t\t\t: textRef.current || '';\n\t\t\t},\n\t\t} );\n\n\t\tclipboard.on( 'success', ( { clearSelection } ) => {\n\t\t\t// Clearing selection will move focus back to the triggering\n\t\t\t// button, ensuring that it is not reset to the body, and\n\t\t\t// further that it is kept within the rendered node.\n\t\t\tclearSelection();\n\t\t\t// Handle ClipboardJS focus bug, see\n\t\t\t// https://github.com/zenorocha/clipboard.js/issues/680\n\t\t\tnode.focus();\n\n\t\t\tif ( onSuccessRef.current ) {\n\t\t\t\tonSuccessRef.current();\n\t\t\t}\n\t\t} );\n\n\t\treturn () => {\n\t\t\tclipboard.destroy();\n\t\t};\n\t}, [] );\n}\n","/**\n * WordPress dependencies\n */\nimport { useRef, useEffect, useCallback } from '@wordpress/element';\nimport { focus } from '@wordpress/dom';\n\n/**\n * Hook used to focus the first tabbable element on mount.\n *\n * @param {boolean | 'firstElement'} focusOnMount Focus on mount mode.\n * @return {import('react').RefCallback<HTMLElement>} Ref callback.\n *\n * @example\n * ```js\n * import { useFocusOnMount } from '@wordpress/compose';\n *\n * const WithFocusOnMount = () => {\n *     const ref = useFocusOnMount()\n *     return (\n *         <div ref={ ref }>\n *             <Button />\n *             <Button />\n *         </div>\n *     );\n * }\n * ```\n */\nexport default function useFocusOnMount( focusOnMount = 'firstElement' ) {\n\tconst focusOnMountRef = useRef( focusOnMount );\n\tuseEffect( () => {\n\t\tfocusOnMountRef.current = focusOnMount;\n\t}, [ focusOnMount ] );\n\n\treturn useCallback( ( node ) => {\n\t\tif ( ! node || focusOnMountRef.current === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( node.contains( node.ownerDocument?.activeElement ?? null ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tlet target = node;\n\n\t\tif ( focusOnMountRef.current === 'firstElement' ) {\n\t\t\tconst firstTabbable = focus.tabbable.find( node )[ 0 ];\n\n\t\t\tif ( firstTabbable ) {\n\t\t\t\ttarget = /** @type {HTMLElement} */ ( firstTabbable );\n\t\t\t}\n\t\t}\n\n\t\ttarget.focus();\n\t}, [] );\n}\n","/**\n * WordPress dependencies\n */\nimport { useRef, useEffect, useCallback } from '@wordpress/element';\n\n/**\n * When opening modals/sidebars/dialogs, the focus\n * must move to the opened area and return to the\n * previously focused element when closed.\n * The current hook implements the returning behavior.\n *\n * @param {() => void} [onFocusReturn] Overrides the default return behavior.\n * @return {import('react').RefCallback<HTMLElement>} Element Ref.\n *\n * @example\n * ```js\n * import { useFocusReturn } from '@wordpress/compose';\n *\n * const WithFocusReturn = () => {\n *     const ref = useFocusReturn()\n *     return (\n *         <div ref={ ref }>\n *             <Button />\n *             <Button />\n *         </div>\n *     );\n * }\n * ```\n */\nfunction useFocusReturn( onFocusReturn ) {\n\t/** @type {import('react').MutableRefObject<null | HTMLElement>} */\n\tconst ref = useRef( null );\n\t/** @type {import('react').MutableRefObject<null | Element>} */\n\tconst focusedBeforeMount = useRef( null );\n\tconst onFocusReturnRef = useRef( onFocusReturn );\n\tuseEffect( () => {\n\t\tonFocusReturnRef.current = onFocusReturn;\n\t}, [ onFocusReturn ] );\n\n\treturn useCallback( ( node ) => {\n\t\tif ( node ) {\n\t\t\t// Set ref to be used when unmounting.\n\t\t\tref.current = node;\n\n\t\t\t// Only set when the node mounts.\n\t\t\tif ( focusedBeforeMount.current ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfocusedBeforeMount.current = node.ownerDocument.activeElement;\n\t\t} else if ( focusedBeforeMount.current ) {\n\t\t\tconst isFocused = ref.current?.contains(\n\t\t\t\tref.current?.ownerDocument.activeElement\n\t\t\t);\n\n\t\t\tif ( ref.current?.isConnected && ! isFocused ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Defer to the component's own explicit focus return behavior, if\n\t\t\t// specified. This allows for support that the `onFocusReturn`\n\t\t\t// decides to allow the default behavior to occur under some\n\t\t\t// conditions.\n\t\t\tif ( onFocusReturnRef.current ) {\n\t\t\t\tonFocusReturnRef.current();\n\t\t\t} else {\n\t\t\t\t/** @type {null | HTMLElement} */ ( focusedBeforeMount.current )?.focus();\n\t\t\t}\n\t\t}\n\t}, [] );\n}\n\nexport default useFocusReturn;\n","/**\n * External dependencies\n */\nimport { includes } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { useCallback, useEffect, useRef } from '@wordpress/element';\n\n/**\n * Input types which are classified as button types, for use in considering\n * whether element is a (focus-normalized) button.\n *\n * @type {string[]}\n */\nconst INPUT_BUTTON_TYPES = [ 'button', 'submit' ];\n\n/**\n * @typedef {HTMLButtonElement | HTMLLinkElement | HTMLInputElement} FocusNormalizedButton\n */\n\n// Disable reason: Rule doesn't support predicate return types.\n/* eslint-disable jsdoc/valid-types */\n/**\n * Returns true if the given element is a button element subject to focus\n * normalization, or false otherwise.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus\n *\n * @param {EventTarget} eventTarget The target from a mouse or touch event.\n *\n * @return {eventTarget is FocusNormalizedButton} Whether element is a button.\n */\nfunction isFocusNormalizedButton( eventTarget ) {\n\tif ( ! ( eventTarget instanceof window.HTMLElement ) ) {\n\t\treturn false;\n\t}\n\tswitch ( eventTarget.nodeName ) {\n\t\tcase 'A':\n\t\tcase 'BUTTON':\n\t\t\treturn true;\n\n\t\tcase 'INPUT':\n\t\t\treturn includes(\n\t\t\t\tINPUT_BUTTON_TYPES,\n\t\t\t\t/** @type {HTMLInputElement} */ ( eventTarget ).type\n\t\t\t);\n\t}\n\n\treturn false;\n}\n/* eslint-enable jsdoc/valid-types */\n\n/**\n * @typedef {import('react').SyntheticEvent} SyntheticEvent\n */\n\n/**\n * @callback EventCallback\n * @param {SyntheticEvent} event input related event.\n */\n\n/**\n * @typedef FocusOutsideReactElement\n * @property {EventCallback} handleFocusOutside callback for a focus outside event.\n */\n\n/**\n * @typedef {import('react').MutableRefObject<FocusOutsideReactElement | undefined>} FocusOutsideRef\n */\n\n/**\n * @typedef {Object} FocusOutsideReturnValue\n * @property {EventCallback} onFocus      An event handler for focus events.\n * @property {EventCallback} onBlur       An event handler for blur events.\n * @property {EventCallback} onMouseDown  An event handler for mouse down events.\n * @property {EventCallback} onMouseUp    An event handler for mouse up events.\n * @property {EventCallback} onTouchStart An event handler for touch start events.\n * @property {EventCallback} onTouchEnd   An event handler for touch end events.\n */\n\n/**\n * A react hook that can be used to check whether focus has moved outside the\n * element the event handlers are bound to.\n *\n * @param {EventCallback} onFocusOutside A callback triggered when focus moves outside\n *                                       the element the event handlers are bound to.\n *\n * @return {FocusOutsideReturnValue} An object containing event handlers. Bind the event handlers\n *                                   to a wrapping element element to capture when focus moves\n *                                   outside that element.\n */\nexport default function useFocusOutside( onFocusOutside ) {\n\tconst currentOnFocusOutside = useRef( onFocusOutside );\n\tuseEffect( () => {\n\t\tcurrentOnFocusOutside.current = onFocusOutside;\n\t}, [ onFocusOutside ] );\n\n\tconst preventBlurCheck = useRef( false );\n\n\t/**\n\t * @type {import('react').MutableRefObject<number | undefined>}\n\t */\n\tconst blurCheckTimeoutId = useRef();\n\n\t/**\n\t * Cancel a blur check timeout.\n\t */\n\tconst cancelBlurCheck = useCallback( () => {\n\t\tclearTimeout( blurCheckTimeoutId.current );\n\t}, [] );\n\n\t// Cancel blur checks on unmount.\n\tuseEffect( () => {\n\t\treturn () => cancelBlurCheck();\n\t}, [] );\n\n\t// Cancel a blur check if the callback or ref is no longer provided.\n\tuseEffect( () => {\n\t\tif ( ! onFocusOutside ) {\n\t\t\tcancelBlurCheck();\n\t\t}\n\t}, [ onFocusOutside, cancelBlurCheck ] );\n\n\t/**\n\t * Handles a mousedown or mouseup event to respectively assign and\n\t * unassign a flag for preventing blur check on button elements. Some\n\t * browsers, namely Firefox and Safari, do not emit a focus event on\n\t * button elements when clicked, while others do. The logic here\n\t * intends to normalize this as treating click on buttons as focus.\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus\n\t *\n\t * @param {SyntheticEvent} event Event for mousedown or mouseup.\n\t */\n\tconst normalizeButtonFocus = useCallback( ( event ) => {\n\t\tconst { type, target } = event;\n\t\tconst isInteractionEnd = includes( [ 'mouseup', 'touchend' ], type );\n\n\t\tif ( isInteractionEnd ) {\n\t\t\tpreventBlurCheck.current = false;\n\t\t} else if ( isFocusNormalizedButton( target ) ) {\n\t\t\tpreventBlurCheck.current = true;\n\t\t}\n\t}, [] );\n\n\t/**\n\t * A callback triggered when a blur event occurs on the element the handler\n\t * is bound to.\n\t *\n\t * Calls the `onFocusOutside` callback in an immediate timeout if focus has\n\t * move outside the bound element and is still within the document.\n\t *\n\t * @param {SyntheticEvent} event Blur event.\n\t */\n\tconst queueBlurCheck = useCallback( ( event ) => {\n\t\t// React does not allow using an event reference asynchronously\n\t\t// due to recycling behavior, except when explicitly persisted.\n\t\tevent.persist();\n\n\t\t// Skip blur check if clicking button. See `normalizeButtonFocus`.\n\t\tif ( preventBlurCheck.current ) {\n\t\t\treturn;\n\t\t}\n\n\t\tblurCheckTimeoutId.current = setTimeout( () => {\n\t\t\t// If document is not focused then focus should remain\n\t\t\t// inside the wrapped component and therefore we cancel\n\t\t\t// this blur event thereby leaving focus in place.\n\t\t\t// https://developer.mozilla.org/en-US/docs/Web/API/Document/hasFocus.\n\t\t\tif ( ! document.hasFocus() ) {\n\t\t\t\tevent.preventDefault();\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( 'function' === typeof currentOnFocusOutside.current ) {\n\t\t\t\tcurrentOnFocusOutside.current( event );\n\t\t\t}\n\t\t}, 0 );\n\t}, [] );\n\n\treturn {\n\t\tonFocus: cancelBlurCheck,\n\t\tonMouseDown: normalizeButtonFocus,\n\t\tonMouseUp: normalizeButtonFocus,\n\t\tonTouchStart: normalizeButtonFocus,\n\t\tonTouchEnd: normalizeButtonFocus,\n\t\tonBlur: queueBlurCheck,\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport { useRef, useCallback, useLayoutEffect } from '@wordpress/element';\n\n/* eslint-disable jsdoc/valid-types */\n/**\n * @template T\n * @typedef {T extends import('react').Ref<infer R> ? R : never} TypeFromRef\n */\n/* eslint-enable jsdoc/valid-types */\n\n/**\n * @template T\n * @param {import('react').Ref<T>} ref\n * @param {T}                      value\n */\nfunction assignRef( ref, value ) {\n\tif ( typeof ref === 'function' ) {\n\t\tref( value );\n\t} else if ( ref && ref.hasOwnProperty( 'current' ) ) {\n\t\t/* eslint-disable jsdoc/no-undefined-types */\n\t\t/** @type {import('react').MutableRefObject<T>} */ ( ref ).current = value;\n\t\t/* eslint-enable jsdoc/no-undefined-types */\n\t}\n}\n\n/**\n * Merges refs into one ref callback.\n *\n * It also ensures that the merged ref callbacks are only called when they\n * change (as a result of a `useCallback` dependency update) OR when the ref\n * value changes, just as React does when passing a single ref callback to the\n * component.\n *\n * As expected, if you pass a new function on every render, the ref callback\n * will be called after every render.\n *\n * If you don't wish a ref callback to be called after every render, wrap it\n * with `useCallback( callback, dependencies )`. When a dependency changes, the\n * old ref callback will be called with `null` and the new ref callback will be\n * called with the same value.\n *\n * To make ref callbacks easier to use, you can also pass the result of\n * `useRefEffect`, which makes cleanup easier by allowing you to return a\n * cleanup function instead of handling `null`.\n *\n * It's also possible to _disable_ a ref (and its behaviour) by simply not\n * passing the ref.\n *\n * ```jsx\n * const ref = useRefEffect( ( node ) => {\n *   node.addEventListener( ... );\n *   return () => {\n *     node.removeEventListener( ... );\n *   };\n * }, [ ...dependencies ] );\n * const otherRef = useRef();\n * const mergedRefs useMergeRefs( [\n *   enabled && ref,\n *   otherRef,\n * ] );\n * return <div ref={ mergedRefs } />;\n * ```\n *\n * @template {import('react').Ref<any>} TRef\n * @param {Array<TRef>} refs The refs to be merged.\n *\n * @return {import('react').RefCallback<TypeFromRef<TRef>>} The merged ref callback.\n */\nexport default function useMergeRefs( refs ) {\n\tconst element = useRef();\n\tconst didElementChange = useRef( false );\n\t/* eslint-disable jsdoc/no-undefined-types */\n\t/** @type {import('react').MutableRefObject<TRef[]>} */\n\t/* eslint-enable jsdoc/no-undefined-types */\n\tconst previousRefs = useRef( [] );\n\tconst currentRefs = useRef( refs );\n\n\t// Update on render before the ref callback is called, so the ref callback\n\t// always has access to the current refs.\n\tcurrentRefs.current = refs;\n\n\t// If any of the refs change, call the previous ref with `null` and the new\n\t// ref with the node, except when the element changes in the same cycle, in\n\t// which case the ref callbacks will already have been called.\n\tuseLayoutEffect( () => {\n\t\tif ( didElementChange.current === false ) {\n\t\t\trefs.forEach( ( ref, index ) => {\n\t\t\t\tconst previousRef = previousRefs.current[ index ];\n\t\t\t\tif ( ref !== previousRef ) {\n\t\t\t\t\tassignRef( previousRef, null );\n\t\t\t\t\tassignRef( ref, element.current );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\tpreviousRefs.current = refs;\n\t}, refs );\n\n\t// No dependencies, must be reset after every render so ref callbacks are\n\t// correctly called after a ref change.\n\tuseLayoutEffect( () => {\n\t\tdidElementChange.current = false;\n\t} );\n\n\t// There should be no dependencies so that `callback` is only called when\n\t// the node changes.\n\treturn useCallback( ( value ) => {\n\t\t// Update the element so it can be used when calling ref callbacks on a\n\t\t// dependency change.\n\t\tassignRef( element, value );\n\n\t\tdidElementChange.current = true;\n\n\t\t// When an element changes, the current ref callback should be called\n\t\t// with the new element and the previous one with `null`.\n\t\tconst refsToAssign = value ? currentRefs.current : previousRefs.current;\n\n\t\t// Update the latest refs.\n\t\tfor ( const ref of refsToAssign ) {\n\t\t\tassignRef( ref, value );\n\t\t}\n\t}, [] );\n}\n","/**\n * WordPress dependencies\n */\nimport { useRef, useEffect, useCallback } from '@wordpress/element';\nimport { ESCAPE } from '@wordpress/keycodes';\n\n/**\n * Internal dependencies\n */\nimport useConstrainedTabbing from '../use-constrained-tabbing';\nimport useFocusOnMount from '../use-focus-on-mount';\nimport useFocusReturn from '../use-focus-return';\nimport useFocusOutside from '../use-focus-outside';\nimport useMergeRefs from '../use-merge-refs';\n\n/* eslint-disable jsdoc/valid-types */\n/**\n * @typedef DialogOptions\n * @property {Parameters<useFocusOnMount>[0]} focusOnMount Focus on mount arguments.\n * @property {() => void}                     onClose      Function to call when the dialog is closed.\n */\n/* eslint-enable jsdoc/valid-types */\n\n/**\n * Returns a ref and props to apply to a dialog wrapper to enable the following behaviors:\n *  - constrained tabbing.\n *  - focus on mount.\n *  - return focus on unmount.\n *  - focus outside.\n *\n * @param {DialogOptions} options Dialog Options.\n */\nfunction useDialog( options ) {\n\t/**\n\t * @type {import('react').MutableRefObject<DialogOptions | undefined>}\n\t */\n\tconst currentOptions = useRef();\n\tuseEffect( () => {\n\t\tcurrentOptions.current = options;\n\t}, Object.values( options ) );\n\tconst constrainedTabbingRef = useConstrainedTabbing();\n\tconst focusOnMountRef = useFocusOnMount( options.focusOnMount );\n\tconst focusReturnRef = useFocusReturn();\n\tconst focusOutsideProps = useFocusOutside( ( event ) => {\n\t\t// This unstable prop  is here only to manage backward compatibility\n\t\t// for the Popover component otherwise, the onClose should be enough.\n\t\t// @ts-ignore unstable property\n\t\tif ( currentOptions.current?.__unstableOnClose ) {\n\t\t\t// @ts-ignore unstable property\n\t\t\tcurrentOptions.current.__unstableOnClose( 'focus-outside', event );\n\t\t} else if ( currentOptions.current?.onClose ) {\n\t\t\tcurrentOptions.current.onClose();\n\t\t}\n\t} );\n\tconst closeOnEscapeRef = useCallback( ( node ) => {\n\t\tif ( ! node ) {\n\t\t\treturn;\n\t\t}\n\n\t\tnode.addEventListener( 'keydown', (\n\t\t\t/** @type {KeyboardEvent} */ event\n\t\t) => {\n\t\t\t// Close on escape.\n\t\t\tif (\n\t\t\t\tevent.keyCode === ESCAPE &&\n\t\t\t\t! event.defaultPrevented &&\n\t\t\t\tcurrentOptions.current?.onClose\n\t\t\t) {\n\t\t\t\tevent.preventDefault();\n\t\t\t\tcurrentOptions.current.onClose();\n\t\t\t}\n\t\t} );\n\t}, [] );\n\n\treturn [\n\t\tuseMergeRefs( [\n\t\t\toptions.focusOnMount !== false ? constrainedTabbingRef : null,\n\t\t\toptions.focusOnMount !== false ? focusReturnRef : null,\n\t\t\toptions.focusOnMount !== false ? focusOnMountRef : null,\n\t\t\tcloseOnEscapeRef,\n\t\t] ),\n\t\t{\n\t\t\t...focusOutsideProps,\n\t\t\ttabIndex: '-1',\n\t\t},\n\t];\n}\n\nexport default useDialog;\n","/**\n * External dependencies\n */\nimport { includes, debounce } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { useCallback, useLayoutEffect, useRef } from '@wordpress/element';\nimport { focus } from '@wordpress/dom';\n\n/**\n * Names of control nodes which qualify for disabled behavior.\n *\n * See WHATWG HTML Standard: 4.10.18.5: \"Enabling and disabling form controls: the disabled attribute\".\n *\n * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#enabling-and-disabling-form-controls:-the-disabled-attribute\n *\n * @type {string[]}\n */\nconst DISABLED_ELIGIBLE_NODE_NAMES = [\n\t'BUTTON',\n\t'FIELDSET',\n\t'INPUT',\n\t'OPTGROUP',\n\t'OPTION',\n\t'SELECT',\n\t'TEXTAREA',\n];\n\n/**\n * In some circumstances, such as block previews, all focusable DOM elements\n * (input fields, links, buttons, etc.) need to be disabled. This hook adds the\n * behavior to disable nested DOM elements to the returned ref.\n *\n * @return {import('react').RefObject<HTMLElement>} Element Ref.\n *\n * @example\n * ```js\n * import { __experimentalUseDisabled as useDisabled } from '@wordpress/compose';\n * const DisabledExample = () => {\n * \tconst disabledRef = useDisabled();\n *\treturn (\n *\t\t<div ref={ disabledRef }>\n *\t\t\t<a href=\"#\">This link will have tabindex set to -1</a>\n *\t\t\t<input placeholder=\"This input will have the disabled attribute added to it.\" type=\"text\" />\n *\t\t</div>\n *\t);\n * };\n * ```\n */\nexport default function useDisabled() {\n\t/** @type {import('react').RefObject<HTMLElement>} */\n\tconst node = useRef( null );\n\n\tconst disable = () => {\n\t\tif ( ! node.current ) {\n\t\t\treturn;\n\t\t}\n\n\t\tfocus.focusable.find( node.current ).forEach( ( focusable ) => {\n\t\t\tif (\n\t\t\t\tincludes( DISABLED_ELIGIBLE_NODE_NAMES, focusable.nodeName )\n\t\t\t) {\n\t\t\t\tfocusable.setAttribute( 'disabled', '' );\n\t\t\t}\n\n\t\t\tif ( focusable.nodeName === 'A' ) {\n\t\t\t\tfocusable.setAttribute( 'tabindex', '-1' );\n\t\t\t}\n\n\t\t\tconst tabIndex = focusable.getAttribute( 'tabindex' );\n\t\t\tif ( tabIndex !== null && tabIndex !== '-1' ) {\n\t\t\t\tfocusable.removeAttribute( 'tabindex' );\n\t\t\t}\n\n\t\t\tif ( focusable.hasAttribute( 'contenteditable' ) ) {\n\t\t\t\tfocusable.setAttribute( 'contenteditable', 'false' );\n\t\t\t}\n\t\t} );\n\t};\n\n\t// Debounce re-disable since disabling process itself will incur\n\t// additional mutations which should be ignored.\n\tconst debouncedDisable = useCallback(\n\t\tdebounce( disable, undefined, { leading: true } ),\n\t\t[]\n\t);\n\n\tuseLayoutEffect( () => {\n\t\tdisable();\n\n\t\t/** @type {MutationObserver | undefined} */\n\t\tlet observer;\n\t\tif ( node.current ) {\n\t\t\tobserver = new window.MutationObserver( debouncedDisable );\n\t\t\tobserver.observe( node.current, {\n\t\t\t\tchildList: true,\n\t\t\t\tattributes: true,\n\t\t\t\tsubtree: true,\n\t\t\t} );\n\t\t}\n\n\t\treturn () => {\n\t\t\tif ( observer ) {\n\t\t\t\tobserver.disconnect();\n\t\t\t}\n\t\t\tdebouncedDisable.cancel();\n\t\t};\n\t}, [] );\n\n\treturn node;\n}\n","/**\n * WordPress dependencies\n */\nimport { useEffect, useLayoutEffect } from '@wordpress/element';\n\n/**\n * Preferred over direct usage of `useLayoutEffect` when supporting\n * server rendered components (SSR) because currently React\n * throws a warning when using useLayoutEffect in that environment.\n */\nconst useIsomorphicLayoutEffect =\n\ttypeof window !== 'undefined' ? useLayoutEffect : useEffect;\n\nexport default useIsomorphicLayoutEffect;\n","/**\n * WordPress dependencies\n */\nimport { useCallback, useEffect, useRef, useState } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport useIsomorphicLayoutEffect from '../use-isomorphic-layout-effect';\n\n/**\n * @param {Object}                  props\n * @param {(e: MouseEvent) => void} props.onDragStart\n * @param {(e: MouseEvent) => void} props.onDragMove\n * @param {(e: MouseEvent) => void} props.onDragEnd\n */\nexport default function useDragging( { onDragStart, onDragMove, onDragEnd } ) {\n\tconst [ isDragging, setIsDragging ] = useState( false );\n\n\tconst eventsRef = useRef( {\n\t\tonDragStart,\n\t\tonDragMove,\n\t\tonDragEnd,\n\t} );\n\tuseIsomorphicLayoutEffect( () => {\n\t\teventsRef.current.onDragStart = onDragStart;\n\t\teventsRef.current.onDragMove = onDragMove;\n\t\teventsRef.current.onDragEnd = onDragEnd;\n\t}, [ onDragStart, onDragMove, onDragEnd ] );\n\n\tconst onMouseMove = useCallback(\n\t\t( /** @type {MouseEvent} */ event ) =>\n\t\t\teventsRef.current.onDragMove &&\n\t\t\teventsRef.current.onDragMove( event ),\n\t\t[]\n\t);\n\tconst endDrag = useCallback( ( /** @type {MouseEvent} */ event ) => {\n\t\tif ( eventsRef.current.onDragEnd ) {\n\t\t\teventsRef.current.onDragEnd( event );\n\t\t}\n\t\tdocument.removeEventListener( 'mousemove', onMouseMove );\n\t\tdocument.removeEventListener( 'mouseup', endDrag );\n\t\tsetIsDragging( false );\n\t}, [] );\n\tconst startDrag = useCallback( ( /** @type {MouseEvent} */ event ) => {\n\t\tif ( eventsRef.current.onDragStart ) {\n\t\t\teventsRef.current.onDragStart( event );\n\t\t}\n\t\tdocument.addEventListener( 'mousemove', onMouseMove );\n\t\tdocument.addEventListener( 'mouseup', endDrag );\n\t\tsetIsDragging( true );\n\t}, [] );\n\n\t// Remove the global events when unmounting if needed.\n\tuseEffect( () => {\n\t\treturn () => {\n\t\t\tif ( isDragging ) {\n\t\t\t\tdocument.removeEventListener( 'mousemove', onMouseMove );\n\t\t\t\tdocument.removeEventListener( 'mouseup', endDrag );\n\t\t\t}\n\t\t};\n\t}, [ isDragging ] );\n\n\treturn {\n\t\tstartDrag,\n\t\tendDrag,\n\t\tisDragging,\n\t};\n}\n","/**\n * External dependencies\n */\nimport Mousetrap from 'mousetrap';\nimport 'mousetrap/plugins/global-bind/mousetrap-global-bind';\nimport { includes, castArray } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { useEffect, useRef } from '@wordpress/element';\n\n/**\n * A block selection object.\n *\n * @typedef {Object} WPKeyboardShortcutConfig\n *\n * @property {boolean}                                [bindGlobal] Handle keyboard events anywhere including inside textarea/input fields.\n * @property {string}                                 [eventName]  Event name used to trigger the handler, defaults to keydown.\n * @property {boolean}                                [isDisabled] Disables the keyboard handler if the value is true.\n * @property {import('react').RefObject<HTMLElement>} [target]     React reference to the DOM element used to catch the keyboard event.\n */\n\n/**\n * Return true if platform is MacOS.\n *\n * @param {Window} [_window] window object by default; used for DI testing.\n *\n * @return {boolean} True if MacOS; false otherwise.\n */\nfunction isAppleOS( _window = window ) {\n\tconst { platform } = _window.navigator;\n\n\treturn (\n\t\tplatform.indexOf( 'Mac' ) !== -1 ||\n\t\tincludes( [ 'iPad', 'iPhone' ], platform )\n\t);\n}\n\n/* eslint-disable jsdoc/valid-types */\n/**\n * Attach a keyboard shortcut handler.\n *\n * @see https://craig.is/killing/mice#api.bind for information about the `callback` parameter.\n *\n * @param {string[]|string}                                                       shortcuts Keyboard Shortcuts.\n * @param {(e: import('mousetrap').ExtendedKeyboardEvent, combo: string) => void} callback  Shortcut callback.\n * @param {WPKeyboardShortcutConfig}                                              options   Shortcut options.\n */\nfunction useKeyboardShortcut(\n\t/* eslint-enable jsdoc/valid-types */\n\tshortcuts,\n\tcallback,\n\t{\n\t\tbindGlobal = false,\n\t\teventName = 'keydown',\n\t\tisDisabled = false, // This is important for performance considerations.\n\t\ttarget,\n\t} = {}\n) {\n\tconst currentCallback = useRef( callback );\n\tuseEffect( () => {\n\t\tcurrentCallback.current = callback;\n\t}, [ callback ] );\n\n\tuseEffect( () => {\n\t\tif ( isDisabled ) {\n\t\t\treturn;\n\t\t}\n\t\tconst mousetrap = new Mousetrap(\n\t\t\ttarget && target.current\n\t\t\t\t? target.current\n\t\t\t\t: // We were passing `document` here previously, so to successfully cast it to Element we must cast it first to `unknown`.\n\t\t\t\t  // Not sure if this is a mistake but it was the behavior previous to the addition of types so we're just doing what's\n\t\t\t\t  // necessary to maintain the existing behavior.\n\t\t\t\t  /** @type {Element} */ (/** @type {unknown} */ ( document ))\n\t\t);\n\t\tcastArray( shortcuts ).forEach( ( shortcut ) => {\n\t\t\tconst keys = shortcut.split( '+' );\n\t\t\t// Determines whether a key is a modifier by the length of the string.\n\t\t\t// E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that\n\t\t\t// the modifiers are Shift and Cmd because they're not a single character.\n\t\t\tconst modifiers = new Set(\n\t\t\t\tkeys.filter( ( value ) => value.length > 1 )\n\t\t\t);\n\t\t\tconst hasAlt = modifiers.has( 'alt' );\n\t\t\tconst hasShift = modifiers.has( 'shift' );\n\n\t\t\t// This should be better moved to the shortcut registration instead.\n\t\t\tif (\n\t\t\t\tisAppleOS() &&\n\t\t\t\t( ( modifiers.size === 1 && hasAlt ) ||\n\t\t\t\t\t( modifiers.size === 2 && hasAlt && hasShift ) )\n\t\t\t) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Cannot bind ${ shortcut }. Alt and Shift+Alt modifiers are reserved for character input.`\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tconst bindFn = bindGlobal ? 'bindGlobal' : 'bind';\n\t\t\t// @ts-ignore `bindGlobal` is an undocumented property\n\t\t\tmousetrap[ bindFn ](\n\t\t\t\tshortcut,\n\t\t\t\t(\n\t\t\t\t\t/* eslint-disable jsdoc/valid-types */\n\t\t\t\t\t/** @type {[e: import('mousetrap').ExtendedKeyboardEvent, combo: string]} */ ...args\n\t\t\t\t) =>\n\t\t\t\t\t/* eslint-enable jsdoc/valid-types */\n\t\t\t\t\tcurrentCallback.current( ...args ),\n\t\t\t\teventName\n\t\t\t);\n\t\t} );\n\n\t\treturn () => {\n\t\t\tmousetrap.reset();\n\t\t};\n\t}, [ shortcuts, bindGlobal, eventName, target, isDisabled ] );\n}\n\nexport default useKeyboardShortcut;\n","/**\n * WordPress dependencies\n */\nimport { useState, useEffect } from '@wordpress/element';\n\n/**\n * Runs a media query and returns its value when it changes.\n *\n * @param {string} [query] Media Query.\n * @return {boolean} return value of the media query.\n */\nexport default function useMediaQuery( query ) {\n\tconst [ match, setMatch ] = useState(\n\t\t() =>\n\t\t\t!! (\n\t\t\t\tquery &&\n\t\t\t\ttypeof window !== 'undefined' &&\n\t\t\t\twindow.matchMedia( query ).matches\n\t\t\t)\n\t);\n\n\tuseEffect( () => {\n\t\tif ( ! query ) {\n\t\t\treturn;\n\t\t}\n\t\tconst updateMatch = () =>\n\t\t\tsetMatch( window.matchMedia( query ).matches );\n\t\tupdateMatch();\n\t\tconst list = window.matchMedia( query );\n\t\tlist.addListener( updateMatch );\n\t\treturn () => {\n\t\t\tlist.removeListener( updateMatch );\n\t\t};\n\t}, [ query ] );\n\n\treturn !! query && match;\n}\n","/**\n * WordPress dependencies\n */\nimport { useEffect, useRef } from '@wordpress/element';\n\n/**\n * Use something's value from the previous render.\n * Based on https://usehooks.com/usePrevious/.\n *\n * @param  value The value to track.\n *\n * @return The value from the previous render.\n */\nexport default function usePrevious< T >( value: T ): T | undefined {\n\tconst ref = useRef< T >();\n\n\t// Store current value in ref.\n\tuseEffect( () => {\n\t\tref.current = value;\n\t}, [ value ] ); // Re-run when value changes.\n\n\t// Return previous value (happens before update in useEffect above).\n\treturn ref.current;\n}\n","/**\n * Internal dependencies\n */\nimport useMediaQuery from '../use-media-query';\n\n/**\n * Hook returning whether the user has a preference for reduced motion.\n *\n * @return {boolean} Reduced motion preference value.\n */\nconst useReducedMotion = () =>\n\tuseMediaQuery( '(prefers-reduced-motion: reduce)' );\n\nexport default useReducedMotion;\n","/**\n * WordPress dependencies\n */\nimport { createContext, useContext } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport useMediaQuery from '../use-media-query';\n\n/**\n * @typedef {\"huge\" | \"wide\" | \"large\" | \"medium\" | \"small\" | \"mobile\"} WPBreakpoint\n */\n\n/**\n * Hash of breakpoint names with pixel width at which it becomes effective.\n *\n * @see _breakpoints.scss\n *\n * @type {Record<WPBreakpoint, number>}\n */\nconst BREAKPOINTS = {\n\thuge: 1440,\n\twide: 1280,\n\tlarge: 960,\n\tmedium: 782,\n\tsmall: 600,\n\tmobile: 480,\n};\n\n/**\n * @typedef {\">=\" | \"<\"} WPViewportOperator\n */\n\n/**\n * Object mapping media query operators to the condition to be used.\n *\n * @type {Record<WPViewportOperator, string>}\n */\nconst CONDITIONS = {\n\t'>=': 'min-width',\n\t'<': 'max-width',\n};\n\n/**\n * Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values.\n *\n * @type {Record<WPViewportOperator, (breakpointValue: number, width: number) => boolean>}\n */\nconst OPERATOR_EVALUATORS = {\n\t'>=': ( breakpointValue, width ) => width >= breakpointValue,\n\t'<': ( breakpointValue, width ) => width < breakpointValue,\n};\n\nconst ViewportMatchWidthContext = createContext(\n\t/** @type {null | number} */ ( null )\n);\n\n/**\n * Returns true if the viewport matches the given query, or false otherwise.\n *\n * @param {WPBreakpoint}       breakpoint      Breakpoint size name.\n * @param {WPViewportOperator} [operator=\">=\"] Viewport operator.\n *\n * @example\n *\n * ```js\n * useViewportMatch( 'huge', '<' );\n * useViewportMatch( 'medium' );\n * ```\n *\n * @return {boolean} Whether viewport matches query.\n */\nconst useViewportMatch = ( breakpoint, operator = '>=' ) => {\n\tconst simulatedWidth = useContext( ViewportMatchWidthContext );\n\tconst mediaQuery =\n\t\t! simulatedWidth &&\n\t\t`(${ CONDITIONS[ operator ] }: ${ BREAKPOINTS[ breakpoint ] }px)`;\n\tconst mediaQueryResult = useMediaQuery( mediaQuery || undefined );\n\tif ( simulatedWidth ) {\n\t\treturn OPERATOR_EVALUATORS[ operator ](\n\t\t\tBREAKPOINTS[ breakpoint ],\n\t\t\tsimulatedWidth\n\t\t);\n\t}\n\treturn mediaQueryResult;\n};\n\nuseViewportMatch.__experimentalWidthProvider =\n\tViewportMatchWidthContext.Provider;\n\nexport default useViewportMatch;\n","/**\n * External dependencies\n */\nimport useResizeAware from 'react-resize-aware';\n\n/**\n * Hook which allows to listen the resize event of any target element when it changes sizes.\n * _Note: `useResizeObserver` will report `null` until after first render_\n *\n * Simply a re-export of `react-resize-aware` so refer to its documentation <https://github.com/FezVrasta/react-resize-aware>\n * for more details.\n *\n * @see https://github.com/FezVrasta/react-resize-aware\n *\n * @example\n *\n * ```js\n * const App = () => {\n * \tconst [ resizeListener, sizes ] = useResizeObserver();\n *\n * \treturn (\n * \t\t<div>\n * \t\t\t{ resizeListener }\n * \t\t\tYour content here\n * \t\t</div>\n * \t);\n * };\n * ```\n *\n */\nexport default useResizeAware;\n","var __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"priorityQueue\"];","/**\n * WordPress dependencies\n */\nimport { useEffect, useState } from '@wordpress/element';\nimport { createQueue } from '@wordpress/priority-queue';\n\ntype AsyncListConfig = {\n\tstep: number;\n};\n\n/**\n * Returns the first items from list that are present on state.\n *\n * @param  list  New array.\n * @param  state Current state.\n * @return First items present iin state.\n */\nfunction getFirstItemsPresentInState< T >( list: T[], state: T[] ): T[] {\n\tconst firstItems = [];\n\n\tfor ( let i = 0; i < list.length; i++ ) {\n\t\tconst item = list[ i ];\n\t\tif ( ! state.includes( item ) ) {\n\t\t\tbreak;\n\t\t}\n\n\t\tfirstItems.push( item );\n\t}\n\n\treturn firstItems;\n}\n\n/**\n * React hook returns an array which items get asynchronously appended from a source array.\n * This behavior is useful if we want to render a list of items asynchronously for performance reasons.\n *\n * @param  list   Source array.\n * @param  config Configuration object.\n *\n * @return Async array.\n */\nfunction useAsyncList< T >(\n\tlist: T[],\n\tconfig: AsyncListConfig = { step: 1 }\n): T[] {\n\tconst { step = 1 } = config;\n\tconst [ current, setCurrent ] = useState( [] as T[] );\n\n\tuseEffect( () => {\n\t\t// On reset, we keep the first items that were previously rendered.\n\t\tlet firstItems = getFirstItemsPresentInState( list, current );\n\t\tif ( firstItems.length < step ) {\n\t\t\tfirstItems = firstItems.concat(\n\t\t\t\tlist.slice( firstItems.length, step )\n\t\t\t);\n\t\t}\n\t\tsetCurrent( firstItems );\n\t\tlet nextIndex = firstItems.length;\n\n\t\tconst asyncQueue = createQueue();\n\t\tconst append = () => {\n\t\t\tif ( list.length <= nextIndex ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsetCurrent( ( state ) => [\n\t\t\t\t...state,\n\t\t\t\t...list.slice( nextIndex, nextIndex + step ),\n\t\t\t] );\n\t\t\tnextIndex += step;\n\t\t\tasyncQueue.add( {}, append );\n\t\t};\n\t\tasyncQueue.add( {}, append );\n\n\t\treturn () => asyncQueue.reset();\n\t}, [ list ] );\n\n\treturn current;\n}\n\nexport default useAsyncList;\n","/**\n * Internal dependencies\n */\nimport usePrevious from '../use-previous';\n\n// Disable reason: Object and object are distinctly different types in TypeScript and we mean the lowercase object in thise case\n// but eslint wants to force us to use `Object`. See https://stackoverflow.com/questions/49464634/difference-between-object-and-object-in-typescript\n/* eslint-disable jsdoc/check-types */\n/**\n * Hook that performs a shallow comparison between the preview value of an object\n * and the new one, if there's a difference, it prints it to the console.\n * this is useful in performance related work, to check why a component re-renders.\n *\n *  @example\n *\n * ```jsx\n * function MyComponent(props) {\n *    useWarnOnChange(props);\n *\n *    return \"Something\";\n * }\n * ```\n *\n * @param {object} object Object which changes to compare.\n * @param {string} prefix Just a prefix to show when console logging.\n */\nfunction useWarnOnChange( object, prefix = 'Change detection' ) {\n\tconst previousValues = usePrevious( object );\n\n\tObject.entries( previousValues ?? [] ).forEach( ( [ key, value ] ) => {\n\t\tif ( value !== object[ /** @type {keyof typeof object} */ ( key ) ] ) {\n\t\t\t// eslint-disable-next-line no-console\n\t\t\tconsole.warn(\n\t\t\t\t`${ prefix }: ${ key } key changed:`,\n\t\t\t\tvalue,\n\t\t\t\tobject[ /** @type {keyof typeof object} */ ( key ) ]\n\t\t\t\t/* eslint-enable jsdoc/check-types */\n\t\t\t);\n\t\t}\n\t} );\n}\n\nexport default useWarnOnChange;\n","import { useState, useRef, useEffect } from 'react';\n\nfunction areInputsEqual(newInputs, lastInputs) {\n  if (newInputs.length !== lastInputs.length) {\n    return false;\n  }\n\n  for (var i = 0; i < newInputs.length; i++) {\n    if (newInputs[i] !== lastInputs[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction useMemoOne(getResult, inputs) {\n  var initial = useState(function () {\n    return {\n      inputs: inputs,\n      result: getResult()\n    };\n  })[0];\n  var committed = useRef(initial);\n  var isInputMatch = Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));\n  var cache = isInputMatch ? committed.current : {\n    inputs: inputs,\n    result: getResult()\n  };\n  useEffect(function () {\n    committed.current = cache;\n  }, [cache]);\n  return cache.result;\n}\nfunction useCallbackOne(callback, inputs) {\n  return useMemoOne(function () {\n    return callback;\n  }, inputs);\n}\nvar useMemo = useMemoOne;\nvar useCallback = useCallbackOne;\n\nexport { useCallback, useCallbackOne, useMemo, useMemoOne };\n","/**\n * External dependencies\n */\nimport { debounce } from 'lodash';\nimport { useMemoOne } from 'use-memo-one';\n\n/**\n * WordPress dependencies\n */\nimport { useEffect } from '@wordpress/element';\n\n/* eslint-disable jsdoc/valid-types */\n/**\n * Debounces a function with Lodash's `debounce`. A new debounced function will\n * be returned and any scheduled calls cancelled if any of the arguments change,\n * including the function to debounce, so please wrap functions created on\n * render in components in `useCallback`.\n *\n * @see https://docs-lodash.com/v4/debounce/\n *\n * @template {(...args: any[]) => void} TFunc\n *\n * @param {TFunc}                             fn        The function to debounce.\n * @param {number}                            [wait]    The number of milliseconds to delay.\n * @param {import('lodash').DebounceSettings} [options] The options object.\n * @return {import('lodash').DebouncedFunc<TFunc>} Debounced function.\n */\nexport default function useDebounce( fn, wait, options ) {\n\t/* eslint-enable jsdoc/valid-types */\n\tconst debounced = useMemoOne( () => debounce( fn, wait, options ), [\n\t\tfn,\n\t\twait,\n\t\toptions,\n\t] );\n\tuseEffect( () => () => debounced.cancel(), [ debounced ] );\n\treturn debounced;\n}\n","/**\n * External dependencies\n */\nimport { throttle } from 'lodash';\nimport { useMemoOne } from 'use-memo-one';\n\n/**\n * WordPress dependencies\n */\nimport { useEffect } from '@wordpress/element';\n\n/**\n * Throttles a function with Lodash's `throttle`. A new throttled function will\n * be returned and any scheduled calls cancelled if any of the arguments change,\n * including the function to throttle, so please wrap functions created on\n * render in components in `useCallback`.\n *\n * @see https://docs-lodash.com/v4/throttle/\n *\n * @template {(...args: any[]) => void} TFunc\n *\n * @param {TFunc}                             fn        The function to throttle.\n * @param {number}                            [wait]    The number of milliseconds to throttle invocations to.\n * @param {import('lodash').ThrottleSettings} [options] The options object. See linked documentation for details.\n * @return {import('lodash').DebouncedFunc<TFunc>} Throttled function.\n */\nexport default function useThrottle( fn, wait, options ) {\n\tconst throttled = useMemoOne( () => throttle( fn, wait, options ), [\n\t\tfn,\n\t\twait,\n\t\toptions,\n\t] );\n\tuseEffect( () => () => throttled.cancel(), [ throttled ] );\n\treturn throttled;\n}\n","/**\n * WordPress dependencies\n */\nimport { useRef } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport useRefEffect from '../use-ref-effect';\n\n/* eslint-disable jsdoc/valid-types */\n/**\n * @template T\n * @param {T} value\n * @return {import('react').MutableRefObject<T|null>} A ref with the value.\n */\nfunction useFreshRef( value ) {\n\t/* eslint-enable jsdoc/valid-types */\n\t/* eslint-disable jsdoc/no-undefined-types */\n\t/** @type {import('react').MutableRefObject<T>} */\n\t/* eslint-enable jsdoc/no-undefined-types */\n\t// Disable reason: We're doing something pretty JavaScript-y here where the\n\t// ref will always have a current value that is not null or undefined but it\n\t// needs to start as undefined. We don't want to change the return type so\n\t// it's easier to just ts-ignore this specific line that's complaining about\n\t// undefined not being part of T.\n\t// @ts-ignore\n\tconst ref = useRef();\n\tref.current = value;\n\treturn ref;\n}\n\n/**\n * A hook to facilitate drag and drop handling.\n *\n * @param {Object}                  props             Named parameters.\n * @param {boolean}                 props.isDisabled  Whether or not to disable the drop zone.\n * @param {(e: DragEvent) => void}  props.onDragStart Called when dragging has started.\n * @param {(e: DragEvent) => void}  props.onDragEnter Called when the zone is entered.\n * @param {(e: DragEvent) => void}  props.onDragOver  Called when the zone is moved within.\n * @param {(e: DragEvent) => void}  props.onDragLeave Called when the zone is left.\n * @param {(e: MouseEvent) => void} props.onDragEnd   Called when dragging has ended.\n * @param {(e: DragEvent) => void}  props.onDrop      Called when dropping in the zone.\n *\n * @return {import('react').RefCallback<HTMLElement>} Ref callback to be passed to the drop zone element.\n */\nexport default function useDropZone( {\n\tisDisabled,\n\tonDrop: _onDrop,\n\tonDragStart: _onDragStart,\n\tonDragEnter: _onDragEnter,\n\tonDragLeave: _onDragLeave,\n\tonDragEnd: _onDragEnd,\n\tonDragOver: _onDragOver,\n} ) {\n\tconst onDropRef = useFreshRef( _onDrop );\n\tconst onDragStartRef = useFreshRef( _onDragStart );\n\tconst onDragEnterRef = useFreshRef( _onDragEnter );\n\tconst onDragLeaveRef = useFreshRef( _onDragLeave );\n\tconst onDragEndRef = useFreshRef( _onDragEnd );\n\tconst onDragOverRef = useFreshRef( _onDragOver );\n\n\treturn useRefEffect(\n\t\t( element ) => {\n\t\t\tif ( isDisabled ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tlet isDragging = false;\n\n\t\t\tconst { ownerDocument } = element;\n\n\t\t\t/**\n\t\t\t * Checks if an element is in the drop zone.\n\t\t\t *\n\t\t\t * @param {EventTarget|null} targetToCheck\n\t\t\t *\n\t\t\t * @return {boolean} True if in drop zone, false if not.\n\t\t\t */\n\t\t\tfunction isElementInZone( targetToCheck ) {\n\t\t\t\tconst { defaultView } = ownerDocument;\n\t\t\t\tif (\n\t\t\t\t\t! targetToCheck ||\n\t\t\t\t\t! defaultView ||\n\t\t\t\t\t! ( targetToCheck instanceof defaultView.HTMLElement ) ||\n\t\t\t\t\t! element.contains( targetToCheck )\n\t\t\t\t) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\t/** @type {HTMLElement|null} */\n\t\t\t\tlet elementToCheck = targetToCheck;\n\n\t\t\t\tdo {\n\t\t\t\t\tif ( elementToCheck.dataset.isDropZone ) {\n\t\t\t\t\t\treturn elementToCheck === element;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elementToCheck = elementToCheck.parentElement ) );\n\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tfunction maybeDragStart( /** @type {DragEvent} */ event ) {\n\t\t\t\tif ( isDragging ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tisDragging = true;\n\n\t\t\t\townerDocument.removeEventListener(\n\t\t\t\t\t'dragenter',\n\t\t\t\t\tmaybeDragStart\n\t\t\t\t);\n\n\t\t\t\t// Note that `dragend` doesn't fire consistently for file and\n\t\t\t\t// HTML drag events where the drag origin is outside the browser\n\t\t\t\t// window. In Firefox it may also not fire if the originating\n\t\t\t\t// node is removed.\n\t\t\t\townerDocument.addEventListener( 'dragend', maybeDragEnd );\n\t\t\t\townerDocument.addEventListener( 'mousemove', maybeDragEnd );\n\n\t\t\t\tif ( onDragStartRef.current ) {\n\t\t\t\t\tonDragStartRef.current( event );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction onDragEnter( /** @type {DragEvent} */ event ) {\n\t\t\t\tevent.preventDefault();\n\n\t\t\t\t// The `dragenter` event will also fire when entering child\n\t\t\t\t// elements, but we only want to call `onDragEnter` when\n\t\t\t\t// entering the drop zone, which means the `relatedTarget`\n\t\t\t\t// (element that has been left) should be outside the drop zone.\n\t\t\t\tif (\n\t\t\t\t\telement.contains(\n\t\t\t\t\t\t/** @type {Node} */ ( event.relatedTarget )\n\t\t\t\t\t)\n\t\t\t\t) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( onDragEnterRef.current ) {\n\t\t\t\t\tonDragEnterRef.current( event );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction onDragOver( /** @type {DragEvent} */ event ) {\n\t\t\t\t// Only call onDragOver for the innermost hovered drop zones.\n\t\t\t\tif ( ! event.defaultPrevented && onDragOverRef.current ) {\n\t\t\t\t\tonDragOverRef.current( event );\n\t\t\t\t}\n\n\t\t\t\t// Prevent the browser default while also signalling to parent\n\t\t\t\t// drop zones that `onDragOver` is already handled.\n\t\t\t\tevent.preventDefault();\n\t\t\t}\n\n\t\t\tfunction onDragLeave( /** @type {DragEvent} */ event ) {\n\t\t\t\t// The `dragleave` event will also fire when leaving child\n\t\t\t\t// elements, but we only want to call `onDragLeave` when\n\t\t\t\t// leaving the drop zone, which means the `relatedTarget`\n\t\t\t\t// (element that has been entered) should be outside the drop\n\t\t\t\t// zone.\n\t\t\t\tif ( isElementInZone( event.relatedTarget ) ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( onDragLeaveRef.current ) {\n\t\t\t\t\tonDragLeaveRef.current( event );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction onDrop( /** @type {DragEvent} */ event ) {\n\t\t\t\t// Don't handle drop if an inner drop zone already handled it.\n\t\t\t\tif ( event.defaultPrevented ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Prevent the browser default while also signalling to parent\n\t\t\t\t// drop zones that `onDrop` is already handled.\n\t\t\t\tevent.preventDefault();\n\n\t\t\t\t// This seemingly useless line has been shown to resolve a\n\t\t\t\t// Safari issue where files dragged directly from the dock are\n\t\t\t\t// not recognized.\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\tevent.dataTransfer && event.dataTransfer.files.length;\n\n\t\t\t\tif ( onDropRef.current ) {\n\t\t\t\t\tonDropRef.current( event );\n\t\t\t\t}\n\n\t\t\t\tmaybeDragEnd( event );\n\t\t\t}\n\n\t\t\tfunction maybeDragEnd( /** @type {MouseEvent} */ event ) {\n\t\t\t\tif ( ! isDragging ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tisDragging = false;\n\n\t\t\t\townerDocument.addEventListener( 'dragenter', maybeDragStart );\n\t\t\t\townerDocument.removeEventListener( 'dragend', maybeDragEnd );\n\t\t\t\townerDocument.removeEventListener( 'mousemove', maybeDragEnd );\n\n\t\t\t\tif ( onDragEndRef.current ) {\n\t\t\t\t\tonDragEndRef.current( event );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\telement.dataset.isDropZone = 'true';\n\t\t\telement.addEventListener( 'drop', onDrop );\n\t\t\telement.addEventListener( 'dragenter', onDragEnter );\n\t\t\telement.addEventListener( 'dragover', onDragOver );\n\t\t\telement.addEventListener( 'dragleave', onDragLeave );\n\t\t\t// The `dragstart` event doesn't fire if the drag started outside\n\t\t\t// the document.\n\t\t\townerDocument.addEventListener( 'dragenter', maybeDragStart );\n\n\t\t\treturn () => {\n\t\t\t\tonDropRef.current = null;\n\t\t\t\tonDragStartRef.current = null;\n\t\t\t\tonDragEnterRef.current = null;\n\t\t\t\tonDragLeaveRef.current = null;\n\t\t\t\tonDragEndRef.current = null;\n\t\t\t\tonDragOverRef.current = null;\n\t\t\t\tdelete element.dataset.isDropZone;\n\t\t\t\telement.removeEventListener( 'drop', onDrop );\n\t\t\t\telement.removeEventListener( 'dragenter', onDragEnter );\n\t\t\t\telement.removeEventListener( 'dragover', onDragOver );\n\t\t\t\telement.removeEventListener( 'dragleave', onDragLeave );\n\t\t\t\townerDocument.removeEventListener( 'dragend', maybeDragEnd );\n\t\t\t\townerDocument.removeEventListener( 'mousemove', maybeDragEnd );\n\t\t\t\townerDocument.addEventListener( 'dragenter', maybeDragStart );\n\t\t\t};\n\t\t},\n\t\t[ isDisabled ]\n\t);\n}\n","/**\n * Internal dependencies\n */\nimport useRefEffect from '../use-ref-effect';\n\n/**\n * Dispatches a bubbling focus event when the iframe receives focus. Use\n * `onFocus` as usual on the iframe or a parent element.\n *\n * @return {Object} Ref to pass to the iframe.\n */\nexport default function useFocusableIframe() {\n\treturn useRefEffect( ( element ) => {\n\t\tconst { ownerDocument } = element;\n\t\tif ( ! ownerDocument ) return;\n\t\tconst { defaultView } = ownerDocument;\n\t\tif ( ! defaultView ) return;\n\n\t\t/**\n\t\t * Checks whether the iframe is the activeElement, inferring that it has\n\t\t * then received focus, and dispatches a focus event.\n\t\t */\n\t\tfunction checkFocus() {\n\t\t\tif ( ownerDocument && ownerDocument.activeElement === element ) {\n\t\t\t\t/** @type {HTMLElement} */ ( element ).focus();\n\t\t\t}\n\t\t}\n\n\t\tdefaultView.addEventListener( 'blur', checkFocus );\n\t\treturn () => {\n\t\t\tdefaultView.removeEventListener( 'blur', checkFocus );\n\t\t};\n\t}, [] );\n}\n","/**\n * External dependencies\n */\nimport { debounce } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { useState, useLayoutEffect } from '@wordpress/element';\nimport { getScrollContainer } from '@wordpress/dom';\nimport { PAGEUP, PAGEDOWN, HOME, END } from '@wordpress/keycodes';\n\nconst DEFAULT_INIT_WINDOW_SIZE = 30;\n\n/**\n * @typedef {Object} WPFixedWindowList\n *\n * @property {number}                  visibleItems Items visible in the current viewport\n * @property {number}                  start        Start index of the window\n * @property {number}                  end          End index of the window\n * @property {(index:number)=>boolean} itemInView   Returns true if item is in the window\n */\n\n/**\n * @typedef {Object} WPFixedWindowListOptions\n *\n * @property {number}  [windowOverscan] Renders windowOverscan number of items before and after the calculated visible window.\n * @property {boolean} [useWindowing]   When false avoids calculating the window size\n * @property {number}  [initWindowSize] Initial window size to use on first render before we can calculate the window size.\n */\n\n/**\n *\n * @param {import('react').RefObject<HTMLElement>} elementRef Used to find the closest scroll container that contains element.\n * @param { number }                               itemHeight Fixed item height in pixels\n * @param { number }                               totalItems Total items in list\n * @param { WPFixedWindowListOptions }             [options]  Options object\n * @return {[ WPFixedWindowList, setFixedListWindow:(nextWindow:WPFixedWindowList)=>void]} Array with the fixed window list and setter\n */\nexport default function useFixedWindowList(\n\telementRef,\n\titemHeight,\n\ttotalItems,\n\toptions\n) {\n\tconst initWindowSize = options?.initWindowSize ?? DEFAULT_INIT_WINDOW_SIZE;\n\tconst useWindowing = options?.useWindowing ?? true;\n\n\tconst [ fixedListWindow, setFixedListWindow ] = useState( {\n\t\tvisibleItems: initWindowSize,\n\t\tstart: 0,\n\t\tend: initWindowSize,\n\t\titemInView: ( /** @type {number} */ index ) => {\n\t\t\treturn index >= 0 && index <= initWindowSize;\n\t\t},\n\t} );\n\n\tuseLayoutEffect( () => {\n\t\tif ( ! useWindowing ) {\n\t\t\treturn;\n\t\t}\n\t\tconst scrollContainer = getScrollContainer( elementRef.current );\n\t\tconst measureWindow = (\n\t\t\t/** @type {boolean | undefined} */ initRender\n\t\t) => {\n\t\t\tif ( ! scrollContainer ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst visibleItems = Math.ceil(\n\t\t\t\tscrollContainer.clientHeight / itemHeight\n\t\t\t);\n\t\t\t// Aim to keep opening list view fast, afterward we can optimize for scrolling.\n\t\t\tconst windowOverscan = initRender\n\t\t\t\t? visibleItems\n\t\t\t\t: options?.windowOverscan ?? visibleItems;\n\t\t\tconst firstViewableIndex = Math.floor(\n\t\t\t\tscrollContainer.scrollTop / itemHeight\n\t\t\t);\n\t\t\tconst start = Math.max( 0, firstViewableIndex - windowOverscan );\n\t\t\tconst end = Math.min(\n\t\t\t\ttotalItems - 1,\n\t\t\t\tfirstViewableIndex + visibleItems + windowOverscan\n\t\t\t);\n\t\t\tsetFixedListWindow( ( lastWindow ) => {\n\t\t\t\tconst nextWindow = {\n\t\t\t\t\tvisibleItems,\n\t\t\t\t\tstart,\n\t\t\t\t\tend,\n\t\t\t\t\titemInView: ( /** @type {number} */ index ) => {\n\t\t\t\t\t\treturn start <= index && index <= end;\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\tif (\n\t\t\t\t\tlastWindow.start !== nextWindow.start ||\n\t\t\t\t\tlastWindow.end !== nextWindow.end ||\n\t\t\t\t\tlastWindow.visibleItems !== nextWindow.visibleItems\n\t\t\t\t) {\n\t\t\t\t\treturn nextWindow;\n\t\t\t\t}\n\t\t\t\treturn lastWindow;\n\t\t\t} );\n\t\t};\n\n\t\tmeasureWindow( true );\n\t\tconst debounceMeasureList = debounce( () => {\n\t\t\tmeasureWindow();\n\t\t}, 16 );\n\t\tscrollContainer?.addEventListener( 'scroll', debounceMeasureList );\n\t\tscrollContainer?.ownerDocument?.defaultView?.addEventListener(\n\t\t\t'resize',\n\t\t\tdebounceMeasureList\n\t\t);\n\t\tscrollContainer?.ownerDocument?.defaultView?.addEventListener(\n\t\t\t'resize',\n\t\t\tdebounceMeasureList\n\t\t);\n\n\t\treturn () => {\n\t\t\tscrollContainer?.removeEventListener(\n\t\t\t\t'scroll',\n\t\t\t\tdebounceMeasureList\n\t\t\t);\n\t\t\tscrollContainer?.ownerDocument?.defaultView?.removeEventListener(\n\t\t\t\t'resize',\n\t\t\t\tdebounceMeasureList\n\t\t\t);\n\t\t};\n\t}, [ itemHeight, elementRef, totalItems ] );\n\n\tuseLayoutEffect( () => {\n\t\tif ( ! useWindowing ) {\n\t\t\treturn;\n\t\t}\n\t\tconst scrollContainer = getScrollContainer( elementRef.current );\n\t\tconst handleKeyDown = ( /** @type {KeyboardEvent} */ event ) => {\n\t\t\tswitch ( event.keyCode ) {\n\t\t\t\tcase HOME: {\n\t\t\t\t\treturn scrollContainer?.scrollTo( { top: 0 } );\n\t\t\t\t}\n\t\t\t\tcase END: {\n\t\t\t\t\treturn scrollContainer?.scrollTo( {\n\t\t\t\t\t\ttop: totalItems * itemHeight,\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t\tcase PAGEUP: {\n\t\t\t\t\treturn scrollContainer?.scrollTo( {\n\t\t\t\t\t\ttop:\n\t\t\t\t\t\t\tscrollContainer.scrollTop -\n\t\t\t\t\t\t\tfixedListWindow.visibleItems * itemHeight,\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t\tcase PAGEDOWN: {\n\t\t\t\t\treturn scrollContainer?.scrollTo( {\n\t\t\t\t\t\ttop:\n\t\t\t\t\t\t\tscrollContainer.scrollTop +\n\t\t\t\t\t\t\tfixedListWindow.visibleItems * itemHeight,\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tscrollContainer?.ownerDocument?.defaultView?.addEventListener(\n\t\t\t'keydown',\n\t\t\thandleKeyDown\n\t\t);\n\t\treturn () => {\n\t\t\tscrollContainer?.ownerDocument?.defaultView?.removeEventListener(\n\t\t\t\t'keydown',\n\t\t\t\thandleKeyDown\n\t\t\t);\n\t\t};\n\t}, [ totalItems, itemHeight, elementRef, fixedListWindow.visibleItems ] );\n\n\treturn [ fixedListWindow, setFixedListWindow ];\n}\n"],"names":["factory","__webpack_modules__","__unused_webpack_module","__webpack_exports__","d","clipboard","tiny_emitter","tiny_emitter_default","n","listen","listen_default","src_select","select_default","_typeof","obj","Symbol","iterator","constructor","prototype","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","clipboard_action","ClipboardAction","options","instance","Constructor","TypeError","_classCallCheck","this","resolveOptions","initSelection","protoProps","value","arguments","undefined","action","container","emitter","text","trigger","selectedText","selectFake","selectTarget","isRTL","document","documentElement","getAttribute","fakeElem","createElement","style","fontSize","border","padding","margin","position","yPosition","window","pageYOffset","scrollTop","top","concat","setAttribute","_this","createFakeElement","fakeHandlerCallback","removeFake","fakeHandler","addEventListener","appendChild","copyText","removeEventListener","removeChild","succeeded","execCommand","err","handleResult","emit","clearSelection","bind","focus","activeElement","blur","getSelection","removeAllRanges","set","_action","Error","get","nodeType","hasAttribute","_target","clipboard_typeof","clipboard_defineProperties","_setPrototypeOf","o","p","setPrototypeOf","__proto__","_possibleConstructorReturn","self","call","ReferenceError","_assertThisInitialized","_getPrototypeOf","getPrototypeOf","getAttributeValue","suffix","element","attribute","_Emitter","subClass","superClass","create","_inherits","Clipboard","staticProps","Derived","hasNativeReflectConstruct","_super","Reflect","construct","sham","Proxy","Date","toString","e","_isNativeReflectConstruct","result","Super","NewTarget","apply","clipboard_classCallCheck","listenClick","actions","support","queryCommandSupported","forEach","defaultAction","defaultTarget","defaultText","body","_this2","listener","onClick","delegateTarget","currentTarget","clipboardAction","selector","querySelector","destroy","module","Element","matches","proto","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","exports","parentNode","__unused_webpack_exports","closest","_delegate","type","callback","useCapture","listenerFn","elements","querySelectorAll","Array","map","node","HTMLElement","nodeList","string","String","fn","is","delegate","listenNode","listenNodeList","listenSelector","nodeName","isReadOnly","select","setSelectionRange","removeAttribute","selection","range","createRange","selectNodeContents","addRange","E","on","name","ctx","push","once","off","_","data","slice","evtArr","len","evts","liveEvents","TinyEmitter","__webpack_module_cache__","moduleId","getter","__esModule","a","definition","prop","hasOwnProperty","default","_REVERSE_MAP","_MAP","_KEYCODE_MAP","_SHIFT_MAP","_SPECIAL_ALIASES","test","navigator","platform","Mousetrap","keys","_bindMultiple","unbind","_directMap","reset","_callbacks","stopCallback","className","indexOf","_belongsTo","composedPath","initialEventTarget","tagName","isContentEditable","handleKey","_handleKey","addKeycodes","object","init","documentMousetrap","method","charAt","_addEvent","attachEvent","_characterFromEvent","character","fromCharCode","which","shiftKey","toLowerCase","_isModifier","_pickBestAction","modifiers","_getReverseMap","_getKeyInfo","combination","replace","split","_keysFromString","ancestor","targetElement","_resetTimer","_sequenceLevels","_ignoreNextKeyup","_ignoreNextKeypress","_nextExpectedAction","_resetSequences","doNotReset","activeSequences","_getMatches","sequenceName","level","modifiers1","modifiers2","seq","metaKey","ctrlKey","sort","join","deleteCombo","combo","deleteSequence","splice","_fireCallback","sequence","srcElement","preventDefault","returnValue","_preventDefault","stopPropagation","cancelBubble","_stopPropagation","_handleKeyEvent","keyCode","altKey","_eventModifiers","_bindSingle","info","_increaseSequence","nextAction","clearTimeout","setTimeout","_callbackAndReset","wrappedCallback","_bindSequence","callbacks","maxLevel","processedSequenceCallback","Math","max","ignoreThisKeypress","combinations","_globalCallbacks","_originalStopCallback","paused","bindGlobal","display","opacity","left","height","width","overflow","pointerEvents","zIndex","onResize","ref","React","getTarget","current","contentDocument","defaultView","run","src","aria-hidden","tabIndex","frameBorder","defaultReporter","offsetWidth","offsetHeight","reporter","sizes","setSizes","ResizeListener","__webpack_require__","cachedModule","r","toStringTag","mapComponent","modifierName","Inner","Outer","displayName","upperFirst","camelCase","compose","predicate","createHigherOrderComponent","WrappedComponent","Wrapped","Component","shouldComponentUpdate","nextProps","nextState","isShallowEqual","state","render","_extends","assign","source","listeners","handleEvent","add","eventType","remove","without","event","withGlobalEvents","eventTypesToHandlers","deprecated","since","alternative","Wrapper","super","handleRef","componentDidMount","componentWillUnmount","handler","wrappedRef","el","forwardedRef","ownProps","forwardRef","instanceMap","WeakMap","createId","instances","useInstanceId","prefix","preferredId","useMemo","id","instanceId","OriginalComponent","timeouts","delay","withState","initialState","setState","useRefEffect","dependencies","cleanup","useRef","useCallback","timeoutId","onKeyDown","TAB","nextElement","contains","domAction","ownerDocument","trap","useCopyOnClick","timeout","hasCopied","setHasCopied","useState","useEffect","useUpdatedRef","useCopyToClipboard","onSuccess","textRef","onSuccessRef","useFocusOnMount","focusOnMount","focusOnMountRef","firstTabbable","onFocusReturn","focusedBeforeMount","onFocusReturnRef","isFocused","isConnected","INPUT_BUTTON_TYPES","useFocusOutside","onFocusOutside","currentOnFocusOutside","preventBlurCheck","blurCheckTimeoutId","cancelBlurCheck","normalizeButtonFocus","includes","eventTarget","isFocusNormalizedButton","queueBlurCheck","persist","hasFocus","onFocus","onMouseDown","onMouseUp","onTouchStart","onTouchEnd","onBlur","assignRef","useMergeRefs","refs","didElementChange","previousRefs","currentRefs","useLayoutEffect","index","previousRef","refsToAssign","currentOptions","values","constrainedTabbingRef","useConstrainedTabbing","focusReturnRef","useFocusReturn","focusOutsideProps","__unstableOnClose","onClose","closeOnEscapeRef","ESCAPE","defaultPrevented","DISABLED_ELIGIBLE_NODE_NAMES","useDisabled","disable","focusable","debouncedDisable","debounce","leading","observer","MutationObserver","observe","childList","attributes","subtree","disconnect","cancel","useDragging","onDragStart","onDragMove","onDragEnd","isDragging","setIsDragging","eventsRef","useIsomorphicLayoutEffect","onMouseMove","endDrag","startDrag","isAppleOS","_window","shortcuts","eventName","isDisabled","currentCallback","mousetrap","castArray","shortcut","Set","filter","hasAlt","has","hasShift","size","useMediaQuery","query","match","setMatch","matchMedia","updateMatch","list","addListener","removeListener","usePrevious","BREAKPOINTS","huge","wide","large","medium","small","mobile","CONDITIONS","OPERATOR_EVALUATORS","breakpointValue","ViewportMatchWidthContext","createContext","useViewportMatch","breakpoint","operator","simulatedWidth","useContext","mediaQuery","mediaQueryResult","__experimentalWidthProvider","Provider","getFirstItemsPresentInState","firstItems","item","config","step","setCurrent","nextIndex","asyncQueue","createQueue","append","previousValues","entries","console","warn","useMemoOne","getResult","inputs","initial","committed","cache","Boolean","newInputs","lastInputs","areInputsEqual","useDebounce","wait","debounced","useThrottle","throttled","throttle","useFreshRef","useDropZone","onDrop","_onDrop","_onDragStart","onDragEnter","_onDragEnter","onDragLeave","_onDragLeave","_onDragEnd","onDragOver","_onDragOver","onDropRef","onDragStartRef","onDragEnterRef","onDragLeaveRef","onDragEndRef","onDragOverRef","maybeDragStart","maybeDragEnd","relatedTarget","targetToCheck","elementToCheck","dataset","isDropZone","parentElement","isElementInZone","dataTransfer","files","useFocusableIframe","checkFocus","useFixedWindowList","elementRef","itemHeight","totalItems","initWindowSize","useWindowing","fixedListWindow","setFixedListWindow","visibleItems","start","end","itemInView","scrollContainer","getScrollContainer","measureWindow","initRender","ceil","clientHeight","windowOverscan","firstViewableIndex","floor","min","lastWindow","nextWindow","debounceMeasureList","handleKeyDown","HOME","scrollTo","END","PAGEUP","PAGEDOWN"],"sourceRoot":""}