enmi-conf.org: comparison wp/wp-includes/js/dist/compose.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/dist/compose.js

changeset 16	a86126ab1dd4
parent 9	177826044cd9
child 18	be944660c56a

equal deleted inserted replaced

-:3d4e9c994f10
+:a86126ab1dd4
 /******/ 	// __webpack_public_path__
 /******/ 	__webpack_require__.p = "";
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 368);
+/******/ 	return __webpack_require__(__webpack_require__.s = 445);
 /******/ })
 /************************************************************************/
 /******/ ({
 /***/ 0:
 (function() { module.exports = this["wp"]["element"]; }());
 /***/ }),
-/***/ 10:
+/***/ 12:
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 "use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
-function _classCallCheck(instance, Constructor) {
+function _assertThisInitialized(self) {
-if (!(instance instanceof Constructor)) {
+if (self === void 0) {
-throw new TypeError("Cannot call a class as a function");
+throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 }
+return self;
 }
 /***/ }),
-/***/ 11:
+/***/ 13:
+/***/ (function(module, exports) {
+(function() { module.exports = this["React"]; }());
+/***/ }),
+/***/ 14:
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 "use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
-/* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(32);
+// EXPORTS
-/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; });
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
-function _possibleConstructorReturn(self, call) {
+var arrayWithHoles = __webpack_require__(38);
-if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) {
-return call;
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
+function _iterableToArrayLimit(arr, i) {
+if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+var _arr = [];
+var _n = true;
+var _d = false;
+var _e = undefined;
+try {
+for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+_arr.push(_s.value);
+if (i && _arr.length === i) break;
+}
+} catch (err) {
+_d = true;
+_e = err;
+} finally {
+try {
+if (!_n && _i["return"] != null) _i["return"]();
+} finally {
+if (_d) throw _e;
+}
 }
-return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
+return _arr;
+}
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+var unsupportedIterableToArray = __webpack_require__(29);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+var nonIterableRest = __webpack_require__(39);
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
+function _slicedToArray(arr, i) {
+return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
 }
 /***/ }),
-/***/ 12:
+/***/ 149:
+/***/ (function(module, exports, __webpack_require__) {
+var e=__webpack_require__(13),n={display:"block",opacity:0,position:"absolute",top:0,left:0,height:"100%",width:"100%",overflow:"hidden",pointerEvents:"none",zIndex:-1},t=function(t){var r=t.onResize,u=e.useRef();return function(n,t){var r=function(){return n.current&&n.current.contentDocument&&n.current.contentDocument.defaultView};function u(){t();var e=r();e&&e.addEventListener("resize",t)}e.useEffect((function(){return r()?u():n.current&&n.current.addEventListener&&n.current.addEventListener("load",u),function(){var e=r();e&&"function"==typeof e.removeEventListener&&e.removeEventListener("resize",t)}}),[])}(u,(function(){return r(u)})),e.createElement("iframe",{style:n,src:"about:blank",ref:u,"aria-hidden":!0,tabIndex:-1,frameBorder:0})},r=function(e){return{width:null!=e?e.offsetWidth:null,height:null!=e?e.offsetHeight:null}};module.exports=function(n){void 0===n&&(n=r);var u=e.useState(n(null)),o=u[0],i=u[1],c=e.useCallback((function(e){return i(n(e.current))}),[n]);return[e.useMemo((function(){return e.createElement(t,{onResize:c})}),[c]),o]};
+/***/ }),
+/***/ 150:
+/***/ (function(module, exports) {
+(function() { module.exports = this["wp"]["priorityQueue"]; }());
+/***/ }),
+/***/ 16:
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });
 function _getPrototypeOf(o) {
 return _getPrototypeOf(o);
 }
 /***/ }),
