| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
1 this["wp"] = this["wp"] || {}; this["wp"]["compose"] = 2 /******/ (function(modules) { // webpackBootstrap 3 /******/ // The module cache 4 /******/ var installedModules = {}; 5 /******/ 6 /******/ // The require function 7 /******/ function __webpack_require__(moduleId) { 8 /******/ 9 /******/ // Check if module is in cache 10 /******/ if(installedModules[moduleId]) { 11 /******/ return installedModules[moduleId].exports; 12 /******/ } 13 /******/ // Create a new module (and put it into the cache) 14 /******/ var module = installedModules[moduleId] = { 15 /******/ i: moduleId, 16 /******/ l: false, 17 /******/ exports: {} 18 /******/ }; 19 /******/ 20 /******/ // Execute the module function 21 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22 /******/ 23 /******/ // Flag the module as loaded 24 /******/ module.l = true; 25 /******/ 26 /******/ // Return the exports of the module 27 /******/ return module.exports; 28 /******/ } 29 /******/ 30 /******/ 31 /******/ // expose the modules object (__webpack_modules__) 32 /******/ __webpack_require__.m = modules; 33 /******/ 34 /******/ // expose the module cache 35 /******/ __webpack_require__.c = installedModules; 36 /******/ 37 /******/ // define getter function for harmony exports 38 /******/ __webpack_require__.d = function(exports, name, getter) { 39 /******/ if(!__webpack_require__.o(exports, name)) { 40 /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41 /******/ } 42 /******/ }; 43 /******/ 44 /******/ // define __esModule on exports 45 /******/ __webpack_require__.r = function(exports) { 46 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48 /******/ } 49 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 50 /******/ }; 51 /******/ 52 /******/ // create a fake namespace object 53 /******/ // mode & 1: value is a module id, require it 54 /******/ // mode & 2: merge all properties of value into the ns 55 /******/ // mode & 4: return value when already ns object 56 /******/ // mode & 8|1: behave like require 57 /******/ __webpack_require__.t = function(value, mode) { 58 /******/ if(mode & 1) value = __webpack_require__(value); 59 /******/ if(mode & 8) return value; 60 /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61 /******/ var ns = Object.create(null); 62 /******/ __webpack_require__.r(ns); 63 /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64 /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65 /******/ return ns; 66 /******/ }; 67 /******/ 68 /******/ // getDefaultExport function for compatibility with non-harmony modules 69 /******/ __webpack_require__.n = function(module) { 70 /******/ var getter = module && module.__esModule ? 71 /******/ function getDefault() { return module['default']; } : 72 /******/ function getModuleExports() { return module; }; 73 /******/ __webpack_require__.d(getter, 'a', getter); 74 /******/ return getter; 75 /******/ }; 76 /******/ 77 /******/ // Object.prototype.hasOwnProperty.call 78 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79 /******/ 80 /******/ // __webpack_public_path__ 81 /******/ __webpack_require__.p = ""; 82 /******/ 83 /******/ 84 /******/ // Load entry module and return exports 85 /******/ return __webpack_require__(__webpack_require__.s = 456); 86 /******/ }) 87 /************************************************************************/ 88 /******/ ({ 89 90 /***/ 0: 91 /***/ (function(module, exports) { 92 93 (function() { module.exports = window["wp"]["element"]; }()); 94 95 /***/ }), 96 97 /***/ 12: 98 /***/ (function(module, __webpack_exports__, __webpack_require__) { 99 100 "use strict"; 101 102 // EXPORTS 103 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; }); 104 105 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js 106 var arrayWithHoles = __webpack_require__(38); 107 108 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js 109 function _iterableToArrayLimit(arr, i) { 110 var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); 111 112 if (_i == null) return; 113 var _arr = []; 114 var _n = true; 115 var _d = false; 116 117 var _s, _e; 118 119 try { 120 for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { 121 _arr.push(_s.value); 122 123 if (i && _arr.length === i) break; 124 } 125 } catch (err) { 126 _d = true; 127 _e = err; 128 } finally { 129 try { 130 if (!_n && _i["return"] != null) _i["return"](); 131 } finally { 132 if (_d) throw _e; 133 } 134 } 135 136 return _arr; 137 } 138 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 139 var unsupportedIterableToArray = __webpack_require__(28); 140 141 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js 142 var nonIterableRest = __webpack_require__(39); 143 144 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js 145 146 147 148 149 function _slicedToArray(arr, i) { 150 return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])(); 151 } 152 153 /***/ }), 154 155 /***/ 13: 156 /***/ (function(module, exports) { 157 158 (function() { module.exports = window["React"]; }()); 159 160 /***/ }), 161 162 /***/ 130: 163 /***/ (function(module, __webpack_exports__, __webpack_require__) { 164 165 "use strict"; 166 /* unused harmony export useCallback */ 167 /* unused harmony export useCallbackOne */ 168 /* unused harmony export useMemo */ 169 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useMemoOne; }); 170 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13); 171 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__); 172 173 174 function areInputsEqual(newInputs, lastInputs) { 175 if (newInputs.length !== lastInputs.length) { 176 return false; 177 } 178 179 for (var i = 0; i < newInputs.length; i++) { 180 if (newInputs[i] !== lastInputs[i]) { 181 return false; 182 } 183 } 184 185 return true; 186 } 187 188 function useMemoOne(getResult, inputs) { 189 var initial = Object(react__WEBPACK_IMPORTED_MODULE_0__["useState"])(function () { 190 return { 191 inputs: inputs, 192 result: getResult() 193 }; 194 })[0]; 195 var isFirstRun = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(true); 196 var committed = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(initial); 197 var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs)); 198 var cache = useCache ? committed.current : { 199 inputs: inputs, 200 result: getResult() 201 }; 202 Object(react__WEBPACK_IMPORTED_MODULE_0__["useEffect"])(function () { 203 isFirstRun.current = false; 204 committed.current = cache; 205 }, [cache]); 206 return cache.result; 207 } 208 function useCallbackOne(callback, inputs) { 209 return useMemoOne(function () { 210 return callback; 211 }, inputs); 212 } 213 var useMemo = useMemoOne; 214 var useCallback = useCallbackOne; 215 216 217 218 219 /***/ }), 220 221 /***/ 15: 222 /***/ (function(module, __webpack_exports__, __webpack_require__) { 223 224 "use strict"; 225 226 // EXPORTS 227 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; }); 228 229 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js 230 var arrayLikeToArray = __webpack_require__(24); 231 232 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js 233 234 function _arrayWithoutHoles(arr) { 235 if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr); 236 } 237 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js 238 var iterableToArray = __webpack_require__(42); 239 240 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 241 var unsupportedIterableToArray = __webpack_require__(28); 242 243 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js 244 function _nonIterableSpread() { 245 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 246 } 247 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js 248 249 250 251 252 function _toConsumableArray(arr) { 253 return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread(); 254 } 255 256 /***/ }), 257 258 /***/ 155: 259 /***/ (function(module, exports, __webpack_require__) { 260 261 var e=__webpack_require__(13),n={display:"block",opacity:0,position:"absolute",top:0,left:0,height:"100%",width:"100%",overflow:"hidden",pointerEvents:"none",zIndex:-1},t=function(t){var r=t.onResize,u=e.useRef();return function(n,t){var r=function(){return n.current&&n.current.contentDocument&&n.current.contentDocument.defaultView};function u(){t();var e=r();e&&e.addEventListener("resize",t)}e.useEffect((function(){return r()?u():n.current&&n.current.addEventListener&&n.current.addEventListener("load",u),function(){var e=r();e&&"function"==typeof e.removeEventListener&&e.removeEventListener("resize",t)}}),[])}(u,(function(){return r(u)})),e.createElement("iframe",{style:n,src:"about:blank",ref:u,"aria-hidden":!0,tabIndex:-1,frameBorder:0})},r=function(e){return{width:null!=e?e.offsetWidth:null,height:null!=e?e.offsetHeight:null}};module.exports=function(n){void 0===n&&(n=r);var u=e.useState(n(null)),o=u[0],i=u[1],c=e.useCallback((function(e){return i(n(e.current))}),[n]);return[e.useMemo((function(){return e.createElement(t,{onResize:c})}),[c]),o]}; 262 263 264 /***/ }), 265 266 /***/ 156: 267 /***/ (function(module, exports) { 268 269 (function() { module.exports = window["wp"]["priorityQueue"]; }()); 270 271 /***/ }), 272 273 /***/ 17: 274 /***/ (function(module, exports) { 275 276 (function() { module.exports = window["wp"]["keycodes"]; }()); 277 278 /***/ }), 279 280 /***/ 18: 281 /***/ (function(module, __webpack_exports__, __webpack_require__) { 282 283 "use strict"; 284 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; }); 285 function _assertThisInitialized(self) { 286 if (self === void 0) { 287 throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 288 } 289 290 return self; 291 } 292 293 /***/ }), 294 295 /***/ 188: 296 /***/ (function(module, exports, __webpack_require__) { 297 298 /*! 299 * clipboard.js v2.0.8 300 * https://clipboardjs.com/ 301 * 302 * Licensed MIT © Zeno Rocha 303 */ 304 (function webpackUniversalModuleDefinition(root, factory) { 305 if(true) 306 module.exports = factory(); 307 else {} 308 })(this, function() { 309 return /******/ (function() { // webpackBootstrap 310 /******/ var __webpack_modules__ = ({ 311 312 /***/ 134: 313 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 314 315 "use strict"; 316 317 // EXPORTS 318 __webpack_require__.d(__webpack_exports__, { 319 "default": function() { return /* binding */ clipboard; } 320 }); 321 322 // EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js 323 var tiny_emitter = __webpack_require__(279); 324 var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter); 325 // EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js 326 var listen = __webpack_require__(370); 327 var listen_default = /*#__PURE__*/__webpack_require__.n(listen); 328 // EXTERNAL MODULE: ./node_modules/select/src/select.js 329 var src_select = __webpack_require__(817); 330 var select_default = /*#__PURE__*/__webpack_require__.n(src_select); 331 ;// CONCATENATED MODULE: ./src/clipboard-action.js 332 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); } 333 334 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 335 336 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); } } 337 338 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } 339 340 341 /** 342 * Inner class which performs selection from either `text` or `target` 343 * properties and then executes copy or cut operations. 344 */ 345 346 var ClipboardAction = /*#__PURE__*/function () { 347 /** 348 * @param {Object} options 349 */ 350 function ClipboardAction(options) { 351 _classCallCheck(this, ClipboardAction); 352 353 this.resolveOptions(options); 354 this.initSelection(); 355 } 356 /** 357 * Defines base properties passed from constructor. 358 * @param {Object} options 359 */ 360 361 362 _createClass(ClipboardAction, [{ 363 key: "resolveOptions", 364 value: function resolveOptions() { 365 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 366 this.action = options.action; 367 this.container = options.container; 368 this.emitter = options.emitter; 369 this.target = options.target; 370 this.text = options.text; 371 this.trigger = options.trigger; 372 this.selectedText = ''; 373 } 374 /** 375 * Decides which selection strategy is going to be applied based 376 * on the existence of `text` and `target` properties. 377 */ 378 379 }, { 380 key: "initSelection", 381 value: function initSelection() { 382 if (this.text) { 383 this.selectFake(); 384 } else if (this.target) { 385 this.selectTarget(); 386 } 387 } 388 /** 389 * Creates a fake textarea element, sets its value from `text` property, 390 */ 391 392 }, { 393 key: "createFakeElement", 394 value: function createFakeElement() { 395 var isRTL = document.documentElement.getAttribute('dir') === 'rtl'; 396 this.fakeElem = document.createElement('textarea'); // Prevent zooming on iOS 397 398 this.fakeElem.style.fontSize = '12pt'; // Reset box model 399 400 this.fakeElem.style.border = '0'; 401 this.fakeElem.style.padding = '0'; 402 this.fakeElem.style.margin = '0'; // Move element out of screen horizontally 403 404 this.fakeElem.style.position = 'absolute'; 405 this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically 406 407 var yPosition = window.pageYOffset || document.documentElement.scrollTop; 408 this.fakeElem.style.top = "".concat(yPosition, "px"); 409 this.fakeElem.setAttribute('readonly', ''); 410 this.fakeElem.value = this.text; 411 return this.fakeElem; 412 } 413 /** 414 * Get's the value of fakeElem, 415 * and makes a selection on it. 416 */ 417 418 }, { 419 key: "selectFake", 420 value: function selectFake() { 421 var _this = this; 422 423 var fakeElem = this.createFakeElement(); 424 425 this.fakeHandlerCallback = function () { 426 return _this.removeFake(); 427 }; 428 429 this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true; 430 this.container.appendChild(fakeElem); 431 this.selectedText = select_default()(fakeElem); 432 this.copyText(); 433 this.removeFake(); 434 } 435 /** 436 * Only removes the fake element after another click event, that way 437 * a user can hit `Ctrl+C` to copy because selection still exists. 438 */ 439 440 }, { 441 key: "removeFake", 442 value: function removeFake() { 443 if (this.fakeHandler) { 444 this.container.removeEventListener('click', this.fakeHandlerCallback); 445 this.fakeHandler = null; 446 this.fakeHandlerCallback = null; 447 } 448 449 if (this.fakeElem) { 450 this.container.removeChild(this.fakeElem); 451 this.fakeElem = null; 452 } 453 } 454 /** 455 * Selects the content from element passed on `target` property. 456 */ 457 458 }, { 459 key: "selectTarget", 460 value: function selectTarget() { 461 this.selectedText = select_default()(this.target); 462 this.copyText(); 463 } 464 /** 465 * Executes the copy operation based on the current selection. 466 */ 467 468 }, { 469 key: "copyText", 470 value: function copyText() { 471 var succeeded; 472 473 try { 474 succeeded = document.execCommand(this.action); 475 } catch (err) { 476 succeeded = false; 477 } 478 479 this.handleResult(succeeded); 480 } 481 /** 482 * Fires an event based on the copy operation result. 483 * @param {Boolean} succeeded 484 */ 485 486 }, { 487 key: "handleResult", 488 value: function handleResult(succeeded) { 489 this.emitter.emit(succeeded ? 'success' : 'error', { 490 action: this.action, 491 text: this.selectedText, 492 trigger: this.trigger, 493 clearSelection: this.clearSelection.bind(this) 494 }); 495 } 496 /** 497 * Moves focus away from `target` and back to the trigger, removes current selection. 498 */ 499 500 }, { 501 key: "clearSelection", 502 value: function clearSelection() { 503 if (this.trigger) { 504 this.trigger.focus(); 505 } 506 507 document.activeElement.blur(); 508 window.getSelection().removeAllRanges(); 509 } 510 /** 511 * Sets the `action` to be performed which can be either 'copy' or 'cut'. 512 * @param {String} action 513 */ 514 515 }, { 516 key: "destroy", 517 518 /** 519 * Destroy lifecycle. 520 */ 521 value: function destroy() { 522 this.removeFake(); 523 } 524 }, { 525 key: "action", 526 set: function set() { 527 var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy'; 528 this._action = action; 529 530 if (this._action !== 'copy' && this._action !== 'cut') { 531 throw new Error('Invalid "action" value, use either "copy" or "cut"'); 532 } 533 } 534 /** 535 * Gets the `action` property. 536 * @return {String} 537 */ 538 , 539 get: function get() { 540 return this._action; 541 } 542 /** 543 * Sets the `target` property using an element 544 * that will be have its content copied. 545 * @param {Element} target 546 */ 547 548 }, { 549 key: "target", 550 set: function set(target) { 551 if (target !== undefined) { 552 if (target && _typeof(target) === 'object' && target.nodeType === 1) { 553 if (this.action === 'copy' && target.hasAttribute('disabled')) { 554 throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute'); 555 } 556 557 if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) { 558 throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes'); 559 } 560 561 this._target = target; 562 } else { 563 throw new Error('Invalid "target" value, use a valid Element'); 564 } 565 } 566 } 567 /** 568 * Gets the `target` property. 569 * @return {String|HTMLElement} 570 */ 571 , 572 get: function get() { 573 return this._target; 574 } 575 }]); 576 577 return ClipboardAction; 578 }(); 579 580 /* harmony default export */ var clipboard_action = (ClipboardAction); 581 ;// CONCATENATED MODULE: ./src/clipboard.js 582 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); } 583 584 function clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 585 586 function clipboard_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } 587 588 function clipboard_createClass(Constructor, protoProps, staticProps) { if (protoProps) clipboard_defineProperties(Constructor.prototype, protoProps); if (staticProps) clipboard_defineProperties(Constructor, staticProps); return Constructor; } 589 590 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); } 591 592 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } 593 594 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); }; } 595 596 function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } 597 598 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } 599 600 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; } } 601 602 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } 603 604 605 606 607 /** 608 * Helper function to retrieve attribute value. 609 * @param {String} suffix 610 * @param {Element} element 611 */ 612 613 function getAttributeValue(suffix, element) { 614 var attribute = "data-clipboard-".concat(suffix); 615 616 if (!element.hasAttribute(attribute)) { 617 return; 618 } 619 620 return element.getAttribute(attribute); 621 } 622 /** 623 * Base class which takes one or more elements, adds event listeners to them, 624 * and instantiates a new `ClipboardAction` on each click. 625 */ 626 627 628 var Clipboard = /*#__PURE__*/function (_Emitter) { 629 _inherits(Clipboard, _Emitter); 630 631 var _super = _createSuper(Clipboard); 632 633 /** 634 * @param {String|HTMLElement|HTMLCollection|NodeList} trigger 635 * @param {Object} options 636 */ 637 function Clipboard(trigger, options) { 638 var _this; 639 640 clipboard_classCallCheck(this, Clipboard); 641 642 _this = _super.call(this); 643 644 _this.resolveOptions(options); 645 646 _this.listenClick(trigger); 647 648 return _this; 649 } 650 /** 651 * Defines if attributes would be resolved using internal setter functions 652 * or custom functions that were passed in the constructor. 653 * @param {Object} options 654 */ 655 656 657 clipboard_createClass(Clipboard, [{ 658 key: "resolveOptions", 659 value: function resolveOptions() { 660 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 661 this.action = typeof options.action === 'function' ? options.action : this.defaultAction; 662 this.target = typeof options.target === 'function' ? options.target : this.defaultTarget; 663 this.text = typeof options.text === 'function' ? options.text : this.defaultText; 664 this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body; 665 } 666 /** 667 * Adds a click event listener to the passed trigger. 668 * @param {String|HTMLElement|HTMLCollection|NodeList} trigger 669 */ 670 671 }, { 672 key: "listenClick", 673 value: function listenClick(trigger) { 674 var _this2 = this; 675 676 this.listener = listen_default()(trigger, 'click', function (e) { 677 return _this2.onClick(e); 678 }); 679 } 680 /** 681 * Defines a new `ClipboardAction` on each click event. 682 * @param {Event} e 683 */ 684 685 }, { 686 key: "onClick", 687 value: function onClick(e) { 688 var trigger = e.delegateTarget || e.currentTarget; 689 690 if (this.clipboardAction) { 691 this.clipboardAction = null; 692 } 693 694 this.clipboardAction = new clipboard_action({ 695 action: this.action(trigger), 696 target: this.target(trigger), 697 text: this.text(trigger), 698 container: this.container, 699 trigger: trigger, 700 emitter: this 701 }); 702 } 703 /** 704 * Default `action` lookup function. 705 * @param {Element} trigger 706 */ 707 708 }, { 709 key: "defaultAction", 710 value: function defaultAction(trigger) { 711 return getAttributeValue('action', trigger); 712 } 713 /** 714 * Default `target` lookup function. 715 * @param {Element} trigger 716 */ 717 718 }, { 719 key: "defaultTarget", 720 value: function defaultTarget(trigger) { 721 var selector = getAttributeValue('target', trigger); 722 723 if (selector) { 724 return document.querySelector(selector); 725 } 726 } 727 /** 728 * Returns the support of the given action, or all actions if no action is 729 * given. 730 * @param {String} [action] 731 */ 732 733 }, { 734 key: "defaultText", 735 736 /** 737 * Default `text` lookup function. 738 * @param {Element} trigger 739 */ 740 value: function defaultText(trigger) { 741 return getAttributeValue('text', trigger); 742 } 743 /** 744 * Destroy lifecycle. 745 */ 746 747 }, { 748 key: "destroy", 749 value: function destroy() { 750 this.listener.destroy(); 751 752 if (this.clipboardAction) { 753 this.clipboardAction.destroy(); 754 this.clipboardAction = null; 755 } 756 } 757 }], [{ 758 key: "isSupported", 759 value: function isSupported() { 760 var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut']; 761 var actions = typeof action === 'string' ? [action] : action; 762 var support = !!document.queryCommandSupported; 763 actions.forEach(function (action) { 764 support = support && !!document.queryCommandSupported(action); 765 }); 766 return support; 767 } 768 }]); 769 770 return Clipboard; 771 }((tiny_emitter_default())); 772 773 /* harmony default export */ var clipboard = (Clipboard); 774 775 /***/ }), 776 777 /***/ 828: 778 /***/ (function(module) { 779 780 var DOCUMENT_NODE_TYPE = 9; 781 782 /** 783 * A polyfill for Element.matches() 784 */ 785 if (typeof Element !== 'undefined' && !Element.prototype.matches) { 786 var proto = Element.prototype; 787 788 proto.matches = proto.matchesSelector || 789 proto.mozMatchesSelector || 790 proto.msMatchesSelector || 791 proto.oMatchesSelector || 792 proto.webkitMatchesSelector; 793 } 794 795 /** 796 * Finds the closest parent that matches a selector. 797 * 798 * @param {Element} element 799 * @param {String} selector 800 * @return {Function} 801 */ 802 function closest (element, selector) { 803 while (element && element.nodeType !== DOCUMENT_NODE_TYPE) { 804 if (typeof element.matches === 'function' && 805 element.matches(selector)) { 806 return element; 807 } 808 element = element.parentNode; 809 } 810 } 811 812 module.exports = closest; 813 814 815 /***/ }), 816 817 /***/ 438: 818 /***/ (function(module, __unused_webpack_exports, __webpack_require__) { 819 820 var closest = __webpack_require__(828); 821 822 /** 823 * Delegates event to a selector. 824 * 825 * @param {Element} element 826 * @param {String} selector 827 * @param {String} type 828 * @param {Function} callback 829 * @param {Boolean} useCapture 830 * @return {Object} 831 */ 832 function _delegate(element, selector, type, callback, useCapture) { 833 var listenerFn = listener.apply(this, arguments); 834 835 element.addEventListener(type, listenerFn, useCapture); 836 837 return { 838 destroy: function() { 839 element.removeEventListener(type, listenerFn, useCapture); 840 } 841 } 842 } 843 844 /** 845 * Delegates event to a selector. 846 * 847 * @param {Element|String|Array} [elements] 848 * @param {String} selector 849 * @param {String} type 850 * @param {Function} callback 851 * @param {Boolean} useCapture 852 * @return {Object} 853 */ 854 function delegate(elements, selector, type, callback, useCapture) { 855 // Handle the regular Element usage 856 if (typeof elements.addEventListener === 'function') { 857 return _delegate.apply(null, arguments); 858 } 859 860 // Handle Element-less usage, it defaults to global delegation 861 if (typeof type === 'function') { 862 // Use `document` as the first parameter, then apply arguments 863 // This is a short way to .unshift `arguments` without running into deoptimizations 864 return _delegate.bind(null, document).apply(null, arguments); 865 } 866 867 // Handle Selector-based usage 868 if (typeof elements === 'string') { 869 elements = document.querySelectorAll(elements); 870 } 871 872 // Handle Array-like based usage 873 return Array.prototype.map.call(elements, function (element) { 874 return _delegate(element, selector, type, callback, useCapture); 875 }); 876 } 877 878 /** 879 * Finds closest match and invokes callback. 880 * 881 * @param {Element} element 882 * @param {String} selector 883 * @param {String} type 884 * @param {Function} callback 885 * @return {Function} 886 */ 887 function listener(element, selector, type, callback) { 888 return function(e) { 889 e.delegateTarget = closest(e.target, selector); 890 891 if (e.delegateTarget) { 892 callback.call(element, e); 893 } 894 } 895 } 896 897 module.exports = delegate; 898 899 900 /***/ }), 901 902 /***/ 879: 903 /***/ (function(__unused_webpack_module, exports) { 904 905 /** 906 * Check if argument is a HTML element. 907 * 908 * @param {Object} value 909 * @return {Boolean} 910 */ 911 exports.node = function(value) { 912 return value !== undefined 913 && value instanceof HTMLElement 914 && value.nodeType === 1; 915 }; 916 917 /** 918 * Check if argument is a list of HTML elements. 919 * 920 * @param {Object} value 921 * @return {Boolean} 922 */ 923 exports.nodeList = function(value) { 924 var type = Object.prototype.toString.call(value); 925 926 return value !== undefined 927 && (type === '[object NodeList]' || type === '[object HTMLCollection]') 928 && ('length' in value) 929 && (value.length === 0 || exports.node(value[0])); 930 }; 931 932 /** 933 * Check if argument is a string. 934 * 935 * @param {Object} value 936 * @return {Boolean} 937 */ 938 exports.string = function(value) { 939 return typeof value === 'string' 940 || value instanceof String; 941 }; 942 943 /** 944 * Check if argument is a function. 945 * 946 * @param {Object} value 947 * @return {Boolean} 948 */ 949 exports.fn = function(value) { 950 var type = Object.prototype.toString.call(value); 951 952 return type === '[object Function]'; 953 }; 954 955 956 /***/ }), 957 958 /***/ 370: 959 /***/ (function(module, __unused_webpack_exports, __webpack_require__) { 960 961 var is = __webpack_require__(879); 962 var delegate = __webpack_require__(438); 963 964 /** 965 * Validates all params and calls the right 966 * listener function based on its target type. 967 * 968 * @param {String|HTMLElement|HTMLCollection|NodeList} target 969 * @param {String} type 970 * @param {Function} callback 971 * @return {Object} 972 */ 973 function listen(target, type, callback) { 974 if (!target && !type && !callback) { 975 throw new Error('Missing required arguments'); 976 } 977 978 if (!is.string(type)) { 979 throw new TypeError('Second argument must be a String'); 980 } 981 982 if (!is.fn(callback)) { 983 throw new TypeError('Third argument must be a Function'); 984 } 985 986 if (is.node(target)) { 987 return listenNode(target, type, callback); 988 } 989 else if (is.nodeList(target)) { 990 return listenNodeList(target, type, callback); 991 } 992 else if (is.string(target)) { 993 return listenSelector(target, type, callback); 994 } 995 else { 996 throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList'); 997 } 998 } 999 1000 /** 1001 * Adds an event listener to a HTML element 1002 * and returns a remove listener function. 1003 * 1004 * @param {HTMLElement} node 1005 * @param {String} type 1006 * @param {Function} callback 1007 * @return {Object} 1008 */ 1009 function listenNode(node, type, callback) { 1010 node.addEventListener(type, callback); 1011 1012 return { 1013 destroy: function() { 1014 node.removeEventListener(type, callback); 1015 } 1016 } 1017 } 1018 1019 /** 1020 * Add an event listener to a list of HTML elements 1021 * and returns a remove listener function. 1022 * 1023 * @param {NodeList|HTMLCollection} nodeList 1024 * @param {String} type 1025 * @param {Function} callback 1026 * @return {Object} 1027 */ 1028 function listenNodeList(nodeList, type, callback) { 1029 Array.prototype.forEach.call(nodeList, function(node) { 1030 node.addEventListener(type, callback); 1031 }); 1032 1033 return { 1034 destroy: function() { 1035 Array.prototype.forEach.call(nodeList, function(node) { 1036 node.removeEventListener(type, callback); 1037 }); 1038 } 1039 } 1040 } 1041 1042 /** 1043 * Add an event listener to a selector 1044 * and returns a remove listener function. 1045 * 1046 * @param {String} selector 1047 * @param {String} type 1048 * @param {Function} callback 1049 * @return {Object} 1050 */ 1051 function listenSelector(selector, type, callback) { 1052 return delegate(document.body, selector, type, callback); 1053 } 1054 1055 module.exports = listen; 1056 1057 1058 /***/ }), 1059 1060 /***/ 817: 1061 /***/ (function(module) { 1062 1063 function select(element) { 1064 var selectedText; 1065 1066 if (element.nodeName === 'SELECT') { 1067 element.focus(); 1068 1069 selectedText = element.value; 1070 } 1071 else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') { 1072 var isReadOnly = element.hasAttribute('readonly'); 1073 1074 if (!isReadOnly) { 1075 element.setAttribute('readonly', ''); 1076 } 1077 1078 element.select(); 1079 element.setSelectionRange(0, element.value.length); 1080 1081 if (!isReadOnly) { 1082 element.removeAttribute('readonly'); 1083 } 1084 1085 selectedText = element.value; 1086 } 1087 else { 1088 if (element.hasAttribute('contenteditable')) { 1089 element.focus(); 1090 } 1091 1092 var selection = window.getSelection(); 1093 var range = document.createRange(); 1094 1095 range.selectNodeContents(element); 1096 selection.removeAllRanges(); 1097 selection.addRange(range); 1098 1099 selectedText = selection.toString(); 1100 } 1101 1102 return selectedText; 1103 } 1104 1105 module.exports = select; 1106 1107 1108 /***/ }), 1109 1110 /***/ 279: 1111 /***/ (function(module) { 1112 1113 function E () { 1114 // Keep this empty so it's easier to inherit from 1115 // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3) 1116 } 1117 1118 E.prototype = { 1119 on: function (name, callback, ctx) { 1120 var e = this.e || (this.e = {}); 1121 1122 (e[name] || (e[name] = [])).push({ 1123 fn: callback, 1124 ctx: ctx 1125 }); 1126 1127 return this; 1128 }, 1129 1130 once: function (name, callback, ctx) { 1131 var self = this; 1132 function listener () { 1133 self.off(name, listener); 1134 callback.apply(ctx, arguments); 1135 }; 1136 1137 listener._ = callback 1138 return this.on(name, listener, ctx); 1139 }, 1140 1141 emit: function (name) { 1142 var data = [].slice.call(arguments, 1); 1143 var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); 1144 var i = 0; 1145 var len = evtArr.length; 1146 1147 for (i; i < len; i++) { 1148 evtArr[i].fn.apply(evtArr[i].ctx, data); 1149 } 1150 1151 return this; 1152 }, 1153 1154 off: function (name, callback) { 1155 var e = this.e || (this.e = {}); 1156 var evts = e[name]; 1157 var liveEvents = []; 1158 1159 if (evts && callback) { 1160 for (var i = 0, len = evts.length; i < len; i++) { 1161 if (evts[i].fn !== callback && evts[i].fn._ !== callback) 1162 liveEvents.push(evts[i]); 1163 } 1164 } 1165 1166 // Remove event from queue to prevent memory leak 1167 // Suggested by https://github.com/lazd 1168 // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910 1169 1170 (liveEvents.length) 1171 ? e[name] = liveEvents 1172 : delete e[name]; 1173 1174 return this; 1175 } 1176 }; 1177 1178 module.exports = E; 1179 module.exports.TinyEmitter = E; 1180 1181 1182 /***/ }) 1183 1184 /******/ }); 1185 /************************************************************************/ 1186 /******/ // The module cache 1187 /******/ var __webpack_module_cache__ = {}; 1188 /******/ 1189 /******/ // The require function 1190 /******/ function __webpack_require__(moduleId) { 1191 /******/ // Check if module is in cache 1192 /******/ if(__webpack_module_cache__[moduleId]) { 1193 /******/ return __webpack_module_cache__[moduleId].exports; 1194 /******/ } 1195 /******/ // Create a new module (and put it into the cache) 1196 /******/ var module = __webpack_module_cache__[moduleId] = { 1197 /******/ // no module.id needed 1198 /******/ // no module.loaded needed 1199 /******/ exports: {} 1200 /******/ }; 1201 /******/ 1202 /******/ // Execute the module function 1203 /******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 1204 /******/ 1205 /******/ // Return the exports of the module 1206 /******/ return module.exports; 1207 /******/ } 1208 /******/ 1209 /************************************************************************/ 1210 /******/ /* webpack/runtime/compat get default export */ 1211 /******/ !function() { 1212 /******/ // getDefaultExport function for compatibility with non-harmony modules 1213 /******/ __webpack_require__.n = function(module) { 1214 /******/ var getter = module && module.__esModule ? 1215 /******/ function() { return module['default']; } : 1216 /******/ function() { return module; }; 1217 /******/ __webpack_require__.d(getter, { a: getter }); 1218 /******/ return getter; 1219 /******/ }; 1220 /******/ }(); 1221 /******/ 1222 /******/ /* webpack/runtime/define property getters */ 1223 /******/ !function() { 1224 /******/ // define getter functions for harmony exports 1225 /******/ __webpack_require__.d = function(exports, definition) { 1226 /******/ for(var key in definition) { 1227 /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 1228 /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 1229 /******/ } 1230 /******/ } 1231 /******/ }; 1232 /******/ }(); 1233 /******/ 1234 /******/ /* webpack/runtime/hasOwnProperty shorthand */ 1235 /******/ !function() { 1236 /******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } 1237 /******/ }(); 1238 /******/ 1239 /************************************************************************/ 1240 /******/ // module exports must be returned from runtime so entry inlining is disabled 1241 /******/ // startup 1242 /******/ // Load entry module and return exports 1243 /******/ return __webpack_require__(134); 1244 /******/ })() 1245 .default; 1246 }); 1247 1248 /***/ }), 1249 1250 /***/ 2: 1251 /***/ (function(module, exports) { 1252 1253 (function() { module.exports = window["lodash"]; }()); 1254 1255 /***/ }), 1256 1257 /***/ 22: 1258 /***/ (function(module, __webpack_exports__, __webpack_require__) { 1259 1260 "use strict"; 1261 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; }); 1262 function _getPrototypeOf(o) { 1263 _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { 1264 return o.__proto__ || Object.getPrototypeOf(o); 1265 }; 1266 return _getPrototypeOf(o); 1267 } 1268 1269 /***/ }), 1270 1271 /***/ 24: 1272 /***/ (function(module, __webpack_exports__, __webpack_require__) { 1273 1274 "use strict"; 1275 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; }); 1276 function _arrayLikeToArray(arr, len) { 1277 if (len == null || len > arr.length) len = arr.length; 1278 1279 for (var i = 0, arr2 = new Array(len); i < len; i++) { 1280 arr2[i] = arr[i]; 1281 } 1282 1283 return arr2; 1284 } 1285 1286 /***/ }), 1287 1288 /***/ 25: 1289 /***/ (function(module, __webpack_exports__, __webpack_require__) { 1290 1291 "use strict"; 1292 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; }); 1293 function _classCallCheck(instance, Constructor) { 1294 if (!(instance instanceof Constructor)) { 1295 throw new TypeError("Cannot call a class as a function"); 1296 } 1297 } 1298 1299 /***/ }), 1300 1301 /***/ 26: 1302 /***/ (function(module, __webpack_exports__, __webpack_require__) { 1303 1304 "use strict"; 1305 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; }); 1306 function _defineProperties(target, props) { 1307 for (var i = 0; i < props.length; i++) { 1308 var descriptor = props[i]; 1309 descriptor.enumerable = descriptor.enumerable || false; 1310 descriptor.configurable = true; 1311 if ("value" in descriptor) descriptor.writable = true; 1312 Object.defineProperty(target, descriptor.key, descriptor); 1313 } 1314 } 1315 1316 function _createClass(Constructor, protoProps, staticProps) { 1317 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 1318 if (staticProps) _defineProperties(Constructor, staticProps); 1319 return Constructor; 1320 } 1321 1322 /***/ }), 1323 1324 /***/ 27: 1325 /***/ (function(module, exports) { 1326 1327 (function() { module.exports = window["wp"]["dom"]; }()); 1328 1329 /***/ }), 1330 1331 /***/ 28: 1332 /***/ (function(module, __webpack_exports__, __webpack_require__) { 1333 1334 "use strict"; 1335 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; }); 1336 /* harmony import */ var _arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24); 1337 1338 function _unsupportedIterableToArray(o, minLen) { 1339 if (!o) return; 1340 if (typeof o === "string") return Object(_arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 1341 var n = Object.prototype.toString.call(o).slice(8, -1); 1342 if (n === "Object" && o.constructor) n = o.constructor.name; 1343 if (n === "Map" || n === "Set") return Array.from(o); 1344 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 1345 } 1346 1347 /***/ }), 1348 1349 /***/ 289: 1350 /***/ (function(module, exports, __webpack_require__) { 1351 1352 var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */ 1353 /** 1354 * Copyright 2012-2017 Craig Campbell 1355 * 1356 * Licensed under the Apache License, Version 2.0 (the "License"); 1357 * you may not use this file except in compliance with the License. 1358 * You may obtain a copy of the License at 1359 * 1360 * http://www.apache.org/licenses/LICENSE-2.0 1361 * 1362 * Unless required by applicable law or agreed to in writing, software 1363 * distributed under the License is distributed on an "AS IS" BASIS, 1364 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1365 * See the License for the specific language governing permissions and 1366 * limitations under the License. 1367 * 1368 * Mousetrap is a simple keyboard shortcut library for Javascript with 1369 * no external dependencies 1370 * 1371 * @version 1.6.5 1372 * @url craig.is/killing/mice 1373 */ 1374 (function(window, document, undefined) { 1375 1376 // Check if mousetrap is used inside browser, if not, return 1377 if (!window) { 1378 return; 1379 } 1380 1381 /** 1382 * mapping of special keycodes to their corresponding keys 1383 * 1384 * everything in this dictionary cannot use keypress events 1385 * so it has to be here to map to the correct keycodes for 1386 * keyup/keydown events 1387 * 1388 * @type {Object} 1389 */ 1390 var _MAP = { 1391 8: 'backspace', 1392 9: 'tab', 1393 13: 'enter', 1394 16: 'shift', 1395 17: 'ctrl', 1396 18: 'alt', 1397 20: 'capslock', 1398 27: 'esc', 1399 32: 'space', 1400 33: 'pageup', 1401 34: 'pagedown', 1402 35: 'end', 1403 36: 'home', 1404 37: 'left', 1405 38: 'up', 1406 39: 'right', 1407 40: 'down', 1408 45: 'ins', 1409 46: 'del', 1410 91: 'meta', 1411 93: 'meta', 1412 224: 'meta' 1413 }; 1414 1415 /** 1416 * mapping for special characters so they can support 1417 * 1418 * this dictionary is only used incase you want to bind a 1419 * keyup or keydown event to one of these keys 1420 * 1421 * @type {Object} 1422 */ 1423 var _KEYCODE_MAP = { 1424 106: '*', 1425 107: '+', 1426 109: '-', 1427 110: '.', 1428 111 : '/', 1429 186: ';', 1430 187: '=', 1431 188: ',', 1432 189: '-', 1433 190: '.', 1434 191: '/', 1435 192: '`', 1436 219: '[', 1437 220: '\\', 1438 221: ']', 1439 222: '\'' 1440 }; 1441 1442 /** 1443 * this is a mapping of keys that require shift on a US keypad 1444 * back to the non shift equivelents 1445 * 1446 * this is so you can use keyup events with these keys 1447 * 1448 * note that this will only work reliably on US keyboards 1449 * 1450 * @type {Object} 1451 */ 1452 var _SHIFT_MAP = { 1453 '~': '`', 1454 '!': '1', 1455 '@': '2', 1456 '#': '3', 1457 '$': '4', 1458 '%': '5', 1459 '^': '6', 1460 '&': '7', 1461 '*': '8', 1462 '(': '9', 1463 ')': '0', 1464 '_': '-', 1465 '+': '=', 1466 ':': ';', 1467 '\"': '\'', 1468 '<': ',', 1469 '>': '.', 1470 '?': '/', 1471 '|': '\\' 1472 }; 1473 1474 /** 1475 * this is a list of special strings you can use to map 1476 * to modifier keys when you specify your keyboard shortcuts 1477 * 1478 * @type {Object} 1479 */ 1480 var _SPECIAL_ALIASES = { 1481 'option': 'alt', 1482 'command': 'meta', 1483 'return': 'enter', 1484 'escape': 'esc', 1485 'plus': '+', 1486 'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl' 1487 }; 1488 1489 /** 1490 * variable to store the flipped version of _MAP from above 1491 * needed to check if we should use keypress or not when no action 1492 * is specified 1493 * 1494 * @type {Object|undefined} 1495 */ 1496 var _REVERSE_MAP; 1497 1498 /** 1499 * loop through the f keys, f1 to f19 and add them to the map 1500 * programatically 1501 */ 1502 for (var i = 1; i < 20; ++i) { 1503 _MAP[111 + i] = 'f' + i; 1504 } 1505 1506 /** 1507 * loop through to map numbers on the numeric keypad 1508 */ 1509 for (i = 0; i <= 9; ++i) { 1510 1511 // This needs to use a string cause otherwise since 0 is falsey 1512 // mousetrap will never fire for numpad 0 pressed as part of a keydown 1513 // event. 1514 // 1515 // @see https://github.com/ccampbell/mousetrap/pull/258 1516 _MAP[i + 96] = i.toString(); 1517 } 1518 1519 /** 1520 * cross browser add event method 1521 * 1522 * @param {Element|HTMLDocument} object 1523 * @param {string} type 1524 * @param {Function} callback 1525 * @returns void 1526 */ 1527 function _addEvent(object, type, callback) { 1528 if (object.addEventListener) { 1529 object.addEventListener(type, callback, false); 1530 return; 1531 } 1532 1533 object.attachEvent('on' + type, callback); 1534 } 1535 1536 /** 1537 * takes the event and returns the key character 1538 * 1539 * @param {Event} e 1540 * @return {string} 1541 */ 1542 function _characterFromEvent(e) { 1543 1544 // for keypress events we should return the character as is 1545 if (e.type == 'keypress') { 1546 var character = String.fromCharCode(e.which); 1547 1548 // if the shift key is not pressed then it is safe to assume 1549 // that we want the character to be lowercase. this means if 1550 // you accidentally have caps lock on then your key bindings 1551 // will continue to work 1552 // 1553 // the only side effect that might not be desired is if you 1554 // bind something like 'A' cause you want to trigger an 1555 // event when capital A is pressed caps lock will no longer 1556 // trigger the event. shift+a will though. 1557 if (!e.shiftKey) { 1558 character = character.toLowerCase(); 1559 } 1560 1561 return character; 1562 } 1563 1564 // for non keypress events the special maps are needed 1565 if (_MAP[e.which]) { 1566 return _MAP[e.which]; 1567 } 1568 1569 if (_KEYCODE_MAP[e.which]) { 1570 return _KEYCODE_MAP[e.which]; 1571 } 1572 1573 // if it is not in the special map 1574 1575 // with keydown and keyup events the character seems to always 1576 // come in as an uppercase character whether you are pressing shift 1577 // or not. we should make sure it is always lowercase for comparisons 1578 return String.fromCharCode(e.which).toLowerCase(); 1579 } 1580 1581 /** 1582 * checks if two arrays are equal 1583 * 1584 * @param {Array} modifiers1 1585 * @param {Array} modifiers2 1586 * @returns {boolean} 1587 */ 1588 function _modifiersMatch(modifiers1, modifiers2) { 1589 return modifiers1.sort().join(',') === modifiers2.sort().join(','); 1590 } 1591 1592 /** 1593 * takes a key event and figures out what the modifiers are 1594 * 1595 * @param {Event} e 1596 * @returns {Array} 1597 */ 1598 function _eventModifiers(e) { 1599 var modifiers = []; 1600 1601 if (e.shiftKey) { 1602 modifiers.push('shift'); 1603 } 1604 1605 if (e.altKey) { 1606 modifiers.push('alt'); 1607 } 1608 1609 if (e.ctrlKey) { 1610 modifiers.push('ctrl'); 1611 } 1612 1613 if (e.metaKey) { 1614 modifiers.push('meta'); 1615 } 1616 1617 return modifiers; 1618 } 1619 1620 /** 1621 * prevents default for this event 1622 * 1623 * @param {Event} e 1624 * @returns void 1625 */ 1626 function _preventDefault(e) { 1627 if (e.preventDefault) { 1628 e.preventDefault(); 1629 return; 1630 } 1631 1632 e.returnValue = false; 1633 } 1634 1635 /** 1636 * stops propogation for this event 1637 * 1638 * @param {Event} e 1639 * @returns void 1640 */ 1641 function _stopPropagation(e) { 1642 if (e.stopPropagation) { 1643 e.stopPropagation(); 1644 return; 1645 } 1646 1647 e.cancelBubble = true; 1648 } 1649 1650 /** 1651 * determines if the keycode specified is a modifier key or not 1652 * 1653 * @param {string} key 1654 * @returns {boolean} 1655 */ 1656 function _isModifier(key) { 1657 return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta'; 1658 } 1659 1660 /** 1661 * reverses the map lookup so that we can look for specific keys 1662 * to see what can and can't use keypress 1663 * 1664 * @return {Object} 1665 */ 1666 function _getReverseMap() { 1667 if (!_REVERSE_MAP) { 1668 _REVERSE_MAP = {}; 1669 for (var key in _MAP) { 1670 1671 // pull out the numeric keypad from here cause keypress should 1672 // be able to detect the keys from the character 1673 if (key > 95 && key < 112) { 1674 continue; 1675 } 1676 1677 if (_MAP.hasOwnProperty(key)) { 1678 _REVERSE_MAP[_MAP[key]] = key; 1679 } 1680 } 1681 } 1682 return _REVERSE_MAP; 1683 } 1684 1685 /** 1686 * picks the best action based on the key combination 1687 * 1688 * @param {string} key - character for key 1689 * @param {Array} modifiers 1690 * @param {string=} action passed in 1691 */ 1692 function _pickBestAction(key, modifiers, action) { 1693 1694 // if no action was picked in we should try to pick the one 1695 // that we think would work best for this key 1696 if (!action) { 1697 action = _getReverseMap()[key] ? 'keydown' : 'keypress'; 1698 } 1699 1700 // modifier keys don't work as expected with keypress, 1701 // switch to keydown 1702 if (action == 'keypress' && modifiers.length) { 1703 action = 'keydown'; 1704 } 1705 1706 return action; 1707 } 1708 1709 /** 1710 * Converts from a string key combination to an array 1711 * 1712 * @param {string} combination like "command+shift+l" 1713 * @return {Array} 1714 */ 1715 function _keysFromString(combination) { 1716 if (combination === '+') { 1717 return ['+']; 1718 } 1719 1720 combination = combination.replace(/\+{2}/g, '+plus'); 1721 return combination.split('+'); 1722 } 1723 1724 /** 1725 * Gets info for a specific key combination 1726 * 1727 * @param {string} combination key combination ("command+s" or "a" or "*") 1728 * @param {string=} action 1729 * @returns {Object} 1730 */ 1731 function _getKeyInfo(combination, action) { 1732 var keys; 1733 var key; 1734 var i; 1735 var modifiers = []; 1736 1737 // take the keys from this pattern and figure out what the actual 1738 // pattern is all about 1739 keys = _keysFromString(combination); 1740 1741 for (i = 0; i < keys.length; ++i) { 1742 key = keys[i]; 1743 1744 // normalize key names 1745 if (_SPECIAL_ALIASES[key]) { 1746 key = _SPECIAL_ALIASES[key]; 1747 } 1748 1749 // if this is not a keypress event then we should 1750 // be smart about using shift keys 1751 // this will only work for US keyboards however 1752 if (action && action != 'keypress' && _SHIFT_MAP[key]) { 1753 key = _SHIFT_MAP[key]; 1754 modifiers.push('shift'); 1755 } 1756 1757 // if this key is a modifier then add it to the list of modifiers 1758 if (_isModifier(key)) { 1759 modifiers.push(key); 1760 } 1761 } 1762 1763 // depending on what the key combination is 1764 // we will try to pick the best event for it 1765 action = _pickBestAction(key, modifiers, action); 1766 1767 return { 1768 key: key, 1769 modifiers: modifiers, 1770 action: action 1771 }; 1772 } 1773 1774 function _belongsTo(element, ancestor) { 1775 if (element === null || element === document) { 1776 return false; 1777 } 1778 1779 if (element === ancestor) { 1780 return true; 1781 } 1782 1783 return _belongsTo(element.parentNode, ancestor); 1784 } 1785 1786 function Mousetrap(targetElement) { 1787 var self = this; 1788 1789 targetElement = targetElement || document; 1790 1791 if (!(self instanceof Mousetrap)) { 1792 return new Mousetrap(targetElement); 1793 } 1794 1795 /** 1796 * element to attach key events to 1797 * 1798 * @type {Element} 1799 */ 1800 self.target = targetElement; 1801 1802 /** 1803 * a list of all the callbacks setup via Mousetrap.bind() 1804 * 1805 * @type {Object} 1806 */ 1807 self._callbacks = {}; 1808 1809 /** 1810 * direct map of string combinations to callbacks used for trigger() 1811 * 1812 * @type {Object} 1813 */ 1814 self._directMap = {}; 1815 1816 /** 1817 * keeps track of what level each sequence is at since multiple 1818 * sequences can start out with the same sequence 1819 * 1820 * @type {Object} 1821 */ 1822 var _sequenceLevels = {}; 1823 1824 /** 1825 * variable to store the setTimeout call 1826 * 1827 * @type {null|number} 1828 */ 1829 var _resetTimer; 1830 1831 /** 1832 * temporary state where we will ignore the next keyup 1833 * 1834 * @type {boolean|string} 1835 */ 1836 var _ignoreNextKeyup = false; 1837 1838 /** 1839 * temporary state where we will ignore the next keypress 1840 * 1841 * @type {boolean} 1842 */ 1843 var _ignoreNextKeypress = false; 1844 1845 /** 1846 * are we currently inside of a sequence? 1847 * type of action ("keyup" or "keydown" or "keypress") or false 1848 * 1849 * @type {boolean|string} 1850 */ 1851 var _nextExpectedAction = false; 1852 1853 /** 1854 * resets all sequence counters except for the ones passed in 1855 * 1856 * @param {Object} doNotReset 1857 * @returns void 1858 */ 1859 function _resetSequences(doNotReset) { 1860 doNotReset = doNotReset || {}; 1861 1862 var activeSequences = false, 1863 key; 1864 1865 for (key in _sequenceLevels) { 1866 if (doNotReset[key]) { 1867 activeSequences = true; 1868 continue; 1869 } 1870 _sequenceLevels[key] = 0; 1871 } 1872 1873 if (!activeSequences) { 1874 _nextExpectedAction = false; 1875 } 1876 } 1877 1878 /** 1879 * finds all callbacks that match based on the keycode, modifiers, 1880 * and action 1881 * 1882 * @param {string} character 1883 * @param {Array} modifiers 1884 * @param {Event|Object} e 1885 * @param {string=} sequenceName - name of the sequence we are looking for 1886 * @param {string=} combination 1887 * @param {number=} level 1888 * @returns {Array} 1889 */ 1890 function _getMatches(character, modifiers, e, sequenceName, combination, level) { 1891 var i; 1892 var callback; 1893 var matches = []; 1894 var action = e.type; 1895 1896 // if there are no events related to this keycode 1897 if (!self._callbacks[character]) { 1898 return []; 1899 } 1900 1901 // if a modifier key is coming up on its own we should allow it 1902 if (action == 'keyup' && _isModifier(character)) { 1903 modifiers = [character]; 1904 } 1905 1906 // loop through all callbacks for the key that was pressed 1907 // and see if any of them match 1908 for (i = 0; i < self._callbacks[character].length; ++i) { 1909 callback = self._callbacks[character][i]; 1910 1911 // if a sequence name is not specified, but this is a sequence at 1912 // the wrong level then move onto the next match 1913 if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) { 1914 continue; 1915 } 1916 1917 // if the action we are looking for doesn't match the action we got 1918 // then we should keep going 1919 if (action != callback.action) { 1920 continue; 1921 } 1922 1923 // if this is a keypress event and the meta key and control key 1924 // are not pressed that means that we need to only look at the 1925 // character, otherwise check the modifiers as well 1926 // 1927 // chrome will not fire a keypress if meta or control is down 1928 // safari will fire a keypress if meta or meta+shift is down 1929 // firefox will fire a keypress if meta or control is down 1930 if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) { 1931 1932 // when you bind a combination or sequence a second time it 1933 // should overwrite the first one. if a sequenceName or 1934 // combination is specified in this call it does just that 1935 // 1936 // @todo make deleting its own method? 1937 var deleteCombo = !sequenceName && callback.combo == combination; 1938 var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level; 1939 if (deleteCombo || deleteSequence) { 1940 self._callbacks[character].splice(i, 1); 1941 } 1942 1943 matches.push(callback); 1944 } 1945 } 1946 1947 return matches; 1948 } 1949 1950 /** 1951 * actually calls the callback function 1952 * 1953 * if your callback function returns false this will use the jquery 1954 * convention - prevent default and stop propogation on the event 1955 * 1956 * @param {Function} callback 1957 * @param {Event} e 1958 * @returns void 1959 */ 1960 function _fireCallback(callback, e, combo, sequence) { 1961 1962 // if this event should not happen stop here 1963 if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) { 1964 return; 1965 } 1966 1967 if (callback(e, combo) === false) { 1968 _preventDefault(e); 1969 _stopPropagation(e); 1970 } 1971 } 1972 1973 /** 1974 * handles a character key event 1975 * 1976 * @param {string} character 1977 * @param {Array} modifiers 1978 * @param {Event} e 1979 * @returns void 1980 */ 1981 self._handleKey = function(character, modifiers, e) { 1982 var callbacks = _getMatches(character, modifiers, e); 1983 var i; 1984 var doNotReset = {}; 1985 var maxLevel = 0; 1986 var processedSequenceCallback = false; 1987 1988 // Calculate the maxLevel for sequences so we can only execute the longest callback sequence 1989 for (i = 0; i < callbacks.length; ++i) { 1990 if (callbacks[i].seq) { 1991 maxLevel = Math.max(maxLevel, callbacks[i].level); 1992 } 1993 } 1994 1995 // loop through matching callbacks for this key event 1996 for (i = 0; i < callbacks.length; ++i) { 1997 1998 // fire for all sequence callbacks 1999 // this is because if for example you have multiple sequences 2000 // bound such as "g i" and "g t" they both need to fire the 2001 // callback for matching g cause otherwise you can only ever 2002 // match the first one 2003 if (callbacks[i].seq) { 2004 2005 // only fire callbacks for the maxLevel to prevent 2006 // subsequences from also firing 2007 // 2008 // for example 'a option b' should not cause 'option b' to fire 2009 // even though 'option b' is part of the other sequence 2010 // 2011 // any sequences that do not match here will be discarded 2012 // below by the _resetSequences call 2013 if (callbacks[i].level != maxLevel) { 2014 continue; 2015 } 2016 2017 processedSequenceCallback = true; 2018 2019 // keep a list of which sequences were matches for later 2020 doNotReset[callbacks[i].seq] = 1; 2021 _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq); 2022 continue; 2023 } 2024 2025 // if there were no sequence matches but we are still here 2026 // that means this is a regular match so we should fire that 2027 if (!processedSequenceCallback) { 2028 _fireCallback(callbacks[i].callback, e, callbacks[i].combo); 2029 } 2030 } 2031 2032 // if the key you pressed matches the type of sequence without 2033 // being a modifier (ie "keyup" or "keypress") then we should 2034 // reset all sequences that were not matched by this event 2035 // 2036 // this is so, for example, if you have the sequence "h a t" and you 2037 // type "h e a r t" it does not match. in this case the "e" will 2038 // cause the sequence to reset 2039 // 2040 // modifier keys are ignored because you can have a sequence 2041 // that contains modifiers such as "enter ctrl+space" and in most 2042 // cases the modifier key will be pressed before the next key 2043 // 2044 // also if you have a sequence such as "ctrl+b a" then pressing the 2045 // "b" key will trigger a "keypress" and a "keydown" 2046 // 2047 // the "keydown" is expected when there is a modifier, but the 2048 // "keypress" ends up matching the _nextExpectedAction since it occurs 2049 // after and that causes the sequence to reset 2050 // 2051 // we ignore keypresses in a sequence that directly follow a keydown 2052 // for the same character 2053 var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress; 2054 if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) { 2055 _resetSequences(doNotReset); 2056 } 2057 2058 _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown'; 2059 }; 2060 2061 /** 2062 * handles a keydown event 2063 * 2064 * @param {Event} e 2065 * @returns void 2066 */ 2067 function _handleKeyEvent(e) { 2068 2069 // normalize e.which for key events 2070 // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion 2071 if (typeof e.which !== 'number') { 2072 e.which = e.keyCode; 2073 } 2074 2075 var character = _characterFromEvent(e); 2076 2077 // no character found then stop 2078 if (!character) { 2079 return; 2080 } 2081 2082 // need to use === for the character check because the character can be 0 2083 if (e.type == 'keyup' && _ignoreNextKeyup === character) { 2084 _ignoreNextKeyup = false; 2085 return; 2086 } 2087 2088 self.handleKey(character, _eventModifiers(e), e); 2089 } 2090 2091 /** 2092 * called to set a 1 second timeout on the specified sequence 2093 * 2094 * this is so after each key press in the sequence you have 1 second 2095 * to press the next key before you have to start over 2096 * 2097 * @returns void 2098 */ 2099 function _resetSequenceTimer() { 2100 clearTimeout(_resetTimer); 2101 _resetTimer = setTimeout(_resetSequences, 1000); 2102 } 2103 2104 /** 2105 * binds a key sequence to an event 2106 * 2107 * @param {string} combo - combo specified in bind call 2108 * @param {Array} keys 2109 * @param {Function} callback 2110 * @param {string=} action 2111 * @returns void 2112 */ 2113 function _bindSequence(combo, keys, callback, action) { 2114 2115 // start off by adding a sequence level record for this combination 2116 // and setting the level to 0 2117 _sequenceLevels[combo] = 0; 2118 2119 /** 2120 * callback to increase the sequence level for this sequence and reset 2121 * all other sequences that were active 2122 * 2123 * @param {string} nextAction 2124 * @returns {Function} 2125 */ 2126 function _increaseSequence(nextAction) { 2127 return function() { 2128 _nextExpectedAction = nextAction; 2129 ++_sequenceLevels[combo]; 2130 _resetSequenceTimer(); 2131 }; 2132 } 2133 2134 /** 2135 * wraps the specified callback inside of another function in order 2136 * to reset all sequence counters as soon as this sequence is done 2137 * 2138 * @param {Event} e 2139 * @returns void 2140 */ 2141 function _callbackAndReset(e) { 2142 _fireCallback(callback, e, combo); 2143 2144 // we should ignore the next key up if the action is key down 2145 // or keypress. this is so if you finish a sequence and 2146 // release the key the final key will not trigger a keyup 2147 if (action !== 'keyup') { 2148 _ignoreNextKeyup = _characterFromEvent(e); 2149 } 2150 2151 // weird race condition if a sequence ends with the key 2152 // another sequence begins with 2153 setTimeout(_resetSequences, 10); 2154 } 2155 2156 // loop through keys one at a time and bind the appropriate callback 2157 // function. for any key leading up to the final one it should 2158 // increase the sequence. after the final, it should reset all sequences 2159 // 2160 // if an action is specified in the original bind call then that will 2161 // be used throughout. otherwise we will pass the action that the 2162 // next key in the sequence should match. this allows a sequence 2163 // to mix and match keypress and keydown events depending on which 2164 // ones are better suited to the key provided 2165 for (var i = 0; i < keys.length; ++i) { 2166 var isFinal = i + 1 === keys.length; 2167 var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action); 2168 _bindSingle(keys[i], wrappedCallback, action, combo, i); 2169 } 2170 } 2171 2172 /** 2173 * binds a single keyboard combination 2174 * 2175 * @param {string} combination 2176 * @param {Function} callback 2177 * @param {string=} action 2178 * @param {string=} sequenceName - name of sequence if part of sequence 2179 * @param {number=} level - what part of the sequence the command is 2180 * @returns void 2181 */ 2182 function _bindSingle(combination, callback, action, sequenceName, level) { 2183 2184 // store a direct mapped reference for use with Mousetrap.trigger 2185 self._directMap[combination + ':' + action] = callback; 2186 2187 // make sure multiple spaces in a row become a single space 2188 combination = combination.replace(/\s+/g, ' '); 2189 2190 var sequence = combination.split(' '); 2191 var info; 2192 2193 // if this pattern is a sequence of keys then run through this method 2194 // to reprocess each pattern one key at a time 2195 if (sequence.length > 1) { 2196 _bindSequence(combination, sequence, callback, action); 2197 return; 2198 } 2199 2200 info = _getKeyInfo(combination, action); 2201 2202 // make sure to initialize array if this is the first time 2203 // a callback is added for this key 2204 self._callbacks[info.key] = self._callbacks[info.key] || []; 2205 2206 // remove an existing match if there is one 2207 _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level); 2208 2209 // add this call back to the array 2210 // if it is a sequence put it at the beginning 2211 // if not put it at the end 2212 // 2213 // this is important because the way these are processed expects 2214 // the sequence ones to come first 2215 self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({ 2216 callback: callback, 2217 modifiers: info.modifiers, 2218 action: info.action, 2219 seq: sequenceName, 2220 level: level, 2221 combo: combination 2222 }); 2223 } 2224 2225 /** 2226 * binds multiple combinations to the same callback 2227 * 2228 * @param {Array} combinations 2229 * @param {Function} callback 2230 * @param {string|undefined} action 2231 * @returns void 2232 */ 2233 self._bindMultiple = function(combinations, callback, action) { 2234 for (var i = 0; i < combinations.length; ++i) { 2235 _bindSingle(combinations[i], callback, action); 2236 } 2237 }; 2238 2239 // start! 2240 _addEvent(targetElement, 'keypress', _handleKeyEvent); 2241 _addEvent(targetElement, 'keydown', _handleKeyEvent); 2242 _addEvent(targetElement, 'keyup', _handleKeyEvent); 2243 } 2244 2245 /** 2246 * binds an event to mousetrap 2247 * 2248 * can be a single key, a combination of keys separated with +, 2249 * an array of keys, or a sequence of keys separated by spaces 2250 * 2251 * be sure to list the modifier keys first to make sure that the 2252 * correct key ends up getting bound (the last key in the pattern) 2253 * 2254 * @param {string|Array} keys 2255 * @param {Function} callback 2256 * @param {string=} action - 'keypress', 'keydown', or 'keyup' 2257 * @returns void 2258 */ 2259 Mousetrap.prototype.bind = function(keys, callback, action) { 2260 var self = this; 2261 keys = keys instanceof Array ? keys : [keys]; 2262 self._bindMultiple.call(self, keys, callback, action); 2263 return self; 2264 }; 2265 2266 /** 2267 * unbinds an event to mousetrap 2268 * 2269 * the unbinding sets the callback function of the specified key combo 2270 * to an empty function and deletes the corresponding key in the 2271 * _directMap dict. 2272 * 2273 * TODO: actually remove this from the _callbacks dictionary instead 2274 * of binding an empty function 2275 * 2276 * the keycombo+action has to be exactly the same as 2277 * it was defined in the bind method 2278 * 2279 * @param {string|Array} keys 2280 * @param {string} action 2281 * @returns void 2282 */ 2283 Mousetrap.prototype.unbind = function(keys, action) { 2284 var self = this; 2285 return self.bind.call(self, keys, function() {}, action); 2286 }; 2287 2288 /** 2289 * triggers an event that has already been bound 2290 * 2291 * @param {string} keys 2292 * @param {string=} action 2293 * @returns void 2294 */ 2295 Mousetrap.prototype.trigger = function(keys, action) { 2296 var self = this; 2297 if (self._directMap[keys + ':' + action]) { 2298 self._directMap[keys + ':' + action]({}, keys); 2299 } 2300 return self; 2301 }; 2302 2303 /** 2304 * resets the library back to its initial state. this is useful 2305 * if you want to clear out the current keyboard shortcuts and bind 2306 * new ones - for example if you switch to another page 2307 * 2308 * @returns void 2309 */ 2310 Mousetrap.prototype.reset = function() { 2311 var self = this; 2312 self._callbacks = {}; 2313 self._directMap = {}; 2314 return self; 2315 }; 2316 2317 /** 2318 * should we stop this event before firing off callbacks 2319 * 2320 * @param {Event} e 2321 * @param {Element} element 2322 * @return {boolean} 2323 */ 2324 Mousetrap.prototype.stopCallback = function(e, element) { 2325 var self = this; 2326 2327 // if the element has the class "mousetrap" then no need to stop 2328 if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) { 2329 return false; 2330 } 2331 2332 if (_belongsTo(element, self.target)) { 2333 return false; 2334 } 2335 2336 // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host, 2337 // not the initial event target in the shadow tree. Note that not all events cross the 2338 // shadow boundary. 2339 // For shadow trees with `mode: 'open'`, the initial event target is the first element in 2340 // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event 2341 // target cannot be obtained. 2342 if ('composedPath' in e && typeof e.composedPath === 'function') { 2343 // For open shadow trees, update `element` so that the following check works. 2344 var initialEventTarget = e.composedPath()[0]; 2345 if (initialEventTarget !== e.target) { 2346 element = initialEventTarget; 2347 } 2348 } 2349 2350 // stop for input, select, and textarea 2351 return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable; 2352 }; 2353 2354 /** 2355 * exposes _handleKey publicly so it can be overwritten by extensions 2356 */ 2357 Mousetrap.prototype.handleKey = function() { 2358 var self = this; 2359 return self._handleKey.apply(self, arguments); 2360 }; 2361 2362 /** 2363 * allow custom key mappings 2364 */ 2365 Mousetrap.addKeycodes = function(object) { 2366 for (var key in object) { 2367 if (object.hasOwnProperty(key)) { 2368 _MAP[key] = object[key]; 2369 } 2370 } 2371 _REVERSE_MAP = null; 2372 }; 2373 2374 /** 2375 * Init the global mousetrap functions 2376 * 2377 * This method is needed to allow the global mousetrap functions to work 2378 * now that mousetrap is a constructor function. 2379 */ 2380 Mousetrap.init = function() { 2381 var documentMousetrap = Mousetrap(document); 2382 for (var method in documentMousetrap) { 2383 if (method.charAt(0) !== '_') { 2384 Mousetrap[method] = (function(method) { 2385 return function() { 2386 return documentMousetrap[method].apply(documentMousetrap, arguments); 2387 }; 2388 } (method)); 2389 } 2390 } 2391 }; 2392 2393 Mousetrap.init(); 2394 2395 // expose mousetrap to the global object 2396 window.Mousetrap = Mousetrap; 2397 2398 // expose as a common js module 2399 if ( true && module.exports) { 2400 module.exports = Mousetrap; 2401 } 2402 2403 // expose mousetrap as an AMD module 2404 if (true) { 2405 !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { 2406 return Mousetrap; 2407 }).call(exports, __webpack_require__, exports, module), 2408 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2409 } 2410 }) (typeof window !== 'undefined' ? window : null, typeof window !== 'undefined' ? document : null); 2411 2412 2413 /***/ }), 2414 2415 /***/ 33: 2416 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2417 2418 "use strict"; 2419 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; }); 2420 /* harmony import */ var _setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55); 2421 2422 function _inherits(subClass, superClass) { 2423 if (typeof superClass !== "function" && superClass !== null) { 2424 throw new TypeError("Super expression must either be null or a function"); 2425 } 2426 2427 subClass.prototype = Object.create(superClass && superClass.prototype, { 2428 constructor: { 2429 value: subClass, 2430 writable: true, 2431 configurable: true 2432 } 2433 }); 2434 if (superClass) Object(_setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(subClass, superClass); 2435 } 2436 2437 /***/ }), 2438 2439 /***/ 34: 2440 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2441 2442 "use strict"; 2443 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; }); 2444 /* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59); 2445 /* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__); 2446 /* harmony import */ var _assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18); 2447 2448 2449 function _possibleConstructorReturn(self, call) { 2450 if (call && (_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default()(call) === "object" || typeof call === "function")) { 2451 return call; 2452 } 2453 2454 return Object(_assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self); 2455 } 2456 2457 /***/ }), 2458 2459 /***/ 35: 2460 /***/ (function(module, exports) { 2461 2462 (function() { module.exports = window["wp"]["deprecated"]; }()); 2463 2464 /***/ }), 2465 2466 /***/ 38: 2467 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2468 2469 "use strict"; 2470 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); 2471 function _arrayWithHoles(arr) { 2472 if (Array.isArray(arr)) return arr; 2473 } 2474 2475 /***/ }), 2476 2477 /***/ 39: 2478 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2479 2480 "use strict"; 2481 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); 2482 function _nonIterableRest() { 2483 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 2484 } 2485 2486 /***/ }), 2487 2488 /***/ 42: 2489 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2490 2491 "use strict"; 2492 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); 2493 function _iterableToArray(iter) { 2494 if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); 2495 } 2496 2497 /***/ }), 2498 2499 /***/ 431: 2500 /***/ (function(module, exports) { 2501 2502 /** 2503 * adds a bindGlobal method to Mousetrap that allows you to 2504 * bind specific keyboard shortcuts that will still work 2505 * inside a text input field 2506 * 2507 * usage: 2508 * Mousetrap.bindGlobal('ctrl+s', _saveChanges); 2509 */ 2510 /* global Mousetrap:true */ 2511 (function(Mousetrap) { 2512 if (! Mousetrap) { 2513 return; 2514 } 2515 var _globalCallbacks = {}; 2516 var _originalStopCallback = Mousetrap.prototype.stopCallback; 2517 2518 Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) { 2519 var self = this; 2520 2521 if (self.paused) { 2522 return true; 2523 } 2524 2525 if (_globalCallbacks[combo] || _globalCallbacks[sequence]) { 2526 return false; 2527 } 2528 2529 return _originalStopCallback.call(self, e, element, combo); 2530 }; 2531 2532 Mousetrap.prototype.bindGlobal = function(keys, callback, action) { 2533 var self = this; 2534 self.bind(keys, callback, action); 2535 2536 if (keys instanceof Array) { 2537 for (var i = 0; i < keys.length; i++) { 2538 _globalCallbacks[keys[i]] = true; 2539 } 2540 return; 2541 } 2542 2543 _globalCallbacks[keys] = true; 2544 }; 2545 2546 Mousetrap.init(); 2547 }) (typeof Mousetrap !== "undefined" ? Mousetrap : undefined); 2548 2549 2550 /***/ }), 2551 2552 /***/ 456: 2553 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2554 2555 "use strict"; 2556 // ESM COMPAT FLAG 2557 __webpack_require__.r(__webpack_exports__); 2558 2559 // EXPORTS 2560 __webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return /* reexport */ create_higher_order_component; }); 2561 __webpack_require__.d(__webpack_exports__, "compose", function() { return /* reexport */ compose; }); 2562 __webpack_require__.d(__webpack_exports__, "ifCondition", function() { return /* reexport */ if_condition; }); 2563 __webpack_require__.d(__webpack_exports__, "pure", function() { return /* reexport */ higher_order_pure; }); 2564 __webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return /* reexport */ withGlobalEvents; }); 2565 __webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return /* reexport */ with_instance_id; }); 2566 __webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return /* reexport */ with_safe_timeout; }); 2567 __webpack_require__.d(__webpack_exports__, "withState", function() { return /* reexport */ withState; }); 2568 __webpack_require__.d(__webpack_exports__, "useConstrainedTabbing", function() { return /* reexport */ use_constrained_tabbing; }); 2569 __webpack_require__.d(__webpack_exports__, "useCopyOnClick", function() { return /* reexport */ useCopyOnClick; }); 2570 __webpack_require__.d(__webpack_exports__, "useCopyToClipboard", function() { return /* reexport */ useCopyToClipboard; }); 2571 __webpack_require__.d(__webpack_exports__, "__experimentalUseDialog", function() { return /* reexport */ use_dialog; }); 2572 __webpack_require__.d(__webpack_exports__, "__experimentalUseDragging", function() { return /* reexport */ useDragging; }); 2573 __webpack_require__.d(__webpack_exports__, "useFocusOnMount", function() { return /* reexport */ useFocusOnMount; }); 2574 __webpack_require__.d(__webpack_exports__, "__experimentalUseFocusOutside", function() { return /* reexport */ useFocusOutside; }); 2575 __webpack_require__.d(__webpack_exports__, "useFocusReturn", function() { return /* reexport */ use_focus_return; }); 2576 __webpack_require__.d(__webpack_exports__, "useInstanceId", function() { return /* reexport */ useInstanceId; }); 2577 __webpack_require__.d(__webpack_exports__, "useIsomorphicLayoutEffect", function() { return /* reexport */ use_isomorphic_layout_effect; }); 2578 __webpack_require__.d(__webpack_exports__, "useKeyboardShortcut", function() { return /* reexport */ use_keyboard_shortcut; }); 2579 __webpack_require__.d(__webpack_exports__, "useMediaQuery", function() { return /* reexport */ useMediaQuery; }); 2580 __webpack_require__.d(__webpack_exports__, "usePrevious", function() { return /* reexport */ usePrevious; }); 2581 __webpack_require__.d(__webpack_exports__, "useReducedMotion", function() { return /* reexport */ use_reduced_motion; }); 2582 __webpack_require__.d(__webpack_exports__, "useViewportMatch", function() { return /* reexport */ use_viewport_match; }); 2583 __webpack_require__.d(__webpack_exports__, "useResizeObserver", function() { return /* reexport */ use_resize_observer; }); 2584 __webpack_require__.d(__webpack_exports__, "useAsyncList", function() { return /* reexport */ use_async_list; }); 2585 __webpack_require__.d(__webpack_exports__, "useWarnOnChange", function() { return /* reexport */ use_warn_on_change; }); 2586 __webpack_require__.d(__webpack_exports__, "useDebounce", function() { return /* reexport */ useDebounce; }); 2587 __webpack_require__.d(__webpack_exports__, "useThrottle", function() { return /* reexport */ useThrottle; }); 2588 __webpack_require__.d(__webpack_exports__, "useMergeRefs", function() { return /* reexport */ useMergeRefs; }); 2589 __webpack_require__.d(__webpack_exports__, "useRefEffect", function() { return /* reexport */ useRefEffect; }); 2590 __webpack_require__.d(__webpack_exports__, "__experimentalUseDropZone", function() { return /* reexport */ useDropZone; }); 2591 2592 // EXTERNAL MODULE: external "lodash" 2593 var external_lodash_ = __webpack_require__(2); 2594 2595 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js 2596 /** 2597 * External dependencies 2598 */ 2599 2600 /** 2601 * Given a function mapping a component to an enhanced component and modifier 2602 * name, returns the enhanced component augmented with a generated displayName. 2603 * 2604 * @param {Function} mapComponentToEnhancedComponent Function mapping component 2605 * to enhanced component. 2606 * @param {string} modifierName Seed name from which to 2607 * generated display name. 2608 * 2609 * @return {WPComponent} Component class with generated display name assigned. 2610 */ 2611 2612 function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) { 2613 return function (OriginalComponent) { 2614 var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent); 2615 var _OriginalComponent$di = OriginalComponent.displayName, 2616 displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di; 2617 EnhancedComponent.displayName = "".concat(Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")"); 2618 return EnhancedComponent; 2619 }; 2620 } 2621 2622 /* harmony default export */ var create_higher_order_component = (createHigherOrderComponent); 2623 2624 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js 2625 /** 2626 * External dependencies 2627 */ 2628 2629 /** 2630 * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function 2631 * composition, where each successive invocation is supplied the return value of the previous. 2632 * 2633 * @param {...Function} hocs The HOC functions to invoke. 2634 * 2635 * @return {Function} Returns the new composite function. 2636 */ 2637 2638 /* harmony default export */ var compose = (external_lodash_["flowRight"]); 2639 2640 // EXTERNAL MODULE: external ["wp","element"] 2641 var external_wp_element_ = __webpack_require__(0); 2642 2643 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js 2644 2645 2646 /** 2647 * Internal dependencies 2648 */ 2649 2650 /** 2651 * Higher-order component creator, creating a new component which renders if 2652 * the given condition is satisfied or with the given optional prop name. 2653 * 2654 * @param {Function} predicate Function to test condition. 2655 * 2656 * @return {Function} Higher-order component. 2657 */ 2658 2659 var if_condition_ifCondition = function ifCondition(predicate) { 2660 return create_higher_order_component(function (WrappedComponent) { 2661 return function (props) { 2662 if (!predicate(props)) { 2663 return null; 2664 } 2665 2666 return Object(external_wp_element_["createElement"])(WrappedComponent, props); 2667 }; 2668 }, 'ifCondition'); 2669 }; 2670 2671 /* harmony default export */ var if_condition = (if_condition_ifCondition); 2672 2673 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js 2674 var classCallCheck = __webpack_require__(25); 2675 2676 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js 2677 var createClass = __webpack_require__(26); 2678 2679 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js 2680 var inherits = __webpack_require__(33); 2681 2682 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js 2683 var possibleConstructorReturn = __webpack_require__(34); 2684 2685 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js 2686 var getPrototypeOf = __webpack_require__(22); 2687 2688 // EXTERNAL MODULE: external ["wp","isShallowEqual"] 2689 var external_wp_isShallowEqual_ = __webpack_require__(67); 2690 var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_); 2691 2692 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js 2693 2694 2695 2696 2697 2698 2699 2700 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 2701 2702 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } 2703 2704 /** 2705 * WordPress dependencies 2706 */ 2707 2708 2709 /** 2710 * Internal dependencies 2711 */ 2712 2713 2714 /** 2715 * Given a component returns the enhanced component augmented with a component 2716 * only rerendering when its props/state change 2717 * 2718 * @param {Function} mapComponentToEnhancedComponent Function mapping component 2719 * to enhanced component. 2720 * @param {string} modifierName Seed name from which to 2721 * generated display name. 2722 * 2723 * @return {WPComponent} Component class with generated display name assigned. 2724 */ 2725 2726 var pure = create_higher_order_component(function (Wrapped) { 2727 if (Wrapped.prototype instanceof external_wp_element_["Component"]) { 2728 return /*#__PURE__*/function (_Wrapped) { 2729 Object(inherits["a" /* default */])(_class, _Wrapped); 2730 2731 var _super = _createSuper(_class); 2732 2733 function _class() { 2734 Object(classCallCheck["a" /* default */])(this, _class); 2735 2736 return _super.apply(this, arguments); 2737 } 2738 2739 Object(createClass["a" /* default */])(_class, [{ 2740 key: "shouldComponentUpdate", 2741 value: function shouldComponentUpdate(nextProps, nextState) { 2742 return !external_wp_isShallowEqual_default()(nextProps, this.props) || !external_wp_isShallowEqual_default()(nextState, this.state); 2743 } 2744 }]); 2745 2746 return _class; 2747 }(Wrapped); 2748 } 2749 2750 return /*#__PURE__*/function (_Component) { 2751 Object(inherits["a" /* default */])(_class2, _Component); 2752 2753 var _super2 = _createSuper(_class2); 2754 2755 function _class2() { 2756 Object(classCallCheck["a" /* default */])(this, _class2); 2757 2758 return _super2.apply(this, arguments); 2759 } 2760 2761 Object(createClass["a" /* default */])(_class2, [{ 2762 key: "shouldComponentUpdate", 2763 value: function shouldComponentUpdate(nextProps) { 2764 return !external_wp_isShallowEqual_default()(nextProps, this.props); 2765 } 2766 }, { 2767 key: "render", 2768 value: function render() { 2769 return Object(external_wp_element_["createElement"])(Wrapped, this.props); 2770 } 2771 }]); 2772 2773 return _class2; 2774 }(external_wp_element_["Component"]); 2775 }, 'pure'); 2776 /* harmony default export */ var higher_order_pure = (pure); 2777 2778 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 2779 var esm_extends = __webpack_require__(8); 2780 2781 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js 2782 var assertThisInitialized = __webpack_require__(18); 2783 2784 // EXTERNAL MODULE: external ["wp","deprecated"] 2785 var external_wp_deprecated_ = __webpack_require__(35); 2786 var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_); 2787 2788 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js 2789 2790 2791 2792 /** 2793 * External dependencies 2794 */ 2795 2796 /** 2797 * Class responsible for orchestrating event handling on the global window, 2798 * binding a single event to be shared across all handling instances, and 2799 * removing the handler when no instances are listening for the event. 2800 */ 2801 2802 var listener_Listener = /*#__PURE__*/function () { 2803 function Listener() { 2804 Object(classCallCheck["a" /* default */])(this, Listener); 2805 2806 this.listeners = {}; 2807 this.handleEvent = this.handleEvent.bind(this); 2808 } 2809 2810 Object(createClass["a" /* default */])(Listener, [{ 2811 key: "add", 2812 value: function add(eventType, instance) { 2813 if (!this.listeners[eventType]) { 2814 // Adding first listener for this type, so bind event. 2815 window.addEventListener(eventType, this.handleEvent); 2816 this.listeners[eventType] = []; 2817 } 2818 2819 this.listeners[eventType].push(instance); 2820 } 2821 }, { 2822 key: "remove", 2823 value: function remove(eventType, instance) { 2824 this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[eventType], instance); 2825 2826 if (!this.listeners[eventType].length) { 2827 // Removing last listener for this type, so unbind event. 2828 window.removeEventListener(eventType, this.handleEvent); 2829 delete this.listeners[eventType]; 2830 } 2831 } 2832 }, { 2833 key: "handleEvent", 2834 value: function handleEvent(event) { 2835 Object(external_lodash_["forEach"])(this.listeners[event.type], function (instance) { 2836 instance.handleEvent(event); 2837 }); 2838 } 2839 }]); 2840 2841 return Listener; 2842 }(); 2843 2844 /* harmony default export */ var listener = (listener_Listener); 2845 2846 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 function with_global_events_createSuper(Derived) { var hasNativeReflectConstruct = with_global_events_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 2857 2858 function with_global_events_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } 2859 2860 /** 2861 * External dependencies 2862 */ 2863 2864 /** 2865 * WordPress dependencies 2866 */ 2867 2868 2869 2870 /** 2871 * Internal dependencies 2872 */ 2873 2874 2875 2876 /** 2877 * Listener instance responsible for managing document event handling. 2878 * 2879 * @type {Listener} 2880 */ 2881 2882 var with_global_events_listener = new listener(); 2883 /** 2884 * Higher-order component creator which, given an object of DOM event types and 2885 * values corresponding to a callback function name on the component, will 2886 * create or update a window event handler to invoke the callback when an event 2887 * occurs. On behalf of the consuming developer, the higher-order component 2888 * manages unbinding when the component unmounts, and binding at most a single 2889 * event handler for the entire application. 2890 * 2891 * @deprecated 2892 * 2893 * @param {Object<string,string>} eventTypesToHandlers Object with keys of DOM 2894 * event type, the value a 2895 * name of the function on 2896 * the original component's 2897 * instance which handles 2898 * the event. 2899 * 2900 * @return {Function} Higher-order component. 2901 */ 2902 2903 function withGlobalEvents(eventTypesToHandlers) { 2904 external_wp_deprecated_default()('wp.compose.withGlobalEvents', { 2905 since: '5.7', 2906 alternative: 'useEffect' 2907 }); 2908 return create_higher_order_component(function (WrappedComponent) { 2909 var Wrapper = /*#__PURE__*/function (_Component) { 2910 Object(inherits["a" /* default */])(Wrapper, _Component); 2911 2912 var _super = with_global_events_createSuper(Wrapper); 2913 2914 function Wrapper() { 2915 var _this; 2916 2917 Object(classCallCheck["a" /* default */])(this, Wrapper); 2918 2919 _this = _super.apply(this, arguments); 2920 _this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(_this)); 2921 _this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(_this)); 2922 return _this; 2923 } 2924 2925 Object(createClass["a" /* default */])(Wrapper, [{ 2926 key: "componentDidMount", 2927 value: function componentDidMount() { 2928 var _this2 = this; 2929 2930 Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { 2931 with_global_events_listener.add(eventType, _this2); 2932 }); 2933 } 2934 }, { 2935 key: "componentWillUnmount", 2936 value: function componentWillUnmount() { 2937 var _this3 = this; 2938 2939 Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { 2940 with_global_events_listener.remove(eventType, _this3); 2941 }); 2942 } 2943 }, { 2944 key: "handleEvent", 2945 value: function handleEvent(event) { 2946 var handler = eventTypesToHandlers[event.type]; 2947 2948 if (typeof this.wrappedRef[handler] === 'function') { 2949 this.wrappedRef[handler](event); 2950 } 2951 } 2952 }, { 2953 key: "handleRef", 2954 value: function handleRef(el) { 2955 this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref` 2956 // will cause `this.props.forwardedRef` to be `null`, so we need this 2957 // check. 2958 2959 if (this.props.forwardedRef) { 2960 this.props.forwardedRef(el); 2961 } 2962 } 2963 }, { 2964 key: "render", 2965 value: function render() { 2966 return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, { 2967 ref: this.handleRef 2968 })); 2969 } 2970 }]); 2971 2972 return Wrapper; 2973 }(external_wp_element_["Component"]); 2974 2975 return Object(external_wp_element_["forwardRef"])(function (props, ref) { 2976 return Object(external_wp_element_["createElement"])(Wrapper, { 2977 ownProps: props, 2978 forwardedRef: ref 2979 }); 2980 }); 2981 }, 'withGlobalEvents'); 2982 } 2983 2984 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js 2985 /** 2986 * WordPress dependencies 2987 */ 2988 2989 /** 2990 * @type {WeakMap<any, number>} 2991 */ 2992 2993 var instanceMap = new WeakMap(); 2994 /** 2995 * Creates a new id for a given object. 2996 * 2997 * @param {unknown} object Object reference to create an id for. 2998 * @return {number} The instance id (index). 2999 */ 3000 3001 function createId(object) { 3002 var instances = instanceMap.get(object) || 0; 3003 instanceMap.set(object, instances + 1); 3004 return instances; 3005 } 3006 /** 3007 * Provides a unique instance ID. 3008 * 3009 * @param {Object} object Object reference to create an id for. 3010 * @param {string} prefix Prefix for the unique id. 3011 * @param {string} preferredId Default ID to use. 3012 * @return {string | number} The unique instance id. 3013 */ 3014 3015 3016 function useInstanceId(object, prefix) { 3017 var preferredId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; 3018 return Object(external_wp_element_["useMemo"])(function () { 3019 if (preferredId) return preferredId; 3020 var id = createId(object); 3021 return prefix ? "".concat(prefix, "-").concat(id) : id; 3022 }, [object]); 3023 } 3024 3025 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js 3026 3027 3028 3029 /** 3030 * Internal dependencies 3031 */ 3032 3033 3034 /** 3035 * A Higher Order Component used to be provide a unique instance ID by 3036 * component. 3037 * 3038 * @param {WPComponent} WrappedComponent The wrapped component. 3039 * 3040 * @return {WPComponent} Component with an instanceId prop. 3041 */ 3042 3043 /* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) { 3044 return function (props) { 3045 var instanceId = useInstanceId(WrappedComponent); 3046 return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, props, { 3047 instanceId: instanceId 3048 })); 3049 }; 3050 }, 'withInstanceId')); 3051 3052 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 function with_safe_timeout_createSuper(Derived) { var hasNativeReflectConstruct = with_safe_timeout_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 3063 3064 function with_safe_timeout_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } 3065 3066 /** 3067 * External dependencies 3068 */ 3069 3070 /** 3071 * WordPress dependencies 3072 */ 3073 3074 3075 /** 3076 * Internal dependencies 3077 */ 3078 3079 3080 /** 3081 * A higher-order component used to provide and manage delayed function calls 3082 * that ought to be bound to a component's lifecycle. 3083 * 3084 * @param {WPComponent} OriginalComponent Component requiring setTimeout 3085 * 3086 * @return {WPComponent} Wrapped component. 3087 */ 3088 3089 var withSafeTimeout = create_higher_order_component(function (OriginalComponent) { 3090 return /*#__PURE__*/function (_Component) { 3091 Object(inherits["a" /* default */])(WrappedComponent, _Component); 3092 3093 var _super = with_safe_timeout_createSuper(WrappedComponent); 3094 3095 function WrappedComponent() { 3096 var _this; 3097 3098 Object(classCallCheck["a" /* default */])(this, WrappedComponent); 3099 3100 _this = _super.apply(this, arguments); 3101 _this.timeouts = []; 3102 _this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3103 _this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3104 return _this; 3105 } 3106 3107 Object(createClass["a" /* default */])(WrappedComponent, [{ 3108 key: "componentWillUnmount", 3109 value: function componentWillUnmount() { 3110 this.timeouts.forEach(clearTimeout); 3111 } 3112 }, { 3113 key: "setTimeout", 3114 value: function (_setTimeout) { 3115 function setTimeout(_x, _x2) { 3116 return _setTimeout.apply(this, arguments); 3117 } 3118 3119 setTimeout.toString = function () { 3120 return _setTimeout.toString(); 3121 }; 3122 3123 return setTimeout; 3124 }(function (fn, delay) { 3125 var _this2 = this; 3126 3127 var id = setTimeout(function () { 3128 fn(); 3129 3130 _this2.clearTimeout(id); 3131 }, delay); 3132 this.timeouts.push(id); 3133 return id; 3134 }) 3135 }, { 3136 key: "clearTimeout", 3137 value: function (_clearTimeout) { 3138 function clearTimeout(_x3) { 3139 return _clearTimeout.apply(this, arguments); 3140 } 3141 3142 clearTimeout.toString = function () { 3143 return _clearTimeout.toString(); 3144 }; 3145 3146 return clearTimeout; 3147 }(function (id) { 3148 clearTimeout(id); 3149 this.timeouts = Object(external_lodash_["without"])(this.timeouts, id); 3150 }) 3151 }, { 3152 key: "render", 3153 value: function render() { 3154 return Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, { 3155 setTimeout: this.setTimeout, 3156 clearTimeout: this.clearTimeout 3157 })); 3158 } 3159 }]); 3160 3161 return WrappedComponent; 3162 }(external_wp_element_["Component"]); 3163 }, 'withSafeTimeout'); 3164 /* harmony default export */ var with_safe_timeout = (withSafeTimeout); 3165 3166 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 function with_state_createSuper(Derived) { var hasNativeReflectConstruct = with_state_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 3177 3178 function with_state_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } 3179 3180 /** 3181 * WordPress dependencies 3182 */ 3183 3184 /** 3185 * Internal dependencies 3186 */ 3187 3188 3189 /** 3190 * A Higher Order Component used to provide and manage internal component state 3191 * via props. 3192 * 3193 * @param {?Object} initialState Optional initial state of the component. 3194 * 3195 * @return {WPComponent} Wrapped component. 3196 */ 3197 3198 function withState() { 3199 var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 3200 return create_higher_order_component(function (OriginalComponent) { 3201 return /*#__PURE__*/function (_Component) { 3202 Object(inherits["a" /* default */])(WrappedComponent, _Component); 3203 3204 var _super = with_state_createSuper(WrappedComponent); 3205 3206 function WrappedComponent() { 3207 var _this; 3208 3209 Object(classCallCheck["a" /* default */])(this, WrappedComponent); 3210 3211 _this = _super.apply(this, arguments); 3212 _this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3213 _this.state = initialState; 3214 return _this; 3215 } 3216 3217 Object(createClass["a" /* default */])(WrappedComponent, [{ 3218 key: "render", 3219 value: function render() { 3220 return Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, { 3221 setState: this.setState 3222 })); 3223 } 3224 }]); 3225 3226 return WrappedComponent; 3227 }(external_wp_element_["Component"]); 3228 }, 'withState'); 3229 } 3230 3231 // EXTERNAL MODULE: external ["wp","keycodes"] 3232 var external_wp_keycodes_ = __webpack_require__(17); 3233 3234 // EXTERNAL MODULE: external ["wp","dom"] 3235 var external_wp_dom_ = __webpack_require__(27); 3236 3237 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-constrained-tabbing/index.js 3238 /** 3239 * WordPress dependencies 3240 */ 3241 3242 3243 3244 /** 3245 * In Dialogs/modals, the tabbing must be constrained to the content of 3246 * the wrapper element. This hook adds the behavior to the returned ref. 3247 * 3248 * @return {Object|Function} Element Ref. 3249 * 3250 * @example 3251 * ```js 3252 * import { useConstrainedTabbing } from '@wordpress/compose'; 3253 * 3254 * const ConstrainedTabbingExample = () => { 3255 * const constrainedTabbingRef = useConstrainedTabbing() 3256 * return ( 3257 * <div ref={ constrainedTabbingRef }> 3258 * <Button /> 3259 * <Button /> 3260 * </div> 3261 * ); 3262 * } 3263 * ``` 3264 */ 3265 3266 function useConstrainedTabbing() { 3267 var ref = Object(external_wp_element_["useCallback"])(function (node) { 3268 if (!node) { 3269 return; 3270 } 3271 3272 node.addEventListener('keydown', function (event) { 3273 if (event.keyCode !== external_wp_keycodes_["TAB"]) { 3274 return; 3275 } 3276 3277 var tabbables = external_wp_dom_["focus"].tabbable.find(node); 3278 3279 if (!tabbables.length) { 3280 return; 3281 } 3282 3283 var firstTabbable = tabbables[0]; 3284 var lastTabbable = tabbables[tabbables.length - 1]; 3285 3286 if (event.shiftKey && event.target === firstTabbable) { 3287 event.preventDefault(); 3288 lastTabbable.focus(); 3289 } else if (!event.shiftKey && event.target === lastTabbable) { 3290 event.preventDefault(); 3291 firstTabbable.focus(); 3292 /* 3293 * When pressing Tab and none of the tabbables has focus, the keydown 3294 * event happens on the wrapper div: move focus on the first tabbable. 3295 */ 3296 } else if (!tabbables.includes(event.target)) { 3297 event.preventDefault(); 3298 firstTabbable.focus(); 3299 } 3300 }); 3301 }, []); 3302 return ref; 3303 } 3304 3305 /* harmony default export */ var use_constrained_tabbing = (useConstrainedTabbing); 3306 3307 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules 3308 var slicedToArray = __webpack_require__(12); 3309 3310 // EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js 3311 var dist_clipboard = __webpack_require__(188); 3312 var clipboard_default = /*#__PURE__*/__webpack_require__.n(dist_clipboard); 3313 3314 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-on-click/index.js 3315 3316 3317 /** 3318 * External dependencies 3319 */ 3320 3321 /** 3322 * WordPress dependencies 3323 */ 3324 3325 3326 3327 /** 3328 * Copies the text to the clipboard when the element is clicked. 3329 * 3330 * @deprecated 3331 * 3332 * @param {Object} ref Reference with the element. 3333 * @param {string|Function} text The text to copy. 3334 * @param {number} timeout Optional timeout to reset the returned 3335 * state. 4 seconds by default. 3336 * 3337 * @return {boolean} Whether or not the text has been copied. Resets after the 3338 * timeout. 3339 */ 3340 3341 function useCopyOnClick(ref, _text) { 3342 var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000; 3343 external_wp_deprecated_default()('wp.compose.useCopyOnClick', { 3344 since: '10.3', 3345 plugin: 'Gutenberg', 3346 alternative: 'wp.compose.useCopyToClipboard' 3347 }); 3348 var clipboard = Object(external_wp_element_["useRef"])(); 3349 3350 var _useState = Object(external_wp_element_["useState"])(false), 3351 _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), 3352 hasCopied = _useState2[0], 3353 setHasCopied = _useState2[1]; 3354 3355 Object(external_wp_element_["useEffect"])(function () { 3356 var timeoutId; // Clipboard listens to click events. 3357 3358 clipboard.current = new clipboard_default.a(ref.current, { 3359 text: function text() { 3360 return typeof _text === 'function' ? _text() : _text; 3361 } 3362 }); 3363 clipboard.current.on('success', function (_ref) { 3364 var clearSelection = _ref.clearSelection, 3365 trigger = _ref.trigger; 3366 // Clearing selection will move focus back to the triggering button, 3367 // ensuring that it is not reset to the body, and further that it is 3368 // kept within the rendered node. 3369 clearSelection(); // Handle ClipboardJS focus bug, see https://github.com/zenorocha/clipboard.js/issues/680 3370 3371 if (trigger) { 3372 trigger.focus(); 3373 } 3374 3375 if (timeout) { 3376 setHasCopied(true); 3377 clearTimeout(timeoutId); 3378 timeoutId = setTimeout(function () { 3379 return setHasCopied(false); 3380 }, timeout); 3381 } 3382 }); 3383 return function () { 3384 clipboard.current.destroy(); 3385 clearTimeout(timeoutId); 3386 }; 3387 }, [_text, timeout, setHasCopied]); 3388 return hasCopied; 3389 } 3390 3391 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-ref-effect/index.js 3392 /** 3393 * WordPress dependencies 3394 */ 3395 3396 /** 3397 * Effect-like ref callback. Just like with `useEffect`, this allows you to 3398 * return a cleanup function to be run if the ref changes or one of the 3399 * dependencies changes. The ref is provided as an argument to the callback 3400 * functions. The main difference between this and `useEffect` is that 3401 * the `useEffect` callback is not called when the ref changes, but this is. 3402 * Pass the returned ref callback as the component's ref and merge multiple refs 3403 * with `useMergeRefs`. 3404 * 3405 * It's worth noting that if the dependencies array is empty, there's not 3406 * strictly a need to clean up event handlers for example, because the node is 3407 * to be removed. It *is* necessary if you add dependencies because the ref 3408 * callback will be called multiple times for the same node. 3409 * 3410 * @param {Function} calllback Callback with ref as argument. 3411 * @param {Array} dependencies Dependencies of the callback. 3412 * 3413 * @return {Function} Ref callback. 3414 */ 3415 3416 function useRefEffect(calllback, dependencies) { 3417 var cleanup = Object(external_wp_element_["useRef"])(); 3418 return Object(external_wp_element_["useCallback"])(function (node) { 3419 if (node) { 3420 cleanup.current = calllback(node); 3421 } else if (cleanup.current) { 3422 cleanup.current(); 3423 } 3424 }, dependencies); 3425 } 3426 3427 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-to-clipboard/index.js 3428 /** 3429 * External dependencies 3430 */ 3431 3432 /** 3433 * WordPress dependencies 3434 */ 3435 3436 3437 /** 3438 * Internal dependencies 3439 */ 3440 3441 3442 /** @typedef {import('@wordpress/element').RefObject} RefObject */ 3443 3444 function useUpdatedRef(value) { 3445 var ref = Object(external_wp_element_["useRef"])(value); 3446 ref.current = value; 3447 return ref; 3448 } 3449 /** 3450 * Copies the given text to the clipboard when the element is clicked. 3451 * 3452 * @param {text|Function} text The text to copy. Use a function if not 3453 * already available and expensive to compute. 3454 * @param {Function} onSuccess Called when to text is copied. 3455 * 3456 * @return {RefObject} A ref to assign to the target element. 3457 */ 3458 3459 3460 function useCopyToClipboard(text, onSuccess) { 3461 // Store the dependencies as refs and continuesly update them so they're 3462 // fresh when the callback is called. 3463 var textRef = useUpdatedRef(text); 3464 var onSuccesRef = useUpdatedRef(onSuccess); 3465 return useRefEffect(function (node) { 3466 // Clipboard listens to click events. 3467 var clipboard = new clipboard_default.a(node, { 3468 text: function text() { 3469 return typeof textRef.current === 'function' ? textRef.current() : textRef.current; 3470 } 3471 }); 3472 clipboard.on('success', function (_ref) { 3473 var clearSelection = _ref.clearSelection; 3474 // Clearing selection will move focus back to the triggering 3475 // button, ensuring that it is not reset to the body, and 3476 // further that it is kept within the rendered node. 3477 clearSelection(); // Handle ClipboardJS focus bug, see 3478 // https://github.com/zenorocha/clipboard.js/issues/680 3479 3480 node.focus(); 3481 3482 if (onSuccesRef.current) { 3483 onSuccesRef.current(); 3484 } 3485 }); 3486 return function () { 3487 clipboard.destroy(); 3488 }; 3489 }, []); 3490 } 3491 3492 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js 3493 var defineProperty = __webpack_require__(5); 3494 3495 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-on-mount/index.js 3496 /** 3497 * WordPress dependencies 3498 */ 3499 3500 3501 /** 3502 * Hook used to focus the first tabbable element on mount. 3503 * 3504 * @param {boolean|string} focusOnMount Focus on mount mode. 3505 * @return {Function} Ref callback. 3506 * 3507 * @example 3508 * ```js 3509 * import { useFocusOnMount } from '@wordpress/compose'; 3510 * 3511 * const WithFocusOnMount = () => { 3512 * const ref = useFocusOnMount() 3513 * return ( 3514 * <div ref={ ref }> 3515 * <Button /> 3516 * <Button /> 3517 * </div> 3518 * ); 3519 * } 3520 * ``` 3521 */ 3522 3523 function useFocusOnMount() { 3524 var focusOnMount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'firstElement'; 3525 var focusOnMountRef = Object(external_wp_element_["useRef"])(focusOnMount); 3526 Object(external_wp_element_["useEffect"])(function () { 3527 focusOnMountRef.current = focusOnMount; 3528 }, [focusOnMount]); 3529 return Object(external_wp_element_["useCallback"])(function (node) { 3530 if (!node || focusOnMountRef.current === false) { 3531 return; 3532 } 3533 3534 if (node.contains(node.ownerDocument.activeElement)) { 3535 return; 3536 } 3537 3538 var target = node; 3539 3540 if (focusOnMountRef.current === 'firstElement') { 3541 var firstTabbable = external_wp_dom_["focus"].tabbable.find(node)[0]; 3542 3543 if (firstTabbable) { 3544 target = firstTabbable; 3545 } 3546 } 3547 3548 target.focus(); 3549 }, []); 3550 } 3551 3552 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-return/index.js 3553 /** 3554 * WordPress dependencies 3555 */ 3556 3557 /** 3558 * When opening modals/sidebars/dialogs, the focus 3559 * must move to the opened area and return to the 3560 * previously focused element when closed. 3561 * The current hook implements the returning behavior. 3562 * 3563 * @param {Function?} onFocusReturn Overrides the default return behavior. 3564 * @return {Function} Element Ref. 3565 * 3566 * @example 3567 * ```js 3568 * import { useFocusReturn } from '@wordpress/compose'; 3569 * 3570 * const WithFocusReturn = () => { 3571 * const ref = useFocusReturn() 3572 * return ( 3573 * <div ref={ ref }> 3574 * <Button /> 3575 * <Button /> 3576 * </div> 3577 * ); 3578 * } 3579 * ``` 3580 */ 3581 3582 function useFocusReturn(onFocusReturn) { 3583 var ref = Object(external_wp_element_["useRef"])(); 3584 var focusedBeforeMount = Object(external_wp_element_["useRef"])(); 3585 var onFocusReturnRef = Object(external_wp_element_["useRef"])(onFocusReturn); 3586 Object(external_wp_element_["useEffect"])(function () { 3587 onFocusReturnRef.current = onFocusReturn; 3588 }, [onFocusReturn]); 3589 return Object(external_wp_element_["useCallback"])(function (node) { 3590 if (node) { 3591 // Set ref to be used when unmounting. 3592 ref.current = node; // Only set when the node mounts. 3593 3594 if (focusedBeforeMount.current) { 3595 return; 3596 } 3597 3598 focusedBeforeMount.current = node.ownerDocument.activeElement; 3599 } else if (focusedBeforeMount.current) { 3600 var isFocused = ref.current.contains(ref.current.ownerDocument.activeElement); 3601 3602 if (ref.current.isConnected && !isFocused) { 3603 return; 3604 } // Defer to the component's own explicit focus return behavior, if 3605 // specified. This allows for support that the `onFocusReturn` 3606 // decides to allow the default behavior to occur under some 3607 // conditions. 3608 3609 3610 if (onFocusReturnRef.current) { 3611 onFocusReturnRef.current(); 3612 } else { 3613 focusedBeforeMount.current.focus(); 3614 } 3615 } 3616 }, []); 3617 } 3618 3619 /* harmony default export */ var use_focus_return = (useFocusReturn); 3620 3621 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-focus-outside/index.js 3622 /** 3623 * External dependencies 3624 */ 3625 3626 /** 3627 * WordPress dependencies 3628 */ 3629 3630 3631 /** 3632 * Input types which are classified as button types, for use in considering 3633 * whether element is a (focus-normalized) button. 3634 * 3635 * @type {string[]} 3636 */ 3637 3638 var INPUT_BUTTON_TYPES = ['button', 'submit']; 3639 /** 3640 * @typedef {HTMLButtonElement | HTMLLinkElement | HTMLInputElement} FocusNormalizedButton 3641 */ 3642 // Disable reason: Rule doesn't support predicate return types 3643 3644 /* eslint-disable jsdoc/valid-types */ 3645 3646 /** 3647 * Returns true if the given element is a button element subject to focus 3648 * normalization, or false otherwise. 3649 * 3650 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus 3651 * 3652 * @param {EventTarget} eventTarget The target from a mouse or touch event. 3653 * 3654 * @return {eventTarget is FocusNormalizedButton} Whether element is a button. 3655 */ 3656 3657 function isFocusNormalizedButton(eventTarget) { 3658 if (!(eventTarget instanceof window.HTMLElement)) { 3659 return false; 3660 } 3661 3662 switch (eventTarget.nodeName) { 3663 case 'A': 3664 case 'BUTTON': 3665 return true; 3666 3667 case 'INPUT': 3668 return Object(external_lodash_["includes"])(INPUT_BUTTON_TYPES, 3669 /** @type {HTMLInputElement} */ 3670 eventTarget.type); 3671 } 3672 3673 return false; 3674 } 3675 /* eslint-enable jsdoc/valid-types */ 3676 3677 /** 3678 * @typedef {import('react').SyntheticEvent} SyntheticEvent 3679 */ 3680 3681 /** 3682 * @callback EventCallback 3683 * @param {SyntheticEvent} event input related event. 3684 */ 3685 3686 /** 3687 * @typedef FocusOutsideReactElement 3688 * @property {EventCallback} handleFocusOutside callback for a focus outside event. 3689 */ 3690 3691 /** 3692 * @typedef {import('react').MutableRefObject<FocusOutsideReactElement | undefined>} FocusOutsideRef 3693 */ 3694 3695 /** 3696 * @typedef {Object} FocusOutsideReturnValue 3697 * @property {EventCallback} onFocus An event handler for focus events. 3698 * @property {EventCallback} onBlur An event handler for blur events. 3699 * @property {EventCallback} onMouseDown An event handler for mouse down events. 3700 * @property {EventCallback} onMouseUp An event handler for mouse up events. 3701 * @property {EventCallback} onTouchStart An event handler for touch start events. 3702 * @property {EventCallback} onTouchEnd An event handler for touch end events. 3703 */ 3704 3705 /** 3706 * A react hook that can be used to check whether focus has moved outside the 3707 * element the event handlers are bound to. 3708 * 3709 * @param {EventCallback} onFocusOutside A callback triggered when focus moves outside 3710 * the element the event handlers are bound to. 3711 * 3712 * @return {FocusOutsideReturnValue} An object containing event handlers. Bind the event handlers 3713 * to a wrapping element element to capture when focus moves 3714 * outside that element. 3715 */ 3716 3717 3718 function useFocusOutside(onFocusOutside) { 3719 var currentOnFocusOutside = Object(external_wp_element_["useRef"])(onFocusOutside); 3720 Object(external_wp_element_["useEffect"])(function () { 3721 currentOnFocusOutside.current = onFocusOutside; 3722 }, [onFocusOutside]); 3723 var preventBlurCheck = Object(external_wp_element_["useRef"])(false); 3724 /** 3725 * @type {import('react').MutableRefObject<number | undefined>} 3726 */ 3727 3728 var blurCheckTimeoutId = Object(external_wp_element_["useRef"])(); 3729 /** 3730 * Cancel a blur check timeout. 3731 */ 3732 3733 var cancelBlurCheck = Object(external_wp_element_["useCallback"])(function () { 3734 clearTimeout(blurCheckTimeoutId.current); 3735 }, []); // Cancel blur checks on unmount. 3736 3737 Object(external_wp_element_["useEffect"])(function () { 3738 return function () { 3739 return cancelBlurCheck(); 3740 }; 3741 }, []); // Cancel a blur check if the callback or ref is no longer provided. 3742 3743 Object(external_wp_element_["useEffect"])(function () { 3744 if (!onFocusOutside) { 3745 cancelBlurCheck(); 3746 } 3747 }, [onFocusOutside, cancelBlurCheck]); 3748 /** 3749 * Handles a mousedown or mouseup event to respectively assign and 3750 * unassign a flag for preventing blur check on button elements. Some 3751 * browsers, namely Firefox and Safari, do not emit a focus event on 3752 * button elements when clicked, while others do. The logic here 3753 * intends to normalize this as treating click on buttons as focus. 3754 * 3755 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus 3756 * 3757 * @param {SyntheticEvent} event Event for mousedown or mouseup. 3758 */ 3759 3760 var normalizeButtonFocus = Object(external_wp_element_["useCallback"])(function (event) { 3761 var type = event.type, 3762 target = event.target; 3763 var isInteractionEnd = Object(external_lodash_["includes"])(['mouseup', 'touchend'], type); 3764 3765 if (isInteractionEnd) { 3766 preventBlurCheck.current = false; 3767 } else if (isFocusNormalizedButton(target)) { 3768 preventBlurCheck.current = true; 3769 } 3770 }, []); 3771 /** 3772 * A callback triggered when a blur event occurs on the element the handler 3773 * is bound to. 3774 * 3775 * Calls the `onFocusOutside` callback in an immediate timeout if focus has 3776 * move outside the bound element and is still within the document. 3777 * 3778 * @param {SyntheticEvent} event Blur event. 3779 */ 3780 3781 var queueBlurCheck = Object(external_wp_element_["useCallback"])(function (event) { 3782 // React does not allow using an event reference asynchronously 3783 // due to recycling behavior, except when explicitly persisted. 3784 event.persist(); // Skip blur check if clicking button. See `normalizeButtonFocus`. 3785 3786 if (preventBlurCheck.current) { 3787 return; 3788 } 3789 3790 blurCheckTimeoutId.current = setTimeout(function () { 3791 // If document is not focused then focus should remain 3792 // inside the wrapped component and therefore we cancel 3793 // this blur event thereby leaving focus in place. 3794 // https://developer.mozilla.org/en-US/docs/Web/API/Document/hasFocus. 3795 if (!document.hasFocus()) { 3796 event.preventDefault(); 3797 return; 3798 } 3799 3800 if ('function' === typeof currentOnFocusOutside.current) { 3801 currentOnFocusOutside.current(event); 3802 } 3803 }, 0); 3804 }, []); 3805 return { 3806 onFocus: cancelBlurCheck, 3807 onMouseDown: normalizeButtonFocus, 3808 onMouseUp: normalizeButtonFocus, 3809 onTouchStart: normalizeButtonFocus, 3810 onTouchEnd: normalizeButtonFocus, 3811 onBlur: queueBlurCheck 3812 }; 3813 } 3814 3815 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-merge-refs/index.js 3816 /** 3817 * WordPress dependencies 3818 */ 3819 3820 /** @typedef {import('@wordpress/element').RefObject} RefObject */ 3821 3822 /** @typedef {import('@wordpress/element').RefCallback} RefCallback */ 3823 3824 /** 3825 * Merges refs into one ref callback. Ensures the merged ref callbacks are only 3826 * called when it changes (as a result of a `useCallback` dependency update) or 3827 * when the ref value changes. If you don't wish a ref callback to be called on 3828 * every render, wrap it with `useCallback( ref, [] )`. 3829 * Dependencies can be added, but when a dependency changes, the old ref 3830 * callback will be called with `null` and the new ref callback will be called 3831 * with the same node. 3832 * 3833 * @param {Array<RefObject|RefCallback>} refs The refs to be merged. 3834 * 3835 * @return {RefCallback} The merged ref callback. 3836 */ 3837 3838 function useMergeRefs(refs) { 3839 var element = Object(external_wp_element_["useRef"])(null); 3840 var didElementChange = Object(external_wp_element_["useRef"])(false); 3841 var previousRefs = Object(external_wp_element_["useRef"])(refs); 3842 var currentRefs = Object(external_wp_element_["useRef"])(refs); // Update on render before the ref callback is called, so the ref callback 3843 // always has access to the current refs. 3844 3845 currentRefs.current = refs; // If any of the refs change, call the previous ref with `null` and the new 3846 // ref with the node, except when the element changes in the same cycle, in 3847 // which case the ref callbacks will already have been called. 3848 3849 Object(external_wp_element_["useLayoutEffect"])(function () { 3850 refs.forEach(function (ref, index) { 3851 var previousRef = previousRefs.current[index]; 3852 3853 if (typeof ref === 'function' && ref !== previousRef && didElementChange.current === false) { 3854 previousRef(null); 3855 ref(element.current); 3856 } 3857 }); 3858 previousRefs.current = refs; 3859 }, refs); // No dependencies, must be reset after every render so ref callbacks are 3860 // correctly called after a ref change. 3861 3862 Object(external_wp_element_["useLayoutEffect"])(function () { 3863 didElementChange.current = false; 3864 }); // There should be no dependencies so that `callback` is only called when 3865 // the node changes. 3866 3867 return Object(external_wp_element_["useCallback"])(function (value) { 3868 // Update the element so it can be used when calling ref callbacks on a 3869 // dependency change. 3870 element.current = value; 3871 didElementChange.current = true; // When an element changes, the current ref callback should be called 3872 // with the new element and the previous one with `null`. 3873 3874 var refsToUpdate = value ? currentRefs.current : previousRefs.current; // Update the latest refs. 3875 3876 refsToUpdate.forEach(function (ref) { 3877 if (typeof ref === 'function') { 3878 ref(value); 3879 } else if (ref && ref.hasOwnProperty('current')) { 3880 ref.current = value; 3881 } 3882 }); 3883 }, []); 3884 } 3885 3886 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dialog/index.js 3887 3888 3889 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; } 3890 3891 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; } 3892 3893 /** 3894 * WordPress dependencies 3895 */ 3896 3897 3898 /** 3899 * Internal dependencies 3900 */ 3901 3902 3903 3904 3905 3906 3907 /** 3908 * Returns a ref and props to apply to a dialog wrapper to enable the following behaviors: 3909 * - constrained tabbing. 3910 * - focus on mount. 3911 * - return focus on unmount. 3912 * - focus outside. 3913 * 3914 * @param {Object} options Dialog Options. 3915 */ 3916 3917 function useDialog(options) { 3918 var onClose = Object(external_wp_element_["useRef"])(); 3919 Object(external_wp_element_["useEffect"])(function () { 3920 onClose.current = options.onClose; 3921 }, [options.onClose]); 3922 var constrainedTabbingRef = use_constrained_tabbing(); 3923 var focusOnMountRef = useFocusOnMount(); 3924 var focusReturnRef = use_focus_return(); 3925 var focusOutsideProps = useFocusOutside(options.onClose); 3926 var closeOnEscapeRef = Object(external_wp_element_["useCallback"])(function (node) { 3927 if (!node) { 3928 return; 3929 } 3930 3931 node.addEventListener('keydown', function (event) { 3932 // Close on escape 3933 if (event.keyCode === external_wp_keycodes_["ESCAPE"] && onClose.current) { 3934 event.stopPropagation(); 3935 onClose.current(); 3936 } 3937 }); 3938 }, []); 3939 return [useMergeRefs([constrainedTabbingRef, focusReturnRef, focusOnMountRef, closeOnEscapeRef]), _objectSpread(_objectSpread({}, focusOutsideProps), {}, { 3940 tabIndex: '-1' 3941 })]; 3942 } 3943 3944 /* harmony default export */ var use_dialog = (useDialog); 3945 3946 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-isomorphic-layout-effect/index.js 3947 /** 3948 * WordPress dependencies 3949 */ 3950 3951 /** 3952 * Preferred over direct usage of `useLayoutEffect` when supporting 3953 * server rendered components (SSR) because currently React 3954 * throws a warning when using useLayoutEffect in that environment. 3955 */ 3956 3957 var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external_wp_element_["useLayoutEffect"] : external_wp_element_["useEffect"]; 3958 /* harmony default export */ var use_isomorphic_layout_effect = (useIsomorphicLayoutEffect); 3959 3960 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js 3961 3962 3963 /** 3964 * WordPress dependencies 3965 */ 3966 3967 /** 3968 * Internal dependencies 3969 */ 3970 3971 3972 function useDragging(_ref) { 3973 var onDragStart = _ref.onDragStart, 3974 onDragMove = _ref.onDragMove, 3975 onDragEnd = _ref.onDragEnd; 3976 3977 var _useState = Object(external_wp_element_["useState"])(false), 3978 _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), 3979 isDragging = _useState2[0], 3980 setIsDragging = _useState2[1]; 3981 3982 var eventsRef = Object(external_wp_element_["useRef"])({ 3983 onDragStart: onDragStart, 3984 onDragMove: onDragMove, 3985 onDragEnd: onDragEnd 3986 }); 3987 use_isomorphic_layout_effect(function () { 3988 eventsRef.current.onDragStart = onDragStart; 3989 eventsRef.current.onDragMove = onDragMove; 3990 eventsRef.current.onDragEnd = onDragEnd; 3991 }, [onDragStart, onDragMove, onDragEnd]); 3992 var onMouseMove = Object(external_wp_element_["useCallback"])(function () { 3993 var _eventsRef$current; 3994 3995 return eventsRef.current.onDragMove && (_eventsRef$current = eventsRef.current).onDragMove.apply(_eventsRef$current, arguments); 3996 }, []); 3997 var endDrag = Object(external_wp_element_["useCallback"])(function () { 3998 if (eventsRef.current.onDragEnd) { 3999 var _eventsRef$current2; 4000 4001 (_eventsRef$current2 = eventsRef.current).onDragEnd.apply(_eventsRef$current2, arguments); 4002 } 4003 4004 document.removeEventListener('mousemove', onMouseMove); 4005 document.removeEventListener('mouseup', endDrag); 4006 setIsDragging(false); 4007 }, []); 4008 var startDrag = Object(external_wp_element_["useCallback"])(function () { 4009 if (eventsRef.current.onDragStart) { 4010 var _eventsRef$current3; 4011 4012 (_eventsRef$current3 = eventsRef.current).onDragStart.apply(_eventsRef$current3, arguments); 4013 } 4014 4015 document.addEventListener('mousemove', onMouseMove); 4016 document.addEventListener('mouseup', endDrag); 4017 setIsDragging(true); 4018 }, []); // Remove the global events when unmounting if needed. 4019 4020 Object(external_wp_element_["useEffect"])(function () { 4021 return function () { 4022 if (isDragging) { 4023 document.removeEventListener('mousemove', onMouseMove); 4024 document.removeEventListener('mouseup', endDrag); 4025 } 4026 }; 4027 }, [isDragging]); 4028 return { 4029 startDrag: startDrag, 4030 endDrag: endDrag, 4031 isDragging: isDragging 4032 }; 4033 } 4034 4035 // EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js 4036 var mousetrap_mousetrap = __webpack_require__(289); 4037 var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap_mousetrap); 4038 4039 // EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js 4040 var mousetrap_global_bind = __webpack_require__(431); 4041 4042 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js 4043 /** 4044 * External dependencies 4045 */ 4046 4047 4048 4049 /** 4050 * WordPress dependencies 4051 */ 4052 4053 4054 /** 4055 * A block selection object. 4056 * 4057 * @typedef {Object} WPKeyboardShortcutConfig 4058 * 4059 * @property {boolean} [bindGlobal] Handle keyboard events anywhere including inside textarea/input fields. 4060 * @property {string} [eventName] Event name used to trigger the handler, defaults to keydown. 4061 * @property {boolean} [isDisabled] Disables the keyboard handler if the value is true. 4062 * @property {Object} [target] React reference to the DOM element used to catch the keyboard event. 4063 */ 4064 4065 /** 4066 * Return true if platform is MacOS. 4067 * 4068 * @param {Object} _window window object by default; used for DI testing. 4069 * 4070 * @return {boolean} True if MacOS; false otherwise. 4071 */ 4072 4073 function isAppleOS() { 4074 var _window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; 4075 4076 var platform = _window.navigator.platform; 4077 return platform.indexOf('Mac') !== -1 || Object(external_lodash_["includes"])(['iPad', 'iPhone'], platform); 4078 } 4079 /** 4080 * Attach a keyboard shortcut handler. 4081 * 4082 * @param {string[]|string} shortcuts Keyboard Shortcuts. 4083 * @param {Function} callback Shortcut callback. 4084 * @param {WPKeyboardShortcutConfig} options Shortcut options. 4085 */ 4086 4087 4088 function useKeyboardShortcut(shortcuts, callback) { 4089 var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, 4090 _ref$bindGlobal = _ref.bindGlobal, 4091 bindGlobal = _ref$bindGlobal === void 0 ? false : _ref$bindGlobal, 4092 _ref$eventName = _ref.eventName, 4093 eventName = _ref$eventName === void 0 ? 'keydown' : _ref$eventName, 4094 _ref$isDisabled = _ref.isDisabled, 4095 isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled, 4096 target = _ref.target; 4097 4098 var currentCallback = Object(external_wp_element_["useRef"])(callback); 4099 Object(external_wp_element_["useEffect"])(function () { 4100 currentCallback.current = callback; 4101 }, [callback]); 4102 Object(external_wp_element_["useEffect"])(function () { 4103 if (isDisabled) { 4104 return; 4105 } 4106 4107 var mousetrap = new mousetrap_default.a(target ? target.current : document); 4108 Object(external_lodash_["castArray"])(shortcuts).forEach(function (shortcut) { 4109 var keys = shortcut.split('+'); // Determines whether a key is a modifier by the length of the string. 4110 // E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that 4111 // the modifiers are Shift and Cmd because they're not a single character. 4112 4113 var modifiers = new Set(keys.filter(function (value) { 4114 return value.length > 1; 4115 })); 4116 var hasAlt = modifiers.has('alt'); 4117 var hasShift = modifiers.has('shift'); // This should be better moved to the shortcut registration instead. 4118 4119 if (isAppleOS() && (modifiers.size === 1 && hasAlt || modifiers.size === 2 && hasAlt && hasShift)) { 4120 throw new Error("Cannot bind ".concat(shortcut, ". Alt and Shift+Alt modifiers are reserved for character input.")); 4121 } 4122 4123 var bindFn = bindGlobal ? 'bindGlobal' : 'bind'; 4124 mousetrap[bindFn](shortcut, function () { 4125 return currentCallback.current.apply(currentCallback, arguments); 4126 }, eventName); 4127 }); 4128 return function () { 4129 mousetrap.reset(); 4130 }; 4131 }, [shortcuts, bindGlobal, eventName, target, isDisabled]); 4132 } 4133 4134 /* harmony default export */ var use_keyboard_shortcut = (useKeyboardShortcut); 4135 4136 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js 4137 4138 4139 /** 4140 * WordPress dependencies 4141 */ 4142 4143 /** 4144 * Runs a media query and returns its value when it changes. 4145 * 4146 * @param {string} [query] Media Query. 4147 * @return {boolean} return value of the media query. 4148 */ 4149 4150 function useMediaQuery(query) { 4151 var _useState = Object(external_wp_element_["useState"])(function () { 4152 return !!(query && typeof window !== 'undefined' && window.matchMedia(query).matches); 4153 }), 4154 _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), 4155 match = _useState2[0], 4156 setMatch = _useState2[1]; 4157 4158 Object(external_wp_element_["useEffect"])(function () { 4159 if (!query) { 4160 return; 4161 } 4162 4163 var updateMatch = function updateMatch() { 4164 return setMatch(window.matchMedia(query).matches); 4165 }; 4166 4167 updateMatch(); 4168 var list = window.matchMedia(query); 4169 list.addListener(updateMatch); 4170 return function () { 4171 list.removeListener(updateMatch); 4172 }; 4173 }, [query]); 4174 return query && match; 4175 } 4176 4177 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-previous/index.js 4178 /** 4179 * WordPress dependencies 4180 */ 4181 4182 /** 4183 * Use something's value from the previous render. 4184 * Based on https://usehooks.com/usePrevious/. 4185 * 4186 * @template T 4187 * 4188 * @param {T} value The value to track. 4189 * 4190 * @return {T|undefined} The value from the previous render. 4191 */ 4192 4193 function usePrevious(value) { 4194 // Disable reason: without an explicit type detail, the type of ref will be 4195 // inferred based on the initial useRef argument, which is undefined. 4196 // https://github.com/WordPress/gutenberg/pull/22597#issuecomment-633588366 4197 4198 /* eslint-disable jsdoc/no-undefined-types */ 4199 var ref = Object(external_wp_element_["useRef"])( 4200 /** @type {T|undefined} */ 4201 undefined); 4202 /* eslint-enable jsdoc/no-undefined-types */ 4203 // Store current value in ref. 4204 4205 Object(external_wp_element_["useEffect"])(function () { 4206 ref.current = value; 4207 }, [value]); // Re-run when value changes. 4208 // Return previous value (happens before update in useEffect above). 4209 4210 return ref.current; 4211 } 4212 4213 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-reduced-motion/index.js 4214 /** 4215 * Internal dependencies 4216 */ 4217 4218 /** 4219 * Whether or not the user agent is Internet Explorer. 4220 * 4221 * @type {boolean} 4222 */ 4223 4224 var IS_IE = typeof window !== 'undefined' && window.navigator.userAgent.indexOf('Trident') >= 0; 4225 /** 4226 * Hook returning whether the user has a preference for reduced motion. 4227 * 4228 * @return {boolean} Reduced motion preference value. 4229 */ 4230 4231 var useReducedMotion = undefined || IS_IE ? function () { 4232 return true; 4233 } : function () { 4234 return useMediaQuery('(prefers-reduced-motion: reduce)'); 4235 }; 4236 /* harmony default export */ var use_reduced_motion = (useReducedMotion); 4237 4238 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-viewport-match/index.js 4239 /** 4240 * WordPress dependencies 4241 */ 4242 4243 /** 4244 * Internal dependencies 4245 */ 4246 4247 4248 /** 4249 * @typedef {"huge"|"wide"|"large"|"medium"|"small"|"mobile"} WPBreakpoint 4250 */ 4251 4252 /** 4253 * Hash of breakpoint names with pixel width at which it becomes effective. 4254 * 4255 * @see _breakpoints.scss 4256 * 4257 * @type {Object<WPBreakpoint,number>} 4258 */ 4259 4260 var BREAKPOINTS = { 4261 huge: 1440, 4262 wide: 1280, 4263 large: 960, 4264 medium: 782, 4265 small: 600, 4266 mobile: 480 4267 }; 4268 /** 4269 * @typedef {">="|"<"} WPViewportOperator 4270 */ 4271 4272 /** 4273 * Object mapping media query operators to the condition to be used. 4274 * 4275 * @type {Object<WPViewportOperator,string>} 4276 */ 4277 4278 var CONDITIONS = { 4279 '>=': 'min-width', 4280 '<': 'max-width' 4281 }; 4282 /** 4283 * Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values. 4284 * 4285 * @type {Object<WPViewportOperator,Function>} 4286 */ 4287 4288 var OPERATOR_EVALUATORS = { 4289 '>=': function _(breakpointValue, width) { 4290 return width >= breakpointValue; 4291 }, 4292 '<': function _(breakpointValue, width) { 4293 return width < breakpointValue; 4294 } 4295 }; 4296 var ViewportMatchWidthContext = Object(external_wp_element_["createContext"])(null); 4297 /** 4298 * Returns true if the viewport matches the given query, or false otherwise. 4299 * 4300 * @param {WPBreakpoint} breakpoint Breakpoint size name. 4301 * @param {WPViewportOperator} [operator=">="] Viewport operator. 4302 * 4303 * @example 4304 * 4305 * ```js 4306 * useViewportMatch( 'huge', '<' ); 4307 * useViewportMatch( 'medium' ); 4308 * ``` 4309 * 4310 * @return {boolean} Whether viewport matches query. 4311 */ 4312 4313 var use_viewport_match_useViewportMatch = function useViewportMatch(breakpoint) { 4314 var operator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '>='; 4315 var simulatedWidth = Object(external_wp_element_["useContext"])(ViewportMatchWidthContext); 4316 var mediaQuery = !simulatedWidth && "(".concat(CONDITIONS[operator], ": ").concat(BREAKPOINTS[breakpoint], "px)"); 4317 var mediaQueryResult = useMediaQuery(mediaQuery); 4318 4319 if (simulatedWidth) { 4320 return OPERATOR_EVALUATORS[operator](BREAKPOINTS[breakpoint], simulatedWidth); 4321 } 4322 4323 return mediaQueryResult; 4324 }; 4325 4326 use_viewport_match_useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider; 4327 /* harmony default export */ var use_viewport_match = (use_viewport_match_useViewportMatch); 4328 4329 // EXTERNAL MODULE: ./node_modules/react-resize-aware/dist/index.js 4330 var dist = __webpack_require__(155); 4331 var dist_default = /*#__PURE__*/__webpack_require__.n(dist); 4332 4333 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/index.js 4334 /** 4335 * External dependencies 4336 */ 4337 4338 /** 4339 * Hook which allows to listen the resize event of any target element when it changes sizes. 4340 * _Note: `useResizeObserver` will report `null` until after first render_ 4341 * 4342 * @return {Array} An array of {Element} `resizeListener` and {?Object} `sizes` with properties `width` and `height` 4343 * 4344 * @example 4345 * 4346 * ```js 4347 * const App = () => { 4348 * const [ resizeListener, sizes ] = useResizeObserver(); 4349 * 4350 * return ( 4351 * <div> 4352 * { resizeListener } 4353 * Your content here 4354 * </div> 4355 * ); 4356 * }; 4357 * ``` 4358 * 4359 */ 4360 4361 /* harmony default export */ var use_resize_observer = (dist_default.a); 4362 4363 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules 4364 var toConsumableArray = __webpack_require__(15); 4365 4366 // EXTERNAL MODULE: external ["wp","priorityQueue"] 4367 var external_wp_priorityQueue_ = __webpack_require__(156); 4368 4369 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-async-list/index.js 4370 4371 4372 4373 /** 4374 * WordPress dependencies 4375 */ 4376 4377 4378 /** 4379 * Returns the first items from list that are present on state. 4380 * 4381 * @param {Array} list New array. 4382 * @param {Array} state Current state. 4383 * @return {Array} First items present iin state. 4384 */ 4385 4386 function getFirstItemsPresentInState(list, state) { 4387 var firstItems = []; 4388 4389 for (var i = 0; i < list.length; i++) { 4390 var item = list[i]; 4391 4392 if (!state.includes(item)) { 4393 break; 4394 } 4395 4396 firstItems.push(item); 4397 } 4398 4399 return firstItems; 4400 } 4401 /** 4402 * Reducer keeping track of a list of appended items. 4403 * 4404 * @param {Array} state Current state 4405 * @param {Object} action Action 4406 * 4407 * @return {Array} update state. 4408 */ 4409 4410 4411 function listReducer(state, action) { 4412 if (action.type === 'reset') { 4413 return action.list; 4414 } 4415 4416 if (action.type === 'append') { 4417 return [].concat(Object(toConsumableArray["a" /* default */])(state), [action.item]); 4418 } 4419 4420 return state; 4421 } 4422 /** 4423 * React hook returns an array which items get asynchronously appended from a source array. 4424 * This behavior is useful if we want to render a list of items asynchronously for performance reasons. 4425 * 4426 * @param {Array} list Source array. 4427 * @return {Array} Async array. 4428 */ 4429 4430 4431 function useAsyncList(list) { 4432 var _useReducer = Object(external_wp_element_["useReducer"])(listReducer, []), 4433 _useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2), 4434 current = _useReducer2[0], 4435 dispatch = _useReducer2[1]; 4436 4437 Object(external_wp_element_["useEffect"])(function () { 4438 // On reset, we keep the first items that were previously rendered. 4439 var firstItems = getFirstItemsPresentInState(list, current); 4440 dispatch({ 4441 type: 'reset', 4442 list: firstItems 4443 }); 4444 var asyncQueue = Object(external_wp_priorityQueue_["createQueue"])(); 4445 4446 var append = function append(index) { 4447 return function () { 4448 if (list.length <= index) { 4449 return; 4450 } 4451 4452 dispatch({ 4453 type: 'append', 4454 item: list[index] 4455 }); 4456 asyncQueue.add({}, append(index + 1)); 4457 }; 4458 }; 4459 4460 asyncQueue.add({}, append(firstItems.length)); 4461 return function () { 4462 return asyncQueue.reset(); 4463 }; 4464 }, [list]); 4465 return current; 4466 } 4467 4468 /* harmony default export */ var use_async_list = (useAsyncList); 4469 4470 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-warn-on-change/index.js 4471 4472 4473 /** 4474 * Internal dependencies 4475 */ 4476 4477 /** 4478 * Hook that performs a shallow comparison between the preview value of an object 4479 * and the new one, if there's a difference, it prints it to the console. 4480 * this is useful in performance related work, to check why a component re-renders. 4481 * 4482 * @example 4483 * 4484 * ```jsx 4485 * function MyComponent(props) { 4486 * useWarnOnChange(props); 4487 * 4488 * return "Something"; 4489 * } 4490 * ``` 4491 * 4492 * @param {Object} object Object which changes to compare. 4493 * @param {string} prefix Just a prefix to show when console logging. 4494 */ 4495 4496 function useWarnOnChange(object) { 4497 var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Change detection'; 4498 var previousValues = usePrevious(object); 4499 Object.entries(previousValues !== null && previousValues !== void 0 ? previousValues : []).forEach(function (_ref) { 4500 var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2), 4501 key = _ref2[0], 4502 value = _ref2[1]; 4503 4504 if (value !== object[key]) { 4505 // eslint-disable-next-line no-console 4506 console.warn("".concat(prefix, ": ").concat(key, " key changed:"), value, object[key]); 4507 } 4508 }); 4509 } 4510 4511 /* harmony default export */ var use_warn_on_change = (useWarnOnChange); 4512 4513 // EXTERNAL MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js 4514 var use_memo_one_esm = __webpack_require__(130); 4515 4516 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-debounce/index.js 4517 /** 4518 * External dependencies 4519 */ 4520 4521 4522 /** 4523 * WordPress dependencies 4524 */ 4525 4526 4527 /** 4528 * Debounces a function with Lodash's `debounce`. A new debounced function will 4529 * be returned and any scheduled calls cancelled if any of the arguments change, 4530 * including the function to debounce, so please wrap functions created on 4531 * render in components in `useCallback`. 4532 * 4533 * @param {...any} args Arguments passed to Lodash's `debounce`. 4534 * 4535 * @return {Function} Debounced function. 4536 */ 4537 4538 function useDebounce() { 4539 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 4540 args[_key] = arguments[_key]; 4541 } 4542 4543 var debounced = Object(use_memo_one_esm["a" /* useMemoOne */])(function () { 4544 return external_lodash_["debounce"].apply(void 0, args); 4545 }, args); 4546 Object(external_wp_element_["useEffect"])(function () { 4547 return function () { 4548 return debounced.cancel(); 4549 }; 4550 }, [debounced]); 4551 return debounced; 4552 } 4553 4554 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-throttle/index.js 4555 /** 4556 * External dependencies 4557 */ 4558 4559 4560 /** 4561 * WordPress dependencies 4562 */ 4563 4564 4565 /** 4566 * Throttles a function with Lodash's `throttle`. A new throttled function will 4567 * be returned and any scheduled calls cancelled if any of the arguments change, 4568 * including the function to throttle, so please wrap functions created on 4569 * render in components in `useCallback`. 4570 * 4571 * @param {...any} args Arguments passed to Lodash's `throttle`. 4572 * 4573 * @return {Function} Throttled function. 4574 */ 4575 4576 function useThrottle() { 4577 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 4578 args[_key] = arguments[_key]; 4579 } 4580 4581 var throttled = Object(use_memo_one_esm["a" /* useMemoOne */])(function () { 4582 return external_lodash_["throttle"].apply(void 0, args); 4583 }, args); 4584 Object(external_wp_element_["useEffect"])(function () { 4585 return function () { 4586 return throttled.cancel(); 4587 }; 4588 }, [throttled]); 4589 return throttled; 4590 } 4591 4592 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-drop-zone/index.js 4593 /** 4594 * WordPress dependencies 4595 */ 4596 4597 /** 4598 * Internal dependencies 4599 */ 4600 4601 4602 /** @typedef {import('@wordpress/element').RefCallback} RefCallback */ 4603 4604 function useFreshRef(value) { 4605 var ref = Object(external_wp_element_["useRef"])(); 4606 ref.current = value; 4607 return ref; 4608 } 4609 /** 4610 * A hook to facilitate drag and drop handling. 4611 * 4612 * @param {Object} $1 Named parameters. 4613 * @param {boolean} $1.isDisabled Whether or not to disable the drop zone. 4614 * @param {DragEvent} $1.onDragStart Called when dragging has started. 4615 * @param {DragEvent} $1.onDragEnter Called when the zone is entered. 4616 * @param {DragEvent} $1.onDragOver Called when the zone is moved within. 4617 * @param {DragEvent} $1.onDragLeave Called when the zone is left. 4618 * @param {MouseEvent} $1.onDragEnd Called when dragging has ended. 4619 * @param {DragEvent} $1.onDrop Called when dropping in the zone. 4620 * 4621 * @return {RefCallback} Ref callback to be passed to the drop zone element. 4622 */ 4623 4624 4625 function useDropZone(_ref) { 4626 var isDisabled = _ref.isDisabled, 4627 _onDrop = _ref.onDrop, 4628 _onDragStart = _ref.onDragStart, 4629 _onDragEnter = _ref.onDragEnter, 4630 _onDragLeave = _ref.onDragLeave, 4631 _onDragEnd = _ref.onDragEnd, 4632 _onDragOver = _ref.onDragOver; 4633 var onDropRef = useFreshRef(_onDrop); 4634 var onDragStartRef = useFreshRef(_onDragStart); 4635 var onDragEnterRef = useFreshRef(_onDragEnter); 4636 var onDragLeaveRef = useFreshRef(_onDragLeave); 4637 var onDragEndRef = useFreshRef(_onDragEnd); 4638 var onDragOverRef = useFreshRef(_onDragOver); 4639 return useRefEffect(function (element) { 4640 if (isDisabled) { 4641 return; 4642 } 4643 4644 var isDragging = false; 4645 var ownerDocument = element.ownerDocument; 4646 4647 function maybeDragStart(event) { 4648 if (isDragging) { 4649 return; 4650 } 4651 4652 isDragging = true; 4653 ownerDocument.removeEventListener('dragenter', maybeDragStart); 4654 4655 if (onDragStartRef.current) { 4656 onDragStartRef.current(event); 4657 } 4658 } 4659 4660 function onDragEnter(event) { 4661 event.preventDefault(); // The `dragenter` event will also fire when entering child 4662 // elements, but we only want to call `onDragEnter` when 4663 // entering the drop zone, which means the `relatedTarget` 4664 // (element that has been left) should be outside the drop zone. 4665 4666 if (element.contains(event.relatedTarget)) { 4667 return; 4668 } 4669 4670 if (onDragEnterRef.current) { 4671 onDragEnterRef.current(event); 4672 } 4673 } 4674 4675 function onDragOver(event) { 4676 // Only call onDragOver for the innermost hovered drop zones. 4677 if (!event.defaultPrevented && onDragOverRef.current) { 4678 onDragOverRef.current(event); 4679 } // Prevent the browser default while also signalling to parent 4680 // drop zones that `onDragOver` is already handled. 4681 4682 4683 event.preventDefault(); 4684 } 4685 4686 function onDragLeave(event) { 4687 // The `dragleave` event will also fire when leaving child 4688 // elements, but we only want to call `onDragLeave` when 4689 // leaving the drop zone, which means the `relatedTarget` 4690 // (element that has been entered) should be outside the drop 4691 // zone. 4692 if (element.contains(event.relatedTarget)) { 4693 return; 4694 } 4695 4696 if (onDragLeaveRef.current) { 4697 onDragLeaveRef.current(event); 4698 } 4699 } 4700 4701 function onDrop(event) { 4702 // Don't handle drop if an inner drop zone already handled it. 4703 if (event.defaultPrevented) { 4704 return; 4705 } // Prevent the browser default while also signalling to parent 4706 // drop zones that `onDrop` is already handled. 4707 4708 4709 event.preventDefault(); // This seemingly useless line has been shown to resolve a 4710 // Safari issue where files dragged directly from the dock are 4711 // not recognized. 4712 // eslint-disable-next-line no-unused-expressions 4713 4714 event.dataTransfer && event.dataTransfer.files.length; 4715 4716 if (onDropRef.current) { 4717 onDropRef.current(event); 4718 } 4719 4720 maybeDragEnd(event); 4721 } 4722 4723 function maybeDragEnd(event) { 4724 if (!isDragging) { 4725 return; 4726 } 4727 4728 isDragging = false; 4729 ownerDocument.addEventListener('dragenter', maybeDragStart); 4730 4731 if (onDragEndRef.current) { 4732 onDragEndRef.current(event); 4733 } 4734 } 4735 4736 element.addEventListener('drop', onDrop); 4737 element.addEventListener('dragenter', onDragEnter); 4738 element.addEventListener('dragover', onDragOver); 4739 element.addEventListener('dragleave', onDragLeave); // Note that `dragend` doesn't fire consistently for file and HTML 4740 // drag events where the drag origin is outside the browser window. 4741 // In Firefox it may also not fire if the originating node is 4742 // removed. 4743 4744 ownerDocument.addEventListener('dragend', maybeDragEnd); 4745 ownerDocument.addEventListener('mouseup', maybeDragEnd); // The `dragstart` event doesn't fire if the drag started outside 4746 // the document. 4747 4748 ownerDocument.addEventListener('dragenter', maybeDragStart); 4749 return function () { 4750 element.removeEventListener('drop', onDrop); 4751 element.removeEventListener('dragenter', onDragEnter); 4752 element.removeEventListener('dragover', onDragOver); 4753 element.removeEventListener('dragleave', onDragLeave); 4754 ownerDocument.removeEventListener('dragend', maybeDragEnd); 4755 ownerDocument.removeEventListener('mouseup', maybeDragEnd); 4756 ownerDocument.addEventListener('dragenter', maybeDragStart); 4757 }; 4758 }, [isDisabled]); 4759 } 4760 4761 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js 4762 // Utils 4763 // Compose helper (aliased flowRight from Lodash) 4764 4765 // Higher-order components 4766 4767 4768 4769 4770 4771 4772 // Hooks 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 /***/ }), 4800 4801 /***/ 5: 4802 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4803 4804 "use strict"; 4805 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); 4806 function _defineProperty(obj, key, value) { 4807 if (key in obj) { 4808 Object.defineProperty(obj, key, { 4809 value: value, 4810 enumerable: true, 4811 configurable: true, 4812 writable: true 4813 }); 4814 } else { 4815 obj[key] = value; 4816 } 4817 4818 return obj; 4819 } 4820 4821 /***/ }), 4822 4823 /***/ 55: 4824 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4825 4826 "use strict"; 4827 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _setPrototypeOf; }); 4828 function _setPrototypeOf(o, p) { 4829 _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { 4830 o.__proto__ = p; 4831 return o; 4832 }; 4833 4834 return _setPrototypeOf(o, p); 4835 } 4836 4837 /***/ }), 4838 4839 /***/ 59: 4840 /***/ (function(module, exports) { 4841 4842 function _typeof(obj) { 4843 "@babel/helpers - typeof"; 4844 4845 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 4846 module.exports = _typeof = function _typeof(obj) { 4847 return typeof obj; 4848 }; 4849 4850 module.exports["default"] = module.exports, module.exports.__esModule = true; 4851 } else { 4852 module.exports = _typeof = function _typeof(obj) { 4853 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 4854 }; 4855 4856 module.exports["default"] = module.exports, module.exports.__esModule = true; 4857 } 4858 4859 return _typeof(obj); 4860 } 4861 4862 module.exports = _typeof; 4863 module.exports["default"] = module.exports, module.exports.__esModule = true; 4864 4865 /***/ }), 4866 4867 /***/ 67: 4868 /***/ (function(module, exports) { 4869 4870 (function() { module.exports = window["wp"]["isShallowEqual"]; }()); 4871 4872 /***/ }), 4873 4874 /***/ 8: 4875 /***/ (function(module, __webpack_exports__, __webpack_require__) { 4876 4877 "use strict"; 4878 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; }); 4879 function _extends() { 4880 _extends = Object.assign || function (target) { 4881 for (var i = 1; i < arguments.length; i++) { 4882 var source = arguments[i]; 4883 4884 for (var key in source) { 4885 if (Object.prototype.hasOwnProperty.call(source, key)) { 4886 target[key] = source[key]; 4887 } 4888 } 4889 } 4890 4891 return target; 4892 }; 4893 4894 return _extends.apply(this, arguments); 4895 } 4896 4897 /***/ }) 4898 4899 /******/ });
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Tue May 18 01:00:05 2021 | Cross-referenced by PHPXref 0.7.1 |