diff -r 3d4e9c994f10 -r a86126ab1dd4 wp/wp-includes/js/dist/compose.js --- a/wp/wp-includes/js/dist/compose.js Tue Oct 22 16:11:46 2019 +0200 +++ b/wp/wp-includes/js/dist/compose.js Tue Dec 15 13:49:49 2020 +0100 @@ -82,7 +82,7 @@ /******/ /******/ /******/ // Load entry module and return exports -/******/ return __webpack_require__(__webpack_require__.s = 368); +/******/ return __webpack_require__(__webpack_require__.s = 445); /******/ }) /************************************************************************/ /******/ ({ @@ -94,39 +94,99 @@ /***/ }), -/***/ 10: +/***/ 12: /***/ (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"); +/* 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; } /***/ }), -/***/ 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); -/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3); - - -function _possibleConstructorReturn(self, call) { - if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) { - return call; + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; }); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js +var arrayWithHoles = __webpack_require__(38); + +// 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"; @@ -140,10 +200,93 @@ /***/ }), -/***/ 13: +/***/ 18: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; }); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js +var arrayLikeToArray = __webpack_require__(26); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr); +} +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js +var iterableToArray = __webpack_require__(35); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js +var unsupportedIterableToArray = __webpack_require__(29); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + + + + +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 _createClass; }); +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); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + 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) { @@ -155,7 +298,6 @@ return _setPrototypeOf(o, p); } // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; }); function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { @@ -174,68 +316,2148 @@ /***/ }), -/***/ 19: +/***/ 23: /***/ (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); +/* 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; } /***/ }), -/***/ 2: +/***/ 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() { module.exports = this["lodash"]; }()); +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; + /***/ }), - -/***/ 3: +/* 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"; -/* 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; +__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); } /***/ }), -/***/ 32: +/***/ 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 _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") { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { - return _typeof2(obj); + return typeof obj; }; } else { _typeof = function _typeof(obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj); + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } @@ -244,16 +2466,91 @@ /***/ }), -/***/ 368: +/***/ 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__); -// EXTERNAL MODULE: external "lodash" -var external_lodash_ = __webpack_require__(2); - -// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/create-higher-order-component/index.js +// 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 */ @@ -275,17 +2572,33 @@ 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, ")"); + 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/if-condition/index.js +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js /** @@ -316,31 +2629,35 @@ /* harmony default export */ var if_condition = (if_condition_ifCondition); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js -var classCallCheck = __webpack_require__(10); +var classCallCheck = __webpack_require__(20); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js -var createClass = __webpack_require__(9); +var createClass = __webpack_require__(19); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js -var possibleConstructorReturn = __webpack_require__(11); +var possibleConstructorReturn = __webpack_require__(23); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js -var getPrototypeOf = __webpack_require__(12); +var getPrototypeOf = __webpack_require__(16); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules -var inherits = __webpack_require__(13); +var inherits = __webpack_require__(22); // EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} -var external_this_wp_isShallowEqual_ = __webpack_require__(42); +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/pure/index.js - - - - - - +// 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 @@ -366,65 +2683,63 @@ 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)); + 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 */])(_class2, [{ + Object(createClass["a" /* default */])(_class, [{ 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); + value: function shouldComponentUpdate(nextProps, nextState) { + return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state); } }]); - return _class2; - }(external_this_wp_element_["Component"]) - ); + 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 build_module_pure = (pure); +/* harmony default export */ var higher_order_pure = (pure); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js -var esm_extends = __webpack_require__(19); +var esm_extends = __webpack_require__(8); // 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 +var assertThisInitialized = __webpack_require__(12); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js @@ -438,9 +2753,7 @@ * removing the handler when no instances are listening for the event. */ -var listener_Listener = -/*#__PURE__*/ -function () { +var listener_Listener = /*#__PURE__*/function () { function Listener() { Object(classCallCheck["a" /* default */])(this, Listener); @@ -462,7 +2775,7 @@ }, { key: "remove", value: function remove(eventType, instance) { - this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[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. @@ -473,7 +2786,7 @@ }, { key: "handleEvent", value: function handleEvent(event) { - Object(external_lodash_["forEach"])(this.listeners[event.type], function (instance) { + Object(external_this_lodash_["forEach"])(this.listeners[event.type], function (instance) { instance.handleEvent(event); }); } @@ -484,15 +2797,19 @@ /* harmony default export */ var listener = (listener_Listener); -// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/index.js - - - - - - - - +// 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 @@ -516,22 +2833,39 @@ */ 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} 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) { + 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 = 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))); + _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; } @@ -540,7 +2874,7 @@ value: function componentDidMount() { var _this2 = this; - Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { + Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { with_global_events_listener.add(eventType, _this2); }); } @@ -549,7 +2883,7 @@ value: function componentWillUnmount() { var _this3 = this; - Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { + Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { with_global_events_listener.remove(eventType, _this3); }); } @@ -596,19 +2930,42 @@ /* harmony default export */ var with_global_events = (withGlobalEvents); -// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-instance-id/index.js - - - - - - - - +// 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 */ @@ -618,51 +2975,33 @@ * A Higher Order Component used to be provide a unique instance ID by * component. * - * @param {WPElement} WrappedComponent The wrapped component. + * @param {WPComponent} WrappedComponent The wrapped component. * - * @return {Component} Component with an instanceId prop. + * @return {WPComponent} 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"]) - ); + 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/with-safe-timeout/index.js - - - - - - - - +// 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 @@ -682,98 +3021,101 @@ * 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 + * @param {WPComponent} OriginalComponent Component requiring setTimeout * - * @return {Component} Wrapped component. + * @return {WPComponent} 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; + 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); } - - 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); } - }, { - 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 - })); + + 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); } - }]); - - return WrappedComponent; - }(external_this_wp_element_["Component"]) - ); + + 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/with-state/index.js - - - - - - - - +// 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 @@ -790,103 +3132,721 @@ * * @param {?Object} initialState Optional initial state of the component. * - * @return {Component} Wrapped 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); - - 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; + 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 + })); } - - 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"]) - ); + }]); + + 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 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 + */ /** - * 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. + * 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} + */ + +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} + */ + +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. * - * @param {...Function} hocs The HOC functions to invoke. + * @type {Object} + */ + +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 ( + *
+ * { resizeListener } + * Your content here + *
+ * ); + * }; + * ``` + * + */ + +/* 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 {Function} Returns the new composite function. + * @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 + + + + + + + + + + + + /***/ }), -/***/ 42: +/***/ 64: /***/ (function(module, exports) { (function() { module.exports = this["wp"]["isShallowEqual"]; }()); /***/ }), -/***/ 9: +/***/ 8: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; }); -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); - } -} - -function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; +/* 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); } /***/ })