/******/ (() => { // webpackBootstrap

/******/ 	var __webpack_modules__ = ({

/***/ 1933:

/***/ ((module, exports, __webpack_require__) => {

var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */

/**

 * Copyright 2012-2017 Craig Campbell

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 * Mousetrap is a simple keyboard shortcut library for Javascript with

 * no external dependencies

 *

 * @version 1.6.5

 * @url craig.is/killing/mice

 */

(function(window, document, undefined) {

    // Check if mousetrap is used inside browser, if not, return

    if (!window) {

        return;

    }

    /**

     * mapping of special keycodes to their corresponding keys

     *

     * everything in this dictionary cannot use keypress events

     * so it has to be here to map to the correct keycodes for

     * keyup/keydown events

     *

     * @type {Object}

     */

    var _MAP = {

        8: 'backspace',

        9: 'tab',

        13: 'enter',

        16: 'shift',

        17: 'ctrl',

        18: 'alt',

        20: 'capslock',

        27: 'esc',

        32: 'space',

        33: 'pageup',

        34: 'pagedown',

        35: 'end',

        36: 'home',

        37: 'left',

        38: 'up',

        39: 'right',

        40: 'down',

        45: 'ins',

        46: 'del',

        91: 'meta',

        93: 'meta',

        224: 'meta'

    };

    /**

     * mapping for special characters so they can support

     *

     * this dictionary is only used incase you want to bind a

     * keyup or keydown event to one of these keys

     *

     * @type {Object}

     */

    var _KEYCODE_MAP = {

        106: '*',

        107: '+',

        109: '-',

        110: '.',

        111 : '/',

        186: ';',

        187: '=',

        188: ',',

        189: '-',

        190: '.',

        191: '/',

        192: '`',

        219: '[',

        220: '\\',

        221: ']',

        222: '\''

    };

    /**

     * this is a mapping of keys that require shift on a US keypad

     * back to the non shift equivelents

     *

     * this is so you can use keyup events with these keys

     *

     * note that this will only work reliably on US keyboards

     *

     * @type {Object}

     */

    var _SHIFT_MAP = {

        '~': '`',

        '!': '1',

        '@': '2',

        '#': '3',

        '$': '4',

        '%': '5',

        '^': '6',

        '&': '7',

        '*': '8',

        '(': '9',

        ')': '0',

        '_': '-',

        '+': '=',

        ':': ';',

        '\"': '\'',

        '<': ',',

        '>': '.',

        '?': '/',

        '|': '\\'

    };

    /**

     * this is a list of special strings you can use to map

     * to modifier keys when you specify your keyboard shortcuts

     *

     * @type {Object}

     */

    var _SPECIAL_ALIASES = {

        'option': 'alt',

        'command': 'meta',

        'return': 'enter',

        'escape': 'esc',

        'plus': '+',

        'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'

    };

    /**

     * variable to store the flipped version of _MAP from above

     * needed to check if we should use keypress or not when no action

     * is specified

     *

     * @type {Object|undefined}

     */

    var _REVERSE_MAP;

    /**

     * loop through the f keys, f1 to f19 and add them to the map

     * programatically

     */

    for (var i = 1; i < 20; ++i) {

        _MAP[111 + i] = 'f' + i;

    }

    /**

     * loop through to map numbers on the numeric keypad

     */

    for (i = 0; i <= 9; ++i) {

        // This needs to use a string cause otherwise since 0 is falsey

        // mousetrap will never fire for numpad 0 pressed as part of a keydown

        // event.

        //

        // @see https://github.com/ccampbell/mousetrap/pull/258

        _MAP[i + 96] = i.toString();

    }

    /**

     * cross browser add event method

     *

     * @param {Element|HTMLDocument} object

     * @param {string} type

     * @param {Function} callback

     * @returns void

     */

    function _addEvent(object, type, callback) {

        if (object.addEventListener) {

            object.addEventListener(type, callback, false);

            return;

        }

        object.attachEvent('on' + type, callback);

    }

    /**

     * takes the event and returns the key character

     *

     * @param {Event} e

     * @return {string}

     */

    function _characterFromEvent(e) {

        // for keypress events we should return the character as is

        if (e.type == 'keypress') {

            var character = String.fromCharCode(e.which);

            // if the shift key is not pressed then it is safe to assume

            // that we want the character to be lowercase.  this means if

            // you accidentally have caps lock on then your key bindings

            // will continue to work

            //

            // the only side effect that might not be desired is if you

            // bind something like 'A' cause you want to trigger an

            // event when capital A is pressed caps lock will no longer

            // trigger the event.  shift+a will though.

            if (!e.shiftKey) {

                character = character.toLowerCase();

            }

            return character;

        }

        // for non keypress events the special maps are needed

        if (_MAP[e.which]) {

            return _MAP[e.which];

        }

        if (_KEYCODE_MAP[e.which]) {

            return _KEYCODE_MAP[e.which];

        }

        // if it is not in the special map

        // with keydown and keyup events the character seems to always

        // come in as an uppercase character whether you are pressing shift

        // or not.  we should make sure it is always lowercase for comparisons

        return String.fromCharCode(e.which).toLowerCase();

    }

    /**

     * checks if two arrays are equal

     *

     * @param {Array} modifiers1

     * @param {Array} modifiers2

     * @returns {boolean}

     */

    function _modifiersMatch(modifiers1, modifiers2) {

        return modifiers1.sort().join(',') === modifiers2.sort().join(',');

    }

    /**

     * takes a key event and figures out what the modifiers are

     *

     * @param {Event} e

     * @returns {Array}

     */

    function _eventModifiers(e) {

        var modifiers = [];

        if (e.shiftKey) {

            modifiers.push('shift');

        }

        if (e.altKey) {

            modifiers.push('alt');

        }

        if (e.ctrlKey) {

            modifiers.push('ctrl');

        }

        if (e.metaKey) {

            modifiers.push('meta');

        }

        return modifiers;

    }

    /**

     * prevents default for this event

     *

     * @param {Event} e

     * @returns void

     */

    function _preventDefault(e) {

        if (e.preventDefault) {

            e.preventDefault();

            return;

        }

        e.returnValue = false;

    }

    /**

     * stops propogation for this event

     *

     * @param {Event} e

     * @returns void

     */

    function _stopPropagation(e) {

        if (e.stopPropagation) {

            e.stopPropagation();

            return;

        }

        e.cancelBubble = true;

    }

    /**

     * determines if the keycode specified is a modifier key or not

     *

     * @param {string} key

     * @returns {boolean}

     */

    function _isModifier(key) {

        return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';

    }

    /**

     * reverses the map lookup so that we can look for specific keys

     * to see what can and can't use keypress

     *

     * @return {Object}

     */

    function _getReverseMap() {

        if (!_REVERSE_MAP) {

            _REVERSE_MAP = {};

            for (var key in _MAP) {

                // pull out the numeric keypad from here cause keypress should

                // be able to detect the keys from the character

                if (key > 95 && key < 112) {

                    continue;

                }

                if (_MAP.hasOwnProperty(key)) {

                    _REVERSE_MAP[_MAP[key]] = key;

                }

            }

        }

        return _REVERSE_MAP;

    }

    /**

     * picks the best action based on the key combination

     *

     * @param {string} key - character for key

     * @param {Array} modifiers

     * @param {string=} action passed in

     */

    function _pickBestAction(key, modifiers, action) {

        // if no action was picked in we should try to pick the one

        // that we think would work best for this key

        if (!action) {

            action = _getReverseMap()[key] ? 'keydown' : 'keypress';

        }

        // modifier keys don't work as expected with keypress,

        // switch to keydown

        if (action == 'keypress' && modifiers.length) {

            action = 'keydown';

        }

        return action;

    }

    /**

     * Converts from a string key combination to an array

     *

     * @param  {string} combination like "command+shift+l"

     * @return {Array}

     */

    function _keysFromString(combination) {

        if (combination === '+') {

            return ['+'];

        }

        combination = combination.replace(/\+{2}/g, '+plus');

        return combination.split('+');

    }

    /**

     * Gets info for a specific key combination

     *

     * @param  {string} combination key combination ("command+s" or "a" or "*")

     * @param  {string=} action

     * @returns {Object}

     */

    function _getKeyInfo(combination, action) {

        var keys;

        var key;

        var i;

        var modifiers = [];

        // take the keys from this pattern and figure out what the actual

        // pattern is all about

        keys = _keysFromString(combination);

        for (i = 0; i < keys.length; ++i) {

            key = keys[i];

            // normalize key names

            if (_SPECIAL_ALIASES[key]) {

                key = _SPECIAL_ALIASES[key];

            }

            // if this is not a keypress event then we should

            // be smart about using shift keys

            // this will only work for US keyboards however

            if (action && action != 'keypress' && _SHIFT_MAP[key]) {

                key = _SHIFT_MAP[key];

                modifiers.push('shift');

            }

            // if this key is a modifier then add it to the list of modifiers

            if (_isModifier(key)) {

                modifiers.push(key);

            }

        }

        // depending on what the key combination is

        // we will try to pick the best event for it

        action = _pickBestAction(key, modifiers, action);

        return {

            key: key,

            modifiers: modifiers,

            action: action

        };

    }

    function _belongsTo(element, ancestor) {

        if (element === null || element === document) {

            return false;

        }

        if (element === ancestor) {

            return true;

        }

        return _belongsTo(element.parentNode, ancestor);

    }

    function Mousetrap(targetElement) {

        var self = this;

        targetElement = targetElement || document;

        if (!(self instanceof Mousetrap)) {

            return new Mousetrap(targetElement);

        }

        /**

         * element to attach key events to

         *

         * @type {Element}

         */

        self.target = targetElement;

        /**

         * a list of all the callbacks setup via Mousetrap.bind()

         *

         * @type {Object}

         */

        self._callbacks = {};

        /**

         * direct map of string combinations to callbacks used for trigger()

         *

         * @type {Object}

         */

        self._directMap = {};

        /**

         * keeps track of what level each sequence is at since multiple

         * sequences can start out with the same sequence

         *

         * @type {Object}

         */

        var _sequenceLevels = {};

        /**

         * variable to store the setTimeout call

         *

         * @type {null|number}

         */

        var _resetTimer;

        /**

         * temporary state where we will ignore the next keyup

         *

         * @type {boolean|string}

         */

        var _ignoreNextKeyup = false;

        /**

         * temporary state where we will ignore the next keypress

         *