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