| [ 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 = 445); 86 /******/ }) 87 /************************************************************************/ 88 /******/ ({ 89 90 /***/ 0: 91 /***/ (function(module, exports) { 92 93 (function() { module.exports = this["wp"]["element"]; }()); 94 95 /***/ }), 96 97 /***/ 10: 98 /***/ (function(module, __webpack_exports__, __webpack_require__) { 99 100 "use strict"; 101 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; }); 102 function _assertThisInitialized(self) { 103 if (self === void 0) { 104 throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 105 } 106 107 return self; 108 } 109 110 /***/ }), 111 112 /***/ 100: 113 /***/ (function(module, exports) { 114 115 // shim for using process in browser 116 var process = module.exports = {}; 117 118 // cached from whatever global is present so that test runners that stub it 119 // don't break things. But we need to wrap it in a try catch in case it is 120 // wrapped in strict mode code which doesn't define any globals. It's inside a 121 // function because try/catches deoptimize in certain engines. 122 123 var cachedSetTimeout; 124 var cachedClearTimeout; 125 126 function defaultSetTimout() { 127 throw new Error('setTimeout has not been defined'); 128 } 129 function defaultClearTimeout () { 130 throw new Error('clearTimeout has not been defined'); 131 } 132 (function () { 133 try { 134 if (typeof setTimeout === 'function') { 135 cachedSetTimeout = setTimeout; 136 } else { 137 cachedSetTimeout = defaultSetTimout; 138 } 139 } catch (e) { 140 cachedSetTimeout = defaultSetTimout; 141 } 142 try { 143 if (typeof clearTimeout === 'function') { 144 cachedClearTimeout = clearTimeout; 145 } else { 146 cachedClearTimeout = defaultClearTimeout; 147 } 148 } catch (e) { 149 cachedClearTimeout = defaultClearTimeout; 150 } 151 } ()) 152 function runTimeout(fun) { 153 if (cachedSetTimeout === setTimeout) { 154 //normal enviroments in sane situations 155 return setTimeout(fun, 0); 156 } 157 // if setTimeout wasn't available but was latter defined 158 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 159 cachedSetTimeout = setTimeout; 160 return setTimeout(fun, 0); 161 } 162 try { 163 // when when somebody has screwed with setTimeout but no I.E. maddness 164 return cachedSetTimeout(fun, 0); 165 } catch(e){ 166 try { 167 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 168 return cachedSetTimeout.call(null, fun, 0); 169 } catch(e){ 170 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error 171 return cachedSetTimeout.call(this, fun, 0); 172 } 173 } 174 175 176 } 177 function runClearTimeout(marker) { 178 if (cachedClearTimeout === clearTimeout) { 179 //normal enviroments in sane situations 180 return clearTimeout(marker); 181 } 182 // if clearTimeout wasn't available but was latter defined 183 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 184 cachedClearTimeout = clearTimeout; 185 return clearTimeout(marker); 186 } 187 try { 188 // when when somebody has screwed with setTimeout but no I.E. maddness 189 return cachedClearTimeout(marker); 190 } catch (e){ 191 try { 192 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 193 return cachedClearTimeout.call(null, marker); 194 } catch (e){ 195 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. 196 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 197 return cachedClearTimeout.call(this, marker); 198 } 199 } 200 201 202 203 } 204 var queue = []; 205 var draining = false; 206 var currentQueue; 207 var queueIndex = -1; 208 209 function cleanUpNextTick() { 210 if (!draining || !currentQueue) { 211 return; 212 } 213 draining = false; 214 if (currentQueue.length) { 215 queue = currentQueue.concat(queue); 216 } else { 217 queueIndex = -1; 218 } 219 if (queue.length) { 220 drainQueue(); 221 } 222 } 223 224 function drainQueue() { 225 if (draining) { 226 return; 227 } 228 var timeout = runTimeout(cleanUpNextTick); 229 draining = true; 230 231 var len = queue.length; 232 while(len) { 233 currentQueue = queue; 234 queue = []; 235 while (++queueIndex < len) { 236 if (currentQueue) { 237 currentQueue[queueIndex].run(); 238 } 239 } 240 queueIndex = -1; 241 len = queue.length; 242 } 243 currentQueue = null; 244 draining = false; 245 runClearTimeout(timeout); 246 } 247 248 process.nextTick = function (fun) { 249 var args = new Array(arguments.length - 1); 250 if (arguments.length > 1) { 251 for (var i = 1; i < arguments.length; i++) { 252 args[i - 1] = arguments[i]; 253 } 254 } 255 queue.push(new Item(fun, args)); 256 if (queue.length === 1 && !draining) { 257 runTimeout(drainQueue); 258 } 259 }; 260 261 // v8 likes predictible objects 262 function Item(fun, array) { 263 this.fun = fun; 264 this.array = array; 265 } 266 Item.prototype.run = function () { 267 this.fun.apply(null, this.array); 268 }; 269 process.title = 'browser'; 270 process.browser = true; 271 process.env = {}; 272 process.argv = []; 273 process.version = ''; // empty string to avoid regexp issues 274 process.versions = {}; 275 276 function noop() {} 277 278 process.on = noop; 279 process.addListener = noop; 280 process.once = noop; 281 process.off = noop; 282 process.removeListener = noop; 283 process.removeAllListeners = noop; 284 process.emit = noop; 285 process.prependListener = noop; 286 process.prependOnceListener = noop; 287 288 process.listeners = function (name) { return [] } 289 290 process.binding = function (name) { 291 throw new Error('process.binding is not supported'); 292 }; 293 294 process.cwd = function () { return '/' }; 295 process.chdir = function (dir) { 296 throw new Error('process.chdir is not supported'); 297 }; 298 process.umask = function() { return 0; }; 299 300 301 /***/ }), 302 303 /***/ 126: 304 /***/ (function(module, __webpack_exports__, __webpack_require__) { 305 306 "use strict"; 307 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useMediaQuery; }); 308 /* harmony import */ var _babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15); 309 /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0); 310 /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__); 311 312 313 /** 314 * WordPress dependencies 315 */ 316 317 /** 318 * Runs a media query and returns its value when it changes. 319 * 320 * @param {string} [query] Media Query. 321 * @return {boolean} return value of the media query. 322 */ 323 324 function useMediaQuery(query) { 325 var _useState = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__["useState"])(query && window.matchMedia(query).matches), 326 _useState2 = Object(_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState, 2), 327 match = _useState2[0], 328 setMatch = _useState2[1]; 329 330 Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_1__["useEffect"])(function () { 331 if (!query) { 332 return; 333 } 334 335 var updateMatch = function updateMatch() { 336 return setMatch(window.matchMedia(query).matches); 337 }; 338 339 updateMatch(); 340 var list = window.matchMedia(query); 341 list.addListener(updateMatch); 342 return function () { 343 list.removeListener(updateMatch); 344 }; 345 }, [query]); 346 return query && match; 347 } 348 349 350 /***/ }), 351 352 /***/ 13: 353 /***/ (function(module, __webpack_exports__, __webpack_require__) { 354 355 "use strict"; 356 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; }); 357 function _getPrototypeOf(o) { 358 _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { 359 return o.__proto__ || Object.getPrototypeOf(o); 360 }; 361 return _getPrototypeOf(o); 362 } 363 364 /***/ }), 365 366 /***/ 143: 367 /***/ (function(module, exports) { 368 369 (function() { module.exports = this["wp"]["priorityQueue"]; }()); 370 371 /***/ }), 372 373 /***/ 15: 374 /***/ (function(module, __webpack_exports__, __webpack_require__) { 375 376 "use strict"; 377 378 // EXPORTS 379 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; }); 380 381 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js 382 var arrayWithHoles = __webpack_require__(38); 383 384 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js 385 function _iterableToArrayLimit(arr, i) { 386 if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 387 var _arr = []; 388 var _n = true; 389 var _d = false; 390 var _e = undefined; 391 392 try { 393 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 394 _arr.push(_s.value); 395 396 if (i && _arr.length === i) break; 397 } 398 } catch (err) { 399 _d = true; 400 _e = err; 401 } finally { 402 try { 403 if (!_n && _i["return"] != null) _i["return"](); 404 } finally { 405 if (_d) throw _e; 406 } 407 } 408 409 return _arr; 410 } 411 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 412 var unsupportedIterableToArray = __webpack_require__(28); 413 414 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js 415 var nonIterableRest = __webpack_require__(39); 416 417 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js 418 419 420 421 422 function _slicedToArray(arr, i) { 423 return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])(); 424 } 425 426 /***/ }), 427 428 /***/ 16: 429 /***/ (function(module, __webpack_exports__, __webpack_require__) { 430 431 "use strict"; 432 433 // EXPORTS 434 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; }); 435 436 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js 437 var arrayLikeToArray = __webpack_require__(26); 438 439 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js 440 441 function _arrayWithoutHoles(arr) { 442 if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr); 443 } 444 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js 445 var iterableToArray = __webpack_require__(35); 446 447 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 448 var unsupportedIterableToArray = __webpack_require__(28); 449 450 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js 451 function _nonIterableSpread() { 452 throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 453 } 454 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js 455 456 457 458 459 function _toConsumableArray(arr) { 460 return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread(); 461 } 462 463 /***/ }), 464 465 /***/ 17: 466 /***/ (function(module, exports) { 467 468 (function() { module.exports = this["React"]; }()); 469 470 /***/ }), 471 472 /***/ 18: 473 /***/ (function(module, __webpack_exports__, __webpack_require__) { 474 475 "use strict"; 476 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; }); 477 function _defineProperties(target, props) { 478 for (var i = 0; i < props.length; i++) { 479 var descriptor = props[i]; 480 descriptor.enumerable = descriptor.enumerable || false; 481 descriptor.configurable = true; 482 if ("value" in descriptor) descriptor.writable = true; 483 Object.defineProperty(target, descriptor.key, descriptor); 484 } 485 } 486 487 function _createClass(Constructor, protoProps, staticProps) { 488 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 489 if (staticProps) _defineProperties(Constructor, staticProps); 490 return Constructor; 491 } 492 493 /***/ }), 494 495 /***/ 19: 496 /***/ (function(module, __webpack_exports__, __webpack_require__) { 497 498 "use strict"; 499 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; }); 500 function _classCallCheck(instance, Constructor) { 501 if (!(instance instanceof Constructor)) { 502 throw new TypeError("Cannot call a class as a function"); 503 } 504 } 505 506 /***/ }), 507 508 /***/ 2: 509 /***/ (function(module, exports) { 510 511 (function() { module.exports = this["lodash"]; }()); 512 513 /***/ }), 514 515 /***/ 20: 516 /***/ (function(module, __webpack_exports__, __webpack_require__) { 517 518 "use strict"; 519 520 // EXPORTS 521 __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _inherits; }); 522 523 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js 524 function _setPrototypeOf(o, p) { 525 _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { 526 o.__proto__ = p; 527 return o; 528 }; 529 530 return _setPrototypeOf(o, p); 531 } 532 // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js 533 534 function _inherits(subClass, superClass) { 535 if (typeof superClass !== "function" && superClass !== null) { 536 throw new TypeError("Super expression must either be null or a function"); 537 } 538 539 subClass.prototype = Object.create(superClass && superClass.prototype, { 540 constructor: { 541 value: subClass, 542 writable: true, 543 configurable: true 544 } 545 }); 546 if (superClass) _setPrototypeOf(subClass, superClass); 547 } 548 549 /***/ }), 550 551 /***/ 21: 552 /***/ (function(module, __webpack_exports__, __webpack_require__) { 553 554 "use strict"; 555 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; }); 556 /* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40); 557 /* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10); 558 559 560 function _possibleConstructorReturn(self, call) { 561 if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) { 562 return call; 563 } 564 565 return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self); 566 } 567 568 /***/ }), 569 570 /***/ 246: 571 /***/ (function(module, __webpack_exports__, __webpack_require__) { 572 573 "use strict"; 574 /* WEBPACK VAR INJECTION */(function(process) {/* harmony import */ var _use_media_query__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(126); 575 /** 576 * Internal dependencies 577 */ 578 579 /** 580 * Whether or not the user agent is Internet Explorer. 581 * 582 * @type {boolean} 583 */ 584 585 var IS_IE = typeof window !== 'undefined' && window.navigator.userAgent.indexOf('Trident') >= 0; 586 /** 587 * Hook returning whether the user has a preference for reduced motion. 588 * 589 * @return {boolean} Reduced motion preference value. 590 */ 591 592 var useReducedMotion = process.env.FORCE_REDUCED_MOTION || IS_IE ? function () { 593 return true; 594 } : function () { 595 return Object(_use_media_query__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])('(prefers-reduced-motion: reduce)'); 596 }; 597 /* harmony default export */ __webpack_exports__["a"] = (useReducedMotion); 598 599 /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(100))) 600 601 /***/ }), 602 603 /***/ 26: 604 /***/ (function(module, __webpack_exports__, __webpack_require__) { 605 606 "use strict"; 607 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; }); 608 function _arrayLikeToArray(arr, len) { 609 if (len == null || len > arr.length) len = arr.length; 610 611 for (var i = 0, arr2 = new Array(len); i < len; i++) { 612 arr2[i] = arr[i]; 613 } 614 615 return arr2; 616 } 617 618 /***/ }), 619 620 /***/ 265: 621 /***/ (function(module, exports, __webpack_require__) { 622 623 /*! 624 * clipboard.js v2.0.6 625 * https://clipboardjs.com/ 626 * 627 * Licensed MIT © Zeno Rocha 628 */ 629 (function webpackUniversalModuleDefinition(root, factory) { 630 if(true) 631 module.exports = factory(); 632 else {} 633 })(this, function() { 634 return /******/ (function(modules) { // webpackBootstrap 635 /******/ // The module cache 636 /******/ var installedModules = {}; 637 /******/ 638 /******/ // The require function 639 /******/ function __webpack_require__(moduleId) { 640 /******/ 641 /******/ // Check if module is in cache 642 /******/ if(installedModules[moduleId]) { 643 /******/ return installedModules[moduleId].exports; 644 /******/ } 645 /******/ // Create a new module (and put it into the cache) 646 /******/ var module = installedModules[moduleId] = { 647 /******/ i: moduleId, 648 /******/ l: false, 649 /******/ exports: {} 650 /******/ }; 651 /******/ 652 /******/ // Execute the module function 653 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 654 /******/ 655 /******/ // Flag the module as loaded 656 /******/ module.l = true; 657 /******/ 658 /******/ // Return the exports of the module 659 /******/ return module.exports; 660 /******/ } 661 /******/ 662 /******/ 663 /******/ // expose the modules object (__webpack_modules__) 664 /******/ __webpack_require__.m = modules; 665 /******/ 666 /******/ // expose the module cache 667 /******/ __webpack_require__.c = installedModules; 668 /******/ 669 /******/ // define getter function for harmony exports 670 /******/ __webpack_require__.d = function(exports, name, getter) { 671 /******/ if(!__webpack_require__.o(exports, name)) { 672 /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 673 /******/ } 674 /******/ }; 675 /******/ 676 /******/ // define __esModule on exports 677 /******/ __webpack_require__.r = function(exports) { 678 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 679 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 680 /******/ } 681 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 682 /******/ }; 683 /******/ 684 /******/ // create a fake namespace object 685 /******/ // mode & 1: value is a module id, require it 686 /******/ // mode & 2: merge all properties of value into the ns 687 /******/ // mode & 4: return value when already ns object 688 /******/ // mode & 8|1: behave like require 689 /******/ __webpack_require__.t = function(value, mode) { 690 /******/ if(mode & 1) value = __webpack_require__(value); 691 /******/ if(mode & 8) return value; 692 /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 693 /******/ var ns = Object.create(null); 694 /******/ __webpack_require__.r(ns); 695 /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 696 /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 697 /******/ return ns; 698 /******/ }; 699 /******/ 700 /******/ // getDefaultExport function for compatibility with non-harmony modules 701 /******/ __webpack_require__.n = function(module) { 702 /******/ var getter = module && module.__esModule ? 703 /******/ function getDefault() { return module['default']; } : 704 /******/ function getModuleExports() { return module; }; 705 /******/ __webpack_require__.d(getter, 'a', getter); 706 /******/ return getter; 707 /******/ }; 708 /******/ 709 /******/ // Object.prototype.hasOwnProperty.call 710 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 711 /******/ 712 /******/ // __webpack_public_path__ 713 /******/ __webpack_require__.p = ""; 714 /******/ 715 /******/ 716 /******/ // Load entry module and return exports 717 /******/ return __webpack_require__(__webpack_require__.s = 6); 718 /******/ }) 719 /************************************************************************/ 720 /******/ ([ 721 /* 0 */ 722 /***/ (function(module, exports) { 723 724 function select(element) { 725 var selectedText; 726 727 if (element.nodeName === 'SELECT') { 728 element.focus(); 729 730 selectedText = element.value; 731 } 732 else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') { 733 var isReadOnly = element.hasAttribute('readonly'); 734 735 if (!isReadOnly) { 736 element.setAttribute('readonly', ''); 737 } 738 739 element.select(); 740 element.setSelectionRange(0, element.value.length); 741 742 if (!isReadOnly) { 743 element.removeAttribute('readonly'); 744 } 745 746 selectedText = element.value; 747 } 748 else { 749 if (element.hasAttribute('contenteditable')) { 750 element.focus(); 751 } 752 753 var selection = window.getSelection(); 754 var range = document.createRange(); 755 756 range.selectNodeContents(element); 757 selection.removeAllRanges(); 758 selection.addRange(range); 759 760 selectedText = selection.toString(); 761 } 762 763 return selectedText; 764 } 765 766 module.exports = select; 767 768 769 /***/ }), 770 /* 1 */ 771 /***/ (function(module, exports) { 772 773 function E () { 774 // Keep this empty so it's easier to inherit from 775 // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3) 776 } 777 778 E.prototype = { 779 on: function (name, callback, ctx) { 780 var e = this.e || (this.e = {}); 781 782 (e[name] || (e[name] = [])).push({ 783 fn: callback, 784 ctx: ctx 785 }); 786 787 return this; 788 }, 789 790 once: function (name, callback, ctx) { 791 var self = this; 792 function listener () { 793 self.off(name, listener); 794 callback.apply(ctx, arguments); 795 }; 796 797 listener._ = callback 798 return this.on(name, listener, ctx); 799 }, 800 801 emit: function (name) { 802 var data = [].slice.call(arguments, 1); 803 var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); 804 var i = 0; 805 var len = evtArr.length; 806 807 for (i; i < len; i++) { 808 evtArr[i].fn.apply(evtArr[i].ctx, data); 809 } 810 811 return this; 812 }, 813 814 off: function (name, callback) { 815 var e = this.e || (this.e = {}); 816 var evts = e[name]; 817 var liveEvents = []; 818 819 if (evts && callback) { 820 for (var i = 0, len = evts.length; i < len; i++) { 821 if (evts[i].fn !== callback && evts[i].fn._ !== callback) 822 liveEvents.push(evts[i]); 823 } 824 } 825 826 // Remove event from queue to prevent memory leak 827 // Suggested by https://github.com/lazd 828 // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910 829 830 (liveEvents.length) 831 ? e[name] = liveEvents 832 : delete e[name]; 833 834 return this; 835 } 836 }; 837 838 module.exports = E; 839 module.exports.TinyEmitter = E; 840 841 842 /***/ }), 843 /* 2 */ 844 /***/ (function(module, exports, __webpack_require__) { 845 846 var is = __webpack_require__(3); 847 var delegate = __webpack_require__(4); 848 849 /** 850 * Validates all params and calls the right 851 * listener function based on its target type. 852 * 853 * @param {String|HTMLElement|HTMLCollection|NodeList} target 854 * @param {String} type 855 * @param {Function} callback 856 * @return {Object} 857 */ 858 function listen(target, type, callback) { 859 if (!target && !type && !callback) { 860 throw new Error('Missing required arguments'); 861 } 862 863 if (!is.string(type)) { 864 throw new TypeError('Second argument must be a String'); 865 } 866 867 if (!is.fn(callback)) { 868 throw new TypeError('Third argument must be a Function'); 869 } 870 871 if (is.node(target)) { 872 return listenNode(target, type, callback); 873 } 874 else if (is.nodeList(target)) { 875 return listenNodeList(target, type, callback); 876 } 877 else if (is.string(target)) { 878 return listenSelector(target, type, callback); 879 } 880 else { 881 throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList'); 882 } 883 } 884 885 /** 886 * Adds an event listener to a HTML element 887 * and returns a remove listener function. 888 * 889 * @param {HTMLElement} node 890 * @param {String} type 891 * @param {Function} callback 892 * @return {Object} 893 */ 894 function listenNode(node, type, callback) { 895 node.addEventListener(type, callback); 896 897 return { 898 destroy: function() { 899 node.removeEventListener(type, callback); 900 } 901 } 902 } 903 904 /** 905 * Add an event listener to a list of HTML elements 906 * and returns a remove listener function. 907 * 908 * @param {NodeList|HTMLCollection} nodeList 909 * @param {String} type 910 * @param {Function} callback 911 * @return {Object} 912 */ 913 function listenNodeList(nodeList, type, callback) { 914 Array.prototype.forEach.call(nodeList, function(node) { 915 node.addEventListener(type, callback); 916 }); 917 918 return { 919 destroy: function() { 920 Array.prototype.forEach.call(nodeList, function(node) { 921 node.removeEventListener(type, callback); 922 }); 923 } 924 } 925 } 926 927 /** 928 * Add an event listener to a selector 929 * and returns a remove listener function. 930 * 931 * @param {String} selector 932 * @param {String} type 933 * @param {Function} callback 934 * @return {Object} 935 */ 936 function listenSelector(selector, type, callback) { 937 return delegate(document.body, selector, type, callback); 938 } 939 940 module.exports = listen; 941 942 943 /***/ }), 944 /* 3 */ 945 /***/ (function(module, exports) { 946 947 /** 948 * Check if argument is a HTML element. 949 * 950 * @param {Object} value 951 * @return {Boolean} 952 */ 953 exports.node = function(value) { 954 return value !== undefined 955 && value instanceof HTMLElement 956 && value.nodeType === 1; 957 }; 958 959 /** 960 * Check if argument is a list of HTML elements. 961 * 962 * @param {Object} value 963 * @return {Boolean} 964 */ 965 exports.nodeList = function(value) { 966 var type = Object.prototype.toString.call(value); 967 968 return value !== undefined 969 && (type === '[object NodeList]' || type === '[object HTMLCollection]') 970 && ('length' in value) 971 && (value.length === 0 || exports.node(value[0])); 972 }; 973 974 /** 975 * Check if argument is a string. 976 * 977 * @param {Object} value 978 * @return {Boolean} 979 */ 980 exports.string = function(value) { 981 return typeof value === 'string' 982 || value instanceof String; 983 }; 984 985 /** 986 * Check if argument is a function. 987 * 988 * @param {Object} value 989 * @return {Boolean} 990 */ 991 exports.fn = function(value) { 992 var type = Object.prototype.toString.call(value); 993 994 return type === '[object Function]'; 995 }; 996 997 998 /***/ }), 999 /* 4 */ 1000 /***/ (function(module, exports, __webpack_require__) { 1001 1002 var closest = __webpack_require__(5); 1003 1004 /** 1005 * Delegates event to a selector. 1006 * 1007 * @param {Element} element 1008 * @param {String} selector 1009 * @param {String} type 1010 * @param {Function} callback 1011 * @param {Boolean} useCapture 1012 * @return {Object} 1013 */ 1014 function _delegate(element, selector, type, callback, useCapture) { 1015 var listenerFn = listener.apply(this, arguments); 1016 1017 element.addEventListener(type, listenerFn, useCapture); 1018 1019 return { 1020 destroy: function() { 1021 element.removeEventListener(type, listenerFn, useCapture); 1022 } 1023 } 1024 } 1025 1026 /** 1027 * Delegates event to a selector. 1028 * 1029 * @param {Element|String|Array} [elements] 1030 * @param {String} selector 1031 * @param {String} type 1032 * @param {Function} callback 1033 * @param {Boolean} useCapture 1034 * @return {Object} 1035 */ 1036 function delegate(elements, selector, type, callback, useCapture) { 1037 // Handle the regular Element usage 1038 if (typeof elements.addEventListener === 'function') { 1039 return _delegate.apply(null, arguments); 1040 } 1041 1042 // Handle Element-less usage, it defaults to global delegation 1043 if (typeof type === 'function') { 1044 // Use `document` as the first parameter, then apply arguments 1045 // This is a short way to .unshift `arguments` without running into deoptimizations 1046 return _delegate.bind(null, document).apply(null, arguments); 1047 } 1048 1049 // Handle Selector-based usage 1050 if (typeof elements === 'string') { 1051 elements = document.querySelectorAll(elements); 1052 } 1053 1054 // Handle Array-like based usage 1055 return Array.prototype.map.call(elements, function (element) { 1056 return _delegate(element, selector, type, callback, useCapture); 1057 }); 1058 } 1059 1060 /** 1061 * Finds closest match and invokes callback. 1062 * 1063 * @param {Element} element 1064 * @param {String} selector 1065 * @param {String} type 1066 * @param {Function} callback 1067 * @return {Function} 1068 */ 1069 function listener(element, selector, type, callback) { 1070 return function(e) { 1071 e.delegateTarget = closest(e.target, selector); 1072 1073 if (e.delegateTarget) { 1074 callback.call(element, e); 1075 } 1076 } 1077 } 1078 1079 module.exports = delegate; 1080 1081 1082 /***/ }), 1083 /* 5 */ 1084 /***/ (function(module, exports) { 1085 1086 var DOCUMENT_NODE_TYPE = 9; 1087 1088 /** 1089 * A polyfill for Element.matches() 1090 */ 1091 if (typeof Element !== 'undefined' && !Element.prototype.matches) { 1092 var proto = Element.prototype; 1093 1094 proto.matches = proto.matchesSelector || 1095 proto.mozMatchesSelector || 1096 proto.msMatchesSelector || 1097 proto.oMatchesSelector || 1098 proto.webkitMatchesSelector; 1099 } 1100 1101 /** 1102 * Finds the closest parent that matches a selector. 1103 * 1104 * @param {Element} element 1105 * @param {String} selector 1106 * @return {Function} 1107 */ 1108 function closest (element, selector) { 1109 while (element && element.nodeType !== DOCUMENT_NODE_TYPE) { 1110 if (typeof element.matches === 'function' && 1111 element.matches(selector)) { 1112 return element; 1113 } 1114 element = element.parentNode; 1115 } 1116 } 1117 1118 module.exports = closest; 1119 1120 1121 /***/ }), 1122 /* 6 */ 1123 /***/ (function(module, __webpack_exports__, __webpack_require__) { 1124 1125 "use strict"; 1126 __webpack_require__.r(__webpack_exports__); 1127 1128 // EXTERNAL MODULE: ./node_modules/select/src/select.js 1129 var src_select = __webpack_require__(0); 1130 var select_default = /*#__PURE__*/__webpack_require__.n(src_select); 1131 1132 // CONCATENATED MODULE: ./src/clipboard-action.js 1133 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 1134 1135 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 1136 1137 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1138 1139 1140 1141 /** 1142 * Inner class which performs selection from either `text` or `target` 1143 * properties and then executes copy or cut operations. 1144 */ 1145 1146 var clipboard_action_ClipboardAction = function () { 1147 /** 1148 * @param {Object} options 1149 */ 1150 function ClipboardAction(options) { 1151 _classCallCheck(this, ClipboardAction); 1152 1153 this.resolveOptions(options); 1154 this.initSelection(); 1155 } 1156 1157 /** 1158 * Defines base properties passed from constructor. 1159 * @param {Object} options 1160 */ 1161 1162 1163 _createClass(ClipboardAction, [{ 1164 key: 'resolveOptions', 1165 value: function resolveOptions() { 1166 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 1167 1168 this.action = options.action; 1169 this.container = options.container; 1170 this.emitter = options.emitter; 1171 this.target = options.target; 1172 this.text = options.text; 1173 this.trigger = options.trigger; 1174 1175 this.selectedText = ''; 1176 } 1177 1178 /** 1179 * Decides which selection strategy is going to be applied based 1180 * on the existence of `text` and `target` properties. 1181 */ 1182 1183 }, { 1184 key: 'initSelection', 1185 value: function initSelection() { 1186 if (this.text) { 1187 this.selectFake(); 1188 } else if (this.target) { 1189 this.selectTarget(); 1190 } 1191 } 1192 1193 /** 1194 * Creates a fake textarea element, sets its value from `text` property, 1195 * and makes a selection on it. 1196 */ 1197 1198 }, { 1199 key: 'selectFake', 1200 value: function selectFake() { 1201 var _this = this; 1202 1203 var isRTL = document.documentElement.getAttribute('dir') == 'rtl'; 1204 1205 this.removeFake(); 1206 1207 this.fakeHandlerCallback = function () { 1208 return _this.removeFake(); 1209 }; 1210 this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true; 1211 1212 this.fakeElem = document.createElement('textarea'); 1213 // Prevent zooming on iOS 1214 this.fakeElem.style.fontSize = '12pt'; 1215 // Reset box model 1216 this.fakeElem.style.border = '0'; 1217 this.fakeElem.style.padding = '0'; 1218 this.fakeElem.style.margin = '0'; 1219 // Move element out of screen horizontally 1220 this.fakeElem.style.position = 'absolute'; 1221 this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px'; 1222 // Move element to the same position vertically 1223 var yPosition = window.pageYOffset || document.documentElement.scrollTop; 1224 this.fakeElem.style.top = yPosition + 'px'; 1225 1226 this.fakeElem.setAttribute('readonly', ''); 1227 this.fakeElem.value = this.text; 1228 1229 this.container.appendChild(this.fakeElem); 1230 1231 this.selectedText = select_default()(this.fakeElem); 1232 this.copyText(); 1233 } 1234 1235 /** 1236 * Only removes the fake element after another click event, that way 1237 * a user can hit `Ctrl+C` to copy because selection still exists. 1238 */ 1239 1240 }, { 1241 key: 'removeFake', 1242 value: function removeFake() { 1243 if (this.fakeHandler) { 1244 this.container.removeEventListener('click', this.fakeHandlerCallback); 1245 this.fakeHandler = null; 1246 this.fakeHandlerCallback = null; 1247 } 1248 1249 if (this.fakeElem) { 1250 this.container.removeChild(this.fakeElem); 1251 this.fakeElem = null; 1252 } 1253 } 1254 1255 /** 1256 * Selects the content from element passed on `target` property. 1257 */ 1258 1259 }, { 1260 key: 'selectTarget', 1261 value: function selectTarget() { 1262 this.selectedText = select_default()(this.target); 1263 this.copyText(); 1264 } 1265 1266 /** 1267 * Executes the copy operation based on the current selection. 1268 */ 1269 1270 }, { 1271 key: 'copyText', 1272 value: function copyText() { 1273 var succeeded = void 0; 1274 1275 try { 1276 succeeded = document.execCommand(this.action); 1277 } catch (err) { 1278 succeeded = false; 1279 } 1280 1281 this.handleResult(succeeded); 1282 } 1283 1284 /** 1285 * Fires an event based on the copy operation result. 1286 * @param {Boolean} succeeded 1287 */ 1288 1289 }, { 1290 key: 'handleResult', 1291 value: function handleResult(succeeded) { 1292 this.emitter.emit(succeeded ? 'success' : 'error', { 1293 action: this.action, 1294 text: this.selectedText, 1295 trigger: this.trigger, 1296 clearSelection: this.clearSelection.bind(this) 1297 }); 1298 } 1299 1300 /** 1301 * Moves focus away from `target` and back to the trigger, removes current selection. 1302 */ 1303 1304 }, { 1305 key: 'clearSelection', 1306 value: function clearSelection() { 1307 if (this.trigger) { 1308 this.trigger.focus(); 1309 } 1310 document.activeElement.blur(); 1311 window.getSelection().removeAllRanges(); 1312 } 1313 1314 /** 1315 * Sets the `action` to be performed which can be either 'copy' or 'cut'. 1316 * @param {String} action 1317 */ 1318 1319 }, { 1320 key: 'destroy', 1321 1322 1323 /** 1324 * Destroy lifecycle. 1325 */ 1326 value: function destroy() { 1327 this.removeFake(); 1328 } 1329 }, { 1330 key: 'action', 1331 set: function set() { 1332 var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy'; 1333 1334 this._action = action; 1335 1336 if (this._action !== 'copy' && this._action !== 'cut') { 1337 throw new Error('Invalid "action" value, use either "copy" or "cut"'); 1338 } 1339 } 1340 1341 /** 1342 * Gets the `action` property. 1343 * @return {String} 1344 */ 1345 , 1346 get: function get() { 1347 return this._action; 1348 } 1349 1350 /** 1351 * Sets the `target` property using an element 1352 * that will be have its content copied. 1353 * @param {Element} target 1354 */ 1355 1356 }, { 1357 key: 'target', 1358 set: function set(target) { 1359 if (target !== undefined) { 1360 if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) { 1361 if (this.action === 'copy' && target.hasAttribute('disabled')) { 1362 throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute'); 1363 } 1364 1365 if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) { 1366 throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes'); 1367 } 1368 1369 this._target = target; 1370 } else { 1371 throw new Error('Invalid "target" value, use a valid Element'); 1372 } 1373 } 1374 } 1375 1376 /** 1377 * Gets the `target` property. 1378 * @return {String|HTMLElement} 1379 */ 1380 , 1381 get: function get() { 1382 return this._target; 1383 } 1384 }]); 1385 1386 return ClipboardAction; 1387 }(); 1388 1389 /* harmony default export */ var clipboard_action = (clipboard_action_ClipboardAction); 1390 // EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js 1391 var tiny_emitter = __webpack_require__(1); 1392 var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter); 1393 1394 // EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js 1395 var listen = __webpack_require__(2); 1396 var listen_default = /*#__PURE__*/__webpack_require__.n(listen); 1397 1398 // CONCATENATED MODULE: ./src/clipboard.js 1399 var clipboard_typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 1400 1401 var clipboard_createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 1402 1403 function clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1404 1405 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 1406 1407 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 1408 1409 1410 1411 1412 1413 /** 1414 * Base class which takes one or more elements, adds event listeners to them, 1415 * and instantiates a new `ClipboardAction` on each click. 1416 */ 1417 1418 var clipboard_Clipboard = function (_Emitter) { 1419 _inherits(Clipboard, _Emitter); 1420 1421 /** 1422 * @param {String|HTMLElement|HTMLCollection|NodeList} trigger 1423 * @param {Object} options 1424 */ 1425 function Clipboard(trigger, options) { 1426 clipboard_classCallCheck(this, Clipboard); 1427 1428 var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this)); 1429 1430 _this.resolveOptions(options); 1431 _this.listenClick(trigger); 1432 return _this; 1433 } 1434 1435 /** 1436 * Defines if attributes would be resolved using internal setter functions 1437 * or custom functions that were passed in the constructor. 1438 * @param {Object} options 1439 */ 1440 1441 1442 clipboard_createClass(Clipboard, [{ 1443 key: 'resolveOptions', 1444 value: function resolveOptions() { 1445 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 1446 1447 this.action = typeof options.action === 'function' ? options.action : this.defaultAction; 1448 this.target = typeof options.target === 'function' ? options.target : this.defaultTarget; 1449 this.text = typeof options.text === 'function' ? options.text : this.defaultText; 1450 this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body; 1451 } 1452 1453 /** 1454 * Adds a click event listener to the passed trigger. 1455 * @param {String|HTMLElement|HTMLCollection|NodeList} trigger 1456 */ 1457 1458 }, { 1459 key: 'listenClick', 1460 value: function listenClick(trigger) { 1461 var _this2 = this; 1462 1463 this.listener = listen_default()(trigger, 'click', function (e) { 1464 return _this2.onClick(e); 1465 }); 1466 } 1467 1468 /** 1469 * Defines a new `ClipboardAction` on each click event. 1470 * @param {Event} e 1471 */ 1472 1473 }, { 1474 key: 'onClick', 1475 value: function onClick(e) { 1476 var trigger = e.delegateTarget || e.currentTarget; 1477 1478 if (this.clipboardAction) { 1479 this.clipboardAction = null; 1480 } 1481 1482 this.clipboardAction = new clipboard_action({ 1483 action: this.action(trigger), 1484 target: this.target(trigger), 1485 text: this.text(trigger), 1486 container: this.container, 1487 trigger: trigger, 1488 emitter: this 1489 }); 1490 } 1491 1492 /** 1493 * Default `action` lookup function. 1494 * @param {Element} trigger 1495 */ 1496 1497 }, { 1498 key: 'defaultAction', 1499 value: function defaultAction(trigger) { 1500 return getAttributeValue('action', trigger); 1501 } 1502 1503 /** 1504 * Default `target` lookup function. 1505 * @param {Element} trigger 1506 */ 1507 1508 }, { 1509 key: 'defaultTarget', 1510 value: function defaultTarget(trigger) { 1511 var selector = getAttributeValue('target', trigger); 1512 1513 if (selector) { 1514 return document.querySelector(selector); 1515 } 1516 } 1517 1518 /** 1519 * Returns the support of the given action, or all actions if no action is 1520 * given. 1521 * @param {String} [action] 1522 */ 1523 1524 }, { 1525 key: 'defaultText', 1526 1527 1528 /** 1529 * Default `text` lookup function. 1530 * @param {Element} trigger 1531 */ 1532 value: function defaultText(trigger) { 1533 return getAttributeValue('text', trigger); 1534 } 1535 1536 /** 1537 * Destroy lifecycle. 1538 */ 1539 1540 }, { 1541 key: 'destroy', 1542 value: function destroy() { 1543 this.listener.destroy(); 1544 1545 if (this.clipboardAction) { 1546 this.clipboardAction.destroy(); 1547 this.clipboardAction = null; 1548 } 1549 } 1550 }], [{ 1551 key: 'isSupported', 1552 value: function isSupported() { 1553 var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut']; 1554 1555 var actions = typeof action === 'string' ? [action] : action; 1556 var support = !!document.queryCommandSupported; 1557 1558 actions.forEach(function (action) { 1559 support = support && !!document.queryCommandSupported(action); 1560 }); 1561 1562 return support; 1563 } 1564 }]); 1565 1566 return Clipboard; 1567 }(tiny_emitter_default.a); 1568 1569 /** 1570 * Helper function to retrieve attribute value. 1571 * @param {String} suffix 1572 * @param {Element} element 1573 */ 1574 1575 1576 function getAttributeValue(suffix, element) { 1577 var attribute = 'data-clipboard-' + suffix; 1578 1579 if (!element.hasAttribute(attribute)) { 1580 return; 1581 } 1582 1583 return element.getAttribute(attribute); 1584 } 1585 1586 /* harmony default export */ var clipboard = __webpack_exports__["default"] = (clipboard_Clipboard); 1587 1588 /***/ }) 1589 /******/ ])["default"]; 1590 }); 1591 1592 /***/ }), 1593 1594 /***/ 266: 1595 /***/ (function(module, exports, __webpack_require__) { 1596 1597 var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */ 1598 /** 1599 * Copyright 2012-2017 Craig Campbell 1600 * 1601 * Licensed under the Apache License, Version 2.0 (the "License"); 1602 * you may not use this file except in compliance with the License. 1603 * You may obtain a copy of the License at 1604 * 1605 * http://www.apache.org/licenses/LICENSE-2.0 1606 * 1607 * Unless required by applicable law or agreed to in writing, software 1608 * distributed under the License is distributed on an "AS IS" BASIS, 1609 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1610 * See the License for the specific language governing permissions and 1611 * limitations under the License. 1612 * 1613 * Mousetrap is a simple keyboard shortcut library for Javascript with 1614 * no external dependencies 1615 * 1616 * @version 1.6.5 1617 * @url craig.is/killing/mice 1618 */ 1619 (function(window, document, undefined) { 1620 1621 // Check if mousetrap is used inside browser, if not, return 1622 if (!window) { 1623 return; 1624 } 1625 1626 /** 1627 * mapping of special keycodes to their corresponding keys 1628 * 1629 * everything in this dictionary cannot use keypress events 1630 * so it has to be here to map to the correct keycodes for 1631 * keyup/keydown events 1632 * 1633 * @type {Object} 1634 */ 1635 var _MAP = { 1636 8: 'backspace', 1637 9: 'tab', 1638 13: 'enter', 1639 16: 'shift', 1640 17: 'ctrl', 1641 18: 'alt', 1642 20: 'capslock', 1643 27: 'esc', 1644 32: 'space', 1645 33: 'pageup', 1646 34: 'pagedown', 1647 35: 'end', 1648 36: 'home', 1649 37: 'left', 1650 38: 'up', 1651 39: 'right', 1652 40: 'down', 1653 45: 'ins', 1654 46: 'del', 1655 91: 'meta', 1656 93: 'meta', 1657 224: 'meta' 1658 }; 1659 1660 /** 1661 * mapping for special characters so they can support 1662 * 1663 * this dictionary is only used incase you want to bind a 1664 * keyup or keydown event to one of these keys 1665 * 1666 * @type {Object} 1667 */ 1668 var _KEYCODE_MAP = { 1669 106: '*', 1670 107: '+', 1671 109: '-', 1672 110: '.', 1673 111 : '/', 1674 186: ';', 1675 187: '=', 1676 188: ',', 1677 189: '-', 1678 190: '.', 1679 191: '/', 1680 192: '`', 1681 219: '[', 1682 220: '\\', 1683 221: ']', 1684 222: '\'' 1685 }; 1686 1687 /** 1688 * this is a mapping of keys that require shift on a US keypad 1689 * back to the non shift equivelents 1690 * 1691 * this is so you can use keyup events with these keys 1692 * 1693 * note that this will only work reliably on US keyboards 1694 * 1695 * @type {Object} 1696 */ 1697 var _SHIFT_MAP = { 1698 '~': '`', 1699 '!': '1', 1700 '@': '2', 1701 '#': '3', 1702 '$': '4', 1703 '%': '5', 1704 '^': '6', 1705 '&': '7', 1706 '*': '8', 1707 '(': '9', 1708 ')': '0', 1709 '_': '-', 1710 '+': '=', 1711 ':': ';', 1712 '\"': '\'', 1713 '<': ',', 1714 '>': '.', 1715 '?': '/', 1716 '|': '\\' 1717 }; 1718 1719 /** 1720 * this is a list of special strings you can use to map 1721 * to modifier keys when you specify your keyboard shortcuts 1722 * 1723 * @type {Object} 1724 */ 1725 var _SPECIAL_ALIASES = { 1726 'option': 'alt', 1727 'command': 'meta', 1728 'return': 'enter', 1729 'escape': 'esc', 1730 'plus': '+', 1731 'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl' 1732 }; 1733 1734 /** 1735 * variable to store the flipped version of _MAP from above 1736 * needed to check if we should use keypress or not when no action 1737 * is specified 1738 * 1739 * @type {Object|undefined} 1740 */ 1741 var _REVERSE_MAP; 1742 1743 /** 1744 * loop through the f keys, f1 to f19 and add them to the map 1745 * programatically 1746 */ 1747 for (var i = 1; i < 20; ++i) { 1748 _MAP[111 + i] = 'f' + i; 1749 } 1750 1751 /** 1752 * loop through to map numbers on the numeric keypad 1753 */ 1754 for (i = 0; i <= 9; ++i) { 1755 1756 // This needs to use a string cause otherwise since 0 is falsey 1757 // mousetrap will never fire for numpad 0 pressed as part of a keydown 1758 // event. 1759 // 1760 // @see https://github.com/ccampbell/mousetrap/pull/258 1761 _MAP[i + 96] = i.toString(); 1762 } 1763 1764 /** 1765 * cross browser add event method 1766 * 1767 * @param {Element|HTMLDocument} object 1768 * @param {string} type 1769 * @param {Function} callback 1770 * @returns void 1771 */ 1772 function _addEvent(object, type, callback) { 1773 if (object.addEventListener) { 1774 object.addEventListener(type, callback, false); 1775 return; 1776 } 1777 1778 object.attachEvent('on' + type, callback); 1779 } 1780 1781 /** 1782 * takes the event and returns the key character 1783 * 1784 * @param {Event} e 1785 * @return {string} 1786 */ 1787 function _characterFromEvent(e) { 1788 1789 // for keypress events we should return the character as is 1790 if (e.type == 'keypress') { 1791 var character = String.fromCharCode(e.which); 1792 1793 // if the shift key is not pressed then it is safe to assume 1794 // that we want the character to be lowercase. this means if 1795 // you accidentally have caps lock on then your key bindings 1796 // will continue to work 1797 // 1798 // the only side effect that might not be desired is if you 1799 // bind something like 'A' cause you want to trigger an 1800 // event when capital A is pressed caps lock will no longer 1801 // trigger the event. shift+a will though. 1802 if (!e.shiftKey) { 1803 character = character.toLowerCase(); 1804 } 1805 1806 return character; 1807 } 1808 1809 // for non keypress events the special maps are needed 1810 if (_MAP[e.which]) { 1811 return _MAP[e.which]; 1812 } 1813 1814 if (_KEYCODE_MAP[e.which]) { 1815 return _KEYCODE_MAP[e.which]; 1816 } 1817 1818 // if it is not in the special map 1819 1820 // with keydown and keyup events the character seems to always 1821 // come in as an uppercase character whether you are pressing shift 1822 // or not. we should make sure it is always lowercase for comparisons 1823 return String.fromCharCode(e.which).toLowerCase(); 1824 } 1825 1826 /** 1827 * checks if two arrays are equal 1828 * 1829 * @param {Array} modifiers1 1830 * @param {Array} modifiers2 1831 * @returns {boolean} 1832 */ 1833 function _modifiersMatch(modifiers1, modifiers2) { 1834 return modifiers1.sort().join(',') === modifiers2.sort().join(','); 1835 } 1836 1837 /** 1838 * takes a key event and figures out what the modifiers are 1839 * 1840 * @param {Event} e 1841 * @returns {Array} 1842 */ 1843 function _eventModifiers(e) { 1844 var modifiers = []; 1845 1846 if (e.shiftKey) { 1847 modifiers.push('shift'); 1848 } 1849 1850 if (e.altKey) { 1851 modifiers.push('alt'); 1852 } 1853 1854 if (e.ctrlKey) { 1855 modifiers.push('ctrl'); 1856 } 1857 1858 if (e.metaKey) { 1859 modifiers.push('meta'); 1860 } 1861 1862 return modifiers; 1863 } 1864 1865 /** 1866 * prevents default for this event 1867 * 1868 * @param {Event} e 1869 * @returns void 1870 */ 1871 function _preventDefault(e) { 1872 if (e.preventDefault) { 1873 e.preventDefault(); 1874 return; 1875 } 1876 1877 e.returnValue = false; 1878 } 1879 1880 /** 1881 * stops propogation for this event 1882 * 1883 * @param {Event} e 1884 * @returns void 1885 */ 1886 function _stopPropagation(e) { 1887 if (e.stopPropagation) { 1888 e.stopPropagation(); 1889 return; 1890 } 1891 1892 e.cancelBubble = true; 1893 } 1894 1895 /** 1896 * determines if the keycode specified is a modifier key or not 1897 * 1898 * @param {string} key 1899 * @returns {boolean} 1900 */ 1901 function _isModifier(key) { 1902 return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta'; 1903 } 1904 1905 /** 1906 * reverses the map lookup so that we can look for specific keys 1907 * to see what can and can't use keypress 1908 * 1909 * @return {Object} 1910 */ 1911 function _getReverseMap() { 1912 if (!_REVERSE_MAP) { 1913 _REVERSE_MAP = {}; 1914 for (var key in _MAP) { 1915 1916 // pull out the numeric keypad from here cause keypress should 1917 // be able to detect the keys from the character 1918 if (key > 95 && key < 112) { 1919 continue; 1920 } 1921 1922 if (_MAP.hasOwnProperty(key)) { 1923 _REVERSE_MAP[_MAP[key]] = key; 1924 } 1925 } 1926 } 1927 return _REVERSE_MAP; 1928 } 1929 1930 /** 1931 * picks the best action based on the key combination 1932 * 1933 * @param {string} key - character for key 1934 * @param {Array} modifiers 1935 * @param {string=} action passed in 1936 */ 1937 function _pickBestAction(key, modifiers, action) { 1938 1939 // if no action was picked in we should try to pick the one 1940 // that we think would work best for this key 1941 if (!action) { 1942 action = _getReverseMap()[key] ? 'keydown' : 'keypress'; 1943 } 1944 1945 // modifier keys don't work as expected with keypress, 1946 // switch to keydown 1947 if (action == 'keypress' && modifiers.length) { 1948 action = 'keydown'; 1949 } 1950 1951 return action; 1952 } 1953 1954 /** 1955 * Converts from a string key combination to an array 1956 * 1957 * @param {string} combination like "command+shift+l" 1958 * @return {Array} 1959 */ 1960 function _keysFromString(combination) { 1961 if (combination === '+') { 1962 return ['+']; 1963 } 1964 1965 combination = combination.replace(/\+{2}/g, '+plus'); 1966 return combination.split('+'); 1967 } 1968 1969 /** 1970 * Gets info for a specific key combination 1971 * 1972 * @param {string} combination key combination ("command+s" or "a" or "*") 1973 * @param {string=} action 1974 * @returns {Object} 1975 */ 1976 function _getKeyInfo(combination, action) { 1977 var keys; 1978 var key; 1979 var i; 1980 var modifiers = []; 1981 1982 // take the keys from this pattern and figure out what the actual 1983 // pattern is all about 1984 keys = _keysFromString(combination); 1985 1986 for (i = 0; i < keys.length; ++i) { 1987 key = keys[i]; 1988 1989 // normalize key names 1990 if (_SPECIAL_ALIASES[key]) { 1991 key = _SPECIAL_ALIASES[key]; 1992 } 1993 1994 // if this is not a keypress event then we should 1995 // be smart about using shift keys 1996 // this will only work for US keyboards however 1997 if (action && action != 'keypress' && _SHIFT_MAP[key]) { 1998 key = _SHIFT_MAP[key]; 1999 modifiers.push('shift'); 2000 } 2001 2002 // if this key is a modifier then add it to the list of modifiers 2003 if (_isModifier(key)) { 2004 modifiers.push(key); 2005 } 2006 } 2007 2008 // depending on what the key combination is 2009 // we will try to pick the best event for it 2010 action = _pickBestAction(key, modifiers, action); 2011 2012 return { 2013 key: key, 2014 modifiers: modifiers, 2015 action: action 2016 }; 2017 } 2018 2019 function _belongsTo(element, ancestor) { 2020 if (element === null || element === document) { 2021 return false; 2022 } 2023 2024 if (element === ancestor) { 2025 return true; 2026 } 2027 2028 return _belongsTo(element.parentNode, ancestor); 2029 } 2030 2031 function Mousetrap(targetElement) { 2032 var self = this; 2033 2034 targetElement = targetElement || document; 2035 2036 if (!(self instanceof Mousetrap)) { 2037 return new Mousetrap(targetElement); 2038 } 2039 2040 /** 2041 * element to attach key events to 2042 * 2043 * @type {Element} 2044 */ 2045 self.target = targetElement; 2046 2047 /** 2048 * a list of all the callbacks setup via Mousetrap.bind() 2049 * 2050 * @type {Object} 2051 */ 2052 self._callbacks = {}; 2053 2054 /** 2055 * direct map of string combinations to callbacks used for trigger() 2056 * 2057 * @type {Object} 2058 */ 2059 self._directMap = {}; 2060 2061 /** 2062 * keeps track of what level each sequence is at since multiple 2063 * sequences can start out with the same sequence 2064 * 2065 * @type {Object} 2066 */ 2067 var _sequenceLevels = {}; 2068 2069 /** 2070 * variable to store the setTimeout call 2071 * 2072 * @type {null|number} 2073 */ 2074 var _resetTimer; 2075 2076 /** 2077 * temporary state where we will ignore the next keyup 2078 * 2079 * @type {boolean|string} 2080 */ 2081 var _ignoreNextKeyup = false; 2082 2083 /** 2084 * temporary state where we will ignore the next keypress 2085 * 2086 * @type {boolean} 2087 */ 2088 var _ignoreNextKeypress = false; 2089 2090 /** 2091 * are we currently inside of a sequence? 2092 * type of action ("keyup" or "keydown" or "keypress") or false 2093 * 2094 * @type {boolean|string} 2095 */ 2096 var _nextExpectedAction = false; 2097 2098 /** 2099 * resets all sequence counters except for the ones passed in 2100 * 2101 * @param {Object} doNotReset 2102 * @returns void 2103 */ 2104 function _resetSequences(doNotReset) { 2105 doNotReset = doNotReset || {}; 2106 2107 var activeSequences = false, 2108 key; 2109 2110 for (key in _sequenceLevels) { 2111 if (doNotReset[key]) { 2112 activeSequences = true; 2113 continue; 2114 } 2115 _sequenceLevels[key] = 0; 2116 } 2117 2118 if (!activeSequences) { 2119 _nextExpectedAction = false; 2120 } 2121 } 2122 2123 /** 2124 * finds all callbacks that match based on the keycode, modifiers, 2125 * and action 2126 * 2127 * @param {string} character 2128 * @param {Array} modifiers 2129 * @param {Event|Object} e 2130 * @param {string=} sequenceName - name of the sequence we are looking for 2131 * @param {string=} combination 2132 * @param {number=} level 2133 * @returns {Array} 2134 */ 2135 function _getMatches(character, modifiers, e, sequenceName, combination, level) { 2136 var i; 2137 var callback; 2138 var matches = []; 2139 var action = e.type; 2140 2141 // if there are no events related to this keycode 2142 if (!self._callbacks[character]) { 2143 return []; 2144 } 2145 2146 // if a modifier key is coming up on its own we should allow it 2147 if (action == 'keyup' && _isModifier(character)) { 2148 modifiers = [character]; 2149 } 2150 2151 // loop through all callbacks for the key that was pressed 2152 // and see if any of them match 2153 for (i = 0; i < self._callbacks[character].length; ++i) { 2154 callback = self._callbacks[character][i]; 2155 2156 // if a sequence name is not specified, but this is a sequence at 2157 // the wrong level then move onto the next match 2158 if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) { 2159 continue; 2160 } 2161 2162 // if the action we are looking for doesn't match the action we got 2163 // then we should keep going 2164 if (action != callback.action) { 2165 continue; 2166 } 2167 2168 // if this is a keypress event and the meta key and control key 2169 // are not pressed that means that we need to only look at the 2170 // character, otherwise check the modifiers as well 2171 // 2172 // chrome will not fire a keypress if meta or control is down 2173 // safari will fire a keypress if meta or meta+shift is down 2174 // firefox will fire a keypress if meta or control is down 2175 if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) { 2176 2177 // when you bind a combination or sequence a second time it 2178 // should overwrite the first one. if a sequenceName or 2179 // combination is specified in this call it does just that 2180 // 2181 // @todo make deleting its own method? 2182 var deleteCombo = !sequenceName && callback.combo == combination; 2183 var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level; 2184 if (deleteCombo || deleteSequence) { 2185 self._callbacks[character].splice(i, 1); 2186 } 2187 2188 matches.push(callback); 2189 } 2190 } 2191 2192 return matches; 2193 } 2194 2195 /** 2196 * actually calls the callback function 2197 * 2198 * if your callback function returns false this will use the jquery 2199 * convention - prevent default and stop propogation on the event 2200 * 2201 * @param {Function} callback 2202 * @param {Event} e 2203 * @returns void 2204 */ 2205 function _fireCallback(callback, e, combo, sequence) { 2206 2207 // if this event should not happen stop here 2208 if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) { 2209 return; 2210 } 2211 2212 if (callback(e, combo) === false) { 2213 _preventDefault(e); 2214 _stopPropagation(e); 2215 } 2216 } 2217 2218 /** 2219 * handles a character key event 2220 * 2221 * @param {string} character 2222 * @param {Array} modifiers 2223 * @param {Event} e 2224 * @returns void 2225 */ 2226 self._handleKey = function(character, modifiers, e) { 2227 var callbacks = _getMatches(character, modifiers, e); 2228 var i; 2229 var doNotReset = {}; 2230 var maxLevel = 0; 2231 var processedSequenceCallback = false; 2232 2233 // Calculate the maxLevel for sequences so we can only execute the longest callback sequence 2234 for (i = 0; i < callbacks.length; ++i) { 2235 if (callbacks[i].seq) { 2236 maxLevel = Math.max(maxLevel, callbacks[i].level); 2237 } 2238 } 2239 2240 // loop through matching callbacks for this key event 2241 for (i = 0; i < callbacks.length; ++i) { 2242 2243 // fire for all sequence callbacks 2244 // this is because if for example you have multiple sequences 2245 // bound such as "g i" and "g t" they both need to fire the 2246 // callback for matching g cause otherwise you can only ever 2247 // match the first one 2248 if (callbacks[i].seq) { 2249 2250 // only fire callbacks for the maxLevel to prevent 2251 // subsequences from also firing 2252 // 2253 // for example 'a option b' should not cause 'option b' to fire 2254 // even though 'option b' is part of the other sequence 2255 // 2256 // any sequences that do not match here will be discarded 2257 // below by the _resetSequences call 2258 if (callbacks[i].level != maxLevel) { 2259 continue; 2260 } 2261 2262 processedSequenceCallback = true; 2263 2264 // keep a list of which sequences were matches for later 2265 doNotReset[callbacks[i].seq] = 1; 2266 _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq); 2267 continue; 2268 } 2269 2270 // if there were no sequence matches but we are still here 2271 // that means this is a regular match so we should fire that 2272 if (!processedSequenceCallback) { 2273 _fireCallback(callbacks[i].callback, e, callbacks[i].combo); 2274 } 2275 } 2276 2277 // if the key you pressed matches the type of sequence without 2278 // being a modifier (ie "keyup" or "keypress") then we should 2279 // reset all sequences that were not matched by this event 2280 // 2281 // this is so, for example, if you have the sequence "h a t" and you 2282 // type "h e a r t" it does not match. in this case the "e" will 2283 // cause the sequence to reset 2284 // 2285 // modifier keys are ignored because you can have a sequence 2286 // that contains modifiers such as "enter ctrl+space" and in most 2287 // cases the modifier key will be pressed before the next key 2288 // 2289 // also if you have a sequence such as "ctrl+b a" then pressing the 2290 // "b" key will trigger a "keypress" and a "keydown" 2291 // 2292 // the "keydown" is expected when there is a modifier, but the 2293 // "keypress" ends up matching the _nextExpectedAction since it occurs 2294 // after and that causes the sequence to reset 2295 // 2296 // we ignore keypresses in a sequence that directly follow a keydown 2297 // for the same character 2298 var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress; 2299 if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) { 2300 _resetSequences(doNotReset); 2301 } 2302 2303 _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown'; 2304 }; 2305 2306 /** 2307 * handles a keydown event 2308 * 2309 * @param {Event} e 2310 * @returns void 2311 */ 2312 function _handleKeyEvent(e) { 2313 2314 // normalize e.which for key events 2315 // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion 2316 if (typeof e.which !== 'number') { 2317 e.which = e.keyCode; 2318 } 2319 2320 var character = _characterFromEvent(e); 2321 2322 // no character found then stop 2323 if (!character) { 2324 return; 2325 } 2326 2327 // need to use === for the character check because the character can be 0 2328 if (e.type == 'keyup' && _ignoreNextKeyup === character) { 2329 _ignoreNextKeyup = false; 2330 return; 2331 } 2332 2333 self.handleKey(character, _eventModifiers(e), e); 2334 } 2335 2336 /** 2337 * called to set a 1 second timeout on the specified sequence 2338 * 2339 * this is so after each key press in the sequence you have 1 second 2340 * to press the next key before you have to start over 2341 * 2342 * @returns void 2343 */ 2344 function _resetSequenceTimer() { 2345 clearTimeout(_resetTimer); 2346 _resetTimer = setTimeout(_resetSequences, 1000); 2347 } 2348 2349 /** 2350 * binds a key sequence to an event 2351 * 2352 * @param {string} combo - combo specified in bind call 2353 * @param {Array} keys 2354 * @param {Function} callback 2355 * @param {string=} action 2356 * @returns void 2357 */ 2358 function _bindSequence(combo, keys, callback, action) { 2359 2360 // start off by adding a sequence level record for this combination 2361 // and setting the level to 0 2362 _sequenceLevels[combo] = 0; 2363 2364 /** 2365 * callback to increase the sequence level for this sequence and reset 2366 * all other sequences that were active 2367 * 2368 * @param {string} nextAction 2369 * @returns {Function} 2370 */ 2371 function _increaseSequence(nextAction) { 2372 return function() { 2373 _nextExpectedAction = nextAction; 2374 ++_sequenceLevels[combo]; 2375 _resetSequenceTimer(); 2376 }; 2377 } 2378 2379 /** 2380 * wraps the specified callback inside of another function in order 2381 * to reset all sequence counters as soon as this sequence is done 2382 * 2383 * @param {Event} e 2384 * @returns void 2385 */ 2386 function _callbackAndReset(e) { 2387 _fireCallback(callback, e, combo); 2388 2389 // we should ignore the next key up if the action is key down 2390 // or keypress. this is so if you finish a sequence and 2391 // release the key the final key will not trigger a keyup 2392 if (action !== 'keyup') { 2393 _ignoreNextKeyup = _characterFromEvent(e); 2394 } 2395 2396 // weird race condition if a sequence ends with the key 2397 // another sequence begins with 2398 setTimeout(_resetSequences, 10); 2399 } 2400 2401 // loop through keys one at a time and bind the appropriate callback 2402 // function. for any key leading up to the final one it should 2403 // increase the sequence. after the final, it should reset all sequences 2404 // 2405 // if an action is specified in the original bind call then that will 2406 // be used throughout. otherwise we will pass the action that the 2407 // next key in the sequence should match. this allows a sequence 2408 // to mix and match keypress and keydown events depending on which 2409 // ones are better suited to the key provided 2410 for (var i = 0; i < keys.length; ++i) { 2411 var isFinal = i + 1 === keys.length; 2412 var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action); 2413 _bindSingle(keys[i], wrappedCallback, action, combo, i); 2414 } 2415 } 2416 2417 /** 2418 * binds a single keyboard combination 2419 * 2420 * @param {string} combination 2421 * @param {Function} callback 2422 * @param {string=} action 2423 * @param {string=} sequenceName - name of sequence if part of sequence 2424 * @param {number=} level - what part of the sequence the command is 2425 * @returns void 2426 */ 2427 function _bindSingle(combination, callback, action, sequenceName, level) { 2428 2429 // store a direct mapped reference for use with Mousetrap.trigger 2430 self._directMap[combination + ':' + action] = callback; 2431 2432 // make sure multiple spaces in a row become a single space 2433 combination = combination.replace(/\s+/g, ' '); 2434 2435 var sequence = combination.split(' '); 2436 var info; 2437 2438 // if this pattern is a sequence of keys then run through this method 2439 // to reprocess each pattern one key at a time 2440 if (sequence.length > 1) { 2441 _bindSequence(combination, sequence, callback, action); 2442 return; 2443 } 2444 2445 info = _getKeyInfo(combination, action); 2446 2447 // make sure to initialize array if this is the first time 2448 // a callback is added for this key 2449 self._callbacks[info.key] = self._callbacks[info.key] || []; 2450 2451 // remove an existing match if there is one 2452 _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level); 2453 2454 // add this call back to the array 2455 // if it is a sequence put it at the beginning 2456 // if not put it at the end 2457 // 2458 // this is important because the way these are processed expects 2459 // the sequence ones to come first 2460 self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({ 2461 callback: callback, 2462 modifiers: info.modifiers, 2463 action: info.action, 2464 seq: sequenceName, 2465 level: level, 2466 combo: combination 2467 }); 2468 } 2469 2470 /** 2471 * binds multiple combinations to the same callback 2472 * 2473 * @param {Array} combinations 2474 * @param {Function} callback 2475 * @param {string|undefined} action 2476 * @returns void 2477 */ 2478 self._bindMultiple = function(combinations, callback, action) { 2479 for (var i = 0; i < combinations.length; ++i) { 2480 _bindSingle(combinations[i], callback, action); 2481 } 2482 }; 2483 2484 // start! 2485 _addEvent(targetElement, 'keypress', _handleKeyEvent); 2486 _addEvent(targetElement, 'keydown', _handleKeyEvent); 2487 _addEvent(targetElement, 'keyup', _handleKeyEvent); 2488 } 2489 2490 /** 2491 * binds an event to mousetrap 2492 * 2493 * can be a single key, a combination of keys separated with +, 2494 * an array of keys, or a sequence of keys separated by spaces 2495 * 2496 * be sure to list the modifier keys first to make sure that the 2497 * correct key ends up getting bound (the last key in the pattern) 2498 * 2499 * @param {string|Array} keys 2500 * @param {Function} callback 2501 * @param {string=} action - 'keypress', 'keydown', or 'keyup' 2502 * @returns void 2503 */ 2504 Mousetrap.prototype.bind = function(keys, callback, action) { 2505 var self = this; 2506 keys = keys instanceof Array ? keys : [keys]; 2507 self._bindMultiple.call(self, keys, callback, action); 2508 return self; 2509 }; 2510 2511 /** 2512 * unbinds an event to mousetrap 2513 * 2514 * the unbinding sets the callback function of the specified key combo 2515 * to an empty function and deletes the corresponding key in the 2516 * _directMap dict. 2517 * 2518 * TODO: actually remove this from the _callbacks dictionary instead 2519 * of binding an empty function 2520 * 2521 * the keycombo+action has to be exactly the same as 2522 * it was defined in the bind method 2523 * 2524 * @param {string|Array} keys 2525 * @param {string} action 2526 * @returns void 2527 */ 2528 Mousetrap.prototype.unbind = function(keys, action) { 2529 var self = this; 2530 return self.bind.call(self, keys, function() {}, action); 2531 }; 2532 2533 /** 2534 * triggers an event that has already been bound 2535 * 2536 * @param {string} keys 2537 * @param {string=} action 2538 * @returns void 2539 */ 2540 Mousetrap.prototype.trigger = function(keys, action) { 2541 var self = this; 2542 if (self._directMap[keys + ':' + action]) { 2543 self._directMap[keys + ':' + action]({}, keys); 2544 } 2545 return self; 2546 }; 2547 2548 /** 2549 * resets the library back to its initial state. this is useful 2550 * if you want to clear out the current keyboard shortcuts and bind 2551 * new ones - for example if you switch to another page 2552 * 2553 * @returns void 2554 */ 2555 Mousetrap.prototype.reset = function() { 2556 var self = this; 2557 self._callbacks = {}; 2558 self._directMap = {}; 2559 return self; 2560 }; 2561 2562 /** 2563 * should we stop this event before firing off callbacks 2564 * 2565 * @param {Event} e 2566 * @param {Element} element 2567 * @return {boolean} 2568 */ 2569 Mousetrap.prototype.stopCallback = function(e, element) { 2570 var self = this; 2571 2572 // if the element has the class "mousetrap" then no need to stop 2573 if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) { 2574 return false; 2575 } 2576 2577 if (_belongsTo(element, self.target)) { 2578 return false; 2579 } 2580 2581 // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host, 2582 // not the initial event target in the shadow tree. Note that not all events cross the 2583 // shadow boundary. 2584 // For shadow trees with `mode: 'open'`, the initial event target is the first element in 2585 // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event 2586 // target cannot be obtained. 2587 if ('composedPath' in e && typeof e.composedPath === 'function') { 2588 // For open shadow trees, update `element` so that the following check works. 2589 var initialEventTarget = e.composedPath()[0]; 2590 if (initialEventTarget !== e.target) { 2591 element = initialEventTarget; 2592 } 2593 } 2594 2595 // stop for input, select, and textarea 2596 return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable; 2597 }; 2598 2599 /** 2600 * exposes _handleKey publicly so it can be overwritten by extensions 2601 */ 2602 Mousetrap.prototype.handleKey = function() { 2603 var self = this; 2604 return self._handleKey.apply(self, arguments); 2605 }; 2606 2607 /** 2608 * allow custom key mappings 2609 */ 2610 Mousetrap.addKeycodes = function(object) { 2611 for (var key in object) { 2612 if (object.hasOwnProperty(key)) { 2613 _MAP[key] = object[key]; 2614 } 2615 } 2616 _REVERSE_MAP = null; 2617 }; 2618 2619 /** 2620 * Init the global mousetrap functions 2621 * 2622 * This method is needed to allow the global mousetrap functions to work 2623 * now that mousetrap is a constructor function. 2624 */ 2625 Mousetrap.init = function() { 2626 var documentMousetrap = Mousetrap(document); 2627 for (var method in documentMousetrap) { 2628 if (method.charAt(0) !== '_') { 2629 Mousetrap[method] = (function(method) { 2630 return function() { 2631 return documentMousetrap[method].apply(documentMousetrap, arguments); 2632 }; 2633 } (method)); 2634 } 2635 } 2636 }; 2637 2638 Mousetrap.init(); 2639 2640 // expose mousetrap to the global object 2641 window.Mousetrap = Mousetrap; 2642 2643 // expose as a common js module 2644 if ( true && module.exports) { 2645 module.exports = Mousetrap; 2646 } 2647 2648 // expose mousetrap as an AMD module 2649 if (true) { 2650 !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { 2651 return Mousetrap; 2652 }).call(exports, __webpack_require__, exports, module), 2653 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2654 } 2655 }) (typeof window !== 'undefined' ? window : null, typeof window !== 'undefined' ? document : null); 2656 2657 2658 /***/ }), 2659 2660 /***/ 267: 2661 /***/ (function(module, exports, __webpack_require__) { 2662 2663 var e=__webpack_require__(17),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]}; 2664 2665 2666 /***/ }), 2667 2668 /***/ 28: 2669 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2670 2671 "use strict"; 2672 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; }); 2673 /* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26); 2674 2675 function _unsupportedIterableToArray(o, minLen) { 2676 if (!o) return; 2677 if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 2678 var n = Object.prototype.toString.call(o).slice(8, -1); 2679 if (n === "Object" && o.constructor) n = o.constructor.name; 2680 if (n === "Map" || n === "Set") return Array.from(o); 2681 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen); 2682 } 2683 2684 /***/ }), 2685 2686 /***/ 35: 2687 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2688 2689 "use strict"; 2690 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); 2691 function _iterableToArray(iter) { 2692 if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); 2693 } 2694 2695 /***/ }), 2696 2697 /***/ 38: 2698 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2699 2700 "use strict"; 2701 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); 2702 function _arrayWithHoles(arr) { 2703 if (Array.isArray(arr)) return arr; 2704 } 2705 2706 /***/ }), 2707 2708 /***/ 39: 2709 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2710 2711 "use strict"; 2712 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); 2713 function _nonIterableRest() { 2714 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 2715 } 2716 2717 /***/ }), 2718 2719 /***/ 40: 2720 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2721 2722 "use strict"; 2723 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; }); 2724 function _typeof(obj) { 2725 "@babel/helpers - typeof"; 2726 2727 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 2728 _typeof = function _typeof(obj) { 2729 return typeof obj; 2730 }; 2731 } else { 2732 _typeof = function _typeof(obj) { 2733 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 2734 }; 2735 } 2736 2737 return _typeof(obj); 2738 } 2739 2740 /***/ }), 2741 2742 /***/ 408: 2743 /***/ (function(module, exports) { 2744 2745 /** 2746 * adds a bindGlobal method to Mousetrap that allows you to 2747 * bind specific keyboard shortcuts that will still work 2748 * inside a text input field 2749 * 2750 * usage: 2751 * Mousetrap.bindGlobal('ctrl+s', _saveChanges); 2752 */ 2753 /* global Mousetrap:true */ 2754 (function(Mousetrap) { 2755 if (! Mousetrap) { 2756 return; 2757 } 2758 var _globalCallbacks = {}; 2759 var _originalStopCallback = Mousetrap.prototype.stopCallback; 2760 2761 Mousetrap.prototype.stopCallback = function(e, element, combo, sequence) { 2762 var self = this; 2763 2764 if (self.paused) { 2765 return true; 2766 } 2767 2768 if (_globalCallbacks[combo] || _globalCallbacks[sequence]) { 2769 return false; 2770 } 2771 2772 return _originalStopCallback.call(self, e, element, combo); 2773 }; 2774 2775 Mousetrap.prototype.bindGlobal = function(keys, callback, action) { 2776 var self = this; 2777 self.bind(keys, callback, action); 2778 2779 if (keys instanceof Array) { 2780 for (var i = 0; i < keys.length; i++) { 2781 _globalCallbacks[keys[i]] = true; 2782 } 2783 return; 2784 } 2785 2786 _globalCallbacks[keys] = true; 2787 }; 2788 2789 Mousetrap.init(); 2790 }) (typeof Mousetrap !== "undefined" ? Mousetrap : undefined); 2791 2792 2793 /***/ }), 2794 2795 /***/ 445: 2796 /***/ (function(module, __webpack_exports__, __webpack_require__) { 2797 2798 "use strict"; 2799 // ESM COMPAT FLAG 2800 __webpack_require__.r(__webpack_exports__); 2801 2802 // EXPORTS 2803 __webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return /* reexport */ create_higher_order_component; }); 2804 __webpack_require__.d(__webpack_exports__, "compose", function() { return /* reexport */ compose; }); 2805 __webpack_require__.d(__webpack_exports__, "ifCondition", function() { return /* reexport */ if_condition; }); 2806 __webpack_require__.d(__webpack_exports__, "pure", function() { return /* reexport */ higher_order_pure; }); 2807 __webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return /* reexport */ with_global_events; }); 2808 __webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return /* reexport */ with_instance_id; }); 2809 __webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return /* reexport */ with_safe_timeout; }); 2810 __webpack_require__.d(__webpack_exports__, "withState", function() { return /* reexport */ withState; }); 2811 __webpack_require__.d(__webpack_exports__, "useCopyOnClick", function() { return /* reexport */ useCopyOnClick; }); 2812 __webpack_require__.d(__webpack_exports__, "__experimentalUseDragging", function() { return /* reexport */ useDragging; }); 2813 __webpack_require__.d(__webpack_exports__, "useInstanceId", function() { return /* reexport */ useInstanceId; }); 2814 __webpack_require__.d(__webpack_exports__, "useKeyboardShortcut", function() { return /* reexport */ use_keyboard_shortcut; }); 2815 __webpack_require__.d(__webpack_exports__, "useMediaQuery", function() { return /* reexport */ use_media_query["a" /* default */]; }); 2816 __webpack_require__.d(__webpack_exports__, "usePrevious", function() { return /* reexport */ usePrevious; }); 2817 __webpack_require__.d(__webpack_exports__, "useReducedMotion", function() { return /* reexport */ use_reduced_motion["a" /* default */]; }); 2818 __webpack_require__.d(__webpack_exports__, "useViewportMatch", function() { return /* reexport */ use_viewport_match; }); 2819 __webpack_require__.d(__webpack_exports__, "useResizeObserver", function() { return /* reexport */ use_resize_observer; }); 2820 __webpack_require__.d(__webpack_exports__, "useAsyncList", function() { return /* reexport */ use_async_list; }); 2821 2822 // EXTERNAL MODULE: external {"this":"lodash"} 2823 var external_this_lodash_ = __webpack_require__(2); 2824 2825 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js 2826 /** 2827 * External dependencies 2828 */ 2829 2830 /** 2831 * Given a function mapping a component to an enhanced component and modifier 2832 * name, returns the enhanced component augmented with a generated displayName. 2833 * 2834 * @param {Function} mapComponentToEnhancedComponent Function mapping component 2835 * to enhanced component. 2836 * @param {string} modifierName Seed name from which to 2837 * generated display name. 2838 * 2839 * @return {WPComponent} Component class with generated display name assigned. 2840 */ 2841 2842 function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) { 2843 return function (OriginalComponent) { 2844 var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent); 2845 var _OriginalComponent$di = OriginalComponent.displayName, 2846 displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di; 2847 EnhancedComponent.displayName = "".concat(Object(external_this_lodash_["upperFirst"])(Object(external_this_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")"); 2848 return EnhancedComponent; 2849 }; 2850 } 2851 2852 /* harmony default export */ var create_higher_order_component = (createHigherOrderComponent); 2853 2854 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js 2855 /** 2856 * External dependencies 2857 */ 2858 2859 /** 2860 * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function 2861 * composition, where each successive invocation is supplied the return value of the previous. 2862 * 2863 * @param {...Function} hocs The HOC functions to invoke. 2864 * 2865 * @return {Function} Returns the new composite function. 2866 */ 2867 2868 /* harmony default export */ var compose = (external_this_lodash_["flowRight"]); 2869 2870 // EXTERNAL MODULE: external {"this":["wp","element"]} 2871 var external_this_wp_element_ = __webpack_require__(0); 2872 2873 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js 2874 2875 2876 /** 2877 * Internal dependencies 2878 */ 2879 2880 /** 2881 * Higher-order component creator, creating a new component which renders if 2882 * the given condition is satisfied or with the given optional prop name. 2883 * 2884 * @param {Function} predicate Function to test condition. 2885 * 2886 * @return {Function} Higher-order component. 2887 */ 2888 2889 var if_condition_ifCondition = function ifCondition(predicate) { 2890 return create_higher_order_component(function (WrappedComponent) { 2891 return function (props) { 2892 if (!predicate(props)) { 2893 return null; 2894 } 2895 2896 return Object(external_this_wp_element_["createElement"])(WrappedComponent, props); 2897 }; 2898 }, 'ifCondition'); 2899 }; 2900 2901 /* harmony default export */ var if_condition = (if_condition_ifCondition); 2902 2903 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js 2904 var classCallCheck = __webpack_require__(19); 2905 2906 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js 2907 var createClass = __webpack_require__(18); 2908 2909 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js 2910 var possibleConstructorReturn = __webpack_require__(21); 2911 2912 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js 2913 var getPrototypeOf = __webpack_require__(13); 2914 2915 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules 2916 var inherits = __webpack_require__(20); 2917 2918 // EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} 2919 var external_this_wp_isShallowEqual_ = __webpack_require__(55); 2920 var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_); 2921 2922 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js 2923 2924 2925 2926 2927 2928 2929 2930 function _createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 2931 2932 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; } } 2933 2934 /** 2935 * WordPress dependencies 2936 */ 2937 2938 2939 /** 2940 * Internal dependencies 2941 */ 2942 2943 2944 /** 2945 * Given a component returns the enhanced component augmented with a component 2946 * only rerendering when its props/state change 2947 * 2948 * @param {Function} mapComponentToEnhancedComponent Function mapping component 2949 * to enhanced component. 2950 * @param {string} modifierName Seed name from which to 2951 * generated display name. 2952 * 2953 * @return {WPComponent} Component class with generated display name assigned. 2954 */ 2955 2956 var pure = create_higher_order_component(function (Wrapped) { 2957 if (Wrapped.prototype instanceof external_this_wp_element_["Component"]) { 2958 return /*#__PURE__*/function (_Wrapped) { 2959 Object(inherits["a" /* default */])(_class, _Wrapped); 2960 2961 var _super = _createSuper(_class); 2962 2963 function _class() { 2964 Object(classCallCheck["a" /* default */])(this, _class); 2965 2966 return _super.apply(this, arguments); 2967 } 2968 2969 Object(createClass["a" /* default */])(_class, [{ 2970 key: "shouldComponentUpdate", 2971 value: function shouldComponentUpdate(nextProps, nextState) { 2972 return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state); 2973 } 2974 }]); 2975 2976 return _class; 2977 }(Wrapped); 2978 } 2979 2980 return /*#__PURE__*/function (_Component) { 2981 Object(inherits["a" /* default */])(_class2, _Component); 2982 2983 var _super2 = _createSuper(_class2); 2984 2985 function _class2() { 2986 Object(classCallCheck["a" /* default */])(this, _class2); 2987 2988 return _super2.apply(this, arguments); 2989 } 2990 2991 Object(createClass["a" /* default */])(_class2, [{ 2992 key: "shouldComponentUpdate", 2993 value: function shouldComponentUpdate(nextProps) { 2994 return !external_this_wp_isShallowEqual_default()(nextProps, this.props); 2995 } 2996 }, { 2997 key: "render", 2998 value: function render() { 2999 return Object(external_this_wp_element_["createElement"])(Wrapped, this.props); 3000 } 3001 }]); 3002 3003 return _class2; 3004 }(external_this_wp_element_["Component"]); 3005 }, 'pure'); 3006 /* harmony default export */ var higher_order_pure = (pure); 3007 3008 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 3009 var esm_extends = __webpack_require__(8); 3010 3011 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js 3012 var assertThisInitialized = __webpack_require__(10); 3013 3014 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js 3015 3016 3017 3018 /** 3019 * External dependencies 3020 */ 3021 3022 /** 3023 * Class responsible for orchestrating event handling on the global window, 3024 * binding a single event to be shared across all handling instances, and 3025 * removing the handler when no instances are listening for the event. 3026 */ 3027 3028 var listener_Listener = /*#__PURE__*/function () { 3029 function Listener() { 3030 Object(classCallCheck["a" /* default */])(this, Listener); 3031 3032 this.listeners = {}; 3033 this.handleEvent = this.handleEvent.bind(this); 3034 } 3035 3036 Object(createClass["a" /* default */])(Listener, [{ 3037 key: "add", 3038 value: function add(eventType, instance) { 3039 if (!this.listeners[eventType]) { 3040 // Adding first listener for this type, so bind event. 3041 window.addEventListener(eventType, this.handleEvent); 3042 this.listeners[eventType] = []; 3043 } 3044 3045 this.listeners[eventType].push(instance); 3046 } 3047 }, { 3048 key: "remove", 3049 value: function remove(eventType, instance) { 3050 this.listeners[eventType] = Object(external_this_lodash_["without"])(this.listeners[eventType], instance); 3051 3052 if (!this.listeners[eventType].length) { 3053 // Removing last listener for this type, so unbind event. 3054 window.removeEventListener(eventType, this.handleEvent); 3055 delete this.listeners[eventType]; 3056 } 3057 } 3058 }, { 3059 key: "handleEvent", 3060 value: function handleEvent(event) { 3061 Object(external_this_lodash_["forEach"])(this.listeners[event.type], function (instance) { 3062 instance.handleEvent(event); 3063 }); 3064 } 3065 }]); 3066 3067 return Listener; 3068 }(); 3069 3070 /* harmony default export */ var listener = (listener_Listener); 3071 3072 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 function with_global_events_createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (with_global_events_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 3083 3084 function with_global_events_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } 3085 3086 /** 3087 * External dependencies 3088 */ 3089 3090 /** 3091 * WordPress dependencies 3092 */ 3093 3094 3095 /** 3096 * Internal dependencies 3097 */ 3098 3099 3100 3101 /** 3102 * Listener instance responsible for managing document event handling. 3103 * 3104 * @type {Listener} 3105 */ 3106 3107 var with_global_events_listener = new listener(); 3108 /** 3109 * Higher-order component creator which, given an object of DOM event types and 3110 * values corresponding to a callback function name on the component, will 3111 * create or update a window event handler to invoke the callback when an event 3112 * occurs. On behalf of the consuming developer, the higher-order component 3113 * manages unbinding when the component unmounts, and binding at most a single 3114 * event handler for the entire application. 3115 * 3116 * @param {Object<string,string>} eventTypesToHandlers Object with keys of DOM 3117 * event type, the value a 3118 * name of the function on 3119 * the original component's 3120 * instance which handles 3121 * the event. 3122 * 3123 * @return {Function} Higher-order component. 3124 */ 3125 3126 function withGlobalEvents(eventTypesToHandlers) { 3127 return create_higher_order_component(function (WrappedComponent) { 3128 var Wrapper = /*#__PURE__*/function (_Component) { 3129 Object(inherits["a" /* default */])(Wrapper, _Component); 3130 3131 var _super = with_global_events_createSuper(Wrapper); 3132 3133 function Wrapper() { 3134 var _this; 3135 3136 Object(classCallCheck["a" /* default */])(this, Wrapper); 3137 3138 _this = _super.apply(this, arguments); 3139 _this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3140 _this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3141 return _this; 3142 } 3143 3144 Object(createClass["a" /* default */])(Wrapper, [{ 3145 key: "componentDidMount", 3146 value: function componentDidMount() { 3147 var _this2 = this; 3148 3149 Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { 3150 with_global_events_listener.add(eventType, _this2); 3151 }); 3152 } 3153 }, { 3154 key: "componentWillUnmount", 3155 value: function componentWillUnmount() { 3156 var _this3 = this; 3157 3158 Object(external_this_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { 3159 with_global_events_listener.remove(eventType, _this3); 3160 }); 3161 } 3162 }, { 3163 key: "handleEvent", 3164 value: function handleEvent(event) { 3165 var handler = eventTypesToHandlers[event.type]; 3166 3167 if (typeof this.wrappedRef[handler] === 'function') { 3168 this.wrappedRef[handler](event); 3169 } 3170 } 3171 }, { 3172 key: "handleRef", 3173 value: function handleRef(el) { 3174 this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref` 3175 // will cause `this.props.forwardedRef` to be `null`, so we need this 3176 // check. 3177 3178 if (this.props.forwardedRef) { 3179 this.props.forwardedRef(el); 3180 } 3181 } 3182 }, { 3183 key: "render", 3184 value: function render() { 3185 return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, { 3186 ref: this.handleRef 3187 })); 3188 } 3189 }]); 3190 3191 return Wrapper; 3192 }(external_this_wp_element_["Component"]); 3193 3194 return Object(external_this_wp_element_["forwardRef"])(function (props, ref) { 3195 return Object(external_this_wp_element_["createElement"])(Wrapper, { 3196 ownProps: props, 3197 forwardedRef: ref 3198 }); 3199 }); 3200 }, 'withGlobalEvents'); 3201 } 3202 3203 /* harmony default export */ var with_global_events = (withGlobalEvents); 3204 3205 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js 3206 /** 3207 * WordPress dependencies 3208 */ 3209 3210 var instanceMap = new WeakMap(); 3211 /** 3212 * Creates a new id for a given object. 3213 * 3214 * @param {Object} object Object reference to create an id for. 3215 */ 3216 3217 function createId(object) { 3218 var instances = instanceMap.get(object) || 0; 3219 instanceMap.set(object, instances + 1); 3220 return instances; 3221 } 3222 /** 3223 * Provides a unique instance ID. 3224 * 3225 * @param {Object} object Object reference to create an id for. 3226 * @param {string} prefix Prefix for the unique id. 3227 */ 3228 3229 3230 function useInstanceId(object, prefix) { 3231 return Object(external_this_wp_element_["useMemo"])(function () { 3232 var id = createId(object); 3233 return prefix ? "".concat(prefix, "-").concat(id) : id; 3234 }, [object]); 3235 } 3236 3237 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js 3238 3239 3240 3241 /** 3242 * Internal dependencies 3243 */ 3244 3245 3246 /** 3247 * A Higher Order Component used to be provide a unique instance ID by 3248 * component. 3249 * 3250 * @param {WPComponent} WrappedComponent The wrapped component. 3251 * 3252 * @return {WPComponent} Component with an instanceId prop. 3253 */ 3254 3255 /* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) { 3256 return function (props) { 3257 var instanceId = useInstanceId(WrappedComponent); 3258 return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, props, { 3259 instanceId: instanceId 3260 })); 3261 }; 3262 }, 'withInstanceId')); 3263 3264 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 function with_safe_timeout_createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (with_safe_timeout_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 3275 3276 function with_safe_timeout_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } 3277 3278 /** 3279 * External dependencies 3280 */ 3281 3282 /** 3283 * WordPress dependencies 3284 */ 3285 3286 3287 /** 3288 * Internal dependencies 3289 */ 3290 3291 3292 /** 3293 * A higher-order component used to provide and manage delayed function calls 3294 * that ought to be bound to a component's lifecycle. 3295 * 3296 * @param {WPComponent} OriginalComponent Component requiring setTimeout 3297 * 3298 * @return {WPComponent} Wrapped component. 3299 */ 3300 3301 var withSafeTimeout = create_higher_order_component(function (OriginalComponent) { 3302 return /*#__PURE__*/function (_Component) { 3303 Object(inherits["a" /* default */])(WrappedComponent, _Component); 3304 3305 var _super = with_safe_timeout_createSuper(WrappedComponent); 3306 3307 function WrappedComponent() { 3308 var _this; 3309 3310 Object(classCallCheck["a" /* default */])(this, WrappedComponent); 3311 3312 _this = _super.apply(this, arguments); 3313 _this.timeouts = []; 3314 _this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3315 _this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3316 return _this; 3317 } 3318 3319 Object(createClass["a" /* default */])(WrappedComponent, [{ 3320 key: "componentWillUnmount", 3321 value: function componentWillUnmount() { 3322 this.timeouts.forEach(clearTimeout); 3323 } 3324 }, { 3325 key: "setTimeout", 3326 value: function (_setTimeout) { 3327 function setTimeout(_x, _x2) { 3328 return _setTimeout.apply(this, arguments); 3329 } 3330 3331 setTimeout.toString = function () { 3332 return _setTimeout.toString(); 3333 }; 3334 3335 return setTimeout; 3336 }(function (fn, delay) { 3337 var _this2 = this; 3338 3339 var id = setTimeout(function () { 3340 fn(); 3341 3342 _this2.clearTimeout(id); 3343 }, delay); 3344 this.timeouts.push(id); 3345 return id; 3346 }) 3347 }, { 3348 key: "clearTimeout", 3349 value: function (_clearTimeout) { 3350 function clearTimeout(_x3) { 3351 return _clearTimeout.apply(this, arguments); 3352 } 3353 3354 clearTimeout.toString = function () { 3355 return _clearTimeout.toString(); 3356 }; 3357 3358 return clearTimeout; 3359 }(function (id) { 3360 clearTimeout(id); 3361 this.timeouts = Object(external_this_lodash_["without"])(this.timeouts, id); 3362 }) 3363 }, { 3364 key: "render", 3365 value: function render() { 3366 return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, { 3367 setTimeout: this.setTimeout, 3368 clearTimeout: this.clearTimeout 3369 })); 3370 } 3371 }]); 3372 3373 return WrappedComponent; 3374 }(external_this_wp_element_["Component"]); 3375 }, 'withSafeTimeout'); 3376 /* harmony default export */ var with_safe_timeout = (withSafeTimeout); 3377 3378 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 function with_state_createSuper(Derived) { return function () { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (with_state_isNativeReflectConstruct()) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; } 3389 3390 function with_state_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } 3391 3392 /** 3393 * WordPress dependencies 3394 */ 3395 3396 /** 3397 * Internal dependencies 3398 */ 3399 3400 3401 /** 3402 * A Higher Order Component used to provide and manage internal component state 3403 * via props. 3404 * 3405 * @param {?Object} initialState Optional initial state of the component. 3406 * 3407 * @return {WPComponent} Wrapped component. 3408 */ 3409 3410 function withState() { 3411 var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 3412 return create_higher_order_component(function (OriginalComponent) { 3413 return /*#__PURE__*/function (_Component) { 3414 Object(inherits["a" /* default */])(WrappedComponent, _Component); 3415 3416 var _super = with_state_createSuper(WrappedComponent); 3417 3418 function WrappedComponent() { 3419 var _this; 3420 3421 Object(classCallCheck["a" /* default */])(this, WrappedComponent); 3422 3423 _this = _super.apply(this, arguments); 3424 _this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(_this)); 3425 _this.state = initialState; 3426 return _this; 3427 } 3428 3429 Object(createClass["a" /* default */])(WrappedComponent, [{ 3430 key: "render", 3431 value: function render() { 3432 return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, { 3433 setState: this.setState 3434 })); 3435 } 3436 }]); 3437 3438 return WrappedComponent; 3439 }(external_this_wp_element_["Component"]); 3440 }, 'withState'); 3441 } 3442 3443 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules 3444 var slicedToArray = __webpack_require__(15); 3445 3446 // EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js 3447 var dist_clipboard = __webpack_require__(265); 3448 var clipboard_default = /*#__PURE__*/__webpack_require__.n(dist_clipboard); 3449 3450 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-on-click/index.js 3451 3452 3453 /** 3454 * External dependencies 3455 */ 3456 3457 /** 3458 * WordPress dependencies 3459 */ 3460 3461 3462 /** 3463 * Copies the text to the clipboard when the element is clicked. 3464 * 3465 * @param {Object} ref Reference with the element. 3466 * @param {string|Function} text The text to copy. 3467 * @param {number} timeout Optional timeout to reset the returned 3468 * state. 4 seconds by default. 3469 * 3470 * @return {boolean} Whether or not the text has been copied. Resets after the 3471 * timeout. 3472 */ 3473 3474 function useCopyOnClick(ref, _text) { 3475 var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4000; 3476 var clipboard = Object(external_this_wp_element_["useRef"])(); 3477 3478 var _useState = Object(external_this_wp_element_["useState"])(false), 3479 _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), 3480 hasCopied = _useState2[0], 3481 setHasCopied = _useState2[1]; 3482 3483 Object(external_this_wp_element_["useEffect"])(function () { 3484 var timeoutId; // Clipboard listens to click events. 3485 3486 clipboard.current = new clipboard_default.a(ref.current, { 3487 text: function text() { 3488 return typeof _text === 'function' ? _text() : _text; 3489 }, 3490 container: ref.current 3491 }); 3492 clipboard.current.on('success', function (_ref) { 3493 var clearSelection = _ref.clearSelection; 3494 // Clearing selection will move focus back to the triggering button, 3495 // ensuring that it is not reset to the body, and further that it is 3496 // kept within the rendered node. 3497 clearSelection(); 3498 3499 if (timeout) { 3500 setHasCopied(true); 3501 clearTimeout(timeoutId); 3502 timeoutId = setTimeout(function () { 3503 return setHasCopied(false); 3504 }, timeout); 3505 } 3506 }); 3507 return function () { 3508 clipboard.current.destroy(); 3509 clearTimeout(timeoutId); 3510 }; 3511 }, [_text, timeout, setHasCopied]); 3512 return hasCopied; 3513 } 3514 3515 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js 3516 3517 3518 /** 3519 * WordPress dependencies 3520 */ 3521 3522 var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external_this_wp_element_["useLayoutEffect"] : external_this_wp_element_["useEffect"]; 3523 function useDragging(_ref) { 3524 var onDragStart = _ref.onDragStart, 3525 onDragMove = _ref.onDragMove, 3526 onDragEnd = _ref.onDragEnd; 3527 3528 var _useState = Object(external_this_wp_element_["useState"])(false), 3529 _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), 3530 isDragging = _useState2[0], 3531 setIsDragging = _useState2[1]; 3532 3533 var eventsRef = Object(external_this_wp_element_["useRef"])({ 3534 onDragStart: onDragStart, 3535 onDragMove: onDragMove, 3536 onDragEnd: onDragEnd 3537 }); 3538 useIsomorphicLayoutEffect(function () { 3539 eventsRef.current.onDragStart = onDragStart; 3540 eventsRef.current.onDragMove = onDragMove; 3541 eventsRef.current.onDragEnd = onDragEnd; 3542 }, [onDragStart, onDragMove, onDragEnd]); 3543 var onMouseMove = Object(external_this_wp_element_["useCallback"])(function () { 3544 var _eventsRef$current; 3545 3546 return eventsRef.current.onDragMove && (_eventsRef$current = eventsRef.current).onDragMove.apply(_eventsRef$current, arguments); 3547 }, []); 3548 var endDrag = Object(external_this_wp_element_["useCallback"])(function () { 3549 if (eventsRef.current.onDragEnd) { 3550 var _eventsRef$current2; 3551 3552 (_eventsRef$current2 = eventsRef.current).onDragEnd.apply(_eventsRef$current2, arguments); 3553 } 3554 3555 document.removeEventListener('mousemove', onMouseMove); 3556 document.removeEventListener('mouseup', endDrag); 3557 setIsDragging(false); 3558 }, []); 3559 var startDrag = Object(external_this_wp_element_["useCallback"])(function () { 3560 if (eventsRef.current.onDragStart) { 3561 var _eventsRef$current3; 3562 3563 (_eventsRef$current3 = eventsRef.current).onDragStart.apply(_eventsRef$current3, arguments); 3564 } 3565 3566 document.addEventListener('mousemove', onMouseMove); 3567 document.addEventListener('mouseup', endDrag); 3568 setIsDragging(true); 3569 }, []); // Remove the global events when unmounting if needed. 3570 3571 Object(external_this_wp_element_["useEffect"])(function () { 3572 return function () { 3573 if (isDragging) { 3574 document.removeEventListener('mousemove', onMouseMove); 3575 document.removeEventListener('mouseup', endDrag); 3576 } 3577 }; 3578 }, [isDragging]); 3579 return { 3580 startDrag: startDrag, 3581 endDrag: endDrag, 3582 isDragging: isDragging 3583 }; 3584 } 3585 3586 // EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js 3587 var mousetrap_mousetrap = __webpack_require__(266); 3588 var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap_mousetrap); 3589 3590 // EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js 3591 var mousetrap_global_bind = __webpack_require__(408); 3592 3593 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js 3594 /** 3595 * External dependencies 3596 */ 3597 3598 3599 3600 /** 3601 * WordPress dependencies 3602 */ 3603 3604 3605 /** 3606 * A block selection object. 3607 * 3608 * @typedef {Object} WPKeyboardShortcutConfig 3609 * 3610 * @property {boolean} [bindGlobal] Handle keyboard events anywhere including inside textarea/input fields. 3611 * @property {string} [eventName] Event name used to trigger the handler, defaults to keydown. 3612 * @property {boolean} [isDisabled] Disables the keyboard handler if the value is true. 3613 * @property {Object} [target] React reference to the DOM element used to catch the keyboard event. 3614 */ 3615 3616 /** 3617 * Return true if platform is MacOS. 3618 * 3619 * @param {Object} _window window object by default; used for DI testing. 3620 * 3621 * @return {boolean} True if MacOS; false otherwise. 3622 */ 3623 3624 function isAppleOS() { 3625 var _window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; 3626 3627 var platform = _window.navigator.platform; 3628 return platform.indexOf('Mac') !== -1 || Object(external_this_lodash_["includes"])(['iPad', 'iPhone'], platform); 3629 } 3630 /** 3631 * Attach a keyboard shortcut handler. 3632 * 3633 * @param {string[]|string} shortcuts Keyboard Shortcuts. 3634 * @param {Function} callback Shortcut callback. 3635 * @param {WPKeyboardShortcutConfig} options Shortcut options. 3636 */ 3637 3638 3639 function useKeyboardShortcut(shortcuts, callback) { 3640 var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, 3641 _ref$bindGlobal = _ref.bindGlobal, 3642 bindGlobal = _ref$bindGlobal === void 0 ? false : _ref$bindGlobal, 3643 _ref$eventName = _ref.eventName, 3644 eventName = _ref$eventName === void 0 ? 'keydown' : _ref$eventName, 3645 _ref$isDisabled = _ref.isDisabled, 3646 isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled, 3647 target = _ref.target; 3648 3649 Object(external_this_wp_element_["useEffect"])(function () { 3650 if (isDisabled) { 3651 return; 3652 } 3653 3654 var mousetrap = new mousetrap_default.a(target ? target.current : document); 3655 Object(external_this_lodash_["castArray"])(shortcuts).forEach(function (shortcut) { 3656 var keys = shortcut.split('+'); // Determines whether a key is a modifier by the length of the string. 3657 // E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that 3658 // the modifiers are Shift and Cmd because they're not a single character. 3659 3660 var modifiers = new Set(keys.filter(function (value) { 3661 return value.length > 1; 3662 })); 3663 var hasAlt = modifiers.has('alt'); 3664 var hasShift = modifiers.has('shift'); // This should be better moved to the shortcut registration instead. 3665 3666 if (isAppleOS() && (modifiers.size === 1 && hasAlt || modifiers.size === 2 && hasAlt && hasShift)) { 3667 throw new Error("Cannot bind ".concat(shortcut, ". Alt and Shift+Alt modifiers are reserved for character input.")); 3668 } 3669 3670 var bindFn = bindGlobal ? 'bindGlobal' : 'bind'; 3671 mousetrap[bindFn](shortcut, callback, eventName); 3672 }); 3673 return function () { 3674 mousetrap.reset(); 3675 }; 3676 }, [shortcuts, bindGlobal, eventName, callback, target, isDisabled]); 3677 } 3678 3679 /* harmony default export */ var use_keyboard_shortcut = (useKeyboardShortcut); 3680 3681 // EXTERNAL MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js 3682 var use_media_query = __webpack_require__(126); 3683 3684 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-previous/index.js 3685 /** 3686 * WordPress dependencies 3687 */ 3688 3689 /** 3690 * Use something's value from the previous render. 3691 * Based on https://usehooks.com/usePrevious/. 3692 * 3693 * @template T 3694 * 3695 * @param {T} value The value to track. 3696 * 3697 * @return {T|undefined} The value from the previous render. 3698 */ 3699 3700 function usePrevious(value) { 3701 // Disable reason: without an explicit type detail, the type of ref will be 3702 // inferred based on the initial useRef argument, which is undefined. 3703 // https://github.com/WordPress/gutenberg/pull/22597#issuecomment-633588366 3704 3705 /* eslint-disable jsdoc/no-undefined-types */ 3706 var ref = Object(external_this_wp_element_["useRef"])( 3707 /** @type {T|undefined} */ 3708 undefined); 3709 /* eslint-enable jsdoc/no-undefined-types */ 3710 // Store current value in ref. 3711 3712 Object(external_this_wp_element_["useEffect"])(function () { 3713 ref.current = value; 3714 }, [value]); // Re-run when value changes. 3715 // Return previous value (happens before update in useEffect above). 3716 3717 return ref.current; 3718 } 3719 3720 // EXTERNAL MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-reduced-motion/index.js 3721 var use_reduced_motion = __webpack_require__(246); 3722 3723 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-viewport-match/index.js 3724 /** 3725 * WordPress dependencies 3726 */ 3727 3728 /** 3729 * Internal dependencies 3730 */ 3731 3732 3733 /** 3734 * @typedef {"huge"|"wide"|"large"|"medium"|"small"|"mobile"} WPBreakpoint 3735 */ 3736 3737 /** 3738 * Hash of breakpoint names with pixel width at which it becomes effective. 3739 * 3740 * @see _breakpoints.scss 3741 * 3742 * @type {Object<WPBreakpoint,number>} 3743 */ 3744 3745 var BREAKPOINTS = { 3746 huge: 1440, 3747 wide: 1280, 3748 large: 960, 3749 medium: 782, 3750 small: 600, 3751 mobile: 480 3752 }; 3753 /** 3754 * @typedef {">="|"<"} WPViewportOperator 3755 */ 3756 3757 /** 3758 * Object mapping media query operators to the condition to be used. 3759 * 3760 * @type {Object<WPViewportOperator,string>} 3761 */ 3762 3763 var CONDITIONS = { 3764 '>=': 'min-width', 3765 '<': 'max-width' 3766 }; 3767 /** 3768 * Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values. 3769 * 3770 * @type {Object<WPViewportOperator,Function>} 3771 */ 3772 3773 var OPERATOR_EVALUATORS = { 3774 '>=': function _(breakpointValue, width) { 3775 return width >= breakpointValue; 3776 }, 3777 '<': function _(breakpointValue, width) { 3778 return width < breakpointValue; 3779 } 3780 }; 3781 var ViewportMatchWidthContext = Object(external_this_wp_element_["createContext"])(null); 3782 /** 3783 * Returns true if the viewport matches the given query, or false otherwise. 3784 * 3785 * @param {WPBreakpoint} breakpoint Breakpoint size name. 3786 * @param {WPViewportOperator} [operator=">="] Viewport operator. 3787 * 3788 * @example 3789 * 3790 * ```js 3791 * useViewportMatch( 'huge', '<' ); 3792 * useViewportMatch( 'medium' ); 3793 * ``` 3794 * 3795 * @return {boolean} Whether viewport matches query. 3796 */ 3797 3798 var use_viewport_match_useViewportMatch = function useViewportMatch(breakpoint) { 3799 var operator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '>='; 3800 var simulatedWidth = Object(external_this_wp_element_["useContext"])(ViewportMatchWidthContext); 3801 var mediaQuery = !simulatedWidth && "(".concat(CONDITIONS[operator], ": ").concat(BREAKPOINTS[breakpoint], "px)"); 3802 var mediaQueryResult = Object(use_media_query["a" /* default */])(mediaQuery); 3803 3804 if (simulatedWidth) { 3805 return OPERATOR_EVALUATORS[operator](BREAKPOINTS[breakpoint], simulatedWidth); 3806 } 3807 3808 return mediaQueryResult; 3809 }; 3810 3811 use_viewport_match_useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider; 3812 /* harmony default export */ var use_viewport_match = (use_viewport_match_useViewportMatch); 3813 3814 // EXTERNAL MODULE: ./node_modules/react-resize-aware/dist/index.js 3815 var dist = __webpack_require__(267); 3816 var dist_default = /*#__PURE__*/__webpack_require__.n(dist); 3817 3818 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/index.js 3819 /** 3820 * External dependencies 3821 */ 3822 3823 /** 3824 * Hook which allows to listen the resize event of any target element when it changes sizes. 3825 * _Note: `useResizeObserver` will report `null` until after first render_ 3826 * 3827 * @return {Array} An array of {Element} `resizeListener` and {?Object} `sizes` with properties `width` and `height` 3828 * 3829 * @example 3830 * 3831 * ```js 3832 * const App = () => { 3833 * const [ resizeListener, sizes ] = useResizeObserver(); 3834 * 3835 * return ( 3836 * <div> 3837 * { resizeListener } 3838 * Your content here 3839 * </div> 3840 * ); 3841 * }; 3842 * ``` 3843 * 3844 */ 3845 3846 /* harmony default export */ var use_resize_observer = (dist_default.a); 3847 3848 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules 3849 var toConsumableArray = __webpack_require__(16); 3850 3851 // EXTERNAL MODULE: external {"this":["wp","priorityQueue"]} 3852 var external_this_wp_priorityQueue_ = __webpack_require__(143); 3853 3854 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-async-list/index.js 3855 3856 3857 3858 /** 3859 * WordPress dependencies 3860 */ 3861 3862 3863 /** 3864 * Returns the first items from list that are present on state. 3865 * 3866 * @param {Array} list New array. 3867 * @param {Array} state Current state. 3868 * @return {Array} First items present iin state. 3869 */ 3870 3871 function getFirstItemsPresentInState(list, state) { 3872 var firstItems = []; 3873 3874 for (var i = 0; i < list.length; i++) { 3875 var item = list[i]; 3876 3877 if (!state.includes(item)) { 3878 break; 3879 } 3880 3881 firstItems.push(item); 3882 } 3883 3884 return firstItems; 3885 } 3886 /** 3887 * Reducer keeping track of a list of appended items. 3888 * 3889 * @param {Array} state Current state 3890 * @param {Object} action Action 3891 * 3892 * @return {Array} update state. 3893 */ 3894 3895 3896 function listReducer(state, action) { 3897 if (action.type === 'reset') { 3898 return action.list; 3899 } 3900 3901 if (action.type === 'append') { 3902 return [].concat(Object(toConsumableArray["a" /* default */])(state), [action.item]); 3903 } 3904 3905 return state; 3906 } 3907 /** 3908 * React hook returns an array which items get asynchronously appended from a source array. 3909 * This behavior is useful if we want to render a list of items asynchronously for performance reasons. 3910 * 3911 * @param {Array} list Source array. 3912 * @return {Array} Async array. 3913 */ 3914 3915 3916 function useAsyncList(list) { 3917 var _useReducer = Object(external_this_wp_element_["useReducer"])(listReducer, []), 3918 _useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2), 3919 current = _useReducer2[0], 3920 dispatch = _useReducer2[1]; 3921 3922 Object(external_this_wp_element_["useEffect"])(function () { 3923 // On reset, we keep the first items that were previously rendered. 3924 var firstItems = getFirstItemsPresentInState(list, current); 3925 dispatch({ 3926 type: 'reset', 3927 list: firstItems 3928 }); 3929 var asyncQueue = Object(external_this_wp_priorityQueue_["createQueue"])(); 3930 3931 var append = function append(index) { 3932 return function () { 3933 if (list.length <= index) { 3934 return; 3935 } 3936 3937 dispatch({ 3938 type: 'append', 3939 item: list[index] 3940 }); 3941 asyncQueue.add({}, append(index + 1)); 3942 }; 3943 }; 3944 3945 asyncQueue.add({}, append(firstItems.length)); 3946 return function () { 3947 return asyncQueue.reset(); 3948 }; 3949 }, [list]); 3950 return current; 3951 } 3952 3953 /* harmony default export */ var use_async_list = (useAsyncList); 3954 3955 // CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js 3956 // Utils 3957 // Compose helper (aliased flowRight from Lodash) 3958 3959 // Higher-order components 3960 3961 3962 3963 3964 3965 3966 // Hooks 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 /***/ }), 3981 3982 /***/ 55: 3983 /***/ (function(module, exports) { 3984 3985 (function() { module.exports = this["wp"]["isShallowEqual"]; }()); 3986 3987 /***/ }), 3988 3989 /***/ 8: 3990 /***/ (function(module, __webpack_exports__, __webpack_require__) { 3991 3992 "use strict"; 3993 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; }); 3994 function _extends() { 3995 _extends = Object.assign || function (target) { 3996 for (var i = 1; i < arguments.length; i++) { 3997 var source = arguments[i]; 3998 3999 for (var key in source) { 4000 if (Object.prototype.hasOwnProperty.call(source, key)) { 4001 target[key] = source[key]; 4002 } 4003 } 4004 } 4005 4006 return target; 4007 }; 4008 4009 return _extends.apply(this, arguments); 4010 } 4011 4012 /***/ }) 4013 4014 /******/ });
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Fri Jul 3 01:00:03 2020 | Cross-referenced by PHPXref 0.7.1 |