diff -r 3d4e9c994f10 -r a86126ab1dd4 wp/wp-includes/js/dist/keyboard-shortcuts.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wp/wp-includes/js/dist/keyboard-shortcuts.js Tue Dec 15 13:49:49 2020 +0100 @@ -0,0 +1,936 @@ +this["wp"] = this["wp"] || {}; this["wp"]["keyboardShortcuts"] = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 456); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 14: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; }); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js +var arrayWithHoles = __webpack_require__(38); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js +var unsupportedIterableToArray = __webpack_require__(29); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js +var nonIterableRest = __webpack_require__(39); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + + + + +function _slicedToArray(arr, i) { + return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])(); +} + +/***/ }), + +/***/ 18: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; }); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js +var arrayLikeToArray = __webpack_require__(26); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr); +} +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js +var iterableToArray = __webpack_require__(35); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js +var unsupportedIterableToArray = __webpack_require__(29); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + + + + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread(); +} + +/***/ }), + +/***/ 2: +/***/ (function(module, exports) { + +(function() { module.exports = this["lodash"]; }()); + +/***/ }), + +/***/ 21: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["keycodes"]; }()); + +/***/ }), + +/***/ 26: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; }); +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) { + arr2[i] = arr[i]; + } + + return arr2; +} + +/***/ }), + +/***/ 29: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; }); +/* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26); + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); +} + +/***/ }), + +/***/ 35: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +/***/ }), + +/***/ 38: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +/***/ }), + +/***/ 39: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +/***/ }), + +/***/ 4: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["data"]; }()); + +/***/ }), + +/***/ 42: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + + +var LEAF_KEY, hasWeakMap; + +/** + * Arbitrary value used as key for referencing cache object in WeakMap tree. + * + * @type {Object} + */ +LEAF_KEY = {}; + +/** + * Whether environment supports WeakMap. + * + * @type {boolean} + */ +hasWeakMap = typeof WeakMap !== 'undefined'; + +/** + * Returns the first argument as the sole entry in an array. + * + * @param {*} value Value to return. + * + * @return {Array} Value returned as entry in array. + */ +function arrayOf( value ) { + return [ value ]; +} + +/** + * Returns true if the value passed is object-like, or false otherwise. A value + * is object-like if it can support property assignment, e.g. object or array. + * + * @param {*} value Value to test. + * + * @return {boolean} Whether value is object-like. + */ +function isObjectLike( value ) { + return !! value && 'object' === typeof value; +} + +/** + * Creates and returns a new cache object. + * + * @return {Object} Cache object. + */ +function createCache() { + var cache = { + clear: function() { + cache.head = null; + }, + }; + + return cache; +} + +/** + * Returns true if entries within the two arrays are strictly equal by + * reference from a starting index. + * + * @param {Array} a First array. + * @param {Array} b Second array. + * @param {number} fromIndex Index from which to start comparison. + * + * @return {boolean} Whether arrays are shallowly equal. + */ +function isShallowEqual( a, b, fromIndex ) { + var i; + + if ( a.length !== b.length ) { + return false; + } + + for ( i = fromIndex; i < a.length; i++ ) { + if ( a[ i ] !== b[ i ] ) { + return false; + } + } + + return true; +} + +/** + * Returns a memoized selector function. The getDependants function argument is + * called before the memoized selector and is expected to return an immutable + * reference or array of references on which the selector depends for computing + * its own return value. The memoize cache is preserved only as long as those + * dependant references remain the same. If getDependants returns a different + * reference(s), the cache is cleared and the selector value regenerated. + * + * @param {Function} selector Selector function. + * @param {Function} getDependants Dependant getter returning an immutable + * reference or array of reference used in + * cache bust consideration. + * + * @return {Function} Memoized selector. + */ +/* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) { + var rootCache, getCache; + + // Use object source as dependant if getter not provided + if ( ! getDependants ) { + getDependants = arrayOf; + } + + /** + * Returns the root cache. If WeakMap is supported, this is assigned to the + * root WeakMap cache set, otherwise it is a shared instance of the default + * cache object. + * + * @return {(WeakMap|Object)} Root cache object. + */ + function getRootCache() { + return rootCache; + } + + /** + * Returns the cache for a given dependants array. When possible, a WeakMap + * will be used to create a unique cache for each set of dependants. This + * is feasible due to the nature of WeakMap in allowing garbage collection + * to occur on entries where the key object is no longer referenced. Since + * WeakMap requires the key to be an object, this is only possible when the + * dependant is object-like. The root cache is created as a hierarchy where + * each top-level key is the first entry in a dependants set, the value a + * WeakMap where each key is the next dependant, and so on. This continues + * so long as the dependants are object-like. If no dependants are object- + * like, then the cache is shared across all invocations. + * + * @see isObjectLike + * + * @param {Array} dependants Selector dependants. + * + * @return {Object} Cache object. + */ + function getWeakMapCache( dependants ) { + var caches = rootCache, + isUniqueByDependants = true, + i, dependant, map, cache; + + for ( i = 0; i < dependants.length; i++ ) { + dependant = dependants[ i ]; + + // Can only compose WeakMap from object-like key. + if ( ! isObjectLike( dependant ) ) { + isUniqueByDependants = false; + break; + } + + // Does current segment of cache already have a WeakMap? + if ( caches.has( dependant ) ) { + // Traverse into nested WeakMap. + caches = caches.get( dependant ); + } else { + // Create, set, and traverse into a new one. + map = new WeakMap(); + caches.set( dependant, map ); + caches = map; + } + } + + // We use an arbitrary (but consistent) object as key for the last item + // in the WeakMap to serve as our running cache. + if ( ! caches.has( LEAF_KEY ) ) { + cache = createCache(); + cache.isUniqueByDependants = isUniqueByDependants; + caches.set( LEAF_KEY, cache ); + } + + return caches.get( LEAF_KEY ); + } + + // Assign cache handler by availability of WeakMap + getCache = hasWeakMap ? getWeakMapCache : getRootCache; + + /** + * Resets root memoization cache. + */ + function clear() { + rootCache = hasWeakMap ? new WeakMap() : createCache(); + } + + // eslint-disable-next-line jsdoc/check-param-names + /** + * The augmented selector call, considering first whether dependants have + * changed before passing it to underlying memoize function. + * + * @param {Object} source Source object for derivation. + * @param {...*} extraArgs Additional arguments to pass to selector. + * + * @return {*} Selector result. + */ + function callSelector( /* source, ...extraArgs */ ) { + var len = arguments.length, + cache, node, i, args, dependants; + + // Create copy of arguments (avoid leaking deoptimization). + args = new Array( len ); + for ( i = 0; i < len; i++ ) { + args[ i ] = arguments[ i ]; + } + + dependants = getDependants.apply( null, args ); + cache = getCache( dependants ); + + // If not guaranteed uniqueness by dependants (primitive type or lack + // of WeakMap support), shallow compare against last dependants and, if + // references have changed, destroy cache to recalculate result. + if ( ! cache.isUniqueByDependants ) { + if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) { + cache.clear(); + } + + cache.lastDependants = dependants; + } + + node = cache.head; + while ( node ) { + // Check whether node arguments match arguments + if ( ! isShallowEqual( node.args, args, 1 ) ) { + node = node.next; + continue; + } + + // At this point we can assume we've found a match + + // Surface matched node to head if not already + if ( node !== cache.head ) { + // Adjust siblings to point to each other. + node.prev.next = node.next; + if ( node.next ) { + node.next.prev = node.prev; + } + + node.next = cache.head; + node.prev = null; + cache.head.prev = node; + cache.head = node; + } + + // Return immediately + return node.val; + } + + // No cached value found. Continue to insertion phase: + + node = { + // Generate the result from original function + val: selector.apply( null, args ), + }; + + // Avoid including the source object in the cache. + args[ 0 ] = null; + node.args = args; + + // Don't need to check whether node is already head, since it would + // have been returned above already if it was + + // Shift existing head down list + if ( cache.head ) { + cache.head.prev = node; + node.next = cache.head; + } + + cache.head = node; + + return node.val; + } + + callSelector.getDependants = getDependants; + callSelector.clear = clear; + clear(); + + return callSelector; +}); + + +/***/ }), + +/***/ 456: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "useShortcut", function() { return /* reexport */ use_shortcut; }); + +// NAMESPACE OBJECT: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/actions.js +var actions_namespaceObject = {}; +__webpack_require__.r(actions_namespaceObject); +__webpack_require__.d(actions_namespaceObject, "registerShortcut", function() { return registerShortcut; }); +__webpack_require__.d(actions_namespaceObject, "unregisterShortcut", function() { return unregisterShortcut; }); + +// NAMESPACE OBJECT: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/selectors.js +var selectors_namespaceObject = {}; +__webpack_require__.r(selectors_namespaceObject); +__webpack_require__.d(selectors_namespaceObject, "getShortcutKeyCombination", function() { return getShortcutKeyCombination; }); +__webpack_require__.d(selectors_namespaceObject, "getShortcutRepresentation", function() { return getShortcutRepresentation; }); +__webpack_require__.d(selectors_namespaceObject, "getShortcutDescription", function() { return getShortcutDescription; }); +__webpack_require__.d(selectors_namespaceObject, "getShortcutAliases", function() { return getShortcutAliases; }); +__webpack_require__.d(selectors_namespaceObject, "getAllShortcutRawKeyCombinations", function() { return getAllShortcutRawKeyCombinations; }); +__webpack_require__.d(selectors_namespaceObject, "getCategoryShortcuts", function() { return getCategoryShortcuts; }); + +// EXTERNAL MODULE: external {"this":["wp","data"]} +var external_this_wp_data_ = __webpack_require__(4); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js +var defineProperty = __webpack_require__(5); + +// EXTERNAL MODULE: external {"this":"lodash"} +var external_this_lodash_ = __webpack_require__(2); + +// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/reducer.js + + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +/** + * External dependencies + */ + +/** + * Reducer returning the registered shortcuts + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function reducer() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'REGISTER_SHORTCUT': + return _objectSpread({}, state, Object(defineProperty["a" /* default */])({}, action.name, { + category: action.category, + keyCombination: action.keyCombination, + aliases: action.aliases, + description: action.description + })); + + case 'UNREGISTER_SHORTCUT': + return Object(external_this_lodash_["omit"])(state, action.name); + } + + return state; +} + +/* harmony default export */ var store_reducer = (reducer); + +// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/actions.js +/** @typedef {import('@wordpress/keycodes').WPKeycodeModifier} WPKeycodeModifier */ + +/** + * Keyboard key combination. + * + * @typedef {Object} WPShortcutKeyCombination + * + * @property {string} character Character. + * @property {WPKeycodeModifier|undefined} modifier Modifier. + */ + +/** + * Configuration of a registered keyboard shortcut. + * + * @typedef {Object} WPShortcutConfig + * + * @property {string} name Shortcut name. + * @property {string} category Shortcut category. + * @property {string} description Shortcut description. + * @property {WPShortcutKeyCombination} keyCombination Shortcut key combination. + * @property {WPShortcutKeyCombination[]} [aliases] Shortcut aliases. + */ + +/** + * Returns an action object used to register a new keyboard shortcut. + * + * @param {WPShortcutConfig} config Shortcut config. + * + * @return {Object} action. + */ +function registerShortcut(_ref) { + var name = _ref.name, + category = _ref.category, + description = _ref.description, + keyCombination = _ref.keyCombination, + aliases = _ref.aliases; + return { + type: 'REGISTER_SHORTCUT', + name: name, + category: category, + keyCombination: keyCombination, + aliases: aliases, + description: description + }; +} +/** + * Returns an action object used to unregister a keyboard shortcut. + * + * @param {string} name Shortcut name. + * + * @return {Object} action. + */ + +function unregisterShortcut(name) { + return { + type: 'UNREGISTER_SHORTCUT', + name: name + }; +} + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules +var slicedToArray = __webpack_require__(14); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules +var toConsumableArray = __webpack_require__(18); + +// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js +var rememo = __webpack_require__(42); + +// EXTERNAL MODULE: external {"this":["wp","keycodes"]} +var external_this_wp_keycodes_ = __webpack_require__(21); + +// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/selectors.js + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + +/** @typedef {import('./actions').WPShortcutKeyCombination} WPShortcutKeyCombination */ + +/** @typedef {import('@wordpress/keycodes').WPKeycodeHandlerByModifier} WPKeycodeHandlerByModifier */ + +/** + * Shared reference to an empty array for cases where it is important to avoid + * returning a new array reference on every invocation. + * + * @type {Array} + */ + +var EMPTY_ARRAY = []; +/** + * Shortcut formatting methods. + * + * @property {WPKeycodeHandlerByModifier} display Display formatting. + * @property {WPKeycodeHandlerByModifier} rawShortcut Raw shortcut formatting. + * @property {WPKeycodeHandlerByModifier} ariaLabel ARIA label formatting. + */ + +var FORMATTING_METHODS = { + display: external_this_wp_keycodes_["displayShortcut"], + raw: external_this_wp_keycodes_["rawShortcut"], + ariaLabel: external_this_wp_keycodes_["shortcutAriaLabel"] +}; +/** + * Returns a string representing the key combination. + * + * @param {?WPShortcutKeyCombination} shortcut Key combination. + * @param {keyof FORMATTING_METHODS} representation Type of representation + * (display, raw, ariaLabel). + * + * @return {string?} Shortcut representation. + */ + +function getKeyCombinationRepresentation(shortcut, representation) { + if (!shortcut) { + return null; + } + + return shortcut.modifier ? FORMATTING_METHODS[representation][shortcut.modifier](shortcut.character) : shortcut.character; +} +/** + * Returns the main key combination for a given shortcut name. + * + * @param {Object} state Global state. + * @param {string} name Shortcut name. + * + * @return {WPShortcutKeyCombination?} Key combination. + */ + + +function getShortcutKeyCombination(state, name) { + return state[name] ? state[name].keyCombination : null; +} +/** + * Returns a string representing the main key combination for a given shortcut name. + * + * @param {Object} state Global state. + * @param {string} name Shortcut name. + * @param {keyof FORMATTING_METHODS} representation Type of representation + * (display, raw, ariaLabel). + * + * @return {string?} Shortcut representation. + */ + +function getShortcutRepresentation(state, name) { + var representation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'display'; + var shortcut = getShortcutKeyCombination(state, name); + return getKeyCombinationRepresentation(shortcut, representation); +} +/** + * Returns the shortcut description given its name. + * + * @param {Object} state Global state. + * @param {string} name Shortcut name. + * + * @return {string?} Shortcut description. + */ + +function getShortcutDescription(state, name) { + return state[name] ? state[name].description : null; +} +/** + * Returns the aliases for a given shortcut name. + * + * @param {Object} state Global state. + * @param {string} name Shortcut name. + * + * @return {WPShortcutKeyCombination[]} Key combinations. + */ + +function getShortcutAliases(state, name) { + return state[name] && state[name].aliases ? state[name].aliases : EMPTY_ARRAY; +} +/** + * Returns the raw representation of all the keyboard combinations of a given shortcut name. + * + * @param {Object} state Global state. + * @param {string} name Shortcut name. + * + * @return {string[]} Shortcuts. + */ + +var getAllShortcutRawKeyCombinations = Object(rememo["a" /* default */])(function (state, name) { + return Object(external_this_lodash_["compact"])([getKeyCombinationRepresentation(getShortcutKeyCombination(state, name), 'raw')].concat(Object(toConsumableArray["a" /* default */])(getShortcutAliases(state, name).map(function (combination) { + return getKeyCombinationRepresentation(combination, 'raw'); + })))); +}, function (state, name) { + return [state[name]]; +}); +/** + * Returns the shortcut names list for a given category name. + * + * @param {Object} state Global state. + * @param {string} name Category name. + * + * @return {string[]} Shortcut names. + */ + +var getCategoryShortcuts = Object(rememo["a" /* default */])(function (state, categoryName) { + return Object.entries(state).filter(function (_ref) { + var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2), + shortcut = _ref2[1]; + + return shortcut.category === categoryName; + }).map(function (_ref3) { + var _ref4 = Object(slicedToArray["a" /* default */])(_ref3, 1), + name = _ref4[0]; + + return name; + }); +}, function (state) { + return [state]; +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/store/index.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + + +/* harmony default export */ var store = (Object(external_this_wp_data_["registerStore"])('core/keyboard-shortcuts', { + reducer: store_reducer, + actions: actions_namespaceObject, + selectors: selectors_namespaceObject +})); + +// EXTERNAL MODULE: external {"this":["wp","compose"]} +var external_this_wp_compose_ = __webpack_require__(9); + +// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/hooks/use-shortcut.js +/** + * WordPress dependencies + */ + + +/** + * Attach a keyboard shortcut handler. + * + * @param {string} name Shortcut name. + * @param {Function} callback Shortcut callback. + * @param {Object} options Shortcut options. + */ + +function useShortcut(name, callback, options) { + var shortcuts = Object(external_this_wp_data_["useSelect"])(function (select) { + return select('core/keyboard-shortcuts').getAllShortcutRawKeyCombinations(name); + }, [name]); + Object(external_this_wp_compose_["useKeyboardShortcut"])(shortcuts, callback, options); +} + +/* harmony default export */ var use_shortcut = (useShortcut); + +// CONCATENATED MODULE: ./node_modules/@wordpress/keyboard-shortcuts/build-module/index.js +/** + * Internal dependencies + */ + + + + +/***/ }), + +/***/ 5: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +/***/ }), + +/***/ 9: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["compose"]; }()); + +/***/ }) + +/******/ }); \ No newline at end of file