https://chansontadoussac.com/wp-includes/js/dist/compose.js?ver=7c895b31cd7a903b5229

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()

171;
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;

889 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 (

1105__.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, __

1529nested_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) {

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];

2284 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}

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,

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) => {