-/***/ 13:
+/***/ 18:
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 "use strict";
-// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+// EXPORTS
-function _setPrototypeOf(o, p) {
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; });
-_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-o.__proto__ = p;
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
-return o;
+var arrayLikeToArray = __webpack_require__(26);
-};
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
-return _setPrototypeOf(o, p);
-}
+function _arrayWithoutHoles(arr) {
-// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
+if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });
+}
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
-function _inherits(subClass, superClass) {
+var iterableToArray = __webpack_require__(35);
-if (typeof superClass !== "function" && superClass !== null) {
-throw new TypeError("Super expression must either be null or a function");
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
-}
+var unsupportedIterableToArray = __webpack_require__(29);
-subClass.prototype = Object.create(superClass && superClass.prototype, {
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
-constructor: {
+function _nonIterableSpread() {
-value: subClass,
+throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-writable: true,
+}
-configurable: true
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
-}
-});
-if (superClass) _setPrototypeOf(subClass, superClass);
+function _toConsumableArray(arr) {
+return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 }
 /***/ }),
 /***/ 19:
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
-function _extends() {
-_extends = Object.assign || function (target) {
-for (var i = 1; i < arguments.length; i++) {
-var source = arguments[i];
-for (var key in source) {
-if (Object.prototype.hasOwnProperty.call(source, key)) {
-target[key] = source[key];
-}
-}
-}
-return target;
-};
-return _extends.apply(this, arguments);
-}
-/***/ }),
-/***/ 2:
-/***/ (function(module, exports) {
-(function() { module.exports = this["lodash"]; }());
-/***/ }),
-/***/ 3:
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
-function _assertThisInitialized(self) {
-if (self === void 0) {
-throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-}
-return self;
-}
-/***/ }),
-/***/ 32:
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; });
-function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
-function _typeof(obj) {
-if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
-_typeof = function _typeof(obj) {
-return _typeof2(obj);
-};
-} else {
-_typeof = function _typeof(obj) {
-return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
-};
-}
-return _typeof(obj);
-}
-/***/ }),
-/***/ 368:
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-// EXTERNAL MODULE: external "lodash"
-var external_lodash_ = __webpack_require__(2);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/create-higher-order-component/index.js
-/**
-* External dependencies
-*/
-/**
-* Given a function mapping a component to an enhanced component and modifier
-* name, returns the enhanced component augmented with a generated displayName.
-*
-* @param {Function} mapComponentToEnhancedComponent Function mapping component
-*                                                   to enhanced component.
-* @param {string}   modifierName                    Seed name from which to
-*                                                   generated display name.
-*
-* @return {WPComponent} Component class with generated display name assigned.
-*/
-function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) {
-return function (OriginalComponent) {
-var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent);
-var _OriginalComponent$di = OriginalComponent.displayName,
-displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di;
-EnhancedComponent.displayName = "".concat(Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")");
-return EnhancedComponent;
-};
-}
-/* harmony default export */ var create_higher_order_component = (createHigherOrderComponent);
-// EXTERNAL MODULE: external {"this":["wp","element"]}
-var external_this_wp_element_ = __webpack_require__(0);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/if-condition/index.js
-/**
-* Internal dependencies
-*/
-/**
-* Higher-order component creator, creating a new component which renders if
-* the given condition is satisfied or with the given optional prop name.
-*
-* @param {Function} predicate Function to test condition.
-*
-* @return {Function} Higher-order component.
-*/
-var if_condition_ifCondition = function ifCondition(predicate) {
-return create_higher_order_component(function (WrappedComponent) {
-return function (props) {
-if (!predicate(props)) {
-return null;
-}
-return Object(external_this_wp_element_["createElement"])(WrappedComponent, props);
-};
-}, 'ifCondition');
-};
-/* harmony default export */ var if_condition = (if_condition_ifCondition);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
-var classCallCheck = __webpack_require__(10);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
-var createClass = __webpack_require__(9);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
-var possibleConstructorReturn = __webpack_require__(11);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
-var getPrototypeOf = __webpack_require__(12);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules
-var inherits = __webpack_require__(13);
-// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]}
-var external_this_wp_isShallowEqual_ = __webpack_require__(42);
-var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/pure/index.js
-/**
-* WordPress dependencies
-*/
-/**
-* Internal dependencies
-*/
-/**
-* Given a component returns the enhanced component augmented with a component
-* only rerendering when its props/state change
-*
-* @param {Function} mapComponentToEnhancedComponent Function mapping component
-*                                                   to enhanced component.
-* @param {string}   modifierName                    Seed name from which to
-*                                                   generated display name.
-*
-* @return {WPComponent} Component class with generated display name assigned.
-*/
-var pure = create_higher_order_component(function (Wrapped) {
-if (Wrapped.prototype instanceof external_this_wp_element_["Component"]) {
-return (
-/*#__PURE__*/
-function (_Wrapped) {
-Object(inherits["a" /* default */])(_class, _Wrapped);
-function _class() {
-Object(classCallCheck["a" /* default */])(this, _class);
-return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments));
-}
-Object(createClass["a" /* default */])(_class, [{
-key: "shouldComponentUpdate",
-value: function shouldComponentUpdate(nextProps, nextState) {
-return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state);
-}
-}]);
-return _class;
-}(Wrapped)
-);
-}
-return (
-/*#__PURE__*/
-function (_Component) {
-Object(inherits["a" /* default */])(_class2, _Component);
-function _class2() {
-Object(classCallCheck["a" /* default */])(this, _class2);
-return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class2).apply(this, arguments));
-}
-Object(createClass["a" /* default */])(_class2, [{
-key: "shouldComponentUpdate",
-value: function shouldComponentUpdate(nextProps) {
-return !external_this_wp_isShallowEqual_default()(nextProps, this.props);
-}
-}, {
-key: "render",
-value: function render() {
-return Object(external_this_wp_element_["createElement"])(Wrapped, this.props);
-}
-}]);
-return _class2;
-}(external_this_wp_element_["Component"])
-);
-}, 'pure');
-/* harmony default export */ var build_module_pure = (pure);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
-var esm_extends = __webpack_require__(19);
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
-var assertThisInitialized = __webpack_require__(3);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/listener.js
-/**
-* External dependencies
-*/
-/**
-* Class responsible for orchestrating event handling on the global window,
-* binding a single event to be shared across all handling instances, and
-* removing the handler when no instances are listening for the event.
-*/
-var listener_Listener =
-/*#__PURE__*/
-function () {
-function Listener() {
-Object(classCallCheck["a" /* default */])(this, Listener);
-this.listeners = {};
-this.handleEvent = this.handleEvent.bind(this);
-}
-Object(createClass["a" /* default */])(Listener, [{
-key: "add",
-value: function add(eventType, instance) {
-if (!this.listeners[eventType]) {
-// Adding first listener for this type, so bind event.
-window.addEventListener(eventType, this.handleEvent);
-this.listeners[eventType] = [];
-}
-this.listeners[eventType].push(instance);
-}
-}, {
-key: "remove",
-value: function remove(eventType, instance) {
-this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[eventType], instance);
-if (!this.listeners[eventType].length) {
-// Removing last listener for this type, so unbind event.
-window.removeEventListener(eventType, this.handleEvent);
-delete this.listeners[eventType];
-}
-}
-}, {
-key: "handleEvent",
-value: function handleEvent(event) {
-Object(external_lodash_["forEach"])(this.listeners[event.type], function (instance) {
-instance.handleEvent(event);
-});
-}
-}]);
-return Listener;
-}();
-/* harmony default export */ var listener = (listener_Listener);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/index.js
-/**
-* External dependencies
-*/
-/**
-* WordPress dependencies
-*/
-/**
-* Internal dependencies
-*/
-/**
-* Listener instance responsible for managing document event handling.
-*
-* @type {Listener}
-*/
-var with_global_events_listener = new listener();
-function withGlobalEvents(eventTypesToHandlers) {
-return create_higher_order_component(function (WrappedComponent) {
-var Wrapper =
-/*#__PURE__*/
-function (_Component) {
-Object(inherits["a" /* default */])(Wrapper, _Component);
-function Wrapper() {
-var _this;
-Object(classCallCheck["a" /* default */])(this, Wrapper);
-_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Wrapper).apply(this, arguments));
-_this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this)));
-_this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this)));
-return _this;
-}
-Object(createClass["a" /* default */])(Wrapper, [{
-key: "componentDidMount",
-value: function componentDidMount() {
-var _this2 = this;
-Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
-with_global_events_listener.add(eventType, _this2);
-});
-}
-}, {
-key: "componentWillUnmount",
-value: function componentWillUnmount() {
-var _this3 = this;
-Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
-with_global_events_listener.remove(eventType, _this3);
-});
-}
-}, {
-key: "handleEvent",
-value: function handleEvent(event) {
-var handler = eventTypesToHandlers[event.type];
-if (typeof this.wrappedRef[handler] === 'function') {
-this.wrappedRef[handler](event);
-}
-}
-}, {
-key: "handleRef",
-value: function handleRef(el) {
-this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref`
-// will cause `this.props.forwardedRef` to be `null`, so we need this
-// check.
-if (this.props.forwardedRef) {
-this.props.forwardedRef(el);
-}
-}
-}, {
-key: "render",
-value: function render() {
-return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, {
-ref: this.handleRef
-}));
-}
-}]);
-return Wrapper;
-}(external_this_wp_element_["Component"]);
-return Object(external_this_wp_element_["forwardRef"])(function (props, ref) {
-return Object(external_this_wp_element_["createElement"])(Wrapper, {
-ownProps: props,
-forwardedRef: ref
-});
-});
-}, 'withGlobalEvents');
-}
-/* harmony default export */ var with_global_events = (withGlobalEvents);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-instance-id/index.js
-/**
-* WordPress dependencies
-*/
-/**
-* Internal dependencies
-*/
-/**
-* A Higher Order Component used to be provide a unique instance ID by
-* component.
-*
-* @param {WPElement} WrappedComponent The wrapped component.
-*
-* @return {Component} Component with an instanceId prop.
-*/
-/* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) {
-var instances = 0;
-return (
-/*#__PURE__*/
-function (_Component) {
-Object(inherits["a" /* default */])(_class, _Component);
-function _class() {
-var _this;
-Object(classCallCheck["a" /* default */])(this, _class);
-_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments));
-_this.instanceId = instances++;
-return _this;
-}
-Object(createClass["a" /* default */])(_class, [{
-key: "render",
-value: function render() {
-return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props, {
-instanceId: this.instanceId
-}));
-}
-}]);
-return _class;
-}(external_this_wp_element_["Component"])
-);
-}, 'withInstanceId'));
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-safe-timeout/index.js
-/**
-* External dependencies
-*/
-/**
-* WordPress dependencies
-*/
-/**
-* Internal dependencies
-*/
-/**
-* A higher-order component used to provide and manage delayed function calls
-* that ought to be bound to a component's lifecycle.
-*
-* @param {Component} OriginalComponent Component requiring setTimeout
-*
-* @return {Component}                  Wrapped component.
-*/
-var withSafeTimeout = create_higher_order_component(function (OriginalComponent) {
-return (
-/*#__PURE__*/
-function (_Component) {
-Object(inherits["a" /* default */])(WrappedComponent, _Component);
-function WrappedComponent() {
-var _this;
-Object(classCallCheck["a" /* default */])(this, WrappedComponent);
-_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments));
-_this.timeouts = [];
-_this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this)));
-_this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this)));
-return _this;
-}
-Object(createClass["a" /* default */])(WrappedComponent, [{
-key: "componentWillUnmount",
-value: function componentWillUnmount() {
-this.timeouts.forEach(clearTimeout);
-}
-}, {
-key: "setTimeout",
-value: function (_setTimeout) {
-function setTimeout(_x, _x2) {
-return _setTimeout.apply(this, arguments);
-}
-setTimeout.toString = function () {
-return _setTimeout.toString();
-};
-return setTimeout;
-}(function (fn, delay) {
-var _this2 = this;
-var id = setTimeout(function () {
-fn();
-_this2.clearTimeout(id);
-}, delay);
-this.timeouts.push(id);
-return id;
-})
-}, {
-key: "clearTimeout",
-value: function (_clearTimeout) {
-function clearTimeout(_x3) {
-return _clearTimeout.apply(this, arguments);
-}
-clearTimeout.toString = function () {
-return _clearTimeout.toString();
-};
-return clearTimeout;
-}(function (id) {
-clearTimeout(id);
-this.timeouts = Object(external_lodash_["without"])(this.timeouts, id);
-})
-}, {
-key: "render",
-value: function render() {
-return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, {
-setTimeout: this.setTimeout,
-clearTimeout: this.clearTimeout
-}));
-}
-}]);
-return WrappedComponent;
-}(external_this_wp_element_["Component"])
-);
-}, 'withSafeTimeout');
-/* harmony default export */ var with_safe_timeout = (withSafeTimeout);
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-state/index.js
-/**
-* WordPress dependencies
-*/
-/**
-* Internal dependencies
-*/
-/**
-* A Higher Order Component used to provide and manage internal component state
-* via props.
-*
-* @param {?Object} initialState Optional initial state of the component.
-*
-* @return {Component} Wrapped component.
-*/
-function withState() {
-var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-return create_higher_order_component(function (OriginalComponent) {
-return (
-/*#__PURE__*/
-function (_Component) {
-Object(inherits["a" /* default */])(WrappedComponent, _Component);
-function WrappedComponent() {
-var _this;
-Object(classCallCheck["a" /* default */])(this, WrappedComponent);
-_this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments));
-_this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this)));
-_this.state = initialState;
-return _this;
-}
-Object(createClass["a" /* default */])(WrappedComponent, [{
-key: "render",
-value: function render() {
-return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, {
-setState: this.setState
-}));
-}
-}]);
-return WrappedComponent;
-}(external_this_wp_element_["Component"])
-);
-}, 'withState');
-}
-// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js
-/* concated harmony reexport createHigherOrderComponent */__webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return create_higher_order_component; });
-/* concated harmony reexport ifCondition */__webpack_require__.d(__webpack_exports__, "ifCondition", function() { return if_condition; });
-/* concated harmony reexport pure */__webpack_require__.d(__webpack_exports__, "pure", function() { return build_module_pure; });
-/* concated harmony reexport withGlobalEvents */__webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return with_global_events; });
-/* concated harmony reexport withInstanceId */__webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return with_instance_id; });
-/* concated harmony reexport withSafeTimeout */__webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return with_safe_timeout; });
-/* concated harmony reexport withState */__webpack_require__.d(__webpack_exports__, "withState", function() { return withState; });
-/* concated harmony reexport compose */__webpack_require__.d(__webpack_exports__, "compose", function() { return external_lodash_["flowRight"]; });
-/**
-* External dependencies
-*/
-/**
-* Composes multiple higher-order components into a single higher-order component. Performs right-to-left function
-* composition, where each successive invocation is supplied the return value of the previous.
-*
-* @param {...Function} hocs The HOC functions to invoke.
-*
-* @return {Function} Returns the new composite function.
-*/
-/***/ }),
-/***/ 42:
-/***/ (function(module, exports) {
-(function() { module.exports = this["wp"]["isShallowEqual"]; }());
-/***/ }),
-/***/ 9:
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
 function _defineProperties(target, props) {
 if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 if (staticProps) _defineProperties(Constructor, staticProps);
 return Constructor;
 }
+/***/ }),
+/***/ 2:
+/***/ (function(module, exports) {
+(function() { module.exports = this["lodash"]; }());
+/***/ }),
+/***/ 20:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
+function _classCallCheck(instance, Constructor) {
+if (!(instance instanceof Constructor)) {
+throw new TypeError("Cannot call a class as a function");
+}
+}
+/***/ }),
+/***/ 22:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _inherits; });
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+function _setPrototypeOf(o, p) {
+_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+o.__proto__ = p;
+return o;
+};
+return _setPrototypeOf(o, p);
+}
+// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
+function _inherits(subClass, superClass) {
+if (typeof superClass !== "function" && superClass !== null) {
+throw new TypeError("Super expression must either be null or a function");
+}
+subClass.prototype = Object.create(superClass && superClass.prototype, {
+constructor: {
+value: subClass,
+writable: true,
+configurable: true
+}
+});
+if (superClass) _setPrototypeOf(subClass, superClass);
+}
+/***/ }),
+/***/ 23:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
+/* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40);
+/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
+function _possibleConstructorReturn(self, call) {
+if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) {
+return call;
+}
+return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
+}
+/***/ }),
+/***/ 26:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
+function _arrayLikeToArray(arr, len) {
+if (len == null || len > arr.length) len = arr.length;
+for (var i = 0, arr2 = new Array(len); i < len; i++) {
+arr2[i] = arr[i];
+}
+return arr2;
+}
+/***/ }),
+/***/ 272:
+/***/ (function(module, exports, __webpack_require__) {
+/*!
+* clipboard.js v2.0.6
+* https://clipboardjs.com/
+*
+* Licensed MIT © Zeno Rocha
+*/
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(true)
+		module.exports = factory();
+	else {}
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 6);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+function select(element) {
+var selectedText;
+if (element.nodeName === 'SELECT') {
+element.focus();
+selectedText = element.value;
+}
+else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
+var isReadOnly = element.hasAttribute('readonly');
+if (!isReadOnly) {
+element.setAttribute('readonly', '');
+}
+element.select();
+element.setSelectionRange(0, element.value.length);
+if (!isReadOnly) {
+element.removeAttribute('readonly');
+}
+selectedText = element.value;
+}
+else {
+if (element.hasAttribute('contenteditable')) {
+element.focus();
+}
+var selection = window.getSelection();
+var range = document.createRange();
+range.selectNodeContents(element);
+selection.removeAllRanges();
+selection.addRange(range);
+selectedText = selection.toString();
+}
+return selectedText;
+}
+module.exports = select;
+/***/ }),
+/* 1 */
+/***/ (function(module, exports) {
+function E () {
+// Keep this empty so it's easier to inherit from
+// (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+}
+E.prototype = {
+on: function (name, callback, ctx) {
+var e = this.e || (this.e = {});
+(e[name] || (e[name] = [])).push({
+fn: callback,
+ctx: ctx
+});
+return this;
+},
+once: function (name, callback, ctx) {
+var self = this;
+function listener () {
+self.off(name, listener);
+callback.apply(ctx, arguments);
+};
+listener._ = callback
+return this.on(name, listener, ctx);
+},
+emit: function (name) {
+var data = [].slice.call(arguments, 1);
+var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+var i = 0;
+var len = evtArr.length;
+for (i; i < len; i++) {
+evtArr[i].fn.apply(evtArr[i].ctx, data);
+}
+return this;
+},
+off: function (name, callback) {
+var e = this.e || (this.e = {});
+var evts = e[name];
+var liveEvents = [];
+if (evts && callback) {
+for (var i = 0, len = evts.length; i < len; i++) {
+if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+liveEvents.push(evts[i]);
+}
+}
+// Remove event from queue to prevent memory leak
+// Suggested by https://github.com/lazd
+// Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+(liveEvents.length)
+? e[name] = liveEvents
+: delete e[name];
+return this;
+}
+};
+module.exports = E;
+module.exports.TinyEmitter = E;
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+var is = __webpack_require__(3);
+var delegate = __webpack_require__(4);
+/**
+* Validates all params and calls the right
+* listener function based on its target type.
+*
+* @param {String|HTMLElement|HTMLCollection|NodeList} target
+* @param {String} type
+* @param {Function} callback
+* @return {Object}
+*/
+function listen(target, type, callback) {
+if (!target && !type && !callback) {
+throw new Error('Missing required arguments');
+}
+if (!is.string(type)) {
+throw new TypeError('Second argument must be a String');
+}
+if (!is.fn(callback)) {
+throw new TypeError('Third argument must be a Function');
+}
+if (is.node(target)) {
+return listenNode(target, type, callback);
+}
+else if (is.nodeList(target)) {
+return listenNodeList(target, type, callback);
+}
+else if (is.string(target)) {
+return listenSelector(target, type, callback);
+}
+else {
+throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
+}
+}
+/**
+* Adds an event listener to a HTML element
+* and returns a remove listener function.
+*
+* @param {HTMLElement} node
+* @param {String} type
+* @param {Function} callback
+* @return {Object}
+*/
+function listenNode(node, type, callback) {
+node.addEventListener(type, callback);
+return {
+destroy: function() {
+node.removeEventListener(type, callback);
+}
+}
+}
+/**
+* Add an event listener to a list of HTML elements
+* and returns a remove listener function.
+*
+* @param {NodeList|HTMLCollection} nodeList
+* @param {String} type
+* @param {Function} callback
+* @return {Object}
+*/
+function listenNodeList(nodeList, type, callback) {
+Array.prototype.forEach.call(nodeList, function(node) {
+node.addEventListener(type, callback);
+});
+return {
+destroy: function() {
+Array.prototype.forEach.call(nodeList, function(node) {
+node.removeEventListener(type, callback);
+});
+}
+}
+}
+/**
+* Add an event listener to a selector
+* and returns a remove listener function.
+*
+* @param {String} selector
+* @param {String} type
+* @param {Function} callback
+* @return {Object}
+*/
+function listenSelector(selector, type, callback) {
+return delegate(document.body, selector, type, callback);
+}
+module.exports = listen;
+/***/ }),
+/* 3 */
+/***/ (function(module, exports) {
+/**
+* Check if argument is a HTML element.
+*
+* @param {Object} value
+* @return {Boolean}
+*/
+exports.node = function(value) {
+return value !== undefined
+&& value instanceof HTMLElement
+&& value.nodeType === 1;
+};
+/**
+* Check if argument is a list of HTML elements.
+*
+* @param {Object} value
+* @return {Boolean}
+*/
+exports.nodeList = function(value) {
+var type = Object.prototype.toString.call(value);
+return value !== undefined
+&& (type === '[object NodeList]' || type === '[object HTMLCollection]')
+&& ('length' in value)
+&& (value.length === 0 || exports.node(value[0]));
+};
+/**
+* Check if argument is a string.
+*
+* @param {Object} value
+* @return {Boolean}
+*/
+exports.string = function(value) {
+return typeof value === 'string'
+|| value instanceof String;
+};
+/**
+* Check if argument is a function.
+*
+* @param {Object} value
+* @return {Boolean}
+*/
+exports.fn = function(value) {
+var type = Object.prototype.toString.call(value);
+return type === '[object Function]';
+};
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+var closest = __webpack_require__(5);
+/**
+* Delegates event to a selector.
+*
+* @param {Element} element
+* @param {String} selector
+* @param {String} type
+* @param {Function} callback
+* @param {Boolean} useCapture
+* @return {Object}
+*/
+function _delegate(element, selector, type, callback, useCapture) {
+var listenerFn = listener.apply(this, arguments);
+element.addEventListener(type, listenerFn, useCapture);
+return {
+destroy: function() {
+element.removeEventListener(type, listenerFn, useCapture);
+}
+}
+}
+/**
+* Delegates event to a selector.
+*
+* @param {Element|String|Array} [elements]
+* @param {String} selector
+* @param {String} type
+* @param {Function} callback
+* @param {Boolean} useCapture
+* @return {Object}
+*/
+function delegate(elements, selector, type, callback, useCapture) {
+// Handle the regular Element usage
+if (typeof elements.addEventListener === 'function') {
+return _delegate.apply(null, arguments);
+}
+// Handle Element-less usage, it defaults to global delegation
+if (typeof type === 'function') {
+// Use `document` as the first parameter, then apply arguments
+// This is a short way to .unshift `arguments` without running into deoptimizations
+return _delegate.bind(null, document).apply(null, arguments);
+}
+// Handle Selector-based usage
+if (typeof elements === 'string') {
+elements = document.querySelectorAll(elements);
+}
+// Handle Array-like based usage
+return Array.prototype.map.call(elements, function (element) {
+return _delegate(element, selector, type, callback, useCapture);
+});
+}
+/**
+* Finds closest match and invokes callback.
+*
+* @param {Element} element
+* @param {String} selector
+* @param {String} type
+* @param {Function} callback
+* @return {Function}
+*/
+function listener(element, selector, type, callback) {
+return function(e) {
+e.delegateTarget = closest(e.target, selector);
+if (e.delegateTarget) {
+callback.call(element, e);
+}
+}
+}
+module.exports = delegate;
+/***/ }),
+/* 5 */
+/***/ (function(module, exports) {
+var DOCUMENT_NODE_TYPE = 9;
+/**
+* A polyfill for Element.matches()
+*/
+if (typeof Element !== 'undefined' && !Element.prototype.matches) {
+var proto = Element.prototype;
+proto.matches = proto.matchesSelector ||
+proto.mozMatchesSelector ||
+proto.msMatchesSelector ||
+proto.oMatchesSelector ||
+proto.webkitMatchesSelector;
+}
+/**
+* Finds the closest parent that matches a selector.
+*
+* @param {Element} element
+* @param {String} selector
+* @return {Function}
+*/
+function closest (element, selector) {
+while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
+if (typeof element.matches === 'function' &&
+element.matches(selector)) {
+return element;
+}
+element = element.parentNode;
+}
+}
+module.exports = closest;
+/***/ }),
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+// EXTERNAL MODULE: ./node_modules/select/src/select.js
+var src_select = __webpack_require__(0);
+var select_default = /*#__PURE__*/__webpack_require__.n(src_select);
+// CONCATENATED MODULE: ./src/clipboard-action.js
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+/**
+* Inner class which performs selection from either `text` or `target`
+* properties and then executes copy or cut operations.
+*/
+var clipboard_action_ClipboardAction = function () {
+/**
+* @param {Object} options
+*/
+function ClipboardAction(options) {
+_classCallCheck(this, ClipboardAction);
+this.resolveOptions(options);
+this.initSelection();
+}
+/**
+* Defines base properties passed from constructor.
+* @param {Object} options
+*/
+_createClass(ClipboardAction, [{
+key: 'resolveOptions',
+value: function resolveOptions() {
+var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+this.action = options.action;
+this.container = options.container;
+this.emitter = options.emitter;
+this.target = options.target;
+this.text = options.text;
+this.trigger = options.trigger;
+this.selectedText = '';
+}
+/**
+* Decides which selection strategy is going to be applied based
+* on the existence of `text` and `target` properties.
+*/
+}, {
+key: 'initSelection',
+value: function initSelection() {
+if (this.text) {
+this.selectFake();
+} else if (this.target) {
+this.selectTarget();
+}
+}
+/**
+* Creates a fake textarea element, sets its value from `text` property,
+* and makes a selection on it.
+*/
+}, {
+key: 'selectFake',
+value: function selectFake() {
+var _this = this;
+var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
+this.removeFake();
+this.fakeHandlerCallback = function () {
+return _this.removeFake();
+};
+this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;
+this.fakeElem = document.createElement('textarea');
+// Prevent zooming on iOS
+this.fakeElem.style.fontSize = '12pt';
+// Reset box model
+this.fakeElem.style.border = '0';
+this.fakeElem.style.padding = '0';
+this.fakeElem.style.margin = '0';
+// Move element out of screen horizontally
+this.fakeElem.style.position = 'absolute';
+this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
+// Move element to the same position vertically
+var yPosition = window.pageYOffset || document.documentElement.scrollTop;
+this.fakeElem.style.top = yPosition + 'px';
+this.fakeElem.setAttribute('readonly', '');
+this.fakeElem.value = this.text;
+this.container.appendChild(this.fakeElem);
+this.selectedText = select_default()(this.fakeElem);
+this.copyText();
+}
+/**
+* Only removes the fake element after another click event, that way
+* a user can hit `Ctrl+C` to copy because selection still exists.
+*/
+}, {
+key: 'removeFake',
+value: function removeFake() {
+if (this.fakeHandler) {
+this.container.removeEventListener('click', this.fakeHandlerCallback);
+this.fakeHandler = null;
+this.fakeHandlerCallback = null;
+}
+if (this.fakeElem) {
+this.container.removeChild(this.fakeElem);
+this.fakeElem = null;
+}
+}
+/**
+* Selects the content from element passed on `target` property.
+*/
+}, {
+key: 'selectTarget',
+value: function selectTarget() {
+this.selectedText = select_default()(this.target);
+this.copyText();
+}
+/**
+* Executes the copy operation based on the current selection.
+*/
+}, {
+key: 'copyText',
+value: function copyText() {
+var succeeded = void 0;
+try {
+succeeded = document.execCommand(this.action);
+} catch (err) {
+succeeded = false;
+}
+this.handleResult(succeeded);
+}
+/**
+* Fires an event based on the copy operation result.
+* @param {Boolean} succeeded
+*/
+}, {
+key: 'handleResult',
+value: function handleResult(succeeded) {
+this.emitter.emit(succeeded ? 'success' : 'error', {
+action: this.action,
+text: this.selectedText,
+trigger: this.trigger,
+clearSelection: this.clearSelection.bind(this)
+});
+}
+/**
+* Moves focus away from `target` and back to the trigger, removes current selection.
+*/
+}, {
+key: 'clearSelection',
+value: function clearSelection() {
+if (this.trigger) {
+this.trigger.focus();
+}
+document.activeElement.blur();
+window.getSelection().removeAllRanges();
+}
+/**
+* Sets the `action` to be performed which can be either 'copy' or 'cut'.
+* @param {String} action
+*/
+}, {
+key: 'destroy',
+/**
+* Destroy lifecycle.
+*/
+value: function destroy() {
+this.removeFake();
+}
+}, {
+key: 'action',
+set: function set() {
+var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
+this._action = action;
+if (this._action !== 'copy' && this._action !== 'cut') {
+throw new Error('Invalid "action" value, use either "copy" or "cut"');
+}
+}
+/**
+* Gets the `action` property.
+* @return {String}
+*/
+,
+get: function get() {
+return this._action;
+}
+/**
+* Sets the `target` property using an element
+* that will be have its content copied.
+* @param {Element} target
+*/
+}, {
+key: 'target',
+set: function set(target) {
+if (target !== undefined) {
+if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
+if (this.action === 'copy' && target.hasAttribute('disabled')) {
+throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+}
+if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
+throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
+}
+this._target = target;
+} else {
+throw new Error('Invalid "target" value, use a valid Element');
+}
+}
+}
+/**
+* Gets the `target` property.
+* @return {String|HTMLElement}
+*/
+,
+get: function get() {
+return this._target;
+}
+}]);
+return ClipboardAction;
+}();
+/* harmony default export */ var clipboard_action = (clipboard_action_ClipboardAction);
+// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js
+var tiny_emitter = __webpack_require__(1);
+var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);
+// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
+var listen = __webpack_require__(2);
+var listen_default = /*#__PURE__*/__webpack_require__.n(listen);
+// CONCATENATED MODULE: ./src/clipboard.js
+var clipboard_typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+var clipboard_createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+function clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+/**
+* Base class which takes one or more elements, adds event listeners to them,
+* and instantiates a new `ClipboardAction` on each click.
+*/
+var clipboard_Clipboard = function (_Emitter) {
+_inherits(Clipboard, _Emitter);
+/**
+* @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+* @param {Object} options
+*/
+function Clipboard(trigger, options) {
+clipboard_classCallCheck(this, Clipboard);
+var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));
+_this.resolveOptions(options);
+_this.listenClick(trigger);
+return _this;
+}
+/**
+* Defines if attributes would be resolved using internal setter functions
+* or custom functions that were passed in the constructor.
+* @param {Object} options
+*/
+clipboard_createClass(Clipboard, [{
+key: 'resolveOptions',
+value: function resolveOptions() {
+var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
+this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
+this.text = typeof options.text === 'function' ? options.text : this.defaultText;
+this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
+}
+/**
+* Adds a click event listener to the passed trigger.
+* @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+*/
+}, {
+key: 'listenClick',
+value: function listenClick(trigger) {
+var _this2 = this;
+this.listener = listen_default()(trigger, 'click', function (e) {
+return _this2.onClick(e);
+});
+}
+/**
+* Defines a new `ClipboardAction` on each click event.
+* @param {Event} e
+*/
+}, {
+key: 'onClick',
+value: function onClick(e) {
+var trigger = e.delegateTarget || e.currentTarget;
+if (this.clipboardAction) {
+this.clipboardAction = null;
+}
+this.clipboardAction = new clipboard_action({
+action: this.action(trigger),
+target: this.target(trigger),
+text: this.text(trigger),
+container: this.container,
+trigger: trigger,
+emitter: this
+});
+}
+/**
+* Default `action` lookup function.
+* @param {Element} trigger
+*/
+}, {
+key: 'defaultAction',
+value: function defaultAction(trigger) {
+return getAttributeValue('action', trigger);
+}
+/**
+* Default `target` lookup function.
+* @param {Element} trigger
+*/
+}, {
+key: 'defaultTarget',
+value: function defaultTarget(trigger) {
+var selector = getAttributeValue('target', trigger);
+if (selector) {
+return document.querySelector(selector);
+}
+}
+/**
+* Returns the support of the given action, or all actions if no action is
+* given.
+* @param {String} [action]
+*/
+}, {
+key: 'defaultText',
+/**
+* Default `text` lookup function.
+* @param {Element} trigger
+*/
+value: function defaultText(trigger) {
+return getAttributeValue('text', trigger);
+}
+/**
+* Destroy lifecycle.
+*/
+}, {
+key: 'destroy',
+value: function destroy() {
+this.listener.destroy();
+if (this.clipboardAction) {
+this.clipboardAction.destroy();
+this.clipboardAction = null;
+}
+}
+}], [{
+key: 'isSupported',
+value: function isSupported() {
+var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
+var actions = typeof action === 'string' ? [action] : action;
+var support = !!document.queryCommandSupported;
+actions.forEach(function (action) {
+support = support && !!document.queryCommandSupported(action);
+});
+return support;
+}
+}]);
+return Clipboard;
+}(tiny_emitter_default.a);
+/**
+* Helper function to retrieve attribute value.
+* @param {String} suffix
+* @param {Element} element
+*/
+function getAttributeValue(suffix, element) {
+var attribute = 'data-clipboard-' + suffix;
+if (!element.hasAttribute(attribute)) {
+return;
+}
+return element.getAttribute(attribute);
+}
+/* harmony default export */ var clipboard = __webpack_exports__["default"] = (clipboard_Clipboard);
 /***/ })
+/******/ ])["default"];
+});
+/***/ }),
+/***/ 273:
+/***/ (function(module, exports, __webpack_require__) {
+var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */
+/**
+* Copyright 2012-2017 Craig Campbell
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* Mousetrap is a simple keyboard shortcut library for Javascript with
+* no external dependencies
+*
+* @version 1.6.5
+* @url craig.is/killing/mice
+*/
+(function(window, document, undefined) {
+// Check if mousetrap is used inside browser, if not, return
+if (!window) {
+return;
+}
+/**
+* mapping of special keycodes to their corresponding keys
+*
+* everything in this dictionary cannot use keypress events
+* so it has to be here to map to the correct keycodes for
+* keyup/keydown events
+*
+* @type {Object}
+*/
+var _MAP = {
+8: 'backspace',
+9: 'tab',
+13: 'enter',
+16: 'shift',
+17: 'ctrl',
+18: 'alt',
+20: 'capslock',
+27: 'esc',
+32: 'space',
+33: 'pageup',
+34: 'pagedown',
+35: 'end',
+36: 'home',
+37: 'left',
+38: 'up',
+39: 'right',
+40: 'down',
+45: 'ins',
+46: 'del',
+91: 'meta',
+93: 'meta',
+224: 'meta'
+};
+/**
+* mapping for special characters so they can support
+*
+* this dictionary is only used incase you want to bind a
+* keyup or keydown event to one of these keys
+*
+* @type {Object}
+*/
+var _KEYCODE_MAP = {
+106: '*',
+107: '+',
+109: '-',
+110: '.',
+111 : '/',
+186: ';',
+187: '=',
+188: ',',
+189: '-',
+190: '.',
+191: '/',
+192: '`',
+219: '[',
+220: '\\',
+221: ']',
+222: '\''
+};
+/**
+* this is a mapping of keys that require shift on a US keypad
+* back to the non shift equivelents
+*
+* this is so you can use keyup events with these keys
+*
+* note that this will only work reliably on US keyboards
+*
+* @type {Object}
+*/
+var _SHIFT_MAP = {
+'~': '`',
+'!': '1',
+'@': '2',
+'#': '3',
+'$': '4',
+'%': '5',
+'^': '6',
+'&': '7',
+'*': '8',
+'(': '9',
+')': '0',
+'_': '-',
+'+': '=',
+':': ';',
+'\"': '\'',
+'<': ',',
+'>': '.',
+'?': '/',
+'|': '\\'
+};
+/**
+* this is a list of special strings you can use to map
+* to modifier keys when you specify your keyboard shortcuts
+*
+* @type {Object}
+*/
+var _SPECIAL_ALIASES = {
+'option': 'alt',
+'command': 'meta',
+'return': 'enter',
+'escape': 'esc',
+'plus': '+',
+'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'
+};
+/**
+* variable to store the flipped version of _MAP from above
+* needed to check if we should use keypress or not when no action
+* is specified
+*
+* @type {Object|undefined}
+*/
+var _REVERSE_MAP;
+/**
+* loop through the f keys, f1 to f19 and add them to the map
+* programatically
+*/
+for (var i = 1; i < 20; ++i) {
+_MAP[111 + i] = 'f' + i;
+}
+/**
+* loop through to map numbers on the numeric keypad
+*/
+for (i = 0; i <= 9; ++i) {
+// This needs to use a string cause otherwise since 0 is falsey
+// mousetrap will never fire for numpad 0 pressed as part of a keydown
+// event.
+//
+// @see https://github.com/ccampbell/mousetrap/pull/258
+_MAP[i + 96] = i.toString();
+}
+/**
+* cross browser add event method
+*
+* @param {Element|HTMLDocument} object
+* @param {string} type
+* @param {Function} callback
+* @returns void
+*/
+function _addEvent(object, type, callback) {
+if (object.addEventListener) {
+object.addEventListener(type, callback, false);
+return;
+}
+object.attachEvent('on' + type, callback);
+}
+/**
+* takes the event and returns the key character
+*
+* @param {Event} e
+* @return {string}
+*/
+function _characterFromEvent(e) {
+// for keypress events we should return the character as is
+if (e.type == 'keypress') {
+var character = String.fromCharCode(e.which);
+// if the shift key is not pressed then it is safe to assume
+// that we want the character to be lowercase.  this means if
+// you accidentally have caps lock on then your key bindings
+// will continue to work
+//
+// the only side effect that might not be desired is if you
+// bind something like 'A' cause you want to trigger an
+// event when capital A is pressed caps lock will no longer
+// trigger the event.  shift+a will though.
+if (!e.shiftKey) {
+character = character.toLowerCase();
+}
+return character;
+}
+// for non keypress events the special maps are needed
+if (_MAP[e.which]) {
+return _MAP[e.which];
+}
+if (_KEYCODE_MAP[e.which]) {
+return _KEYCODE_MAP[e.which];
+}
+// if it is not in the special map
+// with keydown and keyup events the character seems to always
+// come in as an uppercase character whether you are pressing shift
+// or not.  we should make sure it is always lowercase for comparisons
+return String.fromCharCode(e.which).toLowerCase();
+}
+/**
+* checks if two arrays are equal
+*
+* @param {Array} modifiers1
+* @param {Array} modifiers2
+* @returns {boolean}
+*/
+function _modifiersMatch(modifiers1, modifiers2) {
+return modifiers1.sort().join(',') === modifiers2.sort().join(',');
+}
+/**
+* takes a key event and figures out what the modifiers are
+*
+* @param {Event} e
+* @returns {Array}
+*/
+function _eventModifiers(e) {
+var modifiers = [];
+if (e.shiftKey) {
+modifiers.push('shift');
+}
+if (e.altKey) {
+modifiers.push('alt');
+}
+if (e.ctrlKey) {
+modifiers.push('ctrl');
+}
+if (e.metaKey) {
+modifiers.push('meta');
+}
+return modifiers;
+}
+/**
+* prevents default for this event
+*
+* @param {Event} e
+* @returns void
+*/
+function _preventDefault(e) {
+if (e.preventDefault) {
+e.preventDefault();
+return;
+}
+e.returnValue = false;
+}
+/**
+* stops propogation for this event
+*
+* @param {Event} e
+* @returns void
+*/
+function _stopPropagation(e) {
+if (e.stopPropagation) {
+e.stopPropagation();
+return;
+}
+e.cancelBubble = true;
+}
+/**
+* determines if the keycode specified is a modifier key or not
+*
+* @param {string} key
+* @returns {boolean}
+*/
+function _isModifier(key) {
+return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';
+}
+/**
+* reverses the map lookup so that we can look for specific keys
+* to see what can and can't use keypress
+*
+* @return {Object}
+*/
+function _getReverseMap() {
+if (!_REVERSE_MAP) {
+_REVERSE_MAP = {};
+for (var key in _MAP) {
+// pull out the numeric keypad from here cause keypress should
+// be able to detect the keys from the character
+if (key > 95 && key < 112) {
+continue;
+}
+if (_MAP.hasOwnProperty(key)) {
+_REVERSE_MAP[_MAP[key]] = key;
+}
+}
+}
+return _REVERSE_MAP;
+}
+/**
+* picks the best action based on the key combination
+*
+* @param {string} key - character for key
+* @param {Array} modifiers
+* @param {string=} action passed in
+*/
+function _pickBestAction(key, modifiers, action) {
+// if no action was picked in we should try to pick the one
+// that we think would work best for this key
+if (!action) {
+action = _getReverseMap()[key] ? 'keydown' : 'keypress';
+}
+// modifier keys don't work as expected with keypress,
+// switch to keydown
+if (action == 'keypress' && modifiers.length) {
+action = 'keydown';
+}
+return action;
+}
+/**
+* Converts from a string key combination to an array
+*
+* @param  {string} combination like "command+shift+l"
+* @return {Array}
+*/
+function _keysFromString(combination) {
+if (combination === '+') {
+return ['+'];
+}
+combination = combination.replace(/\+{2}/g, '+plus');
+return combination.split('+');
+}
+/**
+* Gets info for a specific key combination
+*
+* @param  {string} combination key combination ("command+s" or "a" or "*")
+* @param  {string=} action
+* @returns {Object}
+*/
+function _getKeyInfo(combination, action) {
+var keys;
+var key;
+var i;
+var modifiers = [];
+// take the keys from this pattern and figure out what the actual
+// pattern is all about
+keys = _keysFromString(combination);
+for (i = 0; i < keys.length; ++i) {
+key = keys[i];
+// normalize key names
+if (_SPECIAL_ALIASES[key]) {
+key = _SPECIAL_ALIASES[key];
+}
+// if this is not a keypress event then we should
+// be smart about using shift keys
+// this will only work for US keyboards however
+if (action && action != 'keypress' && _SHIFT_MAP[key]) {
+key = _SHIFT_MAP[key];
+modifiers.push('shift');
+}
+// if this key is a modifier then add it to the list of modifiers
+if (_isModifier(key)) {
+modifiers.push(key);
+}
+}
+// depending on what the key combination is
+// we will try to pick the best event for it
+action = _pickBestAction(key, modifiers, action);
+return {
+key: key,
+modifiers: modifiers,
+action: action
+};
+}
+function _belongsTo(element, ancestor) {
+if (element === null || element === document) {
+return false;
+}
+if (element === ancestor) {
+return true;
+}
+return _belongsTo(element.parentNode, ancestor);
+}
+function Mousetrap(targetElement) {
+var self = this;
+targetElement = targetElement || document;
+if (!(self instanceof Mousetrap)) {
+return new Mousetrap(targetElement);
+}
+/**
+* element to attach key events to
+*
+* @type {Element}
+*/
+self.target = targetElement;
+/**
+* a list of all the callbacks setup via Mousetrap.bind()
+*
+* @type {Object}
+*/
+self._callbacks = {};
+/**
+* direct map of string combinations to callbacks used for trigger()
+*
+* @type {Object}
+*/
+self._directMap = {};
+/**
+* keeps track of what level each sequence is at since multiple
+* sequences can start out with the same sequence
+*
+* @type {Object}
+*/
+var _sequenceLevels = {};
+/**
+* variable to store the setTimeout call
+*
+* @type {null|number}
+*/
+var _resetTimer;
+/**
+* temporary state where we will ignore the next keyup
+*
+* @type {boolean|string}
+*/
+var _ignoreNextKeyup = false;
+/**
+* temporary state where we will ignore the next keypress
+*
+* @type {boolean}
+*/
+var _ignoreNextKeypress = false;
+/**
+* are we currently inside of a sequence?
+* type of action ("keyup" or "keydown" or "keypress") or false
+*
+* @type {boolean|string}
+*/
+var _nextExpectedAction = false;
+/**
+* resets all sequence counters except for the ones passed in
+*
+* @param {Object} doNotReset
+* @returns void
+*/
+function _resetSequences(doNotReset) {
+doNotReset = doNotReset || {};
+var activeSequences = false,
+key;
+for (key in _sequenceLevels) {
+if (doNotReset[key]) {
+activeSequences = true;
+continue;
+}
+_sequenceLevels[key] = 0;
+}
+if (!activeSequences) {
+_nextExpectedAction = false;
+}
+}
+/**
+* finds all callbacks that match based on the keycode, modifiers,
+* and action
+*
+* @param {string} character
+* @param {Array} modifiers
+* @param {Event|Object} e
+* @param {string=} sequenceName - name of the sequence we are looking for
+* @param {string=} combination
+* @param {number=} level
+* @returns {Array}
+*/
+function _getMatches(character, modifiers, e, sequenceName, combination, level) {
+var i;
+var callback;
+var matches = [];
+var action = e.type;
+// if there are no events related to this keycode
+if (!self._callbacks[character]) {
+return [];
+}
+// if a modifier key is coming up on its own we should allow it
+if (action == 'keyup' && _isModifier(character)) {
+modifiers = [character];
+}
+// loop through all callbacks for the key that was pressed
+// and see if any of them match
+for (i = 0; i < self._callbacks[character].length; ++i) {
+callback = self._callbacks[character][i];
+// if a sequence name is not specified, but this is a sequence at
+// the wrong level then move onto the next match
+if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {
+continue;
+}
+// if the action we are looking for doesn't match the action we got
+// then we should keep going
+if (action != callback.action) {
+continue;
+}
+// if this is a keypress event and the meta key and control key
+// are not pressed that means that we need to only look at the
+// character, otherwise check the modifiers as well
+//
+// chrome will not fire a keypress if meta or control is down
+// safari will fire a keypress if meta or meta+shift is down
+// firefox will fire a keypress if meta or control is down
+if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {
+// when you bind a combination or sequence a second time it
+// should overwrite the first one.  if a sequenceName or
+// combination is specified in this call it does just that
+//
+// @todo make deleting its own method?
+var deleteCombo = !sequenceName && callback.combo == combination;
+var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;
+if (deleteCombo || deleteSequence) {
+self._callbacks[character].splice(i, 1);
+}
+matches.push(callback);
+}
+}
+return matches;
+}
+/**
+* actually calls the callback function
+*
+* if your callback function returns false this will use the jquery
+* convention - prevent default and stop propogation on the event
+*
+* @param {Function} callback
+* @param {Event} e
+* @returns void
+*/
+function _fireCallback(callback, e, combo, sequence) {
+// if this event should not happen stop here
+if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {
+return;
+}
+if (callback(e, combo) === false) {
+_preventDefault(e);
+_stopPropagation(e);
+}
+}
+/**
+* handles a character key event
+*
+* @param {string} character
+* @param {Array} modifiers
+* @param {Event} e
+* @returns void
+*/
+self._handleKey = function(character, modifiers, e) {
+var callbacks = _getMatches(character, modifiers, e);
+var i;
+var doNotReset = {};
+var maxLevel = 0;
+var processedSequenceCallback = false;
+// Calculate the maxLevel for sequences so we can only execute the longest callback sequence
+for (i = 0; i < callbacks.length; ++i) {
+if (callbacks[i].seq) {
+maxLevel = Math.max(maxLevel, callbacks[i].level);
+}
+}
+// loop through matching callbacks for this key event
+for (i = 0; i < callbacks.length; ++i) {
+// fire for all sequence callbacks
+// this is because if for example you have multiple sequences
+// bound such as "g i" and "g t" they both need to fire the
+// callback for matching g cause otherwise you can only ever
+// match the first one
+if (callbacks[i].seq) {
+// only fire callbacks for the maxLevel to prevent
+// subsequences from also firing
+//
+// for example 'a option b' should not cause 'option b' to fire
+// even though 'option b' is part of the other sequence
+//
+// any sequences that do not match here will be discarded
+// below by the _resetSequences call
+if (callbacks[i].level != maxLevel) {
+continue;
+}
+processedSequenceCallback = true;
+// keep a list of which sequences were matches for later
+doNotReset[callbacks[i].seq] = 1;
+_fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);
+continue;
+}
+// if there were no sequence matches but we are still here
+// that means this is a regular match so we should fire that
+if (!processedSequenceCallback) {
+_fireCallback(callbacks[i].callback, e, callbacks[i].combo);
+}
+}
+// if the key you pressed matches the type of sequence without
+// being a modifier (ie "keyup" or "keypress") then we should
+// reset all sequences that were not matched by this event
+//
+// this is so, for example, if you have the sequence "h a t" and you
+// type "h e a r t" it does not match.  in this case the "e" will
+// cause the sequence to reset
+//
+// modifier keys are ignored because you can have a sequence
+// that contains modifiers such as "enter ctrl+space" and in most
+// cases the modifier key will be pressed before the next key
+//
+// also if you have a sequence such as "ctrl+b a" then pressing the
+// "b" key will trigger a "keypress" and a "keydown"
+//
+// the "keydown" is expected when there is a modifier, but the
+// "keypress" ends up matching the _nextExpectedAction since it occurs
+// after and that causes the sequence to reset
+//
+// we ignore keypresses in a sequence that directly follow a keydown
+// for the same character
+var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;
+if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {
+_resetSequences(doNotReset);
+}
+_ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';
+};
+/**
+* handles a keydown event
+*
+* @param {Event} e
+* @returns void
+*/
+function _handleKeyEvent(e) {
+// normalize e.which for key events
+// @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion
+if (typeof e.which !== 'number') {
+e.which = e.keyCode;
+}
+var character = _characterFromEvent(e);
+// no character found then stop
+if (!character) {
+return;
+}
+// need to use === for the character check because the character can be 0
+if (e.type == 'keyup' && _ignoreNextKeyup === character) {
+_ignoreNextKeyup = false;
+return;
+}
+self.handleKey(character, _eventModifiers(e), e);
+}
+/**
+* called to set a 1 second timeout on the specified sequence
+*
+* this is so after each key press in the sequence you have 1 second
+* to press the next key before you have to start over
+*
+* @returns void
+*/
+function _resetSequenceTimer() {
+clearTimeout(_resetTimer);
+_resetTimer = setTimeout(_resetSequences, 1000);
+}
+/**
+* binds a key sequence to an event
+*
+* @param {string} combo - combo specified in bind call
+* @param {Array} keys
+* @param {Function} callback
+* @param {string=} action
+* @returns void
+*/
+function _bindSequence(combo, keys, callback, action) {
+// start off by adding a sequence level record for this combination
+// and setting the level to 0
+_sequenceLevels[combo] = 0;
+/**
+* callback to increase the sequence level for this sequence and reset
+* all other sequences that were active
+*
+* @param {string} nextAction
+* @returns {Function}
+*/
+function _increaseSequence(nextAction) {
+return function() {
+_nextExpectedAction = nextAction;
+++_sequenceLevels[combo];
+_resetSequenceTimer();
+};
+}
+/**
+* wraps the specified callback inside of another function in order
+* to reset all sequence counters as soon as this sequence is done
+*
+* @param {Event} e
+* @returns void
+*/
+function _callbackAndReset(e) {
+_fireCallback(callback, e, combo);
+// we should ignore the next key up if the action is key down
+// or keypress.  this is so if you finish a sequence and
+// release the key the final key will not trigger a keyup
+if (action !== 'keyup') {
+_ignoreNextKeyup = _characterFromEvent(e);
+}
+// weird race condition if a sequence ends with the key
+// another sequence begins with
+setTimeout(_resetSequences, 10);
+}
+// loop through keys one at a time and bind the appropriate callback
+// function.  for any key leading up to the final one it should
+// increase the sequence. after the final, it should reset all sequences
+//
+// if an action is specified in the original bind call then that will
+// be used throughout.  otherwise we will pass the action that the
+// next key in the sequence should match.  this allows a sequence
+// to mix and match keypress and keydown events depending on which
+// ones are better suited to the key provided
+for (var i = 0; i < keys.length; ++i) {
+var isFinal = i + 1 === keys.length;
+var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);
+_bindSingle(keys[i], wrappedCallback, action, combo, i);
+}
+}
+/**
+* binds a single keyboard combination
+*
+* @param {string} combination
+* @param {Function} callback
+* @param {string=} action
+* @param {string=} sequenceName - name of sequence if part of sequence
+* @param {number=} level - what part of the sequence the command is
+* @returns void
+*/
+function _bindSingle(combination, callback, action, sequenceName, level) {
+// store a direct mapped reference for use with Mousetrap.trigger
+self._directMap[combination + ':' + action] = callback;
+// make sure multiple spaces in a row become a single space
+combination = combination.replace(/\s+/g, ' ');
+var sequence = combination.split(' ');
+var info;
+// if this pattern is a sequence of keys then run through this method
+// to reprocess each pattern one key at a time
+if (sequence.length > 1) {
+_bindSequence(combination, sequence, callback, action);
+return;
+}
+info = _getKeyInfo(combination, action);
+// make sure to initialize array if this is the first time
+// a callback is added for this key
+self._callbacks[info.key] = self._callbacks[info.key] || [];
+// remove an existing match if there is one
+_getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);
+// add this call back to the array
+// if it is a sequence put it at the beginning
+// if not put it at the end
+//
+// this is important because the way these are processed expects
+// the sequence ones to come first
+self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({
+callback: callback,
+modifiers: info.modifiers,
+action: info.action,
+seq: sequenceName,
+level: level,
+combo: combination
+});
+}
+/**
+* binds multiple combinations to the same callback
+*
+* @param {Array} combinations
+* @param {Function} callback
+* @param {string|undefined} action
+* @returns void
+*/
+self._bindMultiple = function(combinations, callback, action) {
+for (var i = 0; i < combinations.length; ++i) {
+_bindSingle(combinations[i], callback, action);
+}
+};
+// start!
+_addEvent(targetElement, 'keypress', _handleKeyEvent);
+_addEvent(targetElement, 'keydown', _handleKeyEvent);
+_addEvent(targetElement, 'keyup', _handleKeyEvent);
+}
+/**
+* binds an event to mousetrap
+*
+* can be a single key, a combination of keys separated with +,
+* an array of keys, or a sequence of keys separated by spaces
+*
+* be sure to list the modifier keys first to make sure that the
+* correct key ends up getting bound (the last key in the pattern)
+*
+* @param {string|Array} keys
+* @param {Function} callback
+* @param {string=} action - 'keypress', 'keydown', or 'keyup'
+* @returns void
+*/
+Mousetrap.prototype.bind = function(keys, callback, action) {
+var self = this;
+keys = keys instanceof Array ? keys : [keys];
+self._bindMultiple.call(self, keys, callback, action);
+return self;
+};
+/**
+* unbinds an event to mousetrap
+*
+* the unbinding sets the callback function of the specified key combo
+* to an empty function and deletes the corresponding key in the
+* _directMap dict.
+*
+* TODO: actually remove this from the _callbacks dictionary instead
+* of binding an empty function
+*
+* the keycombo+action has to be exactly the same as
+* it was defined in the bind method
+*
+* @param {string|Array} keys
+* @param {string} action
+* @returns void
+*/
+Mousetrap.prototype.unbind = function(keys, action) {
+var self = this;
+return self.bind.call(self, keys, function() {}, action);
+};
+/**
+* triggers an event that has already been bound
+*
+* @param {string} keys
+* @param {string=} action
+* @returns void
+*/
+Mousetrap.prototype.trigger = function(keys, action) {
+var self = this;
+if (self._directMap[keys + ':' + action]) {
+self._directMap[keys + ':' + action]({}, keys);
+}
+return self;
+};
+/**
+* resets the library back to its initial state.  this is useful
+* if you want to clear out the current keyboard shortcuts and bind
+* new ones - for example if you switch to another page
+*
+* @returns void
+*/
+Mousetrap.prototype.reset = function() {
+var self = this;
+self._callbacks = {};
+self._directMap = {};
+return self;
+};
+/**
+* should we stop this event before firing off callbacks
+*
+* @param {Event} e
+* @param {Element} element
+* @return {boolean}
+*/
+Mousetrap.prototype.stopCallback = function(e, element) {
+var self = this;
+// if the element has the class "mousetrap" then no need to stop
+if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {
+return false;
+}
+if (_belongsTo(element, self.target)) {
+return false;
+}
+// Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,
+// not the initial event target in the shadow tree. Note that not all events cross the
+// shadow boundary.
+// For shadow trees with `mode: 'open'`, the initial event target is the first element in
+// the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event
+// target cannot be obtained.
+if ('composedPath' in e && typeof e.composedPath === 'function') {
+// For open shadow trees, update `element` so that the following check works.
+var initialEventTarget = e.composedPath()[0];
+if (initialEventTarget !== e.target) {
+element = initialEventTarget;
+}
+}
+// stop for input, select, and textarea
+return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;
+};
+/**
+* exposes _handleKey publicly so it can be overwritten by extensions
+*/
+Mousetrap.prototype.handleKey = function() {
+var self = this;
+return self._handleKey.apply(self, arguments);
+};
+/**
+* allow custom key mappings
+*/
+Mousetrap.addKeycodes = function(object) {
+for (var key in object) {
+if (object.hasOwnProperty(key)) {
+_MAP[key] = object[key];
+}
+}
+_REVERSE_MAP = null;
+};
+/**
+* Init the global mousetrap functions
+*
+* This method is needed to allow the global mousetrap functions to work
+* now that mousetrap is a constructor function.
+*/
+Mousetrap.init = function() {
+var documentMousetrap = Mousetrap(document);
+for (var method in documentMousetrap) {
+if (method.charAt(0) !== '_') {
+Mousetrap[method] = (function(method) {
+return function() {
+return documentMousetrap[method].apply(documentMousetrap, arguments);
+};
+} (method));
+}
+}
+};
+Mousetrap.init();
+// expose mousetrap to the global object
+window.Mousetrap = Mousetrap;
+// expose as a common js module
+if ( true && module.exports) {
+module.exports = Mousetrap;
+}
+// expose mousetrap as an AMD module
+if (true) {
+!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
+return Mousetrap;
+}).call(exports, __webpack_require__, exports, module),
+				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+}
+}) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);
+/***/ }),
+/***/ 29:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
+/* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26);
+function _unsupportedIterableToArray(o, minLen) {
+if (!o) return;
+if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
+var n = Object.prototype.toString.call(o).slice(8, -1);
+if (n === "Object" && o.constructor) n = o.constructor.name;
+if (n === "Map" || n === "Set") return Array.from(o);
+if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
+}
+/***/ }),
+/***/ 35:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
+function _iterableToArray(iter) {
+if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+}
+/***/ }),
+/***/ 38:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
+function _arrayWithHoles(arr) {
+if (Array.isArray(arr)) return arr;
+}
+/***/ }),
+/***/ 39:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
+function _nonIterableRest() {
+throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+/***/ }),
+/***/ 40:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; });
+function _typeof(obj) {
+"@babel/helpers - typeof";
+if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+_typeof = function _typeof(obj) {
+return typeof obj;
+};
+} else {
+_typeof = function _typeof(obj) {
+return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+};
+}
+return _typeof(obj);
+}
+/***/ }),
+/***/ 411:
+/***/ (function(module, exports) {
+/**
+* adds a bindGlobal method to Mousetrap that allows you to
+* bind specific keyboard shortcuts that will still work
+* inside a text input field
+*
+* usage:
+* Mousetrap.bindGlobal('ctrl+s', _saveChanges);
+*/
+/* global Mousetrap:true */
+(function(Mousetrap) {
+if (! Mousetrap) {
+return;
+}
+var _globalCallbacks = {};
+var _originalStopCallback = Mousetrap.prototype.stopCallback;
+Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) {
+var self = this;
+if (self.paused) {
+return true;
+}
+if (_globalCallbacks[combo] || _globalCallbacks[sequence]) {
+return false;
+}
+return _originalStopCallback.call(self, e, element, combo);
+};
+Mousetrap.prototype.bindGlobal = function(keys, callback, action) {
+var self = this;
+self.bind(keys, callback, action);
+if (keys instanceof Array) {
+for (var i = 0; i < keys.length; i++) {
+_globalCallbacks[keys[i]] = true;
+}
+return;
+}
+_globalCallbacks[keys] = true;
+};
+Mousetrap.init();
+}) (typeof Mousetrap !== "undefined" ? Mousetrap : undefined);
+/***/ }),
+/***/ 445:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return /* reexport */ create_higher_order_component; });
+__webpack_require__.d(__webpack_exports__, "compose", function() { return /* reexport */ compose; });
+__webpack_require__.d(__webpack_exports__, "ifCondition", function() { return /* reexport */ if_condition; });
+__webpack_require__.d(__webpack_exports__, "pure", function() { return /* reexport */ higher_order_pure; });
+__webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return /* reexport */ with_global_events; });
+__webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return /* reexport */ with_instance_id; });
+__webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return /* reexport */ with_safe_timeout; });
+__webpack_require__.d(__webpack_exports__, "withState", function() { return /* reexport */ withState; });
+__webpack_require__.d(__webpack_exports__, "useCopyOnClick", function() { return /* reexport */ useCopyOnClick; });
+__webpack_require__.d(__webpack_exports__, "__experimentalUseDragging", function() { return /* reexport */ useDragging; });
+__webpack_require__.d(__webpack_exports__, "useInstanceId", function() { return /* reexport */ useInstanceId; });
+__webpack_require__.d(__webpack_exports__, "useKeyboardShortcut", function() { return /* reexport */ use_keyboard_shortcut; });
+__webpack_require__.d(__webpack_exports__, "useMediaQuery", function() { return /* reexport */ useMediaQuery; });
+__webpack_require__.d(__webpack_exports__, "usePrevious", function() { return /* reexport */ usePrevious; });
+__webpack_require__.d(__webpack_exports__, "useReducedMotion", function() { return /* reexport */ use_reduced_motion; });
+__webpack_require__.d(__webpack_exports__, "useViewportMatch", function() { return /* reexport */ use_viewport_match; });
+__webpack_require__.d(__webpack_exports__, "useResizeObserver", function() { return /* reexport */ use_resize_observer; });
+__webpack_require__.d(__webpack_exports__, "useAsyncList", function() { return /* reexport */ use_async_list; });
+__webpack_require__.d(__webpack_exports__, "useWarnOnChange", function() { return /* reexport */ use_warn_on_change; });
+// EXTERNAL MODULE: external {"this":"lodash"}
+var external_this_lodash_ = __webpack_require__(2);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js
+/**
+* External dependencies
+*/
+/**
+* Given a function mapping a component to an enhanced component and modifier
+* name, returns the enhanced component augmented with a generated displayName.
+*
+* @param {Function} mapComponentToEnhancedComponent Function mapping component
+*                                                   to enhanced component.
+* @param {string}   modifierName                    Seed name from which to
+*                                                   generated display name.
+*
+* @return {WPComponent} Component class with generated display name assigned.
+*/
+function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) {
+return function (OriginalComponent) {
+var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent);
+var _OriginalComponent$di = OriginalComponent.displayName,
+displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di;
+EnhancedComponent.displayName = "".concat(Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")");
+return EnhancedComponent;
+};
+}
+/* harmony default export */ var create_higher_order_component = (createHigherOrderComponent);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js
+/**
+* External dependencies
+*/
+/**
+* Composes multiple higher-order components into a single higher-order component. Performs right-to-left function
+* composition, where each successive invocation is supplied the return value of the previous.
+*
+* @param {...Function} hocs The HOC functions to invoke.
+*
+* @return {Function} Returns the new composite function.
+*/
+/* harmony default export */ var compose = (external_this_lodash_["flowRight"]);
+// EXTERNAL MODULE: external {"this":["wp","element"]}
+var external_this_wp_element_ = __webpack_require__(0);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js
+/**
+* Internal dependencies
+*/
+/**
+* Higher-order component creator, creating a new component which renders if
+* the given condition is satisfied or with the given optional prop name.
+*
+* @param {Function} predicate Function to test condition.
+*
+* @return {Function} Higher-order component.
+*/
+var if_condition_ifCondition = function ifCondition(predicate) {
+return create_higher_order_component(function (WrappedComponent) {
+return function (props) {
+if (!predicate(props)) {
+return null;
+}
+return Object(external_this_wp_element_["createElement"])(WrappedComponent, props);
+};
+}, 'ifCondition');
+};
+/* harmony default export */ var if_condition = (if_condition_ifCondition);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
+var classCallCheck = __webpack_require__(20);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
+var createClass = __webpack_require__(19);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
+var possibleConstructorReturn = __webpack_require__(23);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
+var getPrototypeOf = __webpack_require__(16);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules
+var inherits = __webpack_require__(22);
+// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]}
+var external_this_wp_isShallowEqual_ = __webpack_require__(64);
+var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js
+function _createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+/**
+* WordPress dependencies
+*/
+/**
+* Internal dependencies
+*/
+/**
+* Given a component returns the enhanced component augmented with a component
+* only rerendering when its props/state change
+*
+* @param {Function} mapComponentToEnhancedComponent Function mapping component
+*                                                   to enhanced component.
+* @param {string}   modifierName                    Seed name from which to
+*                                                   generated display name.
+*
+* @return {WPComponent} Component class with generated display name assigned.
+*/
+var pure = create_higher_order_component(function (Wrapped) {
+if (Wrapped.prototype instanceof external_this_wp_element_["Component"]) {
+return /*#__PURE__*/function (_Wrapped) {
+Object(inherits["a" /* default */])(_class, _Wrapped);
+var _super = _createSuper(_class);
+function _class() {
+Object(classCallCheck["a" /* default */])(this, _class);
+return _super.apply(this, arguments);
+}
+Object(createClass["a" /* default */])(_class, [{
+key: "shouldComponentUpdate",
+value: function shouldComponentUpdate(nextProps, nextState) {
+return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state);
+}
+}]);
+return _class;
+}(Wrapped);
+}
+return /*#__PURE__*/function (_Component) {
+Object(inherits["a" /* default */])(_class2, _Component);
+var _super2 = _createSuper(_class2);
+function _class2() {
+Object(classCallCheck["a" /* default */])(this, _class2);
+return _super2.apply(this, arguments);
+}
+Object(createClass["a" /* default */])(_class2, [{
+key: "shouldComponentUpdate",
+value: function shouldComponentUpdate(nextProps) {
+return !external_this_wp_isShallowEqual_default()(nextProps, this.props);
+}
+}, {
+key: "render",
+value: function render() {
+return Object(external_this_wp_element_["createElement"])(Wrapped, this.props);
+}
+}]);
+return _class2;
+}(external_this_wp_element_["Component"]);
+}, 'pure');
+/* harmony default export */ var higher_order_pure = (pure);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
+var esm_extends = __webpack_require__(8);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
+var assertThisInitialized = __webpack_require__(12);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js
+/**
+* External dependencies
+*/
+/**
+* Class responsible for orchestrating event handling on the global window,
+* binding a single event to be shared across all handling instances, and
+* removing the handler when no instances are listening for the event.
+*/
+var listener_Listener = /*#__PURE__*/function () {
+function Listener() {
+Object(classCallCheck["a" /* default */])(this, Listener);
+this.listeners = {};
+this.handleEvent = this.handleEvent.bind(this);
+}
+Object(createClass["a" /* default */])(Listener, [{
+key: "add",
+value: function add(eventType, instance) {
+if (!this.listeners[eventType]) {
+// Adding first listener for this type, so bind event.
+window.addEventListener(eventType, this.handleEvent);
+this.listeners[eventType] = [];
+}
+this.listeners[eventType].push(instance);
+}
+}, {
+key: "remove",
+value: function remove(eventType, instance) {
+this.listeners[eventType] = Object(external_this_lodash_["without"])(this.listeners[eventType], instance);
+if (!this.listeners[eventType].length) {
+// Removing last listener for this type, so unbind event.
+window.removeEventListener(eventType, this.handleEvent);
+delete this.listeners[eventType];
+}
+}
+}, {
+key: "handleEvent",
+value: function handleEvent(event) {
+Object(external_this_lodash_["forEach"])(this.listeners[event.type], function (instance) {
+instance.handleEvent(event);
+});
+}
+}]);
+return Listener;
+}();
+/* harmony default export */ var listener = (listener_Listener);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js
+function with_global_events_createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (with_global_events_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
+function with_global_events_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+/**
+* External dependencies
+*/
+/**
+* WordPress dependencies
+*/
+/**
+* Internal dependencies
+*/
+/**
+* Listener instance responsible for managing document event handling.
+*
+* @type {Listener}
+*/
+var with_global_events_listener = new listener();
+/**
+* Higher-order component creator which, given an object of DOM event types and
+* values corresponding to a callback function name on the component, will
+* create or update a window event handler to invoke the callback when an event
+* occurs. On behalf of the consuming developer, the higher-order component
+* manages unbinding when the component unmounts, and binding at most a single
+* event handler for the entire application.
+*
+* @param {Object<string,string>} eventTypesToHandlers Object with keys of DOM
+*                                                     event type, the value a
+*                                                     name of the function on
+*                                                     the original component's
+*                                                     instance which handles
+*                                                     the event.
+*
+* @return {Function} Higher-order component.
+*/
+function withGlobalEvents(eventTypesToHandlers) {
+return create_higher_order_component(function (WrappedComponent) {
+var Wrapper = /*#__PURE__*/function (_Component) {
+Object(inherits["a" /* default */])(Wrapper, _Component);
+var _super = with_global_events_createSuper(Wrapper);
+function Wrapper() {
+var _this;
+Object(classCallCheck["a" /* default */])(this, Wrapper);
+_this = _super.apply(this, arguments);
+_this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(_this));
+_this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(_this));
+return _this;
+}
+Object(createClass["a" /* default */])(Wrapper, [{
+key: "componentDidMount",
+value: function componentDidMount() {
+var _this2 = this;
+Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
+with_global_events_listener.add(eventType, _this2);
+});
+}
+}, {
+key: "componentWillUnmount",
+value: function componentWillUnmount() {
+var _this3 = this;
+Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) {
+with_global_events_listener.remove(eventType, _this3);
+});
+}
+}, {
+key: "handleEvent",
+value: function handleEvent(event) {
+var handler = eventTypesToHandlers[event.type];
+if (typeof this.wrappedRef[handler] === 'function') {
+this.wrappedRef[handler](event);
+}
+}
+}, {
+key: "handleRef",
+value: function handleRef(el) {
+this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref`
+// will cause `this.props.forwardedRef` to be `null`, so we need this
+// check.
+if (this.props.forwardedRef) {
+this.props.forwardedRef(el);
+}
+}
+}, {
+key: "render",
+value: function render() {
+return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, {
+ref: this.handleRef
+}));
+}
+}]);
+return Wrapper;
+}(external_this_wp_element_["Component"]);
+return Object(external_this_wp_element_["forwardRef"])(function (props, ref) {
+return Object(external_this_wp_element_["createElement"])(Wrapper, {
+ownProps: props,
+forwardedRef: ref
+});
+});
+}, 'withGlobalEvents');
+}
+/* harmony default export */ var with_global_events = (withGlobalEvents);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js
+/**
+* WordPress dependencies
+*/
+var instanceMap = new WeakMap();
+/**
+* Creates a new id for a given object.
+*
+* @param {Object} object Object reference to create an id for.
+*/
+function createId(object) {
+var instances = instanceMap.get(object) || 0;
+instanceMap.set(object, instances + 1);
+return instances;
+}
+/**
+* Provides a unique instance ID.
+*
+* @param {Object} object Object reference to create an id for.
+* @param {string} prefix Prefix for the unique id.
+*/
+function useInstanceId(object, prefix) {
+return Object(external_this_wp_element_["useMemo"])(function () {
+var id = createId(object);
+return prefix ? "".concat(prefix, "-").concat(id) : id;
+}, [object]);
+}
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js
+/**
+* Internal dependencies
+*/
+/**
+* A Higher Order Component used to be provide a unique instance ID by
+* component.
+*
+* @param {WPComponent} WrappedComponent The wrapped component.
+*
+* @return {WPComponent} Component with an instanceId prop.
+*/
+/* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) {
+return function (props) {
+var instanceId = useInstanceId(WrappedComponent);
+return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, props, {
+instanceId: instanceId
+}));
+};
+}, 'withInstanceId'));
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js
+function with_safe_timeout_createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (with_safe_timeout_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
+function with_safe_timeout_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+/**
+* External dependencies
+*/
+/**
+* WordPress dependencies
+*/
+/**
+* Internal dependencies
+*/
+/**
+* A higher-order component used to provide and manage delayed function calls
+* that ought to be bound to a component's lifecycle.
+*
+* @param {WPComponent} OriginalComponent Component requiring setTimeout
+*
+* @return {WPComponent} Wrapped component.
+*/
+var withSafeTimeout = create_higher_order_component(function (OriginalComponent) {
+return /*#__PURE__*/function (_Component) {
+Object(inherits["a" /* default */])(WrappedComponent, _Component);
+var _super = with_safe_timeout_createSuper(WrappedComponent);
+function WrappedComponent() {
+var _this;
+Object(classCallCheck["a" /* default */])(this, WrappedComponent);
+_this = _super.apply(this, arguments);
+_this.timeouts = [];
+_this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this));
+_this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this));
+return _this;
+}
+Object(createClass["a" /* default */])(WrappedComponent, [{
+key: "componentWillUnmount",
+value: function componentWillUnmount() {
+this.timeouts.forEach(clearTimeout);
+}
+}, {
+key: "setTimeout",
+value: function (_setTimeout) {
+function setTimeout(_x, _x2) {
+return _setTimeout.apply(this, arguments);
+}
+setTimeout.toString = function () {
+return _setTimeout.toString();
+};
+return setTimeout;
+}(function (fn, delay) {
+var _this2 = this;
+var id = setTimeout(function () {
+fn();
+_this2.clearTimeout(id);
+}, delay);
+this.timeouts.push(id);
+return id;
+})
+}, {
+key: "clearTimeout",
+value: function (_clearTimeout) {
+function clearTimeout(_x3) {
+return _clearTimeout.apply(this, arguments);
+}
+clearTimeout.toString = function () {
+return _clearTimeout.toString();
+};
+return clearTimeout;
+}(function (id) {
+clearTimeout(id);
+this.timeouts = Object(external_this_lodash_["without"])(this.timeouts, id);
+})
+}, {
+key: "render",
+value: function render() {
+return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, {
+setTimeout: this.setTimeout,
+clearTimeout: this.clearTimeout
+}));
+}
+}]);
+return WrappedComponent;
+}(external_this_wp_element_["Component"]);
+}, 'withSafeTimeout');
+/* harmony default export */ var with_safe_timeout = (withSafeTimeout);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js
+function with_state_createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (with_state_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
+function with_state_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+/**
+* WordPress dependencies
+*/
+/**
+* Internal dependencies
+*/
+/**
+* A Higher Order Component used to provide and manage internal component state
+* via props.
+*
+* @param {?Object} initialState Optional initial state of the component.
+*
+* @return {WPComponent} Wrapped component.
+*/
+function withState() {
+var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+return create_higher_order_component(function (OriginalComponent) {
+return /*#__PURE__*/function (_Component) {
+Object(inherits["a" /* default */])(WrappedComponent, _Component);
+var _super = with_state_createSuper(WrappedComponent);
+function WrappedComponent() {
+var _this;
+Object(classCallCheck["a" /* default */])(this, WrappedComponent);
+_this = _super.apply(this, arguments);
+_this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(_this));
+_this.state = initialState;
+return _this;
+}
+Object(createClass["a" /* default */])(WrappedComponent, [{
+key: "render",
+value: function render() {
+return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, {
+setState: this.setState
+}));
+}
+}]);
+return WrappedComponent;
+}(external_this_wp_element_["Component"]);
+}, 'withState');
+}
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
+var slicedToArray = __webpack_require__(14);
+// EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js
+var dist_clipboard = __webpack_require__(272);
+var clipboard_default = /*#__PURE__*/__webpack_require__.n(dist_clipboard);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-on-click/index.js
+/**
+* External dependencies
+*/
+/**
+* WordPress dependencies
+*/
+/**
+* Copies the text to the clipboard when the element is clicked.
+*
+* @param {Object}          ref     Reference with the element.
+* @param {string|Function} text    The text to copy.
+* @param {number}          timeout Optional timeout to reset the returned
+*                                  state. 4 seconds by default.
+*
+* @return {boolean} Whether or not the text has been copied. Resets after the
+*                   timeout.
+*/
+function useCopyOnClick(ref, _text) {
+var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000;
+var clipboard = Object(external_this_wp_element_["useRef"])();
+var _useState = Object(external_this_wp_element_["useState"])(false),
+_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
+hasCopied = _useState2[0],
+setHasCopied = _useState2[1];
+Object(external_this_wp_element_["useEffect"])(function () {
+var timeoutId; // Clipboard listens to click events.
+clipboard.current = new clipboard_default.a(ref.current, {
+text: function text() {
+return typeof _text === 'function' ? _text() : _text;
+}
+});
+clipboard.current.on('success', function (_ref) {
+var clearSelection = _ref.clearSelection,
+trigger = _ref.trigger;
+// Clearing selection will move focus back to the triggering button,
+// ensuring that it is not reset to the body, and further that it is
+// kept within the rendered node.
+clearSelection(); // Handle ClipboardJS focus bug, see https://github.com/zenorocha/clipboard.js/issues/680
+if (trigger) {
+trigger.focus();
+}
+if (timeout) {
+setHasCopied(true);
+clearTimeout(timeoutId);
+timeoutId = setTimeout(function () {
+return setHasCopied(false);
+}, timeout);
+}
+});
+return function () {
+clipboard.current.destroy();
+clearTimeout(timeoutId);
+};
+}, [_text, timeout, setHasCopied]);
+return hasCopied;
+}
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js
+/**
+* WordPress dependencies
+*/
+var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external_this_wp_element_["useLayoutEffect"] : external_this_wp_element_["useEffect"];
+function useDragging(_ref) {
+var onDragStart = _ref.onDragStart,
+onDragMove = _ref.onDragMove,
+onDragEnd = _ref.onDragEnd;
+var _useState = Object(external_this_wp_element_["useState"])(false),
+_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
+isDragging = _useState2[0],
+setIsDragging = _useState2[1];
+var eventsRef = Object(external_this_wp_element_["useRef"])({
+onDragStart: onDragStart,
+onDragMove: onDragMove,
+onDragEnd: onDragEnd
+});
+useIsomorphicLayoutEffect(function () {
+eventsRef.current.onDragStart = onDragStart;
+eventsRef.current.onDragMove = onDragMove;
+eventsRef.current.onDragEnd = onDragEnd;
+}, [onDragStart, onDragMove, onDragEnd]);
+var onMouseMove = Object(external_this_wp_element_["useCallback"])(function () {
+var _eventsRef$current;
+return eventsRef.current.onDragMove && (_eventsRef$current = eventsRef.current).onDragMove.apply(_eventsRef$current, arguments);
+}, []);
+var endDrag = Object(external_this_wp_element_["useCallback"])(function () {
+if (eventsRef.current.onDragEnd) {
+var _eventsRef$current2;
+(_eventsRef$current2 = eventsRef.current).onDragEnd.apply(_eventsRef$current2, arguments);
+}
+document.removeEventListener('mousemove', onMouseMove);
+document.removeEventListener('mouseup', endDrag);
+setIsDragging(false);
+}, []);
+var startDrag = Object(external_this_wp_element_["useCallback"])(function () {
+if (eventsRef.current.onDragStart) {
+var _eventsRef$current3;
+(_eventsRef$current3 = eventsRef.current).onDragStart.apply(_eventsRef$current3, arguments);
+}
+document.addEventListener('mousemove', onMouseMove);
+document.addEventListener('mouseup', endDrag);
+setIsDragging(true);
+}, []); // Remove the global events when unmounting if needed.
+Object(external_this_wp_element_["useEffect"])(function () {
+return function () {
+if (isDragging) {
+document.removeEventListener('mousemove', onMouseMove);
+document.removeEventListener('mouseup', endDrag);
+}
+};
+}, [isDragging]);
+return {
+startDrag: startDrag,
+endDrag: endDrag,
+isDragging: isDragging
+};
+}
+// EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js
+var mousetrap_mousetrap = __webpack_require__(273);
+var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap_mousetrap);
+// EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js
+var mousetrap_global_bind = __webpack_require__(411);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js
+/**
+* External dependencies
+*/
+/**
+* WordPress dependencies
+*/
+/**
+* A block selection object.
+*
+* @typedef {Object} WPKeyboardShortcutConfig
+*
+* @property {boolean} [bindGlobal]  Handle keyboard events anywhere including inside textarea/input fields.
+* @property {string}  [eventName]   Event name used to trigger the handler, defaults to keydown.
+* @property {boolean} [isDisabled]  Disables the keyboard handler if the value is true.
+* @property {Object}  [target]      React reference to the DOM element used to catch the keyboard event.
+*/
+/**
+* Return true if platform is MacOS.
+*
+* @param {Object} _window   window object by default; used for DI testing.
+*
+* @return {boolean} True if MacOS; false otherwise.
+*/
+function isAppleOS() {
+var _window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window;
+var platform = _window.navigator.platform;
+return platform.indexOf('Mac') !== -1 || Object(external_this_lodash_["includes"])(['iPad', 'iPhone'], platform);
+}
+/**
+* Attach a keyboard shortcut handler.
+*
+* @param {string[]|string}         shortcuts  Keyboard Shortcuts.
+* @param {Function}                callback   Shortcut callback.
+* @param {WPKeyboardShortcutConfig} options    Shortcut options.
+*/
+function useKeyboardShortcut(shortcuts, callback) {
+var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+_ref$bindGlobal = _ref.bindGlobal,
+bindGlobal = _ref$bindGlobal === void 0 ? false : _ref$bindGlobal,
+_ref$eventName = _ref.eventName,
+eventName = _ref$eventName === void 0 ? 'keydown' : _ref$eventName,
+_ref$isDisabled = _ref.isDisabled,
+isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled,
+target = _ref.target;
+var currentCallback = Object(external_this_wp_element_["useRef"])(callback);
+Object(external_this_wp_element_["useEffect"])(function () {
+currentCallback.current = callback;
+}, [callback]);
+Object(external_this_wp_element_["useEffect"])(function () {
+if (isDisabled) {
+return;
+}
+var mousetrap = new mousetrap_default.a(target ? target.current : document);
+Object(external_this_lodash_["castArray"])(shortcuts).forEach(function (shortcut) {
+var keys = shortcut.split('+'); // Determines whether a key is a modifier by the length of the string.
+// E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that
+// the modifiers are Shift and Cmd because they're not a single character.
+var modifiers = new Set(keys.filter(function (value) {
+return value.length > 1;
+}));
+var hasAlt = modifiers.has('alt');
+var hasShift = modifiers.has('shift'); // This should be better moved to the shortcut registration instead.
+if (isAppleOS() && (modifiers.size === 1 && hasAlt || modifiers.size === 2 && hasAlt && hasShift)) {
+throw new Error("Cannot bind ".concat(shortcut, ". Alt and Shift+Alt modifiers are reserved for character input."));
+}
+var bindFn = bindGlobal ? 'bindGlobal' : 'bind';
+mousetrap[bindFn](shortcut, function () {
+return currentCallback.current.apply(currentCallback, arguments);
+}, eventName);
+});
+return function () {
+mousetrap.reset();
+};
+}, [shortcuts, bindGlobal, eventName, target, isDisabled]);
+}
+/* harmony default export */ var use_keyboard_shortcut = (useKeyboardShortcut);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js
+/**
+* WordPress dependencies
+*/
+/**
+* Runs a media query and returns its value when it changes.
+*
+* @param {string} [query] Media Query.
+* @return {boolean} return value of the media query.
+*/
+function useMediaQuery(query) {
+var _useState = Object(external_this_wp_element_["useState"])(query && window.matchMedia(query).matches),
+_useState2 = Object(slicedToArray["a" /* default */])(_useState, 2),
+match = _useState2[0],
+setMatch = _useState2[1];
+Object(external_this_wp_element_["useEffect"])(function () {
+if (!query) {
+return;
+}
+var updateMatch = function updateMatch() {
+return setMatch(window.matchMedia(query).matches);
+};
+updateMatch();
+var list = window.matchMedia(query);
+list.addListener(updateMatch);
+return function () {
+list.removeListener(updateMatch);
+};
+}, [query]);
+return query && match;
+}
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-previous/index.js
+/**
+* WordPress dependencies
+*/
+/**
+* Use something's value from the previous render.
+* Based on https://usehooks.com/usePrevious/.
+*
+* @template T
+*
+* @param {T} value The value to track.
+*
+* @return {T|undefined} The value from the previous render.
+*/
+function usePrevious(value) {
+// Disable reason: without an explicit type detail, the type of ref will be
+// inferred based on the initial useRef argument, which is undefined.
+// https://github.com/WordPress/gutenberg/pull/22597#issuecomment-633588366
+/* eslint-disable jsdoc/no-undefined-types */
+var ref = Object(external_this_wp_element_["useRef"])(
+/** @type {T|undefined} */
+undefined);
+/* eslint-enable jsdoc/no-undefined-types */
+// Store current value in ref.
+Object(external_this_wp_element_["useEffect"])(function () {
+ref.current = value;
+}, [value]); // Re-run when value changes.
+// Return previous value (happens before update in useEffect above).
+return ref.current;
+}
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-reduced-motion/index.js
+/**
+* Internal dependencies
+*/
+/**
+* Whether or not the user agent is Internet Explorer.
+*
+* @type {boolean}
+*/
+var IS_IE = typeof window !== 'undefined' && window.navigator.userAgent.indexOf('Trident') >= 0;
+/**
+* Hook returning whether the user has a preference for reduced motion.
+*
+* @return {boolean} Reduced motion preference value.
+*/
+var useReducedMotion = undefined || IS_IE ? function () {
+return true;
+} : function () {
+return useMediaQuery('(prefers-reduced-motion: reduce)');
+};
+/* harmony default export */ var use_reduced_motion = (useReducedMotion);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-viewport-match/index.js
+/**
+* WordPress dependencies
+*/
+/**
+* Internal dependencies
+*/
+/**
+* @typedef {"huge"|"wide"|"large"|"medium"|"small"|"mobile"} WPBreakpoint
+*/
+/**
+* Hash of breakpoint names with pixel width at which it becomes effective.
+*
+* @see _breakpoints.scss
+*
+* @type {Object<WPBreakpoint,number>}
+*/
+var BREAKPOINTS = {
+huge: 1440,
+wide: 1280,
+large: 960,
+medium: 782,
+small: 600,
+mobile: 480
+};
+/**
+* @typedef {">="|"<"} WPViewportOperator
+*/
+/**
+* Object mapping media query operators to the condition to be used.
+*
+* @type {Object<WPViewportOperator,string>}
+*/
+var CONDITIONS = {
+'>=': 'min-width',
+'<': 'max-width'
+};
+/**
+* Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values.
+*
+* @type {Object<WPViewportOperator,Function>}
+*/
+var OPERATOR_EVALUATORS = {
+'>=': function _(breakpointValue, width) {
+return width >= breakpointValue;
+},
+'<': function _(breakpointValue, width) {
+return width < breakpointValue;
+}
+};
+var ViewportMatchWidthContext = Object(external_this_wp_element_["createContext"])(null);
+/**
+* Returns true if the viewport matches the given query, or false otherwise.
+*
+* @param {WPBreakpoint}       breakpoint      Breakpoint size name.
+* @param {WPViewportOperator} [operator=">="] Viewport operator.
+*
+* @example
+*
+* ```js
+* useViewportMatch( 'huge', '<' );
+* useViewportMatch( 'medium' );
+* ```
+*
+* @return {boolean} Whether viewport matches query.
+*/
+var use_viewport_match_useViewportMatch = function useViewportMatch(breakpoint) {
+var operator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '>=';
+var simulatedWidth = Object(external_this_wp_element_["useContext"])(ViewportMatchWidthContext);
+var mediaQuery = !simulatedWidth && "(".concat(CONDITIONS[operator], ": ").concat(BREAKPOINTS[breakpoint], "px)");
+var mediaQueryResult = useMediaQuery(mediaQuery);
+if (simulatedWidth) {
+return OPERATOR_EVALUATORS[operator](BREAKPOINTS[breakpoint], simulatedWidth);
+}
+return mediaQueryResult;
+};
+use_viewport_match_useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider;
+/* harmony default export */ var use_viewport_match = (use_viewport_match_useViewportMatch);
+// EXTERNAL MODULE: ./node_modules/react-resize-aware/dist/index.js
+var dist = __webpack_require__(149);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/index.js
+/**
+* External dependencies
+*/
+/**
+* Hook which allows to listen the resize event of any target element when it changes sizes.
+* _Note: `useResizeObserver` will report `null` until after first render_
+*
+* @return {Array} An array of {Element} `resizeListener` and {?Object} `sizes` with properties `width` and `height`
+*
+* @example
+*
+* ```js
+* const App = () => {
+* 	const [ resizeListener, sizes ] = useResizeObserver();
+*
+* 	return (
+* 		<div>
+* 			{ resizeListener }
+* 			Your content here
+* 		</div>
+* 	);
+* };
+* ```
+*
+*/
+/* harmony default export */ var use_resize_observer = (dist_default.a);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
+var toConsumableArray = __webpack_require__(18);
+// EXTERNAL MODULE: external {"this":["wp","priorityQueue"]}
+var external_this_wp_priorityQueue_ = __webpack_require__(150);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-async-list/index.js
+/**
+* WordPress dependencies
+*/
+/**
+* Returns the first items from list that are present on state.
+*
+* @param {Array} list  New array.
+* @param {Array} state Current state.
+* @return {Array} First items present iin state.
+*/
+function getFirstItemsPresentInState(list, state) {
+var firstItems = [];
+for (var i = 0; i < list.length; i++) {
+var item = list[i];
+if (!state.includes(item)) {
+break;
+}
+firstItems.push(item);
+}
+return firstItems;
+}
+/**
+* Reducer keeping track of a list of appended items.
+*
+* @param {Array}  state  Current state
+* @param {Object} action Action
+*
+* @return {Array} update state.
+*/
+function listReducer(state, action) {
+if (action.type === 'reset') {
+return action.list;
+}
+if (action.type === 'append') {
+return [].concat(Object(toConsumableArray["a" /* default */])(state), [action.item]);
+}
+return state;
+}
+/**
+* React hook returns an array which items get asynchronously appended from a source array.
+* This behavior is useful if we want to render a list of items asynchronously for performance reasons.
+*
+* @param {Array} list Source array.
+* @return {Array} Async array.
+*/
+function useAsyncList(list) {
+var _useReducer = Object(external_this_wp_element_["useReducer"])(listReducer, []),
+_useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2),
+current = _useReducer2[0],
+dispatch = _useReducer2[1];
+Object(external_this_wp_element_["useEffect"])(function () {
+// On reset, we keep the first items that were previously rendered.
+var firstItems = getFirstItemsPresentInState(list, current);
+dispatch({
+type: 'reset',
+list: firstItems
+});
+var asyncQueue = Object(external_this_wp_priorityQueue_["createQueue"])();
+var append = function append(index) {
+return function () {
+if (list.length <= index) {
+return;
+}
+dispatch({
+type: 'append',
+item: list[index]
+});
+asyncQueue.add({}, append(index + 1));
+};
+};
+asyncQueue.add({}, append(firstItems.length));
+return function () {
+return asyncQueue.reset();
+};
+}, [list]);
+return current;
+}
+/* harmony default export */ var use_async_list = (useAsyncList);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-warn-on-change/index.js
+/**
+* Internal dependencies
+*/
+/**
+* Hook that performs a shallow comparison between the preview value of an object
+* and the new one, if there's a difference, it prints it to the console.
+* this is useful in performance related work, to check why a component re-renders.
+*
+*  @example
+*
+* ```jsx
+* function MyComponent(props) {
+*    useWarnOnChange(props);
+*
+*    return "Something";
+* }
+* ```
+*
+* @param {Object} object Object which changes to compare.
+* @param {string} prefix Just a prefix to show when console logging.
+*/
+function useWarnOnChange(object) {
+var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Change detection';
+var previousValues = usePrevious(object);
+Object.entries(previousValues !== null && previousValues !== void 0 ? previousValues : []).forEach(function (_ref) {
+var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2),
+key = _ref2[0],
+value = _ref2[1];
+if (value !== object[key]) {
+// eslint-disable-next-line no-console
+console.warn("".concat(prefix, ": ").concat(key, " key changed:"), value, object[key]);
+}
+});
+}
+/* harmony default export */ var use_warn_on_change = (useWarnOnChange);
+// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js
+// Utils
+// Compose helper (aliased flowRight from Lodash)
+// Higher-order components
+// Hooks
+/***/ }),
+/***/ 64:
+/***/ (function(module, exports) {
+(function() { module.exports = this["wp"]["isShallowEqual"]; }());
+/***/ }),
+/***/ 8:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
+function _extends() {
+_extends = Object.assign || function (target) {
+for (var i = 1; i < arguments.length; i++) {
+var source = arguments[i];
+for (var key in source) {
+if (Object.prototype.hasOwnProperty.call(source, key)) {
+target[key] = source[key];
+}
+}
+}
+return target;
+};
+return _extends.apply(this, arguments);
+}
+/***/ })
 /******/ });

enmi-conf.org