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