diff options
Diffstat (limited to '')
| -rw-r--r-- | wp-includes/js/dist/compose.js | 5819 |
1 files changed, 5819 insertions, 0 deletions
diff --git a/wp-includes/js/dist/compose.js b/wp-includes/js/dist/compose.js new file mode 100644 index 0000000..a107935 --- /dev/null +++ b/wp-includes/js/dist/compose.js @@ -0,0 +1,5819 @@ +/******/ (function() { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 5360: +/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ createUndoManager: function() { return /* binding */ createUndoManager; } +/* harmony export */ }); +/* harmony import */ var _wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9127); +/* harmony import */ var _wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0__); +/** + * WordPress dependencies + */ + + +/** @typedef {import('./types').HistoryRecord} HistoryRecord */ +/** @typedef {import('./types').HistoryChange} HistoryChange */ +/** @typedef {import('./types').HistoryChanges} HistoryChanges */ +/** @typedef {import('./types').UndoManager} UndoManager */ + +/** + * Merge changes for a single item into a record of changes. + * + * @param {Record< string, HistoryChange >} changes1 Previous changes + * @param {Record< string, HistoryChange >} changes2 NextChanges + * + * @return {Record< string, HistoryChange >} Merged changes + */ +function mergeHistoryChanges(changes1, changes2) { + /** + * @type {Record< string, HistoryChange >} + */ + const newChanges = { + ...changes1 + }; + Object.entries(changes2).forEach(([key, value]) => { + if (newChanges[key]) { + newChanges[key] = { + ...newChanges[key], + to: value.to + }; + } else { + newChanges[key] = value; + } + }); + return newChanges; +} + +/** + * Adds history changes for a single item into a record of changes. + * + * @param {HistoryRecord} record The record to merge into. + * @param {HistoryChanges} changes The changes to merge. + */ +const addHistoryChangesIntoRecord = (record, changes) => { + const existingChangesIndex = record?.findIndex(({ + id: recordIdentifier + }) => { + return typeof recordIdentifier === 'string' ? recordIdentifier === changes.id : _wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0___default()(recordIdentifier, changes.id); + }); + const nextRecord = [...record]; + if (existingChangesIndex !== -1) { + // If the edit is already in the stack leave the initial "from" value. + nextRecord[existingChangesIndex] = { + id: changes.id, + changes: mergeHistoryChanges(nextRecord[existingChangesIndex].changes, changes.changes) + }; + } else { + nextRecord.push(changes); + } + return nextRecord; +}; + +/** + * Creates an undo manager. + * + * @return {UndoManager} Undo manager. + */ +function createUndoManager() { + /** + * @type {HistoryRecord[]} + */ + let history = []; + /** + * @type {HistoryRecord} + */ + let stagedRecord = []; + /** + * @type {number} + */ + let offset = 0; + const dropPendingRedos = () => { + history = history.slice(0, offset || undefined); + offset = 0; + }; + const appendStagedRecordToLatestHistoryRecord = () => { + var _history$index; + const index = history.length === 0 ? 0 : history.length - 1; + let latestRecord = (_history$index = history[index]) !== null && _history$index !== void 0 ? _history$index : []; + stagedRecord.forEach(changes => { + latestRecord = addHistoryChangesIntoRecord(latestRecord, changes); + }); + stagedRecord = []; + history[index] = latestRecord; + }; + + /** + * Checks whether a record is empty. + * A record is considered empty if it the changes keep the same values. + * Also updates to function values are ignored. + * + * @param {HistoryRecord} record + * @return {boolean} Whether the record is empty. + */ + const isRecordEmpty = record => { + const filteredRecord = record.filter(({ + changes + }) => { + return Object.values(changes).some(({ + from, + to + }) => typeof from !== 'function' && typeof to !== 'function' && !_wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0___default()(from, to)); + }); + return !filteredRecord.length; + }; + return { + /** + * Record changes into the history. + * + * @param {HistoryRecord=} record A record of changes to record. + * @param {boolean} isStaged Whether to immediately create an undo point or not. + */ + addRecord(record, isStaged = false) { + const isEmpty = !record || isRecordEmpty(record); + if (isStaged) { + if (isEmpty) { + return; + } + record.forEach(changes => { + stagedRecord = addHistoryChangesIntoRecord(stagedRecord, changes); + }); + } else { + dropPendingRedos(); + if (stagedRecord.length) { + appendStagedRecordToLatestHistoryRecord(); + } + if (isEmpty) { + return; + } + history.push(record); + } + }, + undo() { + if (stagedRecord.length) { + dropPendingRedos(); + appendStagedRecordToLatestHistoryRecord(); + } + const undoRecord = history[history.length - 1 + offset]; + if (!undoRecord) { + return; + } + offset -= 1; + return undoRecord; + }, + redo() { + const redoRecord = history[history.length + offset]; + if (!redoRecord) { + return; + } + offset += 1; + return redoRecord; + }, + hasUndo() { + return !!history[history.length - 1 + offset]; + }, + hasRedo() { + return !!history[history.length + offset]; + } + }; +} + + +/***/ }), + +/***/ 8294: +/***/ (function(module) { + +/*! + * clipboard.js v2.0.11 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */ +(function webpackUniversalModuleDefinition(root, factory) { + if(true) + module.exports = factory(); + else {} +})(this, function() { +return /******/ (function() { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 686: +/***/ (function(__unused_webpack_module, __nested_webpack_exports__, __nested_webpack_require_623__) { + +"use strict"; + +// EXPORTS +__nested_webpack_require_623__.d(__nested_webpack_exports__, { + "default": function() { return /* binding */ clipboard; } +}); + +// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js +var tiny_emitter = __nested_webpack_require_623__(279); +var tiny_emitter_default = /*#__PURE__*/__nested_webpack_require_623__.n(tiny_emitter); +// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js +var listen = __nested_webpack_require_623__(370); +var listen_default = /*#__PURE__*/__nested_webpack_require_623__.n(listen); +// EXTERNAL MODULE: ./node_modules/select/src/select.js +var src_select = __nested_webpack_require_623__(817); +var select_default = /*#__PURE__*/__nested_webpack_require_623__.n(src_select); +;// CONCATENATED MODULE: ./src/common/command.js +/** + * Executes a given operation type. + * @param {String} type + * @return {Boolean} + */ +function command(type) { + try { + return document.execCommand(type); + } catch (err) { + return false; + } +} +;// CONCATENATED MODULE: ./src/actions/cut.js + + +/** + * Cut action wrapper. + * @param {String|HTMLElement} target + * @return {String} + */ + +var ClipboardActionCut = function ClipboardActionCut(target) { + var selectedText = select_default()(target); + command('cut'); + return selectedText; +}; + +/* harmony default export */ var actions_cut = (ClipboardActionCut); +;// CONCATENATED MODULE: ./src/common/create-fake-element.js +/** + * Creates a fake textarea element with a value. + * @param {String} value + * @return {HTMLElement} + */ +function createFakeElement(value) { + var isRTL = document.documentElement.getAttribute('dir') === 'rtl'; + var fakeElement = document.createElement('textarea'); // Prevent zooming on iOS + + fakeElement.style.fontSize = '12pt'; // Reset box model + + fakeElement.style.border = '0'; + fakeElement.style.padding = '0'; + fakeElement.style.margin = '0'; // Move element out of screen horizontally + + fakeElement.style.position = 'absolute'; + fakeElement.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically + + var yPosition = window.pageYOffset || document.documentElement.scrollTop; + fakeElement.style.top = "".concat(yPosition, "px"); + fakeElement.setAttribute('readonly', ''); + fakeElement.value = value; + return fakeElement; +} +;// CONCATENATED MODULE: ./src/actions/copy.js + + + +/** + * Create fake copy action wrapper using a fake element. + * @param {String} target + * @param {Object} options + * @return {String} + */ + +var fakeCopyAction = function fakeCopyAction(value, options) { + var fakeElement = createFakeElement(value); + options.container.appendChild(fakeElement); + var selectedText = select_default()(fakeElement); + command('copy'); + fakeElement.remove(); + return selectedText; +}; +/** + * Copy action wrapper. + * @param {String|HTMLElement} target + * @param {Object} options + * @return {String} + */ + + +var ClipboardActionCopy = function ClipboardActionCopy(target) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { + container: document.body + }; + var selectedText = ''; + + if (typeof target === 'string') { + selectedText = fakeCopyAction(target, options); + } else if (target instanceof HTMLInputElement && !['text', 'search', 'url', 'tel', 'password'].includes(target === null || target === void 0 ? void 0 : target.type)) { + // If input type doesn't support `setSelectionRange`. Simulate it. https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setSelectionRange + selectedText = fakeCopyAction(target.value, options); + } else { + selectedText = select_default()(target); + command('copy'); + } + + return selectedText; +}; + +/* harmony default export */ var actions_copy = (ClipboardActionCopy); +;// CONCATENATED MODULE: ./src/actions/default.js +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + + + +/** + * Inner function which performs selection from either `text` or `target` + * properties and then executes copy or cut operations. + * @param {Object} options + */ + +var ClipboardActionDefault = function ClipboardActionDefault() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + // Defines base properties passed from constructor. + var _options$action = options.action, + action = _options$action === void 0 ? 'copy' : _options$action, + container = options.container, + target = options.target, + text = options.text; // Sets the `action` to be performed which can be either 'copy' or 'cut'. + + if (action !== 'copy' && action !== 'cut') { + throw new Error('Invalid "action" value, use either "copy" or "cut"'); + } // Sets the `target` property using an element that will be have its content copied. + + + if (target !== undefined) { + if (target && _typeof(target) === 'object' && target.nodeType === 1) { + if (action === 'copy' && target.hasAttribute('disabled')) { + throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute'); + } + + if (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'); + } + } else { + throw new Error('Invalid "target" value, use a valid Element'); + } + } // Define selection strategy based on `text` property. + + + if (text) { + return actions_copy(text, { + container: container + }); + } // Defines which selection strategy based on `target` property. + + + if (target) { + return action === 'cut' ? actions_cut(target) : actions_copy(target, { + container: container + }); + } +}; + +/* harmony default export */ var actions_default = (ClipboardActionDefault); +;// CONCATENATED MODULE: ./src/clipboard.js +function clipboard_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { clipboard_typeof = function _typeof(obj) { return typeof obj; }; } else { clipboard_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return clipboard_typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +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; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + + + + + + +/** + * Helper function to retrieve attribute value. + * @param {String} suffix + * @param {Element} element + */ + +function getAttributeValue(suffix, element) { + var attribute = "data-clipboard-".concat(suffix); + + if (!element.hasAttribute(attribute)) { + return; + } + + return element.getAttribute(attribute); +} +/** + * Base class which takes one or more elements, adds event listeners to them, + * and instantiates a new `ClipboardAction` on each click. + */ + + +var Clipboard = /*#__PURE__*/function (_Emitter) { + _inherits(Clipboard, _Emitter); + + var _super = _createSuper(Clipboard); + + /** + * @param {String|HTMLElement|HTMLCollection|NodeList} trigger + * @param {Object} options + */ + function Clipboard(trigger, options) { + var _this; + + _classCallCheck(this, Clipboard); + + _this = _super.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 + */ + + + _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; + var action = this.action(trigger) || 'copy'; + var text = actions_default({ + action: action, + container: this.container, + target: this.target(trigger), + text: this.text(trigger) + }); // Fires an event based on the copy operation result. + + this.emit(text ? 'success' : 'error', { + action: action, + text: text, + trigger: trigger, + clearSelection: function clearSelection() { + if (trigger) { + trigger.focus(); + } + + window.getSelection().removeAllRanges(); + } + }); + } + /** + * 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); + } + } + /** + * Allow fire programmatically a copy action + * @param {String|HTMLElement} target + * @param {Object} options + * @returns Text copied. + */ + + }, { + 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(); + } + }], [{ + key: "copy", + value: function copy(target) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { + container: document.body + }; + return actions_copy(target, options); + } + /** + * Allow fire programmatically a cut action + * @param {String|HTMLElement} target + * @returns Text cutted. + */ + + }, { + key: "cut", + value: function cut(target) { + return actions_cut(target); + } + /** + * Returns the support of the given action, or all actions if no action is + * given. + * @param {String} [action] + */ + + }, { + 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())); + +/* harmony default export */ var clipboard = (Clipboard); + +/***/ }), + +/***/ 828: +/***/ (function(module) { + +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; + + +/***/ }), + +/***/ 438: +/***/ (function(module, __unused_webpack_exports, __nested_webpack_require_15749__) { + +var closest = __nested_webpack_require_15749__(828); + +/** + * 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; + + +/***/ }), + +/***/ 879: +/***/ (function(__unused_webpack_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]'; +}; + + +/***/ }), + +/***/ 370: +/***/ (function(module, __unused_webpack_exports, __nested_webpack_require_19113__) { + +var is = __nested_webpack_require_19113__(879); +var delegate = __nested_webpack_require_19113__(438); + +/** + * 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; + + +/***/ }), + +/***/ 817: +/***/ (function(module) { + +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; + + +/***/ }), + +/***/ 279: +/***/ (function(module) { + +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; + + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __nested_webpack_require_24495__(moduleId) { +/******/ // Check if module is in cache +/******/ if(__webpack_module_cache__[moduleId]) { +/******/ return __webpack_module_cache__[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId](module, module.exports, __nested_webpack_require_24495__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/compat get default export */ +/******/ !function() { +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __nested_webpack_require_24495__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function() { return module['default']; } : +/******/ function() { return module; }; +/******/ __nested_webpack_require_24495__.d(getter, { a: getter }); +/******/ return getter; +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/define property getters */ +/******/ !function() { +/******/ // define getter functions for harmony exports +/******/ __nested_webpack_require_24495__.d = function(exports, definition) { +/******/ for(var key in definition) { +/******/ if(__nested_webpack_require_24495__.o(definition, key) && !__nested_webpack_require_24495__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ !function() { +/******/ __nested_webpack_require_24495__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } +/******/ }(); +/******/ +/************************************************************************/ +/******/ // module exports must be returned from runtime so entry inlining is disabled +/******/ // startup +/******/ // Load entry module and return exports +/******/ return __nested_webpack_require_24495__(686); +/******/ })() +.default; +}); + +/***/ }), + +/***/ 7973: +/***/ (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); + + +/***/ }), + +/***/ 5538: +/***/ (function() { + +/** + * 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); + + +/***/ }), + +/***/ 9127: +/***/ (function(module) { + +"use strict"; +module.exports = window["wp"]["isShallowEqual"]; + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/compat get default export */ +/******/ !function() { +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function() { return module['default']; } : +/******/ function() { return module; }; +/******/ __webpack_require__.d(getter, { a: getter }); +/******/ return getter; +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/define property getters */ +/******/ !function() { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = function(exports, definition) { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ !function() { +/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } +/******/ }(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ !function() { +/******/ // 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 }); +/******/ }; +/******/ }(); +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be in strict mode. +!function() { +"use strict"; +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + __experimentalUseDialog: function() { return /* reexport */ use_dialog; }, + __experimentalUseDragging: function() { return /* reexport */ useDragging; }, + __experimentalUseDropZone: function() { return /* reexport */ useDropZone; }, + __experimentalUseFixedWindowList: function() { return /* reexport */ useFixedWindowList; }, + __experimentalUseFocusOutside: function() { return /* reexport */ useFocusOutside; }, + compose: function() { return /* reexport */ higher_order_compose; }, + createHigherOrderComponent: function() { return /* reexport */ createHigherOrderComponent; }, + debounce: function() { return /* reexport */ debounce; }, + ifCondition: function() { return /* reexport */ if_condition; }, + pipe: function() { return /* reexport */ higher_order_pipe; }, + pure: function() { return /* reexport */ higher_order_pure; }, + throttle: function() { return /* reexport */ throttle; }, + useAsyncList: function() { return /* reexport */ use_async_list; }, + useConstrainedTabbing: function() { return /* reexport */ use_constrained_tabbing; }, + useCopyOnClick: function() { return /* reexport */ useCopyOnClick; }, + useCopyToClipboard: function() { return /* reexport */ useCopyToClipboard; }, + useDebounce: function() { return /* reexport */ useDebounce; }, + useDisabled: function() { return /* reexport */ useDisabled; }, + useFocusOnMount: function() { return /* reexport */ useFocusOnMount; }, + useFocusReturn: function() { return /* reexport */ use_focus_return; }, + useFocusableIframe: function() { return /* reexport */ useFocusableIframe; }, + useInstanceId: function() { return /* reexport */ use_instance_id; }, + useIsomorphicLayoutEffect: function() { return /* reexport */ use_isomorphic_layout_effect; }, + useKeyboardShortcut: function() { return /* reexport */ use_keyboard_shortcut; }, + useMediaQuery: function() { return /* reexport */ useMediaQuery; }, + useMergeRefs: function() { return /* reexport */ useMergeRefs; }, + usePrevious: function() { return /* reexport */ usePrevious; }, + useReducedMotion: function() { return /* reexport */ use_reduced_motion; }, + useRefEffect: function() { return /* reexport */ useRefEffect; }, + useResizeObserver: function() { return /* reexport */ useResizeAware; }, + useStateWithHistory: function() { return /* reexport */ useStateWithHistory; }, + useThrottle: function() { return /* reexport */ useThrottle; }, + useViewportMatch: function() { return /* reexport */ use_viewport_match; }, + useWarnOnChange: function() { return /* reexport */ use_warn_on_change; }, + withGlobalEvents: function() { return /* reexport */ withGlobalEvents; }, + withInstanceId: function() { return /* reexport */ with_instance_id; }, + withSafeTimeout: function() { return /* reexport */ with_safe_timeout; }, + withState: function() { return /* reexport */ withState; } +}); + +;// CONCATENATED MODULE: ./node_modules/tslib/tslib.es6.mjs +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise, SuppressedError, Symbol */ + +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); +}; + +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} + +var __assign = function() { + __assign = Object.assign || function __assign(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; + } + return __assign.apply(this, arguments); +} + +function __rest(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +} + +function __decorate(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +} + +function __param(paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +} + +function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } + else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; +}; + +function __runInitializers(thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; +}; + +function __propKey(x) { + return typeof x === "symbol" ? x : "".concat(x); +}; + +function __setFunctionName(f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); +}; + +function __metadata(metadataKey, metadataValue) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); +} + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (g && (g = 0, op[0] && (_ = 0)), _) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +} + +var __createBinding = Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +}); + +function __exportStar(m, o) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); +} + +function __values(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +} + +function __read(o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +} + +/** @deprecated */ +function __spread() { + for (var ar = [], i = 0; i < arguments.length; i++) + ar = ar.concat(__read(arguments[i])); + return ar; +} + +/** @deprecated */ +function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +} + +function __spreadArray(to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +} + +function __await(v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); +} + +function __asyncGenerator(thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +} + +function __asyncDelegator(o) { + var i, p; + return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; } +} + +function __asyncValues(o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +} + +function __makeTemplateObject(cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; +}; + +var __setModuleDefault = Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}; + +function __importStar(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +} + +function __importDefault(mod) { + return (mod && mod.__esModule) ? mod : { default: mod }; +} + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +} + +function __classPrivateFieldIn(state, receiver) { + if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); + return typeof state === "function" ? receiver === state : state.has(receiver); +} + +function __addDisposableResource(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; +} + +var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +function __disposeResources(env) { + function fail(e) { + env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + function next() { + while (env.stack.length) { + var rec = env.stack.pop(); + try { + var result = rec.dispose && rec.dispose.call(rec.value); + if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + catch (e) { + fail(e); + } + } + if (env.hasError) throw env.error; + } + return next(); +} + +/* harmony default export */ var tslib_es6 = ({ + __extends, + __assign, + __rest, + __decorate, + __param, + __metadata, + __awaiter, + __generator, + __createBinding, + __exportStar, + __values, + __read, + __spread, + __spreadArrays, + __spreadArray, + __await, + __asyncGenerator, + __asyncDelegator, + __asyncValues, + __makeTemplateObject, + __importStar, + __importDefault, + __classPrivateFieldGet, + __classPrivateFieldSet, + __classPrivateFieldIn, + __addDisposableResource, + __disposeResources, +}); + +;// CONCATENATED MODULE: ./node_modules/lower-case/dist.es2015/index.js +/** + * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt + */ +var SUPPORTED_LOCALE = { + tr: { + regexp: /\u0130|\u0049|\u0049\u0307/g, + map: { + İ: "\u0069", + I: "\u0131", + İ: "\u0069", + }, + }, + az: { + regexp: /\u0130/g, + map: { + İ: "\u0069", + I: "\u0131", + İ: "\u0069", + }, + }, + lt: { + regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g, + map: { + I: "\u0069\u0307", + J: "\u006A\u0307", + Į: "\u012F\u0307", + Ì: "\u0069\u0307\u0300", + Í: "\u0069\u0307\u0301", + Ĩ: "\u0069\u0307\u0303", + }, + }, +}; +/** + * Localized lower case. + */ +function localeLowerCase(str, locale) { + var lang = SUPPORTED_LOCALE[locale.toLowerCase()]; + if (lang) + return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; })); + return lowerCase(str); +} +/** + * Lower case as a function. + */ +function lowerCase(str) { + return str.toLowerCase(); +} + +;// CONCATENATED MODULE: ./node_modules/no-case/dist.es2015/index.js + +// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case"). +var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g]; +// Remove all non-word characters. +var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi; +/** + * Normalize the string into something other libraries can manipulate easier. + */ +function noCase(input, options) { + if (options === void 0) { options = {}; } + var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d; + var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0"); + var start = 0; + var end = result.length; + // Trim the delimiter from around the output string. + while (result.charAt(start) === "\0") + start++; + while (result.charAt(end - 1) === "\0") + end--; + // Transform each token independently. + return result.slice(start, end).split("\0").map(transform).join(delimiter); +} +/** + * Replace `re` in the input string with the replacement value. + */ +function replace(input, re, value) { + if (re instanceof RegExp) + return input.replace(re, value); + return re.reduce(function (input, re) { return input.replace(re, value); }, input); +} + +;// CONCATENATED MODULE: ./node_modules/pascal-case/dist.es2015/index.js + + +function pascalCaseTransform(input, index) { + var firstChar = input.charAt(0); + var lowerChars = input.substr(1).toLowerCase(); + if (index > 0 && firstChar >= "0" && firstChar <= "9") { + return "_" + firstChar + lowerChars; + } + return "" + firstChar.toUpperCase() + lowerChars; +} +function pascalCaseTransformMerge(input) { + return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase(); +} +function pascalCase(input, options) { + if (options === void 0) { options = {}; } + return noCase(input, __assign({ delimiter: "", transform: pascalCaseTransform }, options)); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js +/** + * External dependencies + */ + +/** + * Given a function mapping a component to an enhanced component and modifier + * name, returns the enhanced component augmented with a generated displayName. + * + * @param mapComponent Function mapping component to enhanced component. + * @param modifierName Seed name from which to generated display name. + * + * @return Component class with generated display name assigned. + */ +function createHigherOrderComponent(mapComponent, modifierName) { + return Inner => { + const Outer = mapComponent(Inner); + Outer.displayName = hocName(modifierName, Inner); + return Outer; + }; +} + +/** + * Returns a displayName for a higher-order component, given a wrapper name. + * + * @example + * hocName( 'MyMemo', Widget ) === 'MyMemo(Widget)'; + * hocName( 'MyMemo', <div /> ) === 'MyMemo(Component)'; + * + * @param name Name assigned to higher-order component's wrapper component. + * @param Inner Wrapped component inside higher-order component. + * @return Wrapped name of higher-order component. + */ +const hocName = (name, Inner) => { + const inner = Inner.displayName || Inner.name || 'Component'; + const outer = pascalCase(name !== null && name !== void 0 ? name : ''); + return `${outer}(${inner})`; +}; + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/debounce/index.js +/** + * Parts of this source were derived and modified from lodash, + * released under the MIT license. + * + * https://github.com/lodash/lodash + * + * Copyright JS Foundation and other contributors <https://js.foundation/> + * + * Based on Underscore.js, copyright Jeremy Ashkenas, + * DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/> + * + * This software consists of voluntary contributions made by many + * individuals. For exact contribution history, see the revision history + * available at https://github.com/lodash/lodash + * + * The following license applies to all parts of this software except as + * documented below: + * + * ==== + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * A simplified and properly typed version of lodash's `debounce`, that + * always uses timers instead of sometimes using rAF. + * + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel delayed + * `func` invocations and a `flush` method to immediately invoke them. Provide + * `options` to indicate whether `func` should be invoked on the leading and/or + * trailing edge of the `wait` timeout. The `func` is invoked with the last + * arguments provided to the debounced function. Subsequent calls to the debounced + * function return the result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until the next tick, similar to `setTimeout` with a timeout of `0`. + * + * @param {Function} func The function to debounce. + * @param {number} wait The number of milliseconds to delay. + * @param {Partial< DebounceOptions >} options The options object. + * @param {boolean} options.leading Specify invoking on the leading edge of the timeout. + * @param {number} options.maxWait The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} options.trailing Specify invoking on the trailing edge of the timeout. + * + * @return Returns the new debounced function. + */ +const debounce = (func, wait, options) => { + let lastArgs; + let lastThis; + let maxWait = 0; + let result; + let timerId; + let lastCallTime; + let lastInvokeTime = 0; + let leading = false; + let maxing = false; + let trailing = true; + if (options) { + leading = !!options.leading; + maxing = 'maxWait' in options; + if (options.maxWait !== undefined) { + maxWait = Math.max(options.maxWait, wait); + } + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + function invokeFunc(time) { + const args = lastArgs; + const thisArg = lastThis; + lastArgs = undefined; + lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + function startTimer(pendingFunc, waitTime) { + timerId = setTimeout(pendingFunc, waitTime); + } + function cancelTimer() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + } + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + startTimer(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + function getTimeSinceLastCall(time) { + return time - (lastCallTime || 0); + } + function remainingWait(time) { + const timeSinceLastCall = getTimeSinceLastCall(time); + const timeSinceLastInvoke = time - lastInvokeTime; + const timeWaiting = wait - timeSinceLastCall; + return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting; + } + function shouldInvoke(time) { + const timeSinceLastCall = getTimeSinceLastCall(time); + const timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait; + } + function timerExpired() { + const time = Date.now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + startTimer(timerExpired, remainingWait(time)); + return undefined; + } + function clearTimer() { + timerId = undefined; + } + function trailingEdge(time) { + clearTimer(); + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + function cancel() { + cancelTimer(); + lastInvokeTime = 0; + clearTimer(); + lastArgs = lastCallTime = lastThis = undefined; + } + function flush() { + return pending() ? trailingEdge(Date.now()) : result; + } + function pending() { + return timerId !== undefined; + } + function debounced(...args) { + const time = Date.now(); + const isInvoking = shouldInvoke(time); + lastArgs = args; + lastThis = this; + lastCallTime = time; + if (isInvoking) { + if (!pending()) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + startTimer(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (!pending()) { + startTimer(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + debounced.pending = pending; + return debounced; +}; + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/throttle/index.js +/** + * Parts of this source were derived and modified from lodash, + * released under the MIT license. + * + * https://github.com/lodash/lodash + * + * Copyright JS Foundation and other contributors <https://js.foundation/> + * + * Based on Underscore.js, copyright Jeremy Ashkenas, + * DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/> + * + * This software consists of voluntary contributions made by many + * individuals. For exact contribution history, see the revision history + * available at https://github.com/lodash/lodash + * + * The following license applies to all parts of this software except as + * documented below: + * + * ==== + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * Internal dependencies + */ + +/** + * A simplified and properly typed version of lodash's `throttle`, that + * always uses timers instead of sometimes using rAF. + * + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return + * the result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until the next tick, similar to `setTimeout` with a timeout of `0`. + * + * @param {Function} func The function to throttle. + * @param {number} wait The number of milliseconds to throttle invocations to. + * @param {Partial< ThrottleOptions >} options The options object. + * @param {boolean} options.leading Specify invoking on the leading edge of the timeout. + * @param {boolean} options.trailing Specify invoking on the trailing edge of the timeout. + * @return Returns the new throttled function. + */ +const throttle = (func, wait, options) => { + let leading = true; + let trailing = true; + if (options) { + leading = 'leading' in options ? !!options.leading : leading; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + return debounce(func, wait, { + leading, + trailing, + maxWait: wait + }); +}; + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pipe.js +/** + * Parts of this source were derived and modified from lodash, + * released under the MIT license. + * + * https://github.com/lodash/lodash + * + * Copyright JS Foundation and other contributors <https://js.foundation/> + * + * Based on Underscore.js, copyright Jeremy Ashkenas, + * DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/> + * + * This software consists of voluntary contributions made by many + * individuals. For exact contribution history, see the revision history + * available at https://github.com/lodash/lodash + * + * The following license applies to all parts of this software except as + * documented below: + * + * ==== + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * Creates a pipe function. + * + * Allows to choose whether to perform left-to-right or right-to-left composition. + * + * @see https://docs-lodash.com/v4/flow/ + * + * @param {boolean} reverse True if right-to-left, false for left-to-right composition. + */ +const basePipe = (reverse = false) => (...funcs) => (...args) => { + const functions = funcs.flat(); + if (reverse) { + functions.reverse(); + } + return functions.reduce((prev, func) => [func(...prev)], args)[0]; +}; + +/** + * Composes multiple higher-order components into a single higher-order component. Performs left-to-right function + * composition, where each successive invocation is supplied the return value of the previous. + * + * This is inspired by `lodash`'s `flow` function. + * + * @see https://docs-lodash.com/v4/flow/ + */ +const pipe = basePipe(); + +/* harmony default export */ var higher_order_pipe = (pipe); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js +/** + * Internal 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. + * + * This is inspired by `lodash`'s `flowRight` function. + * + * @see https://docs-lodash.com/v4/flow-right/ + */ +const compose = basePipe(true); +/* harmony default export */ var higher_order_compose = (compose); + +;// CONCATENATED MODULE: external ["wp","element"] +var external_wp_element_namespaceObject = window["wp"]["element"]; +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js + +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * Higher-order component creator, creating a new component which renders if + * the given condition is satisfied or with the given optional prop name. + * + * @example + * ```ts + * type Props = { foo: string }; + * const Component = ( props: Props ) => <div>{ props.foo }</div>; + * const ConditionalComponent = ifCondition( ( props: Props ) => props.foo.length !== 0 )( Component ); + * <ConditionalComponent foo="" />; // => null + * <ConditionalComponent foo="bar" />; // => <div>bar</div>; + * ``` + * + * @param predicate Function to test condition. + * + * @return Higher-order component. + */ +function ifCondition(predicate) { + return createHigherOrderComponent(WrappedComponent => props => { + if (!predicate(props)) { + return null; + } + return (0,external_wp_element_namespaceObject.createElement)(WrappedComponent, { + ...props + }); + }, 'ifCondition'); +} +/* harmony default export */ var if_condition = (ifCondition); + +// EXTERNAL MODULE: external ["wp","isShallowEqual"] +var external_wp_isShallowEqual_ = __webpack_require__(9127); +var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_); +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +/** + * Given a component returns the enhanced component augmented with a component + * only re-rendering when its props/state change + */ +const pure = createHigherOrderComponent(function (WrappedComponent) { + if (WrappedComponent.prototype instanceof external_wp_element_namespaceObject.Component) { + return class extends WrappedComponent { + shouldComponentUpdate(nextProps, nextState) { + return !external_wp_isShallowEqual_default()(nextProps, this.props) || !external_wp_isShallowEqual_default()(nextState, this.state); + } + }; + } + return class extends external_wp_element_namespaceObject.Component { + shouldComponentUpdate(nextProps) { + return !external_wp_isShallowEqual_default()(nextProps, this.props); + } + render() { + return (0,external_wp_element_namespaceObject.createElement)(WrappedComponent, { + ...this.props + }); + } + }; +}, 'pure'); +/* harmony default export */ var higher_order_pure = (pure); + +;// CONCATENATED MODULE: external ["wp","deprecated"] +var external_wp_deprecated_namespaceObject = window["wp"]["deprecated"]; +var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject); +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js +/** + * Class responsible for orchestrating event handling on the global window, + * binding a single event to be shared across all handling instances, and + * removing the handler when no instances are listening for the event. + */ +class Listener { + constructor() { + /** @type {any} */ + this.listeners = {}; + this.handleEvent = this.handleEvent.bind(this); + } + add( /** @type {any} */eventType, /** @type {any} */instance) { + if (!this.listeners[eventType]) { + // Adding first listener for this type, so bind event. + window.addEventListener(eventType, this.handleEvent); + this.listeners[eventType] = []; + } + this.listeners[eventType].push(instance); + } + remove( /** @type {any} */eventType, /** @type {any} */instance) { + if (!this.listeners[eventType]) { + return; + } + this.listeners[eventType] = this.listeners[eventType].filter(( /** @type {any} */listener) => listener !== instance); + if (!this.listeners[eventType].length) { + // Removing last listener for this type, so unbind event. + window.removeEventListener(eventType, this.handleEvent); + delete this.listeners[eventType]; + } + } + handleEvent( /** @type {any} */event) { + this.listeners[event.type]?.forEach(( /** @type {any} */instance) => { + instance.handleEvent(event); + }); + } +} +/* harmony default export */ var listener = (Listener); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + +/** + * Listener instance responsible for managing document event handling. + */ +const with_global_events_listener = new listener(); + +/* eslint-disable jsdoc/no-undefined-types */ +/** + * 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. + * + * @deprecated + * + * @param {Record<keyof GlobalEventHandlersEventMap, string>} eventTypesToHandlers Object with keys of DOM + * event type, the value a + * name of the function on + * the original component's + * instance which handles + * the event. + * + * @return {any} Higher-order component. + */ +function withGlobalEvents(eventTypesToHandlers) { + external_wp_deprecated_default()('wp.compose.withGlobalEvents', { + since: '5.7', + alternative: 'useEffect' + }); + + // @ts-ignore We don't need to fix the type-related issues because this is deprecated. + return createHigherOrderComponent(WrappedComponent => { + class Wrapper extends external_wp_element_namespaceObject.Component { + constructor( /** @type {any} */props) { + super(props); + this.handleEvent = this.handleEvent.bind(this); + this.handleRef = this.handleRef.bind(this); + } + componentDidMount() { + Object.keys(eventTypesToHandlers).forEach(eventType => { + with_global_events_listener.add(eventType, this); + }); + } + componentWillUnmount() { + Object.keys(eventTypesToHandlers).forEach(eventType => { + with_global_events_listener.remove(eventType, this); + }); + } + handleEvent( /** @type {any} */event) { + const handler = eventTypesToHandlers[/** @type {keyof GlobalEventHandlersEventMap} */ + event.type + + /* eslint-enable jsdoc/no-undefined-types */]; + + if (typeof this.wrappedRef[handler] === 'function') { + this.wrappedRef[handler](event); + } + } + handleRef( /** @type {any} */el) { + this.wrappedRef = el; + // Any component using `withGlobalEvents` that is not setting a `ref` + // will cause `this.props.forwardedRef` to be `null`, so we need this + // check. + if (this.props.forwardedRef) { + this.props.forwardedRef(el); + } + } + render() { + return (0,external_wp_element_namespaceObject.createElement)(WrappedComponent, { + ...this.props.ownProps, + ref: this.handleRef + }); + } + } + return (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { + return (0,external_wp_element_namespaceObject.createElement)(Wrapper, { + ownProps: props, + forwardedRef: ref + }); + }); + }, 'withGlobalEvents'); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js +/** + * WordPress dependencies + */ + +const instanceMap = new WeakMap(); + +/** + * Creates a new id for a given object. + * + * @param object Object reference to create an id for. + * @return The instance id (index). + */ +function createId(object) { + const instances = instanceMap.get(object) || 0; + instanceMap.set(object, instances + 1); + return instances; +} + +/** + * Specify the useInstanceId *function* signatures. + * + * More accurately, useInstanceId distinguishes between three different + * signatures: + * + * 1. When only object is given, the returned value is a number + * 2. When object and prefix is given, the returned value is a string + * 3. When preferredId is given, the returned value is the type of preferredId + * + * @param object Object reference to create an id for. + */ + +/** + * Provides a unique instance ID. + * + * @param object Object reference to create an id for. + * @param [prefix] Prefix for the unique id. + * @param [preferredId] Default ID to use. + * @return The unique instance id. + */ +function useInstanceId(object, prefix, preferredId) { + return (0,external_wp_element_namespaceObject.useMemo)(() => { + if (preferredId) return preferredId; + const id = createId(object); + return prefix ? `${prefix}-${id}` : id; + }, [object, preferredId, prefix]); +} +/* harmony default export */ var use_instance_id = (useInstanceId); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js + +/** + * Internal dependencies + */ + + + +/** + * A Higher Order Component used to be provide a unique instance ID by + * component. + */ +const withInstanceId = createHigherOrderComponent(WrappedComponent => { + return props => { + const instanceId = use_instance_id(WrappedComponent); + // @ts-ignore + return (0,external_wp_element_namespaceObject.createElement)(WrappedComponent, { + ...props, + instanceId: instanceId + }); + }; +}, 'instanceId'); +/* harmony default export */ var with_instance_id = (withInstanceId); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + +/** + * We cannot use the `Window['setTimeout']` and `Window['clearTimeout']` + * types here because those functions include functionality that is not handled + * by this component, like the ability to pass extra arguments. + * + * In the case of this component, we only handle the simplest case where + * `setTimeout` only accepts a function (not a string) and an optional delay. + */ + +/** + * A higher-order component used to provide and manage delayed function calls + * that ought to be bound to a component's lifecycle. + */ +const withSafeTimeout = createHigherOrderComponent(OriginalComponent => { + return class WrappedComponent extends external_wp_element_namespaceObject.Component { + constructor(props) { + super(props); + this.timeouts = []; + this.setTimeout = this.setTimeout.bind(this); + this.clearTimeout = this.clearTimeout.bind(this); + } + componentWillUnmount() { + this.timeouts.forEach(clearTimeout); + } + setTimeout(fn, delay) { + const id = setTimeout(() => { + fn(); + this.clearTimeout(id); + }, delay); + this.timeouts.push(id); + return id; + } + clearTimeout(id) { + clearTimeout(id); + this.timeouts = this.timeouts.filter(timeoutId => timeoutId !== id); + } + render() { + return ( + // @ts-ignore + (0,external_wp_element_namespaceObject.createElement)(OriginalComponent, { + ...this.props, + setTimeout: this.setTimeout, + clearTimeout: this.clearTimeout + }) + ); + } + }; +}, 'withSafeTimeout'); +/* harmony default export */ var with_safe_timeout = (withSafeTimeout); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +/** + * A Higher Order Component used to provide and manage internal component state + * via props. + * + * @deprecated Use `useState` instead. + * + * @param {any} initialState Optional initial state of the component. + * + * @return {any} A higher order component wrapper accepting a component that takes the state props + its own props + `setState` and returning a component that only accepts the own props. + */ +function withState(initialState = {}) { + external_wp_deprecated_default()('wp.compose.withState', { + since: '5.8', + alternative: 'wp.element.useState' + }); + return createHigherOrderComponent(OriginalComponent => { + return class WrappedComponent extends external_wp_element_namespaceObject.Component { + constructor( /** @type {any} */props) { + super(props); + this.setState = this.setState.bind(this); + this.state = initialState; + } + render() { + return (0,external_wp_element_namespaceObject.createElement)(OriginalComponent, { + ...this.props, + ...this.state, + setState: this.setState + }); + } + }; + }, 'withState'); +} + +;// CONCATENATED MODULE: external ["wp","keycodes"] +var external_wp_keycodes_namespaceObject = window["wp"]["keycodes"]; +;// CONCATENATED MODULE: external ["wp","dom"] +var external_wp_dom_namespaceObject = window["wp"]["dom"]; +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-ref-effect/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Effect-like ref callback. Just like with `useEffect`, this allows you to + * return a cleanup function to be run if the ref changes or one of the + * dependencies changes. The ref is provided as an argument to the callback + * functions. The main difference between this and `useEffect` is that + * the `useEffect` callback is not called when the ref changes, but this is. + * Pass the returned ref callback as the component's ref and merge multiple refs + * with `useMergeRefs`. + * + * It's worth noting that if the dependencies array is empty, there's not + * strictly a need to clean up event handlers for example, because the node is + * to be removed. It *is* necessary if you add dependencies because the ref + * callback will be called multiple times for the same node. + * + * @param callback Callback with ref as argument. + * @param dependencies Dependencies of the callback. + * + * @return Ref callback. + */ +function useRefEffect(callback, dependencies) { + const cleanup = (0,external_wp_element_namespaceObject.useRef)(); + return (0,external_wp_element_namespaceObject.useCallback)(node => { + if (node) { + cleanup.current = callback(node); + } else if (cleanup.current) { + cleanup.current(); + } + }, dependencies); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-constrained-tabbing/index.js +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +/** + * In Dialogs/modals, the tabbing must be constrained to the content of + * the wrapper element. This hook adds the behavior to the returned ref. + * + * @return {import('react').RefCallback<Element>} Element Ref. + * + * @example + * ```js + * import { useConstrainedTabbing } from '@wordpress/compose'; + * + * const ConstrainedTabbingExample = () => { + * const constrainedTabbingRef = useConstrainedTabbing() + * return ( + * <div ref={ constrainedTabbingRef }> + * <Button /> + * <Button /> + * </div> + * ); + * } + * ``` + */ +function useConstrainedTabbing() { + return useRefEffect(( /** @type {HTMLElement} */node) => { + function onKeyDown( /** @type {KeyboardEvent} */event) { + const { + keyCode, + shiftKey, + target + } = event; + if (keyCode !== external_wp_keycodes_namespaceObject.TAB) { + return; + } + const action = shiftKey ? 'findPrevious' : 'findNext'; + const nextElement = external_wp_dom_namespaceObject.focus.tabbable[action]( /** @type {HTMLElement} */target) || null; + + // When the target element contains the element that is about to + // receive focus, for example when the target is a tabbable + // container, browsers may disagree on where to move focus next. + // In this case we can't rely on native browsers behavior. We need + // to manage focus instead. + // See https://github.com/WordPress/gutenberg/issues/46041. + if ( /** @type {HTMLElement} */target.contains(nextElement)) { + event.preventDefault(); + /** @type {HTMLElement} */ + nextElement?.focus(); + return; + } + + // If the element that is about to receive focus is inside the + // area, rely on native browsers behavior and let tabbing follow + // the native tab sequence. + if (node.contains(nextElement)) { + return; + } + + // If the element that is about to receive focus is outside the + // area, move focus to a div and insert it at the start or end of + // the area, depending on the direction. Without preventing default + // behaviour, the browser will then move focus to the next element. + const domAction = shiftKey ? 'append' : 'prepend'; + const { + ownerDocument + } = node; + const trap = ownerDocument.createElement('div'); + trap.tabIndex = -1; + node[domAction](trap); + + // Remove itself when the trap loses focus. + trap.addEventListener('blur', () => node.removeChild(trap)); + trap.focus(); + } + node.addEventListener('keydown', onKeyDown); + return () => { + node.removeEventListener('keydown', onKeyDown); + }; + }, []); +} +/* harmony default export */ var use_constrained_tabbing = (useConstrainedTabbing); + +// EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js +var dist_clipboard = __webpack_require__(8294); +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 + */ + + + +/* eslint-disable jsdoc/no-undefined-types */ +/** + * Copies the text to the clipboard when the element is clicked. + * + * @deprecated + * + * @param {import('react').RefObject<string | Element | NodeListOf<Element>>} 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, timeout = 4000) { + /* eslint-enable jsdoc/no-undefined-types */ + external_wp_deprecated_default()('wp.compose.useCopyOnClick', { + since: '5.8', + alternative: 'wp.compose.useCopyToClipboard' + }); + + /** @type {import('react').MutableRefObject<Clipboard | undefined>} */ + const clipboard = (0,external_wp_element_namespaceObject.useRef)(); + const [hasCopied, setHasCopied] = (0,external_wp_element_namespaceObject.useState)(false); + (0,external_wp_element_namespaceObject.useEffect)(() => { + /** @type {number | undefined} */ + let timeoutId; + if (!ref.current) { + return; + } + + // Clipboard listens to click events. + clipboard.current = new (clipboard_default())(ref.current, { + text: () => typeof text === 'function' ? text() : text + }); + clipboard.current.on('success', ({ + clearSelection, + 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) { + /** @type {HTMLElement} */trigger.focus(); + } + if (timeout) { + setHasCopied(true); + clearTimeout(timeoutId); + timeoutId = setTimeout(() => setHasCopied(false), timeout); + } + }); + return () => { + if (clipboard.current) { + clipboard.current.destroy(); + } + clearTimeout(timeoutId); + }; + }, [text, timeout, setHasCopied]); + return hasCopied; +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-to-clipboard/index.js +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * @template T + * @param {T} value + * @return {import('react').RefObject<T>} The updated ref + */ +function useUpdatedRef(value) { + const ref = (0,external_wp_element_namespaceObject.useRef)(value); + ref.current = value; + return ref; +} + +/** + * Copies the given text to the clipboard when the element is clicked. + * + * @template {HTMLElement} TElementType + * @param {string | (() => string)} text The text to copy. Use a function if not + * already available and expensive to compute. + * @param {Function} onSuccess Called when to text is copied. + * + * @return {import('react').Ref<TElementType>} A ref to assign to the target element. + */ +function useCopyToClipboard(text, onSuccess) { + // Store the dependencies as refs and continuously update them so they're + // fresh when the callback is called. + const textRef = useUpdatedRef(text); + const onSuccessRef = useUpdatedRef(onSuccess); + return useRefEffect(node => { + // Clipboard listens to click events. + const clipboard = new (clipboard_default())(node, { + text() { + return typeof textRef.current === 'function' ? textRef.current() : textRef.current || ''; + } + }); + clipboard.on('success', ({ + clearSelection + }) => { + // 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 + node.focus(); + if (onSuccessRef.current) { + onSuccessRef.current(); + } + }); + return () => { + clipboard.destroy(); + }; + }, []); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-on-mount/index.js +/** + * WordPress dependencies + */ + + + +/** + * Hook used to focus the first tabbable element on mount. + * + * @param {boolean | 'firstElement'} focusOnMount Focus on mount mode. + * @return {import('react').RefCallback<HTMLElement>} Ref callback. + * + * @example + * ```js + * import { useFocusOnMount } from '@wordpress/compose'; + * + * const WithFocusOnMount = () => { + * const ref = useFocusOnMount() + * return ( + * <div ref={ ref }> + * <Button /> + * <Button /> + * </div> + * ); + * } + * ``` + */ +function useFocusOnMount(focusOnMount = 'firstElement') { + const focusOnMountRef = (0,external_wp_element_namespaceObject.useRef)(focusOnMount); + + /** + * Sets focus on a DOM element. + * + * @param {HTMLElement} target The DOM element to set focus to. + * @return {void} + */ + const setFocus = target => { + target.focus({ + // When focusing newly mounted dialogs, + // the position of the popover is often not right on the first render + // This prevents the layout shifts when focusing the dialogs. + preventScroll: true + }); + }; + + /** @type {import('react').MutableRefObject<ReturnType<setTimeout> | undefined>} */ + const timerId = (0,external_wp_element_namespaceObject.useRef)(); + (0,external_wp_element_namespaceObject.useEffect)(() => { + focusOnMountRef.current = focusOnMount; + }, [focusOnMount]); + (0,external_wp_element_namespaceObject.useEffect)(() => { + return () => { + if (timerId.current) { + clearTimeout(timerId.current); + } + }; + }, []); + return (0,external_wp_element_namespaceObject.useCallback)(node => { + var _node$ownerDocument$a; + if (!node || focusOnMountRef.current === false) { + return; + } + if (node.contains((_node$ownerDocument$a = node.ownerDocument?.activeElement) !== null && _node$ownerDocument$a !== void 0 ? _node$ownerDocument$a : null)) { + return; + } + if (focusOnMountRef.current === 'firstElement') { + timerId.current = setTimeout(() => { + const firstTabbable = external_wp_dom_namespaceObject.focus.tabbable.find(node)[0]; + if (firstTabbable) { + setFocus( /** @type {HTMLElement} */firstTabbable); + } + }, 0); + return; + } + setFocus(node); + }, []); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-return/index.js +/** + * WordPress dependencies + */ + + +/** @type {Element|null} */ +let origin = null; + +/** + * Adds the unmount behavior of returning focus to the element which had it + * previously as is expected for roles like menus or dialogs. + * + * @param {() => void} [onFocusReturn] Overrides the default return behavior. + * @return {import('react').RefCallback<HTMLElement>} Element Ref. + * + * @example + * ```js + * import { useFocusReturn } from '@wordpress/compose'; + * + * const WithFocusReturn = () => { + * const ref = useFocusReturn() + * return ( + * <div ref={ ref }> + * <Button /> + * <Button /> + * </div> + * ); + * } + * ``` + */ +function useFocusReturn(onFocusReturn) { + /** @type {import('react').MutableRefObject<null | HTMLElement>} */ + const ref = (0,external_wp_element_namespaceObject.useRef)(null); + /** @type {import('react').MutableRefObject<null | Element>} */ + const focusedBeforeMount = (0,external_wp_element_namespaceObject.useRef)(null); + const onFocusReturnRef = (0,external_wp_element_namespaceObject.useRef)(onFocusReturn); + (0,external_wp_element_namespaceObject.useEffect)(() => { + onFocusReturnRef.current = onFocusReturn; + }, [onFocusReturn]); + return (0,external_wp_element_namespaceObject.useCallback)(node => { + if (node) { + // Set ref to be used when unmounting. + ref.current = node; + + // Only set when the node mounts. + if (focusedBeforeMount.current) { + return; + } + focusedBeforeMount.current = node.ownerDocument.activeElement; + } else if (focusedBeforeMount.current) { + const isFocused = ref.current?.contains(ref.current?.ownerDocument.activeElement); + if (ref.current?.isConnected && !isFocused) { + var _origin; + (_origin = origin) !== null && _origin !== void 0 ? _origin : origin = focusedBeforeMount.current; + return; + } + + // Defer to the component's own explicit focus return behavior, if + // specified. This allows for support that the `onFocusReturn` + // decides to allow the default behavior to occur under some + // conditions. + if (onFocusReturnRef.current) { + onFocusReturnRef.current(); + } else { + /** @type {null|HTMLElement} */(!focusedBeforeMount.current.isConnected ? origin : focusedBeforeMount.current)?.focus(); + } + origin = null; + } + }, []); +} +/* harmony default export */ var use_focus_return = (useFocusReturn); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-outside/index.js +/** + * WordPress dependencies + */ + + +/** + * Input types which are classified as button types, for use in considering + * whether element is a (focus-normalized) button. + */ +const INPUT_BUTTON_TYPES = ['button', 'submit']; + +/** + * List of HTML button elements subject to focus normalization + * + * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus + */ + +/** + * Returns true if the given element is a button element subject to focus + * normalization, or false otherwise. + * + * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus + * + * @param eventTarget The target from a mouse or touch event. + * + * @return Whether the element is a button element subject to focus normalization. + */ +function isFocusNormalizedButton(eventTarget) { + if (!(eventTarget instanceof window.HTMLElement)) { + return false; + } + switch (eventTarget.nodeName) { + case 'A': + case 'BUTTON': + return true; + case 'INPUT': + return INPUT_BUTTON_TYPES.includes(eventTarget.type); + } + return false; +} +/** + * A react hook that can be used to check whether focus has moved outside the + * element the event handlers are bound to. + * + * @param onFocusOutside A callback triggered when focus moves outside + * the element the event handlers are bound to. + * + * @return An object containing event handlers. Bind the event handlers to a + * wrapping element element to capture when focus moves outside that element. + */ +function useFocusOutside(onFocusOutside) { + const currentOnFocusOutside = (0,external_wp_element_namespaceObject.useRef)(onFocusOutside); + (0,external_wp_element_namespaceObject.useEffect)(() => { + currentOnFocusOutside.current = onFocusOutside; + }, [onFocusOutside]); + const preventBlurCheck = (0,external_wp_element_namespaceObject.useRef)(false); + const blurCheckTimeoutId = (0,external_wp_element_namespaceObject.useRef)(); + + /** + * Cancel a blur check timeout. + */ + const cancelBlurCheck = (0,external_wp_element_namespaceObject.useCallback)(() => { + clearTimeout(blurCheckTimeoutId.current); + }, []); + + // Cancel blur checks on unmount. + (0,external_wp_element_namespaceObject.useEffect)(() => { + return () => cancelBlurCheck(); + }, []); + + // Cancel a blur check if the callback or ref is no longer provided. + (0,external_wp_element_namespaceObject.useEffect)(() => { + if (!onFocusOutside) { + cancelBlurCheck(); + } + }, [onFocusOutside, cancelBlurCheck]); + + /** + * Handles a mousedown or mouseup event to respectively assign and + * unassign a flag for preventing blur check on button elements. Some + * browsers, namely Firefox and Safari, do not emit a focus event on + * button elements when clicked, while others do. The logic here + * intends to normalize this as treating click on buttons as focus. + * + * @param event + * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus + */ + const normalizeButtonFocus = (0,external_wp_element_namespaceObject.useCallback)(event => { + const { + type, + target + } = event; + const isInteractionEnd = ['mouseup', 'touchend'].includes(type); + if (isInteractionEnd) { + preventBlurCheck.current = false; + } else if (isFocusNormalizedButton(target)) { + preventBlurCheck.current = true; + } + }, []); + + /** + * A callback triggered when a blur event occurs on the element the handler + * is bound to. + * + * Calls the `onFocusOutside` callback in an immediate timeout if focus has + * move outside the bound element and is still within the document. + */ + const queueBlurCheck = (0,external_wp_element_namespaceObject.useCallback)(event => { + // React does not allow using an event reference asynchronously + // due to recycling behavior, except when explicitly persisted. + event.persist(); + + // Skip blur check if clicking button. See `normalizeButtonFocus`. + if (preventBlurCheck.current) { + return; + } + + // The usage of this attribute should be avoided. The only use case + // would be when we load modals that are not React components and + // therefore don't exist in the React tree. An example is opening + // the Media Library modal from another dialog. + // This attribute should contain a selector of the related target + // we want to ignore, because we still need to trigger the blur event + // on all other cases. + const ignoreForRelatedTarget = event.target.getAttribute('data-unstable-ignore-focus-outside-for-relatedtarget'); + if (ignoreForRelatedTarget && event.relatedTarget?.closest(ignoreForRelatedTarget)) { + return; + } + blurCheckTimeoutId.current = setTimeout(() => { + // If document is not focused then focus should remain + // inside the wrapped component and therefore we cancel + // this blur event thereby leaving focus in place. + // https://developer.mozilla.org/en-US/docs/Web/API/Document/hasFocus. + if (!document.hasFocus()) { + event.preventDefault(); + return; + } + if ('function' === typeof currentOnFocusOutside.current) { + currentOnFocusOutside.current(event); + } + }, 0); + }, []); + return { + onFocus: cancelBlurCheck, + onMouseDown: normalizeButtonFocus, + onMouseUp: normalizeButtonFocus, + onTouchStart: normalizeButtonFocus, + onTouchEnd: normalizeButtonFocus, + onBlur: queueBlurCheck + }; +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-merge-refs/index.js +/** + * WordPress dependencies + */ + + +/* eslint-disable jsdoc/valid-types */ +/** + * @template T + * @typedef {T extends import('react').Ref<infer R> ? R : never} TypeFromRef + */ +/* eslint-enable jsdoc/valid-types */ + +/** + * @template T + * @param {import('react').Ref<T>} ref + * @param {T} value + */ +function assignRef(ref, value) { + if (typeof ref === 'function') { + ref(value); + } else if (ref && ref.hasOwnProperty('current')) { + /* eslint-disable jsdoc/no-undefined-types */ + /** @type {import('react').MutableRefObject<T>} */ref.current = value; + /* eslint-enable jsdoc/no-undefined-types */ + } +} + +/** + * Merges refs into one ref callback. + * + * It also ensures that the merged ref callbacks are only called when they + * change (as a result of a `useCallback` dependency update) OR when the ref + * value changes, just as React does when passing a single ref callback to the + * component. + * + * As expected, if you pass a new function on every render, the ref callback + * will be called after every render. + * + * If you don't wish a ref callback to be called after every render, wrap it + * with `useCallback( callback, dependencies )`. When a dependency changes, the + * old ref callback will be called with `null` and the new ref callback will be + * called with the same value. + * + * To make ref callbacks easier to use, you can also pass the result of + * `useRefEffect`, which makes cleanup easier by allowing you to return a + * cleanup function instead of handling `null`. + * + * It's also possible to _disable_ a ref (and its behaviour) by simply not + * passing the ref. + * + * ```jsx + * const ref = useRefEffect( ( node ) => { + * node.addEventListener( ... ); + * return () => { + * node.removeEventListener( ... ); + * }; + * }, [ ...dependencies ] ); + * const otherRef = useRef(); + * const mergedRefs useMergeRefs( [ + * enabled && ref, + * otherRef, + * ] ); + * return <div ref={ mergedRefs } />; + * ``` + * + * @template {import('react').Ref<any>} TRef + * @param {Array<TRef>} refs The refs to be merged. + * + * @return {import('react').RefCallback<TypeFromRef<TRef>>} The merged ref callback. + */ +function useMergeRefs(refs) { + const element = (0,external_wp_element_namespaceObject.useRef)(); + const isAttached = (0,external_wp_element_namespaceObject.useRef)(false); + const didElementChange = (0,external_wp_element_namespaceObject.useRef)(false); + /* eslint-disable jsdoc/no-undefined-types */ + /** @type {import('react').MutableRefObject<TRef[]>} */ + /* eslint-enable jsdoc/no-undefined-types */ + const previousRefs = (0,external_wp_element_namespaceObject.useRef)([]); + const currentRefs = (0,external_wp_element_namespaceObject.useRef)(refs); + + // Update on render before the ref callback is called, so the ref callback + // always has access to the current refs. + currentRefs.current = refs; + + // If any of the refs change, call the previous ref with `null` and the new + // ref with the node, except when the element changes in the same cycle, in + // which case the ref callbacks will already have been called. + (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { + if (didElementChange.current === false && isAttached.current === true) { + refs.forEach((ref, index) => { + const previousRef = previousRefs.current[index]; + if (ref !== previousRef) { + assignRef(previousRef, null); + assignRef(ref, element.current); + } + }); + } + previousRefs.current = refs; + }, refs); + + // No dependencies, must be reset after every render so ref callbacks are + // correctly called after a ref change. + (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { + didElementChange.current = false; + }); + + // There should be no dependencies so that `callback` is only called when + // the node changes. + return (0,external_wp_element_namespaceObject.useCallback)(value => { + // Update the element so it can be used when calling ref callbacks on a + // dependency change. + assignRef(element, value); + didElementChange.current = true; + isAttached.current = value !== null; + + // When an element changes, the current ref callback should be called + // with the new element and the previous one with `null`. + const refsToAssign = value ? currentRefs.current : previousRefs.current; + + // Update the latest refs. + for (const ref of refsToAssign) { + assignRef(ref, value); + } + }, []); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dialog/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + + +/** + * Returns a ref and props to apply to a dialog wrapper to enable the following behaviors: + * - constrained tabbing. + * - focus on mount. + * - return focus on unmount. + * - focus outside. + * + * @param options Dialog Options. + */ +function useDialog(options) { + const currentOptions = (0,external_wp_element_namespaceObject.useRef)(); + (0,external_wp_element_namespaceObject.useEffect)(() => { + currentOptions.current = options; + }, Object.values(options)); + const constrainedTabbingRef = use_constrained_tabbing(); + const focusOnMountRef = useFocusOnMount(options.focusOnMount); + const focusReturnRef = use_focus_return(); + const focusOutsideProps = useFocusOutside(event => { + // This unstable prop is here only to manage backward compatibility + // for the Popover component otherwise, the onClose should be enough. + if (currentOptions.current?.__unstableOnClose) { + currentOptions.current.__unstableOnClose('focus-outside', event); + } else if (currentOptions.current?.onClose) { + currentOptions.current.onClose(); + } + }); + const closeOnEscapeRef = (0,external_wp_element_namespaceObject.useCallback)(node => { + if (!node) { + return; + } + node.addEventListener('keydown', event => { + // Close on escape. + if (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE && !event.defaultPrevented && currentOptions.current?.onClose) { + event.preventDefault(); + currentOptions.current.onClose(); + } + }); + }, []); + return [useMergeRefs([options.focusOnMount !== false ? constrainedTabbingRef : null, options.focusOnMount !== false ? focusReturnRef : null, options.focusOnMount !== false ? focusOnMountRef : null, closeOnEscapeRef]), { + ...focusOutsideProps, + tabIndex: -1 + }]; +} +/* harmony default export */ var use_dialog = (useDialog); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-disabled/index.js +/** + * Internal dependencies + */ + + + +/** + * In some circumstances, such as block previews, all focusable DOM elements + * (input fields, links, buttons, etc.) need to be disabled. This hook adds the + * behavior to disable nested DOM elements to the returned ref. + * + * If you can, prefer the use of the inert HTML attribute. + * + * @param {Object} config Configuration object. + * @param {boolean=} config.isDisabled Whether the element should be disabled. + * @return {import('react').RefCallback<HTMLElement>} Element Ref. + * + * @example + * ```js + * import { useDisabled } from '@wordpress/compose'; + * + * const DisabledExample = () => { + * const disabledRef = useDisabled(); + * return ( + * <div ref={ disabledRef }> + * <a href="#">This link will have tabindex set to -1</a> + * <input placeholder="This input will have the disabled attribute added to it." type="text" /> + * </div> + * ); + * }; + * ``` + */ +function useDisabled({ + isDisabled: isDisabledProp = false +} = {}) { + return useRefEffect(node => { + if (isDisabledProp) { + return; + } + const defaultView = node?.ownerDocument?.defaultView; + if (!defaultView) { + return; + } + + /** A variable keeping track of the previous updates in order to restore them. */ + const updates = []; + const disable = () => { + node.childNodes.forEach(child => { + if (!(child instanceof defaultView.HTMLElement)) { + return; + } + if (!child.getAttribute('inert')) { + child.setAttribute('inert', 'true'); + updates.push(() => { + child.removeAttribute('inert'); + }); + } + }); + }; + + // Debounce re-disable since disabling process itself will incur + // additional mutations which should be ignored. + const debouncedDisable = debounce(disable, 0, { + leading: true + }); + disable(); + + /** @type {MutationObserver | undefined} */ + const observer = new window.MutationObserver(debouncedDisable); + observer.observe(node, { + childList: true + }); + return () => { + if (observer) { + observer.disconnect(); + } + debouncedDisable.cancel(); + updates.forEach(update => update()); + }; + }, [isDisabledProp]); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-isomorphic-layout-effect/index.js +/** + * WordPress dependencies + */ + + +/** + * Preferred over direct usage of `useLayoutEffect` when supporting + * server rendered components (SSR) because currently React + * throws a warning when using useLayoutEffect in that environment. + */ +const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external_wp_element_namespaceObject.useLayoutEffect : external_wp_element_namespaceObject.useEffect; +/* harmony default export */ var use_isomorphic_layout_effect = (useIsomorphicLayoutEffect); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +// Event handlers that are triggered from `document` listeners accept a MouseEvent, +// while those triggered from React listeners accept a React.MouseEvent. +/** + * @param {Object} props + * @param {(e: import('react').MouseEvent) => void} props.onDragStart + * @param {(e: MouseEvent) => void} props.onDragMove + * @param {(e?: MouseEvent) => void} props.onDragEnd + */ +function useDragging({ + onDragStart, + onDragMove, + onDragEnd +}) { + const [isDragging, setIsDragging] = (0,external_wp_element_namespaceObject.useState)(false); + const eventsRef = (0,external_wp_element_namespaceObject.useRef)({ + onDragStart, + onDragMove, + onDragEnd + }); + use_isomorphic_layout_effect(() => { + eventsRef.current.onDragStart = onDragStart; + eventsRef.current.onDragMove = onDragMove; + eventsRef.current.onDragEnd = onDragEnd; + }, [onDragStart, onDragMove, onDragEnd]); + + /** @type {(e: MouseEvent) => void} */ + const onMouseMove = (0,external_wp_element_namespaceObject.useCallback)(event => eventsRef.current.onDragMove && eventsRef.current.onDragMove(event), []); + /** @type {(e?: MouseEvent) => void} */ + const endDrag = (0,external_wp_element_namespaceObject.useCallback)(event => { + if (eventsRef.current.onDragEnd) { + eventsRef.current.onDragEnd(event); + } + document.removeEventListener('mousemove', onMouseMove); + document.removeEventListener('mouseup', endDrag); + setIsDragging(false); + }, []); + /** @type {(e: import('react').MouseEvent) => void} */ + const startDrag = (0,external_wp_element_namespaceObject.useCallback)(event => { + if (eventsRef.current.onDragStart) { + eventsRef.current.onDragStart(event); + } + document.addEventListener('mousemove', onMouseMove); + document.addEventListener('mouseup', endDrag); + setIsDragging(true); + }, []); + + // Remove the global events when unmounting if needed. + (0,external_wp_element_namespaceObject.useEffect)(() => { + return () => { + if (isDragging) { + document.removeEventListener('mousemove', onMouseMove); + document.removeEventListener('mouseup', endDrag); + } + }; + }, [isDragging]); + return { + startDrag, + endDrag, + isDragging + }; +} + +// EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js +var mousetrap_mousetrap = __webpack_require__(7973); +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__(5538); +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js +/** + * External dependencies + */ + + + +/** + * WordPress dependencies + */ + + + +/** + * A block selection object. + * + * @typedef {Object} WPKeyboardShortcutConfig + * + * @property {boolean} [bindGlobal] Handle keyboard events anywhere including inside textarea/input fields. + * @property {string} [eventName] Event name used to trigger the handler, defaults to keydown. + * @property {boolean} [isDisabled] Disables the keyboard handler if the value is true. + * @property {import('react').RefObject<HTMLElement>} [target] React reference to the DOM element used to catch the keyboard event. + */ + +/* eslint-disable jsdoc/valid-types */ +/** + * Attach a keyboard shortcut handler. + * + * @see https://craig.is/killing/mice#api.bind for information about the `callback` parameter. + * + * @param {string[]|string} shortcuts Keyboard Shortcuts. + * @param {(e: import('mousetrap').ExtendedKeyboardEvent, combo: string) => void} callback Shortcut callback. + * @param {WPKeyboardShortcutConfig} options Shortcut options. + */ +function useKeyboardShortcut( /* eslint-enable jsdoc/valid-types */ +shortcuts, callback, { + bindGlobal = false, + eventName = 'keydown', + isDisabled = false, + // This is important for performance considerations. + target +} = {}) { + const currentCallback = (0,external_wp_element_namespaceObject.useRef)(callback); + (0,external_wp_element_namespaceObject.useEffect)(() => { + currentCallback.current = callback; + }, [callback]); + (0,external_wp_element_namespaceObject.useEffect)(() => { + if (isDisabled) { + return; + } + const mousetrap = new (mousetrap_default())(target && target.current ? target.current : + // We were passing `document` here previously, so to successfully cast it to Element we must cast it first to `unknown`. + // Not sure if this is a mistake but it was the behavior previous to the addition of types so we're just doing what's + // necessary to maintain the existing behavior. + /** @type {Element} */ /** @type {unknown} */ + document); + const shortcutsArray = Array.isArray(shortcuts) ? shortcuts : [shortcuts]; + shortcutsArray.forEach(shortcut => { + const 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. + const modifiers = new Set(keys.filter(value => value.length > 1)); + const hasAlt = modifiers.has('alt'); + const hasShift = modifiers.has('shift'); + + // This should be better moved to the shortcut registration instead. + if ((0,external_wp_keycodes_namespaceObject.isAppleOS)() && (modifiers.size === 1 && hasAlt || modifiers.size === 2 && hasAlt && hasShift)) { + throw new Error(`Cannot bind ${shortcut}. Alt and Shift+Alt modifiers are reserved for character input.`); + } + const bindFn = bindGlobal ? 'bindGlobal' : 'bind'; + // @ts-ignore `bindGlobal` is an undocumented property + mousetrap[bindFn](shortcut, ( /* eslint-disable jsdoc/valid-types */ + /** @type {[e: import('mousetrap').ExtendedKeyboardEvent, combo: string]} */...args) => /* eslint-enable jsdoc/valid-types */ + currentCallback.current(...args), eventName); + }); + return () => { + 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 + */ + + +/** + * A new MediaQueryList object for the media query + * + * @param {string} [query] Media Query. + * @return {MediaQueryList|null} A new object for the media query + */ +function getMediaQueryList(query) { + if (query && typeof window !== 'undefined' && typeof window.matchMedia === 'function') { + return window.matchMedia(query); + } + return null; +} + +/** + * 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) { + const source = (0,external_wp_element_namespaceObject.useMemo)(() => { + const mediaQueryList = getMediaQueryList(query); + return { + /** @type {(onStoreChange: () => void) => () => void} */ + subscribe(onStoreChange) { + if (!mediaQueryList) { + return () => {}; + } + + // Avoid a fatal error when browsers don't support `addEventListener` on MediaQueryList. + mediaQueryList.addEventListener?.('change', onStoreChange); + return () => { + mediaQueryList.removeEventListener?.('change', onStoreChange); + }; + }, + getValue() { + var _mediaQueryList$match; + return (_mediaQueryList$match = mediaQueryList?.matches) !== null && _mediaQueryList$match !== void 0 ? _mediaQueryList$match : false; + } + }; + }, [query]); + return (0,external_wp_element_namespaceObject.useSyncExternalStore)(source.subscribe, source.getValue, () => false); +} + +;// 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/. + * + * @param value The value to track. + * + * @return The value from the previous render. + */ +function usePrevious(value) { + const ref = (0,external_wp_element_namespaceObject.useRef)(); + + // Store current value in ref. + (0,external_wp_element_namespaceObject.useEffect)(() => { + 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 + */ + + +/** + * Hook returning whether the user has a preference for reduced motion. + * + * @return {boolean} Reduced motion preference value. + */ +const useReducedMotion = () => useMediaQuery('(prefers-reduced-motion: reduce)'); +/* harmony default export */ var use_reduced_motion = (useReducedMotion); + +// EXTERNAL MODULE: ./node_modules/@wordpress/undo-manager/build-module/index.js +var build_module = __webpack_require__(5360); +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-state-with-history/index.js +/** + * WordPress dependencies + */ + + +function undoRedoReducer(state, action) { + switch (action.type) { + case 'UNDO': + { + const undoRecord = state.manager.undo(); + if (undoRecord) { + return { + ...state, + value: undoRecord[0].changes.prop.from + }; + } + return state; + } + case 'REDO': + { + const redoRecord = state.manager.redo(); + if (redoRecord) { + return { + ...state, + value: redoRecord[0].changes.prop.to + }; + } + return state; + } + case 'RECORD': + { + state.manager.addRecord([{ + id: 'object', + changes: { + prop: { + from: state.value, + to: action.value + } + } + }], action.isStaged); + return { + ...state, + value: action.value + }; + } + } + return state; +} +function initReducer(value) { + return { + manager: (0,build_module.createUndoManager)(), + value + }; +} + +/** + * useState with undo/redo history. + * + * @param initialValue Initial value. + * @return Value, setValue, hasUndo, hasRedo, undo, redo. + */ +function useStateWithHistory(initialValue) { + const [state, dispatch] = (0,external_wp_element_namespaceObject.useReducer)(undoRedoReducer, initialValue, initReducer); + return { + value: state.value, + setValue: (0,external_wp_element_namespaceObject.useCallback)((newValue, isStaged) => { + dispatch({ + type: 'RECORD', + value: newValue, + isStaged + }); + }, []), + hasUndo: state.manager.hasUndo(), + hasRedo: state.manager.hasRedo(), + undo: (0,external_wp_element_namespaceObject.useCallback)(() => { + dispatch({ + type: 'UNDO' + }); + }, []), + redo: (0,external_wp_element_namespaceObject.useCallback)(() => { + dispatch({ + type: 'REDO' + }); + }, []) + }; +} + +;// 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 {Record<WPBreakpoint, number>} + */ +const 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 {Record<WPViewportOperator, string>} + */ +const CONDITIONS = { + '>=': 'min-width', + '<': 'max-width' +}; + +/** + * Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values. + * + * @type {Record<WPViewportOperator, (breakpointValue: number, width: number) => boolean>} + */ +const OPERATOR_EVALUATORS = { + '>=': (breakpointValue, width) => width >= breakpointValue, + '<': (breakpointValue, width) => width < breakpointValue +}; +const ViewportMatchWidthContext = (0,external_wp_element_namespaceObject.createContext)( /** @type {null | number} */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. + */ +const useViewportMatch = (breakpoint, operator = '>=') => { + const simulatedWidth = (0,external_wp_element_namespaceObject.useContext)(ViewportMatchWidthContext); + const mediaQuery = !simulatedWidth && `(${CONDITIONS[operator]}: ${BREAKPOINTS[breakpoint]}px)`; + const mediaQueryResult = useMediaQuery(mediaQuery || undefined); + if (simulatedWidth) { + return OPERATOR_EVALUATORS[operator](BREAKPOINTS[breakpoint], simulatedWidth); + } + return mediaQueryResult; +}; +useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider; +/* harmony default export */ var use_viewport_match = (useViewportMatch); + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/index.js + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + +// This of course could've been more streamlined with internal state instead of +// refs, but then host hooks / components could not opt out of renders. +// This could've been exported to its own module, but the current build doesn't +// seem to work with module imports and I had no more time to spend on this... +function useResolvedElement(subscriber, refOrElement) { + const callbackRefElement = (0,external_wp_element_namespaceObject.useRef)(null); + const lastReportRef = (0,external_wp_element_namespaceObject.useRef)(null); + const cleanupRef = (0,external_wp_element_namespaceObject.useRef)(); + const callSubscriber = (0,external_wp_element_namespaceObject.useCallback)(() => { + let element = null; + if (callbackRefElement.current) { + element = callbackRefElement.current; + } else if (refOrElement) { + if (refOrElement instanceof HTMLElement) { + element = refOrElement; + } else { + element = refOrElement.current; + } + } + if (lastReportRef.current && lastReportRef.current.element === element && lastReportRef.current.reporter === callSubscriber) { + return; + } + if (cleanupRef.current) { + cleanupRef.current(); + // Making sure the cleanup is not called accidentally multiple times. + cleanupRef.current = null; + } + lastReportRef.current = { + reporter: callSubscriber, + element + }; + + // Only calling the subscriber, if there's an actual element to report. + if (element) { + cleanupRef.current = subscriber(element); + } + }, [refOrElement, subscriber]); + + // On each render, we check whether a ref changed, or if we got a new raw + // element. + (0,external_wp_element_namespaceObject.useEffect)(() => { + // With this we're *technically* supporting cases where ref objects' current value changes, but only if there's a + // render accompanying that change as well. + // To guarantee we always have the right element, one must use the ref callback provided instead, but we support + // RefObjects to make the hook API more convenient in certain cases. + callSubscriber(); + }, [callSubscriber]); + return (0,external_wp_element_namespaceObject.useCallback)(element => { + callbackRefElement.current = element; + callSubscriber(); + }, [callSubscriber]); +} +// We're only using the first element of the size sequences, until future versions of the spec solidify on how +// exactly it'll be used for fragments in multi-column scenarios: +// From the spec: +// > The box size properties are exposed as FrozenArray in order to support elements that have multiple fragments, +// > which occur in multi-column scenarios. However the current definitions of content rect and border box do not +// > mention how those boxes are affected by multi-column layout. In this spec, there will only be a single +// > ResizeObserverSize returned in the FrozenArray, which will correspond to the dimensions of the first column. +// > A future version of this spec will extend the returned FrozenArray to contain the per-fragment size information. +// (https://drafts.csswg.org/resize-observer/#resize-observer-entry-interface) +// +// Also, testing these new box options revealed that in both Chrome and FF everything is returned in the callback, +// regardless of the "box" option. +// The spec states the following on this: +// > This does not have any impact on which box dimensions are returned to the defined callback when the event +// > is fired, it solely defines which box the author wishes to observe layout changes on. +// (https://drafts.csswg.org/resize-observer/#resize-observer-interface) +// I'm not exactly clear on what this means, especially when you consider a later section stating the following: +// > This section is non-normative. An author may desire to observe more than one CSS box. +// > In this case, author will need to use multiple ResizeObservers. +// (https://drafts.csswg.org/resize-observer/#resize-observer-interface) +// Which is clearly not how current browser implementations behave, and seems to contradict the previous quote. +// For this reason I decided to only return the requested size, +// even though it seems we have access to results for all box types. +// This also means that we get to keep the current api, being able to return a simple { width, height } pair, +// regardless of box option. +const extractSize = (entry, boxProp, sizeType) => { + if (!entry[boxProp]) { + if (boxProp === 'contentBoxSize') { + // The dimensions in `contentBoxSize` and `contentRect` are equivalent according to the spec. + // See the 6th step in the description for the RO algorithm: + // https://drafts.csswg.org/resize-observer/#create-and-populate-resizeobserverentry-h + // > Set this.contentRect to logical this.contentBoxSize given target and observedBox of "content-box". + // In real browser implementations of course these objects differ, but the width/height values should be equivalent. + return entry.contentRect[sizeType === 'inlineSize' ? 'width' : 'height']; + } + return undefined; + } + + // A couple bytes smaller than calling Array.isArray() and just as effective here. + return entry[boxProp][0] ? entry[boxProp][0][sizeType] : + // TS complains about this, because the RO entry type follows the spec and does not reflect Firefox's current + // behaviour of returning objects instead of arrays for `borderBoxSize` and `contentBoxSize`. + // @ts-ignore + entry[boxProp][sizeType]; +}; +function useResizeObserver(opts = {}) { + // Saving the callback as a ref. With this, I don't need to put onResize in the + // effect dep array, and just passing in an anonymous function without memoising + // will not reinstantiate the hook's ResizeObserver. + const onResize = opts.onResize; + const onResizeRef = (0,external_wp_element_namespaceObject.useRef)(undefined); + onResizeRef.current = onResize; + const round = opts.round || Math.round; + + // Using a single instance throughout the hook's lifetime + const resizeObserverRef = (0,external_wp_element_namespaceObject.useRef)(); + const [size, setSize] = (0,external_wp_element_namespaceObject.useState)({ + width: undefined, + height: undefined + }); + + // In certain edge cases the RO might want to report a size change just after + // the component unmounted. + const didUnmount = (0,external_wp_element_namespaceObject.useRef)(false); + (0,external_wp_element_namespaceObject.useEffect)(() => { + didUnmount.current = false; + return () => { + didUnmount.current = true; + }; + }, []); + + // Using a ref to track the previous width / height to avoid unnecessary renders. + const previous = (0,external_wp_element_namespaceObject.useRef)({ + width: undefined, + height: undefined + }); + + // This block is kinda like a useEffect, only it's called whenever a new + // element could be resolved based on the ref option. It also has a cleanup + // function. + const refCallback = useResolvedElement((0,external_wp_element_namespaceObject.useCallback)(element => { + // We only use a single Resize Observer instance, and we're instantiating it on demand, only once there's something to observe. + // This instance is also recreated when the `box` option changes, so that a new observation is fired if there was a previously observed element with a different box option. + if (!resizeObserverRef.current || resizeObserverRef.current.box !== opts.box || resizeObserverRef.current.round !== round) { + resizeObserverRef.current = { + box: opts.box, + round, + instance: new ResizeObserver(entries => { + const entry = entries[0]; + let boxProp = 'borderBoxSize'; + if (opts.box === 'border-box') { + boxProp = 'borderBoxSize'; + } else { + boxProp = opts.box === 'device-pixel-content-box' ? 'devicePixelContentBoxSize' : 'contentBoxSize'; + } + const reportedWidth = extractSize(entry, boxProp, 'inlineSize'); + const reportedHeight = extractSize(entry, boxProp, 'blockSize'); + const newWidth = reportedWidth ? round(reportedWidth) : undefined; + const newHeight = reportedHeight ? round(reportedHeight) : undefined; + if (previous.current.width !== newWidth || previous.current.height !== newHeight) { + const newSize = { + width: newWidth, + height: newHeight + }; + previous.current.width = newWidth; + previous.current.height = newHeight; + if (onResizeRef.current) { + onResizeRef.current(newSize); + } else if (!didUnmount.current) { + setSize(newSize); + } + } + }) + }; + } + resizeObserverRef.current.instance.observe(element, { + box: opts.box + }); + return () => { + if (resizeObserverRef.current) { + resizeObserverRef.current.instance.unobserve(element); + } + }; + }, [opts.box, round]), opts.ref); + return (0,external_wp_element_namespaceObject.useMemo)(() => ({ + ref: refCallback, + width: size.width, + height: size.height + }), [refCallback, size ? size.width : null, size ? size.height : null]); +} + +/** + * 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. + * + * @example + * + * ```js + * const App = () => { + * const [ resizeListener, sizes ] = useResizeObserver(); + * + * return ( + * <div> + * { resizeListener } + * Your content here + * </div> + * ); + * }; + * ``` + */ +function useResizeAware() { + const { + ref, + width, + height + } = useResizeObserver(); + const sizes = (0,external_wp_element_namespaceObject.useMemo)(() => { + return { + width: width !== null && width !== void 0 ? width : null, + height: height !== null && height !== void 0 ? height : null + }; + }, [width, height]); + const resizeListener = (0,external_wp_element_namespaceObject.createElement)("div", { + style: { + position: 'absolute', + top: 0, + left: 0, + right: 0, + bottom: 0, + pointerEvents: 'none', + opacity: 0, + overflow: 'hidden', + zIndex: -1 + }, + "aria-hidden": "true", + ref: ref + }); + return [resizeListener, sizes]; +} + +;// CONCATENATED MODULE: external ["wp","priorityQueue"] +var external_wp_priorityQueue_namespaceObject = window["wp"]["priorityQueue"]; +;// 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 list New array. + * @param state Current state. + * @return First items present iin state. + */ +function getFirstItemsPresentInState(list, state) { + const firstItems = []; + for (let i = 0; i < list.length; i++) { + const item = list[i]; + if (!state.includes(item)) { + break; + } + firstItems.push(item); + } + return firstItems; +} + +/** + * 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 list Source array. + * @param config Configuration object. + * + * @return Async array. + */ +function useAsyncList(list, config = { + step: 1 +}) { + const { + step = 1 + } = config; + const [current, setCurrent] = (0,external_wp_element_namespaceObject.useState)([]); + (0,external_wp_element_namespaceObject.useEffect)(() => { + // On reset, we keep the first items that were previously rendered. + let firstItems = getFirstItemsPresentInState(list, current); + if (firstItems.length < step) { + firstItems = firstItems.concat(list.slice(firstItems.length, step)); + } + setCurrent(firstItems); + const asyncQueue = (0,external_wp_priorityQueue_namespaceObject.createQueue)(); + for (let i = firstItems.length; i < list.length; i += step) { + asyncQueue.add({}, () => { + (0,external_wp_element_namespaceObject.flushSync)(() => { + setCurrent(state => [...state, ...list.slice(i, i + step)]); + }); + }); + } + 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 + */ + + +// Disable reason: Object and object are distinctly different types in TypeScript and we mean the lowercase object in thise case +// but eslint wants to force us to use `Object`. See https://stackoverflow.com/questions/49464634/difference-between-object-and-object-in-typescript +/* eslint-disable jsdoc/check-types */ +/** + * 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, prefix = 'Change detection') { + const previousValues = usePrevious(object); + Object.entries(previousValues !== null && previousValues !== void 0 ? previousValues : []).forEach(([key, value]) => { + if (value !== object[/** @type {keyof typeof object} */key]) { + // eslint-disable-next-line no-console + console.warn(`${prefix}: ${key} key changed:`, value, object[/** @type {keyof typeof object} */key] + /* eslint-enable jsdoc/check-types */); + } + }); +} + +/* harmony default export */ var use_warn_on_change = (useWarnOnChange); + +;// CONCATENATED MODULE: external "React" +var external_React_namespaceObject = window["React"]; +;// CONCATENATED MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js + + +function areInputsEqual(newInputs, lastInputs) { + if (newInputs.length !== lastInputs.length) { + return false; + } + + for (var i = 0; i < newInputs.length; i++) { + if (newInputs[i] !== lastInputs[i]) { + return false; + } + } + + return true; +} + +function useMemoOne(getResult, inputs) { + var initial = (0,external_React_namespaceObject.useState)(function () { + return { + inputs: inputs, + result: getResult() + }; + })[0]; + var isFirstRun = (0,external_React_namespaceObject.useRef)(true); + var committed = (0,external_React_namespaceObject.useRef)(initial); + var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs)); + var cache = useCache ? committed.current : { + inputs: inputs, + result: getResult() + }; + (0,external_React_namespaceObject.useEffect)(function () { + isFirstRun.current = false; + committed.current = cache; + }, [cache]); + return cache.result; +} +function useCallbackOne(callback, inputs) { + return useMemoOne(function () { + return callback; + }, inputs); +} +var useMemo = (/* unused pure expression or super */ null && (useMemoOne)); +var useCallback = (/* unused pure expression or super */ null && (useCallbackOne)); + + + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-debounce/index.js +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * Debounces a function similar to Lodash's `debounce`. A new debounced function will + * be returned and any scheduled calls cancelled if any of the arguments change, + * including the function to debounce, so please wrap functions created on + * render in components in `useCallback`. + * + * @see https://docs-lodash.com/v4/debounce/ + * + * @template {(...args: any[]) => void} TFunc + * + * @param {TFunc} fn The function to debounce. + * @param {number} [wait] The number of milliseconds to delay. + * @param {import('../../utils/debounce').DebounceOptions} [options] The options object. + * @return {import('../../utils/debounce').DebouncedFunc<TFunc>} Debounced function. + */ +function useDebounce(fn, wait, options) { + const debounced = useMemoOne(() => debounce(fn, wait !== null && wait !== void 0 ? wait : 0, options), [fn, wait, options]); + (0,external_wp_element_namespaceObject.useEffect)(() => () => debounced.cancel(), [debounced]); + return debounced; +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-throttle/index.js +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * Throttles a function similar to Lodash's `throttle`. A new throttled function will + * be returned and any scheduled calls cancelled if any of the arguments change, + * including the function to throttle, so please wrap functions created on + * render in components in `useCallback`. + * + * @see https://docs-lodash.com/v4/throttle/ + * + * @template {(...args: any[]) => void} TFunc + * + * @param {TFunc} fn The function to throttle. + * @param {number} [wait] The number of milliseconds to throttle invocations to. + * @param {import('../../utils/throttle').ThrottleOptions} [options] The options object. See linked documentation for details. + * @return {import('../../utils/debounce').DebouncedFunc<TFunc>} Throttled function. + */ +function useThrottle(fn, wait, options) { + const throttled = useMemoOne(() => throttle(fn, wait !== null && wait !== void 0 ? wait : 0, options), [fn, wait, options]); + (0,external_wp_element_namespaceObject.useEffect)(() => () => throttled.cancel(), [throttled]); + return throttled; +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-drop-zone/index.js +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/* eslint-disable jsdoc/valid-types */ +/** + * @template T + * @param {T} value + * @return {import('react').MutableRefObject<T|null>} A ref with the value. + */ +function useFreshRef(value) { + /* eslint-enable jsdoc/valid-types */ + /* eslint-disable jsdoc/no-undefined-types */ + /** @type {import('react').MutableRefObject<T>} */ + /* eslint-enable jsdoc/no-undefined-types */ + // Disable reason: We're doing something pretty JavaScript-y here where the + // ref will always have a current value that is not null or undefined but it + // needs to start as undefined. We don't want to change the return type so + // it's easier to just ts-ignore this specific line that's complaining about + // undefined not being part of T. + // @ts-ignore + const ref = (0,external_wp_element_namespaceObject.useRef)(); + ref.current = value; + return ref; +} + +/** + * A hook to facilitate drag and drop handling. + * + * @param {Object} props Named parameters. + * @param {?HTMLElement} [props.dropZoneElement] Optional element to be used as the drop zone. + * @param {boolean} [props.isDisabled] Whether or not to disable the drop zone. + * @param {(e: DragEvent) => void} [props.onDragStart] Called when dragging has started. + * @param {(e: DragEvent) => void} [props.onDragEnter] Called when the zone is entered. + * @param {(e: DragEvent) => void} [props.onDragOver] Called when the zone is moved within. + * @param {(e: DragEvent) => void} [props.onDragLeave] Called when the zone is left. + * @param {(e: MouseEvent) => void} [props.onDragEnd] Called when dragging has ended. + * @param {(e: DragEvent) => void} [props.onDrop] Called when dropping in the zone. + * + * @return {import('react').RefCallback<HTMLElement>} Ref callback to be passed to the drop zone element. + */ +function useDropZone({ + dropZoneElement, + isDisabled, + onDrop: _onDrop, + onDragStart: _onDragStart, + onDragEnter: _onDragEnter, + onDragLeave: _onDragLeave, + onDragEnd: _onDragEnd, + onDragOver: _onDragOver +}) { + const onDropRef = useFreshRef(_onDrop); + const onDragStartRef = useFreshRef(_onDragStart); + const onDragEnterRef = useFreshRef(_onDragEnter); + const onDragLeaveRef = useFreshRef(_onDragLeave); + const onDragEndRef = useFreshRef(_onDragEnd); + const onDragOverRef = useFreshRef(_onDragOver); + return useRefEffect(elem => { + if (isDisabled) { + return; + } + + // If a custom dropZoneRef is passed, use that instead of the element. + // This allows the dropzone to cover an expanded area, rather than + // be restricted to the area of the ref returned by this hook. + const element = dropZoneElement !== null && dropZoneElement !== void 0 ? dropZoneElement : elem; + let isDragging = false; + const { + ownerDocument + } = element; + + /** + * Checks if an element is in the drop zone. + * + * @param {EventTarget|null} targetToCheck + * + * @return {boolean} True if in drop zone, false if not. + */ + function isElementInZone(targetToCheck) { + const { + defaultView + } = ownerDocument; + if (!targetToCheck || !defaultView || !(targetToCheck instanceof defaultView.HTMLElement) || !element.contains(targetToCheck)) { + return false; + } + + /** @type {HTMLElement|null} */ + let elementToCheck = targetToCheck; + do { + if (elementToCheck.dataset.isDropZone) { + return elementToCheck === element; + } + } while (elementToCheck = elementToCheck.parentElement); + return false; + } + function maybeDragStart( /** @type {DragEvent} */event) { + if (isDragging) { + return; + } + isDragging = true; + + // Note that `dragend` doesn't fire consistently for file and + // HTML drag events where the drag origin is outside the browser + // window. In Firefox it may also not fire if the originating + // node is removed. + ownerDocument.addEventListener('dragend', maybeDragEnd); + ownerDocument.addEventListener('mousemove', maybeDragEnd); + if (onDragStartRef.current) { + onDragStartRef.current(event); + } + } + function onDragEnter( /** @type {DragEvent} */event) { + event.preventDefault(); + + // The `dragenter` event will also fire when entering child + // elements, but we only want to call `onDragEnter` when + // entering the drop zone, which means the `relatedTarget` + // (element that has been left) should be outside the drop zone. + if (element.contains( /** @type {Node} */event.relatedTarget)) { + return; + } + if (onDragEnterRef.current) { + onDragEnterRef.current(event); + } + } + function onDragOver( /** @type {DragEvent} */event) { + // Only call onDragOver for the innermost hovered drop zones. + if (!event.defaultPrevented && onDragOverRef.current) { + onDragOverRef.current(event); + } + + // Prevent the browser default while also signalling to parent + // drop zones that `onDragOver` is already handled. + event.preventDefault(); + } + function onDragLeave( /** @type {DragEvent} */event) { + // The `dragleave` event will also fire when leaving child + // elements, but we only want to call `onDragLeave` when + // leaving the drop zone, which means the `relatedTarget` + // (element that has been entered) should be outside the drop + // zone. + // Note: This is not entirely reliable in Safari due to this bug + // https://bugs.webkit.org/show_bug.cgi?id=66547 + if (isElementInZone(event.relatedTarget)) { + return; + } + if (onDragLeaveRef.current) { + onDragLeaveRef.current(event); + } + } + function onDrop( /** @type {DragEvent} */event) { + // Don't handle drop if an inner drop zone already handled it. + if (event.defaultPrevented) { + return; + } + + // Prevent the browser default while also signalling to parent + // drop zones that `onDrop` is already handled. + event.preventDefault(); + + // This seemingly useless line has been shown to resolve a + // Safari issue where files dragged directly from the dock are + // not recognized. + // eslint-disable-next-line no-unused-expressions + event.dataTransfer && event.dataTransfer.files.length; + if (onDropRef.current) { + onDropRef.current(event); + } + maybeDragEnd(event); + } + function maybeDragEnd( /** @type {MouseEvent} */event) { + if (!isDragging) { + return; + } + isDragging = false; + ownerDocument.removeEventListener('dragend', maybeDragEnd); + ownerDocument.removeEventListener('mousemove', maybeDragEnd); + if (onDragEndRef.current) { + onDragEndRef.current(event); + } + } + element.dataset.isDropZone = 'true'; + element.addEventListener('drop', onDrop); + element.addEventListener('dragenter', onDragEnter); + element.addEventListener('dragover', onDragOver); + element.addEventListener('dragleave', onDragLeave); + // The `dragstart` event doesn't fire if the drag started outside + // the document. + ownerDocument.addEventListener('dragenter', maybeDragStart); + return () => { + delete element.dataset.isDropZone; + element.removeEventListener('drop', onDrop); + element.removeEventListener('dragenter', onDragEnter); + element.removeEventListener('dragover', onDragOver); + element.removeEventListener('dragleave', onDragLeave); + ownerDocument.removeEventListener('dragend', maybeDragEnd); + ownerDocument.removeEventListener('mousemove', maybeDragEnd); + ownerDocument.removeEventListener('dragenter', maybeDragStart); + }; + }, [isDisabled, dropZoneElement] // Refresh when the passed in dropZoneElement changes. + ); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focusable-iframe/index.js +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * Dispatches a bubbling focus event when the iframe receives focus. Use + * `onFocus` as usual on the iframe or a parent element. + * + * @return Ref to pass to the iframe. + */ +function useFocusableIframe() { + return useRefEffect(element => { + const { + ownerDocument + } = element; + if (!ownerDocument) return; + const { + defaultView + } = ownerDocument; + if (!defaultView) return; + + /** + * Checks whether the iframe is the activeElement, inferring that it has + * then received focus, and dispatches a focus event. + */ + function checkFocus() { + if (ownerDocument && ownerDocument.activeElement === element) { + element.focus(); + } + } + defaultView.addEventListener('blur', checkFocus); + return () => { + defaultView.removeEventListener('blur', checkFocus); + }; + }, []); +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-fixed-window-list/index.js +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + +const DEFAULT_INIT_WINDOW_SIZE = 30; + +/** + * @typedef {Object} WPFixedWindowList + * + * @property {number} visibleItems Items visible in the current viewport + * @property {number} start Start index of the window + * @property {number} end End index of the window + * @property {(index:number)=>boolean} itemInView Returns true if item is in the window + */ + +/** + * @typedef {Object} WPFixedWindowListOptions + * + * @property {number} [windowOverscan] Renders windowOverscan number of items before and after the calculated visible window. + * @property {boolean} [useWindowing] When false avoids calculating the window size + * @property {number} [initWindowSize] Initial window size to use on first render before we can calculate the window size. + * @property {any} [expandedState] Used to recalculate the window size when the expanded state of a list changes. + */ + +/** + * + * @param {import('react').RefObject<HTMLElement>} elementRef Used to find the closest scroll container that contains element. + * @param { number } itemHeight Fixed item height in pixels + * @param { number } totalItems Total items in list + * @param { WPFixedWindowListOptions } [options] Options object + * @return {[ WPFixedWindowList, setFixedListWindow:(nextWindow:WPFixedWindowList)=>void]} Array with the fixed window list and setter + */ +function useFixedWindowList(elementRef, itemHeight, totalItems, options) { + var _options$initWindowSi, _options$useWindowing; + const initWindowSize = (_options$initWindowSi = options?.initWindowSize) !== null && _options$initWindowSi !== void 0 ? _options$initWindowSi : DEFAULT_INIT_WINDOW_SIZE; + const useWindowing = (_options$useWindowing = options?.useWindowing) !== null && _options$useWindowing !== void 0 ? _options$useWindowing : true; + const [fixedListWindow, setFixedListWindow] = (0,external_wp_element_namespaceObject.useState)({ + visibleItems: initWindowSize, + start: 0, + end: initWindowSize, + itemInView: ( /** @type {number} */index) => { + return index >= 0 && index <= initWindowSize; + } + }); + (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { + if (!useWindowing) { + return; + } + const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(elementRef.current); + const measureWindow = ( /** @type {boolean | undefined} */initRender) => { + var _options$windowOversc; + if (!scrollContainer) { + return; + } + const visibleItems = Math.ceil(scrollContainer.clientHeight / itemHeight); + // Aim to keep opening list view fast, afterward we can optimize for scrolling. + const windowOverscan = initRender ? visibleItems : (_options$windowOversc = options?.windowOverscan) !== null && _options$windowOversc !== void 0 ? _options$windowOversc : visibleItems; + const firstViewableIndex = Math.floor(scrollContainer.scrollTop / itemHeight); + const start = Math.max(0, firstViewableIndex - windowOverscan); + const end = Math.min(totalItems - 1, firstViewableIndex + visibleItems + windowOverscan); + setFixedListWindow(lastWindow => { + const nextWindow = { + visibleItems, + start, + end, + itemInView: ( /** @type {number} */index) => { + return start <= index && index <= end; + } + }; + if (lastWindow.start !== nextWindow.start || lastWindow.end !== nextWindow.end || lastWindow.visibleItems !== nextWindow.visibleItems) { + return nextWindow; + } + return lastWindow; + }); + }; + measureWindow(true); + const debounceMeasureList = debounce(() => { + measureWindow(); + }, 16); + scrollContainer?.addEventListener('scroll', debounceMeasureList); + scrollContainer?.ownerDocument?.defaultView?.addEventListener('resize', debounceMeasureList); + scrollContainer?.ownerDocument?.defaultView?.addEventListener('resize', debounceMeasureList); + return () => { + scrollContainer?.removeEventListener('scroll', debounceMeasureList); + scrollContainer?.ownerDocument?.defaultView?.removeEventListener('resize', debounceMeasureList); + }; + }, [itemHeight, elementRef, totalItems, options?.expandedState, options?.windowOverscan, useWindowing]); + (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { + if (!useWindowing) { + return; + } + const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(elementRef.current); + const handleKeyDown = ( /** @type {KeyboardEvent} */event) => { + switch (event.keyCode) { + case external_wp_keycodes_namespaceObject.HOME: + { + return scrollContainer?.scrollTo({ + top: 0 + }); + } + case external_wp_keycodes_namespaceObject.END: + { + return scrollContainer?.scrollTo({ + top: totalItems * itemHeight + }); + } + case external_wp_keycodes_namespaceObject.PAGEUP: + { + return scrollContainer?.scrollTo({ + top: scrollContainer.scrollTop - fixedListWindow.visibleItems * itemHeight + }); + } + case external_wp_keycodes_namespaceObject.PAGEDOWN: + { + return scrollContainer?.scrollTo({ + top: scrollContainer.scrollTop + fixedListWindow.visibleItems * itemHeight + }); + } + } + }; + scrollContainer?.ownerDocument?.defaultView?.addEventListener('keydown', handleKeyDown); + return () => { + scrollContainer?.ownerDocument?.defaultView?.removeEventListener('keydown', handleKeyDown); + }; + }, [totalItems, itemHeight, elementRef, fixedListWindow.visibleItems, useWindowing, options?.expandedState]); + return [fixedListWindow, setFixedListWindow]; +} + +;// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js +// The `createHigherOrderComponent` helper and helper types. + +// The `debounce` helper and its types. + +// The `throttle` helper and its types. + + +// The `compose` and `pipe` helpers (inspired by `flowRight` and `flow` from Lodash). + + + +// Higher-order components. + + + + + + + +// Hooks. + + + + + + + + + + + + + + + + + + + + + + + + + + + + +}(); +(window.wp = window.wp || {}).compose = __webpack_exports__; +/******/ })() +;
\ No newline at end of file |