4 /***/ 6689:

     4 /***/ 1933:

     5 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

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

     6 

     6 

     7 "use strict";

     7 var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */

     8 /* harmony export */ __webpack_require__.d(__webpack_exports__, {

     8 /**

     9 /* harmony export */   createUndoManager: () => (/* binding */ createUndoManager)

     9  * Copyright 2012-2017 Craig Campbell

    10 /* harmony export */ });

    10  *

    11 /* harmony import */ var _wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(923);

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

    12 /* harmony import */ var _wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0__);

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

    13 /**

    13  * You may obtain a copy of the License at

    14  * WordPress dependencies

    14  *

    15  */

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

    16 

    16  *

    17 

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

    18 /** @typedef {import('./types').HistoryRecord}  HistoryRecord */

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

    19 /** @typedef {import('./types').HistoryChange}  HistoryChange */

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

    20 /** @typedef {import('./types').HistoryChanges} HistoryChanges */

    20  * See the License for the specific language governing permissions and

    21 /** @typedef {import('./types').UndoManager} UndoManager */

    21  * limitations under the License.

    22 

    22  *

    23 /**

    23  * Mousetrap is a simple keyboard shortcut library for Javascript with

    24  * Merge changes for a single item into a record of changes.

    24  * no external dependencies

    25  *

    25  *

    26  * @param {Record< string, HistoryChange >} changes1 Previous changes

    26  * @version 1.6.5

    27  * @param {Record< string, HistoryChange >} changes2 NextChanges

    27  * @url craig.is/killing/mice

    28  *

    28  */

    29  * @return {Record< string, HistoryChange >} Merged changes

    29 (function(window, document, undefined) {

    30  */

    30 

    31 function mergeHistoryChanges(changes1, changes2) {

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

    32   /**

    32     if (!window) {

    33    * @type {Record< string, HistoryChange >}

    33         return;

    34    */

    34     }

    35   const newChanges = {

    35 

    36     ...changes1

    36     /**

    37   };

    37      * mapping of special keycodes to their corresponding keys

    38   Object.entries(changes2).forEach(([key, value]) => {

    38      *

    39     if (newChanges[key]) {

    39      * everything in this dictionary cannot use keypress events

    40       newChanges[key] = {

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

    41         ...newChanges[key],

    41      * keyup/keydown events

    42         to: value.to

    42      *

    43       };

    43      * @type {Object}

    44     } else {

    44      */

    45       newChanges[key] = value;

    45     var _MAP = {

    46     }

    46         8: 'backspace',

    47   });

    47         9: 'tab',

    48   return newChanges;

    48         13: 'enter',

    49 }

    49         16: 'shift',

    50 

    50         17: 'ctrl',

    51 /**

    51         18: 'alt',

    52  * Adds history changes for a single item into a record of changes.

    52         20: 'capslock',

    53  *

    53         27: 'esc',

    54  * @param {HistoryRecord}  record  The record to merge into.

    54         32: 'space',

    55  * @param {HistoryChanges} changes The changes to merge.

    55         33: 'pageup',

    56  */

    56         34: 'pagedown',

    57 const addHistoryChangesIntoRecord = (record, changes) => {

    57         35: 'end',

    58   const existingChangesIndex = record?.findIndex(({

    58         36: 'home',

    59     id: recordIdentifier

    59         37: 'left',

    60   }) => {

    60         38: 'up',

    61     return typeof recordIdentifier === 'string' ? recordIdentifier === changes.id : _wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0___default()(recordIdentifier, changes.id);

    61         39: 'right',

    62   });

    62         40: 'down',

    63   const nextRecord = [...record];

    63         45: 'ins',

    64   if (existingChangesIndex !== -1) {

    64         46: 'del',

    65     // If the edit is already in the stack leave the initial "from" value.

    65         91: 'meta',

    66     nextRecord[existingChangesIndex] = {

    66         93: 'meta',

    67       id: changes.id,

    67         224: 'meta'

    68       changes: mergeHistoryChanges(nextRecord[existingChangesIndex].changes, changes.changes)

    70   } else {

    69 

    71     nextRecord.push(changes);

    72   }

    73   return nextRecord;

    74 };

    75 

    76 /**

    77  * Creates an undo manager.

    78  *

    79  * @return {UndoManager} Undo manager.

    80  */

    81 function createUndoManager() {

    82   /**

    83    * @type {HistoryRecord[]}

    84    */

    85   let history = [];

    86   /**

    87    * @type {HistoryRecord}

    88    */

    89   let stagedRecord = [];

    90   /**

    91    * @type {number}

    92    */

    93   let offset = 0;

    94   const dropPendingRedos = () => {

    95     history = history.slice(0, offset || undefined);

    96     offset = 0;

    97   };

    98   const appendStagedRecordToLatestHistoryRecord = () => {

    99     var _history$index;

   100     const index = history.length === 0 ? 0 : history.length - 1;

   101     let latestRecord = (_history$index = history[index]) !== null && _history$index !== void 0 ? _history$index : [];

   102     stagedRecord.forEach(changes => {

   103       latestRecord = addHistoryChangesIntoRecord(latestRecord, changes);

   104     });

   105     stagedRecord = [];

   106     history[index] = latestRecord;

   107   };

   108 

   109   /**

   110    * Checks whether a record is empty.

   111    * A record is considered empty if it the changes keep the same values.

   112    * Also updates to function values are ignored.

   113    *

   114    * @param {HistoryRecord} record

   115    * @return {boolean} Whether the record is empty.

   116    */

   117   const isRecordEmpty = record => {

   118     const filteredRecord = record.filter(({

   119       changes

   120     }) => {

   121       return Object.values(changes).some(({

   122         from,

   123         to

   124       }) => typeof from !== 'function' && typeof to !== 'function' && !_wordpress_is_shallow_equal__WEBPACK_IMPORTED_MODULE_0___default()(from, to));

   125     });

   126     return !filteredRecord.length;

   127   };

   128   return {

   130      * Record changes into the history.

    71      * mapping for special characters so they can support

   132      * @param {HistoryRecord=} record   A record of changes to record.

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

   133      * @param {boolean}        isStaged Whether to immediately create an undo point or not.

    74      * keyup or keydown event to one of these keys

    75      *

    76      * @type {Object}

   135     addRecord(record, isStaged = false) {

    78     var _KEYCODE_MAP = {

   136       const isEmpty = !record || isRecordEmpty(record);

    79         106: '*',

   137       if (isStaged) {

    80         107: '+',

   138         if (isEmpty) {

    81         109: '-',

   139           return;

    82         110: '.',

    83         111 : '/',

    84         186: ';',

    85         187: '=',

    86         188: ',',

    87         189: '-',

    88         190: '.',

    89         191: '/',

    90         192: '`',

    91         219: '[',

    92         220: '\\',

    93         221: ']',

    94         222: '\''

    95     };

    96 

    97     /**

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

    99      * back to the non shift equivelents

   100      *

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

   102      *

   103      * note that this will only work reliably on US keyboards

   104      *

   105      * @type {Object}

   106      */

   107     var _SHIFT_MAP = {

   108         '~': '`',

   109         '!': '1',

   110         '@': '2',

   111         '#': '3',

   112         '$': '4',

   113         '%': '5',

   114         '^': '6',

   115         '&': '7',

   116         '*': '8',

   117         '(': '9',

   118         ')': '0',

   119         '_': '-',

   120         '+': '=',

   121         ':': ';',

   122         '\"': '\'',

   123         '<': ',',

   124         '>': '.',

   125         '?': '/',

   126         '|': '\\'

   127     };

   128 

   129     /**

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

   131      * to modifier keys when you specify your keyboard shortcuts

   132      *

   133      * @type {Object}

   134      */

   135     var _SPECIAL_ALIASES = {

   136         'option': 'alt',

   137         'command': 'meta',

   138         'return': 'enter',

   139         'escape': 'esc',

   140         'plus': '+',

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

   142     };

   143 

   144     /**

   145      * variable to store the flipped version of _MAP from above

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

   147      * is specified

   148      *

   149      * @type {Object|undefined}

   150      */

   151     var _REVERSE_MAP;

   152 

   153     /**

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

   155      * programatically

   156      */

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

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

   159     }

   160 

   161     /**

   162      * loop through to map numbers on the numeric keypad

   163      */

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

   165 

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

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

   168         // event.

   169         //

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

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

   172     }

   173 

   174     /**

   175      * cross browser add event method

   176      *

   177      * @param {Element|HTMLDocument} object

   178      * @param {string} type

   179      * @param {Function} callback

   180      * @returns void

   181      */

   182     function _addEvent(object, type, callback) {

   183         if (object.addEventListener) {

   184             object.addEventListener(type, callback, false);

   185             return;

   141         record.forEach(changes => {

   187 

   142           stagedRecord = addHistoryChangesIntoRecord(stagedRecord, changes);

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

   143         });

   189     }

   144       } else {

   190 

   145         dropPendingRedos();

   191     /**

   146         if (stagedRecord.length) {

   192      * takes the event and returns the key character

   147           appendStagedRecordToLatestHistoryRecord();

   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;

   149         if (isEmpty) {

   218 

   150           return;

   219         // for non keypress events the special maps are needed

   220         if (_MAP[e.which]) {

   221             return _MAP[e.which];

   152         history.push(record);

   223 

   153       }

   224         if (_KEYCODE_MAP[e.which]) {

   154     },

   225             return _KEYCODE_MAP[e.which];

   155     undo() {

   226         }

   156       if (stagedRecord.length) {

   227 

   157         dropPendingRedos();

   228         // if it is not in the special map

   158         appendStagedRecordToLatestHistoryRecord();

   229 

   159       }

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

   160       const undoRecord = history[history.length - 1 + offset];

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

   161       if (!undoRecord) {

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

   162         return;

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

   163       }

   234     }

   164       offset -= 1;

   235 

   165       return undoRecord;

   236     /**

   166     },

   237      * checks if two arrays are equal

   167     redo() {

   238      *

   168       const redoRecord = history[history.length + offset];

   239      * @param {Array} modifiers1

   169       if (!redoRecord) {

   240      * @param {Array} modifiers2

   170         return;

   241      * @returns {boolean}

   171       }

   242      */

   172       offset += 1;

   243     function _modifiersMatch(modifiers1, modifiers2) {

   173       return redoRecord;

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

   174     },

   245     }

   175     hasUndo() {

   246 

   176       return !!history[history.length - 1 + offset];

   247     /**

   177     },

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

   178     hasRedo() {

   249      *

   179       return !!history[history.length + offset];

   250      * @param {Event} e

   180     }

   251      * @returns {Array}

   181   };

   252      */

   182 }

   253     function _eventModifiers(e) {

   254         var modifiers = [];

   255 

   256         if (e.shiftKey) {

   257             modifiers.push('shift');

   258         }

   259 

   260         if (e.altKey) {

   261             modifiers.push('alt');

   262         }

   263 

   264         if (e.ctrlKey) {

   265             modifiers.push('ctrl');

   266         }

   267 

   268         if (e.metaKey) {

   269             modifiers.push('meta');

   270         }

   271 

   272         return modifiers;

   273     }

   274 

   275     /**

   276      * prevents default for this event

   277      *

   278      * @param {Event} e

   279      * @returns void

   280      */

   281     function _preventDefault(e) {

   282         if (e.preventDefault) {

   283             e.preventDefault();

   284             return;

   285         }

   286 

   287         e.returnValue = false;

   288     }

   289 

   290     /**

   291      * stops propogation for this event

   292      *

   293      * @param {Event} e

   294      * @returns void

   295      */

   296     function _stopPropagation(e) {

   297         if (e.stopPropagation) {

   298             e.stopPropagation();

   299             return;

   300         }

   301 

   302         e.cancelBubble = true;

   303     }

   304 

   305     /**

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

   307      *

   308      * @param {string} key

   309      * @returns {boolean}

   310      */

   311     function _isModifier(key) {

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

   313     }

   314 

   315     /**

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

   317      * to see what can and can't use keypress

   318      *

   319      * @return {Object}

   320      */

   321     function _getReverseMap() {

   322         if (!_REVERSE_MAP) {

   323             _REVERSE_MAP = {};

   324             for (var key in _MAP) {

   325 

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

   327                 // be able to detect the keys from the character

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

   329                     continue;

   330                 }

   331 

   332                 if (_MAP.hasOwnProperty(key)) {

   333                     _REVERSE_MAP[_MAP[key]] = key;

   334                 }

   335             }

   336         }

   337         return _REVERSE_MAP;

   338     }

   339 

   340     /**

   341      * picks the best action based on the key combination

   342      *

   343      * @param {string} key - character for key

   344      * @param {Array} modifiers

   345      * @param {string=} action passed in

   346      */

   347     function _pickBestAction(key, modifiers, action) {

   348 

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

   350         // that we think would work best for this key

   351         if (!action) {

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

   353         }

   354 

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

   356         // switch to keydown

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

   358             action = 'keydown';

   359         }

   360 

   361         return action;

   362     }

   363 

   364     /**

   365      * Converts from a string key combination to an array

   366      *

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

   368      * @return {Array}

   369      */

   370     function _keysFromString(combination) {

   371         if (combination === '+') {

   372             return ['+'];

   373         }

   374 

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

   376         return combination.split('+');

   377     }

   378 

   379     /**

   380      * Gets info for a specific key combination

   381      *

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

   383      * @param  {string=} action

   384      * @returns {Object}

   385      */

   386     function _getKeyInfo(combination, action) {

   387         var keys;

   388         var key;

   389         var i;

   390         var modifiers = [];

   391 

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

   393         // pattern is all about

   394         keys = _keysFromString(combination);

   395 

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

   397             key = keys[i];

   398 

   399             // normalize key names

   400             if (_SPECIAL_ALIASES[key]) {

   401                 key = _SPECIAL_ALIASES[key];

   402             }

   403 

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

   405             // be smart about using shift keys

   406             // this will only work for US keyboards however

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

   408                 key = _SHIFT_MAP[key];

   409                 modifiers.push('shift');

   410             }

   411 

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

   413             if (_isModifier(key)) {

   414                 modifiers.push(key);

   415             }

   416         }

   417 

   418         // depending on what the key combination is

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

   420         action = _pickBestAction(key, modifiers, action);

   421 

   422         return {

   423             key: key,

   424             modifiers: modifiers,

   425             action: action

   426         };

   427     }

   428 

   429     function _belongsTo(element, ancestor) {

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

   431             return false;

   432         }

   433 

   434         if (element === ancestor) {

   435             return true;

   436         }

   437 

   438         return _belongsTo(element.parentNode, ancestor);

   439     }

   440 

   441     function Mousetrap(targetElement) {

   442         var self = this;

   443 

   444         targetElement = targetElement || document;

   445 

   446         if (!(self instanceof Mousetrap)) {

   447             return new Mousetrap(targetElement);

   448         }

   449 

   450         /**

   451          * element to attach key events to

   452          *

   453          * @type {Element}

   454          */

   455         self.target = targetElement;

   456 

   457         /**

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

   459          *

   460          * @type {Object}

   461          */

   462         self._callbacks = {};

   463 

   464         /**

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

   466          *

   467          * @type {Object}

   468          */

   469         self._directMap = {};

   470 

   471         /**

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

   473          * sequences can start out with the same sequence

   474          *

   475          * @type {Object}

   476          */

   477         var _sequenceLevels = {};

   478 

   479         /**

   480          * variable to store the setTimeout call

   481          *

   482          * @type {null|number}

   483          */

   484         var _resetTimer;

   485 

   486         /**

   487          * temporary state where we will ignore the next keyup

   488          *

   489          * @type {boolean|string}

   490          */

   491         var _ignoreNextKeyup = false;

   492 

   493         /**

   494          * temporary state where we will ignore the next keypress

   495          *

   496          * @type {boolean}

   497          */

   498         var _ignoreNextKeypress = false;

   499 

   500         /**

   501          * are we currently inside of a sequence?

   502          * type of action ("keyup" or "keydown" or "keypress") or false

   503          *

   504          * @type {boolean|string}

   505          */

   506         var _nextExpectedAction = false;

   507 

   508         /**

   509          * resets all sequence counters except for the ones passed in

   510          *

   511          * @param {Object} doNotReset

   512          * @returns void

   513          */

   514         function _resetSequences(doNotReset) {

   515             doNotReset = doNotReset || {};

   516 

   517             var activeSequences = false,

   518                 key;

   519 

   520             for (key in _sequenceLevels) {

   521                 if (doNotReset[key]) {

   522                     activeSequences = true;

   523                     continue;

   524                 }

   525                 _sequenceLevels[key] = 0;

   526             }

   527 

   528             if (!activeSequences) {

   529                 _nextExpectedAction = false;

   530             }

   531         }

   532 

   533         /**

   534          * finds all callbacks that match based on the keycode, modifiers,

   535          * and action

   536          *

   537          * @param {string} character

   538          * @param {Array} modifiers

   539          * @param {Event|Object} e

   540          * @param {string=} sequenceName - name of the sequence we are looking for

   541          * @param {string=} combination

   542          * @param {number=} level

   543          * @returns {Array}

   544          */

   545         function _getMatches(character, modifiers, e, sequenceName, combination, level) {

   546             var i;

   547             var callback;

   548             var matches = [];

   549             var action = e.type;

   550 

   551             // if there are no events related to this keycode

   552             if (!self._callbacks[character]) {

   553                 return [];

   554             }

   555 

   556             // if a modifier key is coming up on its own we should allow it

   557             if (action == 'keyup' && _isModifier(character)) {

   558                 modifiers = [character];

   559             }

   560 

   561             // loop through all callbacks for the key that was pressed

   562             // and see if any of them match

   563             for (i = 0; i < self._callbacks[character].length; ++i) {

   564                 callback = self._callbacks[character][i];

   565 

   566                 // if a sequence name is not specified, but this is a sequence at

   567                 // the wrong level then move onto the next match

   568                 if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {

   569                     continue;

   570                 }

   571 

   572                 // if the action we are looking for doesn't match the action we got

   573                 // then we should keep going

   574                 if (action != callback.action) {

   575                     continue;

   576                 }

   577 

   578                 // if this is a keypress event and the meta key and control key

   579                 // are not pressed that means that we need to only look at the

   580                 // character, otherwise check the modifiers as well

   581                 //

   582                 // chrome will not fire a keypress if meta or control is down

   583                 // safari will fire a keypress if meta or meta+shift is down

   584                 // firefox will fire a keypress if meta or control is down

   585                 if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {

   586 

   587                     // when you bind a combination or sequence a second time it

   588                     // should overwrite the first one.  if a sequenceName or

   589                     // combination is specified in this call it does just that

   590                     //

   591                     // @todo make deleting its own method?

   592                     var deleteCombo = !sequenceName && callback.combo == combination;

   593                     var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;

   594                     if (deleteCombo || deleteSequence) {

   595                         self._callbacks[character].splice(i, 1);

   596                     }

   597 

   598                     matches.push(callback);

   599                 }

   600             }

   601 

   602             return matches;

   603         }

   604 

   605         /**

   606          * actually calls the callback function

   607          *

   608          * if your callback function returns false this will use the jquery

   609          * convention - prevent default and stop propogation on the event

   610          *

   611          * @param {Function} callback

   612          * @param {Event} e

   613          * @returns void

   614          */

   615         function _fireCallback(callback, e, combo, sequence) {

   616 

   617             // if this event should not happen stop here

   618             if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {

   619                 return;

   620             }

   621 

   622             if (callback(e, combo) === false) {

   623                 _preventDefault(e);

   624                 _stopPropagation(e);

   625             }

   626         }

   627 

   628         /**

   629          * handles a character key event

   630          *

   631          * @param {string} character

   632          * @param {Array} modifiers

   633          * @param {Event} e

   634          * @returns void

   635          */

   636         self._handleKey = function(character, modifiers, e) {

   637             var callbacks = _getMatches(character, modifiers, e);

   638             var i;

   639             var doNotReset = {};

   640             var maxLevel = 0;

   641             var processedSequenceCallback = false;

   642 

   643             // Calculate the maxLevel for sequences so we can only execute the longest callback sequence

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

   645                 if (callbacks[i].seq) {

   646                     maxLevel = Math.max(maxLevel, callbacks[i].level);

   647                 }

   648             }

   649 

   650             // loop through matching callbacks for this key event

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

   652 

   653                 // fire for all sequence callbacks

   654                 // this is because if for example you have multiple sequences

   655                 // bound such as "g i" and "g t" they both need to fire the

   656                 // callback for matching g cause otherwise you can only ever

   657                 // match the first one

   658                 if (callbacks[i].seq) {

   659 

   660                     // only fire callbacks for the maxLevel to prevent

   661                     // subsequences from also firing

   662                     //

   663                     // for example 'a option b' should not cause 'option b' to fire

   664                     // even though 'option b' is part of the other sequence

   665                     //

   666                     // any sequences that do not match here will be discarded

   667                     // below by the _resetSequences call

   668                     if (callbacks[i].level != maxLevel) {

   669                         continue;

   670                     }

   671 

   672                     processedSequenceCallback = true;

   673 

   674                     // keep a list of which sequences were matches for later

   675                     doNotReset[callbacks[i].seq] = 1;

   676                     _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);

   677                     continue;

   678                 }

   679 

   680                 // if there were no sequence matches but we are still here

   681                 // that means this is a regular match so we should fire that

   682                 if (!processedSequenceCallback) {

   683                     _fireCallback(callbacks[i].callback, e, callbacks[i].combo);

   684                 }

   685             }

   686 

   687             // if the key you pressed matches the type of sequence without

   688             // being a modifier (ie "keyup" or "keypress") then we should

   689             // reset all sequences that were not matched by this event

   690             //

   691             // this is so, for example, if you have the sequence "h a t" and you

   692             // type "h e a r t" it does not match.  in this case the "e" will

   693             // cause the sequence to reset

   694             //

   695             // modifier keys are ignored because you can have a sequence

   696             // that contains modifiers such as "enter ctrl+space" and in most

   697             // cases the modifier key will be pressed before the next key

   698             //

   699             // also if you have a sequence such as "ctrl+b a" then pressing the

   700             // "b" key will trigger a "keypress" and a "keydown"

   701             //

   702             // the "keydown" is expected when there is a modifier, but the

   703             // "keypress" ends up matching the _nextExpectedAction since it occurs

   704             // after and that causes the sequence to reset

   705             //

   706             // we ignore keypresses in a sequence that directly follow a keydown

   707             // for the same character

   708             var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;

   709             if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {

   710                 _resetSequences(doNotReset);

   711             }

   712 

   713             _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';

   714         };

   715 

   716         /**

   717          * handles a keydown event

   718          *

   719          * @param {Event} e

   720          * @returns void

   721          */

   722         function _handleKeyEvent(e) {

   723 

   724             // normalize e.which for key events

   725             // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion

   726             if (typeof e.which !== 'number') {

   727                 e.which = e.keyCode;

   728             }

   729 

   730             var character = _characterFromEvent(e);

   731 

   732             // no character found then stop

   733             if (!character) {

   734                 return;

   735             }

   736 

   737             // need to use === for the character check because the character can be 0

   738             if (e.type == 'keyup' && _ignoreNextKeyup === character) {

   739                 _ignoreNextKeyup = false;

   740                 return;

   741             }

   742 

   743             self.handleKey(character, _eventModifiers(e), e);

   744         }

   745 

   746         /**

   747          * called to set a 1 second timeout on the specified sequence

   748          *

   749          * this is so after each key press in the sequence you have 1 second

   750          * to press the next key before you have to start over

   751          *

   752          * @returns void

   753          */

   754         function _resetSequenceTimer() {

   755             clearTimeout(_resetTimer);

   756             _resetTimer = setTimeout(_resetSequences, 1000);

   757         }

   758 

   759         /**

   760          * binds a key sequence to an event

   761          *

   762          * @param {string} combo - combo specified in bind call

   763          * @param {Array} keys

   764          * @param {Function} callback

   765          * @param {string=} action

   766          * @returns void

   767          */

   768         function _bindSequence(combo, keys, callback, action) {

   769 

   770             // start off by adding a sequence level record for this combination

   771             // and setting the level to 0

   772             _sequenceLevels[combo] = 0;

   773 

   774             /**

   775              * callback to increase the sequence level for this sequence and reset

   776              * all other sequences that were active

   777              *

   778              * @param {string} nextAction

   779              * @returns {Function}

   780              */

   781             function _increaseSequence(nextAction) {

   782                 return function() {

   783                     _nextExpectedAction = nextAction;

   784                     ++_sequenceLevels[combo];

   785                     _resetSequenceTimer();

   786                 };

   787             }

   788 

   789             /**

   790              * wraps the specified callback inside of another function in order

   791              * to reset all sequence counters as soon as this sequence is done

   792              *

   793              * @param {Event} e

   794              * @returns void

   795              */

   796             function _callbackAndReset(e) {

   797                 _fireCallback(callback, e, combo);

   798 

   799                 // we should ignore the next key up if the action is key down

   800                 // or keypress.  this is so if you finish a sequence and

   801                 // release the key the final key will not trigger a keyup

   802                 if (action !== 'keyup') {

   803                     _ignoreNextKeyup = _characterFromEvent(e);

   804                 }

   805 

   806                 // weird race condition if a sequence ends with the key

   807                 // another sequence begins with

   808                 setTimeout(_resetSequences, 10);

   809             }

   810 

   811             // loop through keys one at a time and bind the appropriate callback

   812             // function.  for any key leading up to the final one it should

   813             // increase the sequence. after the final, it should reset all sequences

   814             //

   815             // if an action is specified in the original bind call then that will

   816             // be used throughout.  otherwise we will pass the action that the

   817             // next key in the sequence should match.  this allows a sequence

   818             // to mix and match keypress and keydown events depending on which

   819             // ones are better suited to the key provided

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

   821                 var isFinal = i + 1 === keys.length;

   822                 var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);

   823                 _bindSingle(keys[i], wrappedCallback, action, combo, i);

   824             }

   825         }

   826 

   827         /**

   828          * binds a single keyboard combination

   829          *

   830          * @param {string} combination

   831          * @param {Function} callback

   832          * @param {string=} action

   833          * @param {string=} sequenceName - name of sequence if part of sequence

   834          * @param {number=} level - what part of the sequence the command is

   835          * @returns void

   836          */

   837         function _bindSingle(combination, callback, action, sequenceName, level) {

   838 

   839             // store a direct mapped reference for use with Mousetrap.trigger

   840             self._directMap[combination + ':' + action] = callback;

   841 

   842             // make sure multiple spaces in a row become a single space

   843             combination = combination.replace(/\s+/g, ' ');

   844 

   845             var sequence = combination.split(' ');

   846             var info;

   847 

   848             // if this pattern is a sequence of keys then run through this method

   849             // to reprocess each pattern one key at a time

   850             if (sequence.length > 1) {

   851                 _bindSequence(combination, sequence, callback, action);

   852                 return;

   853             }

   854 

   855             info = _getKeyInfo(combination, action);

   856 

   857             // make sure to initialize array if this is the first time

   858             // a callback is added for this key

   859             self._callbacks[info.key] = self._callbacks[info.key] || [];

   860 

   861             // remove an existing match if there is one

   862             _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);

   863 

   864             // add this call back to the array

   865             // if it is a sequence put it at the beginning

   866             // if not put it at the end

   867             //

   868             // this is important because the way these are processed expects

   869             // the sequence ones to come first

   870             self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({

   871                 callback: callback,

   872                 modifiers: info.modifiers,

   873                 action: info.action,

   874                 seq: sequenceName,

   875                 level: level,

   876                 combo: combination

   877             });

   878         }

   879 

   880         /**

   881          * binds multiple combinations to the same callback

   882          *

   883          * @param {Array} combinations

   884          * @param {Function} callback

   885          * @param {string|undefined} action

   886          * @returns void

   887          */

   888         self._bindMultiple = function(combinations, callback, action) {

   889             for (var i = 0; i < combinations.length; ++i) {

   890                 _bindSingle(combinations[i], callback, action);

   891             }

   892         };

   893 

   894         // start!

   895         _addEvent(targetElement, 'keypress', _handleKeyEvent);

   896         _addEvent(targetElement, 'keydown', _handleKeyEvent);

   897         _addEvent(targetElement, 'keyup', _handleKeyEvent);

   898     }

   899 

   900     /**

   901      * binds an event to mousetrap

   902      *

   903      * can be a single key, a combination of keys separated with +,

   904      * an array of keys, or a sequence of keys separated by spaces

   905      *

   906      * be sure to list the modifier keys first to make sure that the

   907      * correct key ends up getting bound (the last key in the pattern)

   908      *

   909      * @param {string|Array} keys

   910      * @param {Function} callback

   911      * @param {string=} action - 'keypress', 'keydown', or 'keyup'

   912      * @returns void

   913      */

   914     Mousetrap.prototype.bind = function(keys, callback, action) {

   915         var self = this;

   916         keys = keys instanceof Array ? keys : [keys];

   917         self._bindMultiple.call(self, keys, callback, action);

   918         return self;

   919     };

   920 

   921     /**

   922      * unbinds an event to mousetrap

   923      *

   924      * the unbinding sets the callback function of the specified key combo

   925      * to an empty function and deletes the corresponding key in the

   926      * _directMap dict.

   927      *

   928      * TODO: actually remove this from the _callbacks dictionary instead

   929      * of binding an empty function

   930      *

   931      * the keycombo+action has to be exactly the same as

   932      * it was defined in the bind method

   933      *

   934      * @param {string|Array} keys

   935      * @param {string} action

   936      * @returns void

   937      */

   938     Mousetrap.prototype.unbind = function(keys, action) {

   939         var self = this;

   940         return self.bind.call(self, keys, function() {}, action);

   941     };

   942 

   943     /**

   944      * triggers an event that has already been bound

   945      *

   946      * @param {string} keys

   947      * @param {string=} action

   948      * @returns void

   949      */

   950     Mousetrap.prototype.trigger = function(keys, action) {

   951         var self = this;

   952         if (self._directMap[keys + ':' + action]) {

   953             self._directMap[keys + ':' + action]({}, keys);

   954         }

   955         return self;

   956     };

   957 

   958     /**

   959      * resets the library back to its initial state.  this is useful

   960      * if you want to clear out the current keyboard shortcuts and bind

   961      * new ones - for example if you switch to another page

   962      *

   963      * @returns void

   964      */

   965     Mousetrap.prototype.reset = function() {

   966         var self = this;

   967         self._callbacks = {};

   968         self._directMap = {};

   969         return self;

   970     };

   971 

   972     /**

   973      * should we stop this event before firing off callbacks

   974      *

   975      * @param {Event} e

   976      * @param {Element} element

   977      * @return {boolean}

   978      */

   979     Mousetrap.prototype.stopCallback = function(e, element) {

   980         var self = this;

   981 

   982         // if the element has the class "mousetrap" then no need to stop

   983         if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {

   984             return false;

   985         }

   986 

   987         if (_belongsTo(element, self.target)) {

   988             return false;

   989         }

   990 

   991         // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,

   992         // not the initial event target in the shadow tree. Note that not all events cross the

   993         // shadow boundary.

   994         // For shadow trees with `mode: 'open'`, the initial event target is the first element in

   995         // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event

   996         // target cannot be obtained.

   997         if ('composedPath' in e && typeof e.composedPath === 'function') {

   998             // For open shadow trees, update `element` so that the following check works.

   999             var initialEventTarget = e.composedPath()[0];

  1000             if (initialEventTarget !== e.target) {

  1001                 element = initialEventTarget;

  1002             }

  1003         }

  1004 

  1005         // stop for input, select, and textarea

  1006         return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;

  1007     };

  1008 

  1009     /**

  1010      * exposes _handleKey publicly so it can be overwritten by extensions

  1011      */

  1012     Mousetrap.prototype.handleKey = function() {

  1013         var self = this;

  1014         return self._handleKey.apply(self, arguments);

  1015     };

  1016 

  1017     /**

  1018      * allow custom key mappings

  1019      */

  1020     Mousetrap.addKeycodes = function(object) {

  1021         for (var key in object) {

  1022             if (object.hasOwnProperty(key)) {

  1023                 _MAP[key] = object[key];

  1024             }

  1025         }

  1026         _REVERSE_MAP = null;

  1027     };

  1028 

  1029     /**

  1030      * Init the global mousetrap functions

  1031      *

  1032      * This method is needed to allow the global mousetrap functions to work

  1033      * now that mousetrap is a constructor function.

  1034      */

  1035     Mousetrap.init = function() {

  1036         var documentMousetrap = Mousetrap(document);

  1037         for (var method in documentMousetrap) {

  1038             if (method.charAt(0) !== '_') {

  1039                 Mousetrap[method] = (function(method) {

  1040                     return function() {

  1041                         return documentMousetrap[method].apply(documentMousetrap, arguments);

  1042                     };

  1043                 } (method));

  1044             }

  1045         }

  1046     };

  1047 

  1048     Mousetrap.init();

  1049 

  1050     // expose mousetrap to the global object

  1051     window.Mousetrap = Mousetrap;

  1052 

  1053     // expose as a common js module

  1054     if ( true && module.exports) {

  1055         module.exports = Mousetrap;

  1056     }

  1057 

  1058     // expose mousetrap as an AMD module

  1059     if (true) {

  1060         !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {

  1061             return Mousetrap;

  1062         }).call(exports, __webpack_require__, exports, module),

  1063 		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

  1064     }

  1065 }) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);