var kbdUtil = (function() {

"use strict";

function substituteCodepoint(cp) {

}

function isMac() {

return navigator && !!(/mac/i).exec(navigator.platform);

}

function isWindows() {

return navigator && !!(/win/i).exec(navigator.platform);

}

function isLinux() {

return navigator && !!(/linux/i).exec(navigator.platform);

}

// Return true if a modifier which is not the specified char modifier (and is not shift) is down

function hasShortcutModifier(charModifier, currentModifiers) {

}

// Return true if the specified char modifier is currently down

function hasCharModifier(charModifier, currentModifiers) {

}

// Helper object tracking modifier key state

// and generates fake key events to compensate if it gets out of sync

function ModifierSync(charModifier) {

}

// Get a key ID from a keyboard event

// May be a string or an integer depending on the available properties

function getKey(evt){

}

// Get the most reliable keysym value we can get from a key event

// if char/charCode is available, prefer those, otherwise fall back to key/keyCode/which

function getKeysym(evt){

}

// Given a keycode, try to predict which keysym it might be.

// If the keycode is unknown, null is returned.

function keysymFromKeyCode(keycode, shiftPressed) {

}

// if the key is a known non-character key (any key which doesn't generate character data)

// return its keysym value. Otherwise return null

function nonCharacterKey(evt) {

}

return {

hasShortcutModifier : hasShortcutModifier,

hasCharModifier : hasCharModifier,

ModifierSync : ModifierSync,

getKey : getKey,

getKeysym : getKeysym,

keysymFromKeyCode : keysymFromKeyCode,

nonCharacterKey : nonCharacterKey,

substituteCodepoint : substituteCodepoint

};

})();

// Takes a DOM keyboard event and:

// - determines which keysym it represents

// - determines a keyId identifying the key that was pressed (corresponding to the key/keyCode properties on the DOM event)

// - synthesizes events to synchronize modifier key state between which modifiers are actually down, and which we thought were down

// - marks each event with an 'escape' property if a modifier was down which should be "escaped"

// - generates a "stall" event in cases where it might be necessary to wait and see if a keypress event follows a keydown

// This information is collected into an object which is passed to the next() function. (one call per event)

function KeyEventDecoder(modifierState, next) {

}

// Combines keydown and keypress events where necessary to handle char modifiers.

// On some OS'es, a char modifier is sometimes used as a shortcut modifier.

// For example, on Windows, AltGr is synonymous with Ctrl-Alt. On a Danish keyboard layout, AltGr-2 yields a @, but Ctrl-Alt-D does nothing

// so when used with the '2' key, Ctrl-Alt counts as a char modifier (and should be escaped), but when used with 'D', it does not.

// The only way we can distinguish these cases is to wait and see if a keypress event arrives

// When we receive a "stall" event, wait a few ms before processing the next keydown. If a keypress has also arrived, merge the two

function VerifyCharModifier(next) {

}

// Keeps track of which keys we (and the server) believe are down

// When a keyup is received, match it against this list, to determine the corresponding keysym(s)

// in some cases, a single key may produce multiple keysyms, so the corresponding keyup event must release all of these chars

// key repeat events should be merged into a single entry.

// Because we can't always identify which entry a keydown or keyup event corresponds to, we sometimes have to guess

function TrackKeyState(next) {

}

// Handles "escaping" of modifiers: if a char modifier is used to produce a keysym (such as AltGr-2 to generate an @),

// then the modifier must be "undone" before sending the @, and "redone" afterwards.

function EscapeModifiers(next) {

}