kea-rails 1.0.1 → 1.0.2

data/vendor/assets/components/Keypress/keypress.coffee

@@ -0,0 +1,921 @@
+###
+Copyright 2014 David Mauro
+
+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.
+
+Keypress is a robust keyboard input capturing Javascript utility
+focused on input for games.
+
+version 2.1.0
+###
+
+###
+Combo options available and their defaults:
+    keys            : []            - An array of the keys pressed together to activate combo.
+    count           : 0             - The number of times a counting combo has been pressed. Reset on release.
+    is_unordered    : false         - Unless this is set to true, the keys can be pressed down in any order.
+    is_counting     : false         - Makes this a counting combo (see documentation).
+    is_exclusive    : false         - This combo will replace other exclusive combos when true.
+    is_solitary     : false         - This combo will only fire if ONLY it's keys are pressed down.
+    is_sequence     : false         - Rather than a key combo, this is an ordered key sequence.
+    prevent_default : false         - Prevent default behavior for all component key keypresses.
+    prevent_repeat  : false         - Prevent the combo from repeating when keydown is held.
+    on_keydown      : null          - A function that is called when the combo is pressed.
+    on_keyup        : null          - A function that is called when the combo is released.
+    on_release      : null          - A function that is called when all keys in the combo are released.
+    this            : undefined     - Defines the scope for your callback functions.
+###
+
+###########
+# Constants
+###########
+
+_factory_defaults =
+    is_unordered    : false
+    is_counting     : false
+    is_exclusive    : false
+    is_solitary     : false
+    prevent_default : false
+    prevent_repeat  : false
+
+_modifier_keys = ["meta", "alt", "option", "ctrl", "shift", "cmd"]
+
+_metakey = "ctrl"
+
+###########################
+# Public object and Classes
+###########################
+
+keypress = {}
+
+keypress.debug = false
+
+class Combo
+    constructor: (dictionary) ->
+        # Copy over any non-false values
+        for own property, value of dictionary
+            @[property] = value if value != false
+
+        # Standard Defaults
+        @keys = @keys or []
+        @count = @count or 0
+
+    allows_key_repeat: ->
+        # Combos with keydown functions should be able to rapid fire
+        # when holding down the key for an extended period
+        return not @prevent_repeat and typeof @on_keydown is "function"
+
+    reset: ->
+        @count = 0
+        @keyup_fired = null
+
+class keypress.Listener
+    constructor:(element, defaults) ->
+        # Public properties
+        @should_suppress_event_defaults = false
+        @should_force_event_defaults = false
+        @sequence_delay = 800
+
+        # Private properties
+        @_registered_combos = []
+        @_keys_down = []
+        @_active_combos = []
+        @_sequence = []
+        @_sequence_timer = null
+        @_prevent_capture = false
+        @_defaults = defaults or {}
+        for own property, value of _factory_defaults
+            @_defaults[property] = @_defaults[property] or value
+
+        # Attach handlers to element
+        @element = element or document.body
+
+        attach_handler = (target, event, handler) ->
+            if target.addEventListener
+                target.addEventListener event, handler
+            else if target.attachEvent
+                target.attachEvent "on#{event}", handler
+
+            return handler
+
+        @keydown_event = attach_handler @element, "keydown", (e) =>
+            e = e or window.event
+            @_receive_input e, true
+            @_bug_catcher e
+
+        @keyup_event = attach_handler @element, "keyup", (e) =>
+            e = e or window.event
+            @_receive_input e, false
+
+        @blur_event = attach_handler window, "blur", =>
+            # Assume all keys are released when we can't catch key events
+            # This prevents alt+tab conflicts
+            for key in @_keys_down
+                @_key_up key, {}
+            @_keys_down = []
+
+    destroy: () ->
+        remove_handler = (target, event, handler) ->
+            if target.removeEventListener?
+                target.removeEventListener event, handler
+            else if target.removeEvent?
+                target.removeEvent "on#{event}", handler
+
+        remove_handler @element, "keydown", @keydown_event
+        remove_handler @element, "keyup", @keyup_event
+        remove_handler window, "blur", @blur_event
+
+    # Helper Methods
+
+    _bug_catcher: (e) ->
+        # This seems to be Mac specific weirdness, so we'll target "cmd" as metaKey
+        # Force a keyup for non-modifier keys when command is held because they don't fire
+        if _metakey is "cmd" and "cmd" in @_keys_down and _convert_key_to_readable(e.keyCode) not in ["cmd", "shift", "alt", "caps", "tab"]
+            @_receive_input e, false
+        # Note: we're currently ignoring the fact that this doesn't catch the bug that a keyup
+        # will not fire if you keydown a combo, then press and hold cmd, then keyup the combo.
+        # Perhaps we should fire keyup on all active combos when we press cmd?
+
+    _cmd_bug_check: (combo_keys) ->
+        # We don't want to allow combos to activate if the cmd key
+        # is pressed, but cmd isn't in them. This is so they don't
+        # accidentally rapid fire due to our hack-around for the cmd
+        # key bug and having to fake keyups.
+        if _metakey is "cmd" and "cmd" in @_keys_down and "cmd" not in combo_keys
+            return false
+        return true
+
+    _prevent_default: (e, should_prevent) ->
+        # If we've pressed a combo, or if we are working towards
+        # one, we should prevent the default keydown event.
+        if (should_prevent or @should_suppress_event_defaults) and not @should_force_event_defaults
+            if e.preventDefault then e.preventDefault() else e.returnValue = false    
+            e.stopPropagation() if e.stopPropagation
+
+    # Tracking Combos
+
+    _get_active_combos: (key) ->
+        # Based on the keys_down and the key just pressed or released
+        # (which should not be in keys_down), we determine if any
+        # combo in registered_combos could be considered active.
+        # This will return an array of active combos
+
+        active_combos = []
+
+        # First check that every key in keys_down maps to a combo
+        keys_down = _filter_array @_keys_down, (down_key) ->
+            down_key isnt key
+        keys_down.push key
+
+        # Get perfect matches
+        @_match_combo_arrays keys_down, (match) =>
+            active_combos.push(match) if @_cmd_bug_check match.keys
+
+        # Get fuzzy matches
+        @_fuzzy_match_combo_arrays keys_down, (match) =>
+            return if match in active_combos
+            active_combos.push(match) unless match.is_solitary or not @_cmd_bug_check match.keys
+        
+        return active_combos
+
+    _get_potential_combos: (key) ->
+        # Check if we are working towards pressing a combo.
+        # Used for preventing default on keys that might match
+        # to a combo in the future.
+        potentials = []
+        for combo in @_registered_combos
+            continue if combo.is_sequence
+            potentials.push(combo) if key in combo.keys and @_cmd_bug_check combo.keys
+        return potentials
+
+    _add_to_active_combos: (combo) ->
+        should_replace = false
+        should_prepend = true
+        already_replaced = false
+        # An active combo is any combo which the user has already entered.
+        # We use this to track when a user has released the last key of a
+        # combo for on_release, and to keep combos from 'overlapping'.
+        if combo in @_active_combos
+            return true
+        else if @_active_combos.length
+            # We have to check if we're replacing another active combo
+            # So compare the combo.keys to all active combos' keys.
+            for i in [0...@_active_combos.length]
+                active_combo = @_active_combos[i]
+                continue unless active_combo and active_combo.is_exclusive and combo.is_exclusive
+                active_keys = active_combo.keys
+                unless should_replace
+                    for active_key in active_keys
+                        should_replace = true
+                        unless active_key in combo.keys
+                            should_replace = false
+                            break
+
+                if should_prepend and not should_replace
+                    for combo_key in combo.keys
+                        should_prepend = false
+                        unless combo_key in active_keys
+                            should_prepend = true
+                            break
+
+                if should_replace
+                    if already_replaced
+                        active_combo = @_active_combos.splice(i, 1)[0]
+                        active_combo.reset() if active_combo?
+                    else
+                        active_combo =  @_active_combos.splice(i, 1, combo)[0]
+                        active_combo.reset() if active_combo?
+                        already_replaced = true
+                    should_prepend = false
+        if should_prepend
+            @_active_combos.unshift combo
+
+        return should_replace or should_prepend
+
+    _remove_from_active_combos: (combo) ->
+        for i in [0...@_active_combos.length]
+            active_combo = @_active_combos[i]
+            if active_combo is combo
+                combo = @_active_combos.splice(i, 1)[0]
+                combo.reset()
+                break
+        return
+
+    # Sequence Methods
+
+    _get_possible_sequences: ->
+        # Determine what if any sequences we're working towards.
+        # We will consider any which any part of the end of the sequence
+        # matches and return all of them.
+        matches = []
+        for combo in @_registered_combos
+            for j in [1..@_sequence.length]
+                sequence = @_sequence.slice -j
+                continue unless combo.is_sequence
+                unless "shift" in combo.keys
+                    sequence = _filter_array sequence, (key) ->
+                        return key isnt "shift"
+                    continue unless sequence.length
+                for i in [0...sequence.length]
+                    if combo.keys[i] is sequence[i]
+                        match = true
+                    else
+                        match = false
+                        break
+                matches.push(combo) if match
+        return matches
+
+    _add_key_to_sequence: (key, e) ->
+        @_sequence.push key
+        # Now check if they're working towards a sequence
+        sequence_combos = @_get_possible_sequences()
+        if sequence_combos.length
+            for combo in sequence_combos
+                @_prevent_default e, combo.prevent_default
+            # If we're working towards one, give them more time to keep going
+            clearTimeout(@_sequence_timer) if @_sequence_timer
+            if @sequence_delay > -1
+                @_sequence_timer = setTimeout ->
+                    @_sequence = []
+                , @sequence_delay
+        else
+            # If we're not working towards something, just clear it out
+            @_sequence = []
+        return
+
+    _get_sequence: (key) ->
+        # Compare _sequence to all combos
+        for combo in @_registered_combos
+            continue unless combo.is_sequence
+            for j in [1..@_sequence.length]
+                # As we are traversing backwards through the sequence keys,
+                # Take out any shift keys, unless shift is in the combo.
+                sequence = (_filter_array @_sequence, (seq_key) ->
+                    return true if "shift" in combo.keys
+                    return seq_key isnt "shift"
+                ).slice -j
+                continue unless combo.keys.length is sequence.length
+                for i in [0...sequence.length]
+                    seq_key = sequence[i]
+                    # Special case for shift. Ignore shift keys, unless the sequence explicitly uses them
+                    continue if seq_key is "shift" unless "shift" in combo.keys
+                    # Don't select this combo if we're pressing shift and shift isn't in it
+                    continue if key is "shift" and "shift" not in combo.keys
+                    if combo.keys[i] is seq_key
+                        match = true
+                    else
+                        match = false
+                        break
+            return combo if match
+        return false
+
+    # Catching Combos
+
+    _receive_input: (e, is_keydown) ->
+        # If we're not capturing input, we should
+        # clear out _keys_down for good measure
+        if @_prevent_capture
+            @_keys_down = [] if @_keys_down.length
+            return
+        key = _convert_key_to_readable e.keyCode
+        # Catch tabbing out of a non-capturing state
+        if !is_keydown and !@_keys_down.length and key in ["alt", _metakey]
+            return
+        return unless key
+        if is_keydown
+            @_key_down key, e
+        else
+            @_key_up key, e
+        
+    _fire: (event, combo, key_event, is_autorepeat) ->
+        # Only fire this event if the function is defined
+        if typeof combo["on_" + event] is "function"
+            @_prevent_default key_event, (combo["on_" + event].call(combo.this, key_event, combo.count, is_autorepeat) isnt true)
+        # We need to mark that keyup has already happened
+        if event is "release"
+            combo.count = 0
+        if event is "keyup"
+            combo.keyup_fired = true
+
+    _match_combo_arrays: (potential_match, match_handler) ->
+        # This will return all combos that match
+        for source_combo in @_registered_combos
+            if (not source_combo.is_unordered and _compare_arrays_sorted(potential_match, source_combo.keys)) or (source_combo.is_unordered and _compare_arrays(potential_match, source_combo.keys))
+                match_handler source_combo
+        return
+
+    _fuzzy_match_combo_arrays: (potential_match, match_handler) ->
+        # This will return combos that match even if other keys are pressed
+        for source_combo in @_registered_combos
+            if (not source_combo.is_unordered and _is_array_in_array_sorted(source_combo.keys, potential_match)) or (source_combo.is_unordered and _is_array_in_array(source_combo.keys, potential_match))
+                match_handler source_combo
+        return
+
+    _keys_remain: (combo) ->
+        for key in combo.keys
+            if key in @_keys_down
+                keys_remain = true
+                break
+        return keys_remain
+
+    _key_down: (key, e) ->
+        # Check if we're holding shift
+        shifted_key = _convert_to_shifted_key key, e
+        key = shifted_key if shifted_key
+
+        # Add the key to sequences
+        @_add_key_to_sequence key, e
+        sequence_combo = @_get_sequence key
+        @_fire("keydown", sequence_combo, e) if sequence_combo
+
+        # We might have modifier keys down when coming back to
+        # this window and they might not be in _keys_down, so
+        # we're doing a check to make sure we put it back in.
+        # This only works for explicit modifier keys.
+        for mod, event_mod of _modifier_event_mapping
+            continue unless e[event_mod]
+            continue if mod is key or mod in @_keys_down
+            @_keys_down.push mod
+        # Alternatively, we might not have modifier keys down
+        # that we think are, so we should catch those too
+        for mod, event_mod of _modifier_event_mapping
+            continue if mod is key
+            if mod in @_keys_down and not e[event_mod]
+                # The Windows key will think it is the cmd key, but won't trigger the event mod 
+                continue if mod is "cmd" and _metakey isnt "cmd"
+                for i in [0...@_keys_down.length]
+                    @_keys_down.splice(i, 1) if @_keys_down[i] is mod
+
+        # Find which combos we have pressed or might be working towards, and prevent default
+        combos = @_get_active_combos key
+        potential_combos = @_get_potential_combos key
+        for combo in combos
+            @_handle_combo_down combo, potential_combos, key, e
+        if potential_combos.length
+            for potential in potential_combos
+                @_prevent_default e, potential.prevent_default
+
+        if key not in @_keys_down
+            @_keys_down.push key
+        return
+
+    _handle_combo_down: (combo, potential_combos, key, e) ->
+        # Make sure we're not trying to fire for a combo that already fired
+        return false unless key in combo.keys
+
+        @_prevent_default e, (combo and combo.prevent_default)
+
+        is_autorepeat = false
+        # If we've already pressed this key, check that we want to fire
+        # again, otherwise just add it to the keys_down list.
+        if key in @_keys_down
+            is_autorepeat = true
+            return false unless combo.allows_key_repeat()
+
+        # Now we add this combo or replace it in _active_combos
+        result = @_add_to_active_combos combo, key
+
+        # We reset the keyup_fired property because you should be
+        # able to fire that again, if you've pressed the key down again
+        combo.keyup_fired = false
+
+        # Now we fire the keydown event unless there is a larger exclusive potential combo
+        is_other_exclusive = false
+        if combo.is_exclusive
+            for potential_combo in potential_combos
+                if potential_combo.is_exclusive and potential_combo.keys.length > combo.keys.length
+                    is_other_exclusive = true
+                    break
+
+        unless is_other_exclusive
+            if combo.is_counting and typeof combo.on_keydown is "function"
+                combo.count += 1
+
+            # Only fire keydown if we added it
+            if result
+                @_fire "keydown", combo, e, is_autorepeat
+
+    _key_up: (key, e) ->
+        # Check if we're holding shift
+        unshifted_key = key
+        shifted_key = _convert_to_shifted_key key, e
+        key = shifted_key if shifted_key
+        shifted_key = _keycode_shifted_keys[unshifted_key]
+        # We have to make sure the key matches to what we had in _keys_down
+        if e.shiftKey
+            key = unshifted_key unless shifted_key and shifted_key in @_keys_down
+        else
+            key = shifted_key unless unshifted_key and unshifted_key in @_keys_down
+
+        # Check if we have a keyup firing
+        sequence_combo = @_get_sequence key
+        @_fire("keyup", sequence_combo, e) if sequence_combo
+
+        # Remove from the list
+        return false unless key in @_keys_down
+        for i in [0...@_keys_down.length]
+            if @_keys_down[i] in [key, shifted_key, unshifted_key]
+                @_keys_down.splice i, 1
+                break
+
+        # Store this for later cleanup
+        active_combos_length = @_active_combos.length
+
+        # When releasing we should only check if we
+        # match from _active_combos so that we don't
+        # accidentally fire for a combo that was a
+        # smaller part of the one we actually wanted.
+        combos = []
+        for active_combo in @_active_combos
+            if key in active_combo.keys
+                combos.push active_combo
+        for combo in combos
+            @_handle_combo_up combo, e, key
+
+        # We also need to check other combos that might still be in active_combos
+        # and needs to be removed from it.
+        if active_combos_length > 1
+            for active_combo in @_active_combos
+                continue if active_combo is undefined or active_combo in combos
+                unless @_keys_remain active_combo
+                    @_remove_from_active_combos active_combo
+        return
+
+    _handle_combo_up: (combo, e, key) ->
+        @_prevent_default e, (combo and combo.prevent_default)
+        
+        # Check if any keys from this combo are still being held.
+        keys_remaining = @_keys_remain combo
+
+        # Any unactivated combos will fire
+        if !combo.keyup_fired
+            # And we should not fire it if it is a solitary combo and something else is pressed
+            keys_down = @_keys_down.slice()
+            keys_down.push key
+            if not combo.is_solitary or _compare_arrays keys_down, combo.keys
+                @_fire "keyup", combo, e
+                # Dont' add to the count unless we only have a keyup callback
+                if combo.is_counting and typeof combo.on_keyup is "function" and typeof combo.on_keydown isnt "function"
+                    combo.count += 1
+
+        # If this was the last key released of the combo, clean up.
+        unless keys_remaining
+            @_fire "release", combo, e
+            @_remove_from_active_combos combo
+        return
+
+    # Public Registration Methods
+
+    simple_combo: (keys, callback) ->
+        # Shortcut for simple combos.
+        @register_combo(
+            keys            : keys
+            on_keydown      : callback
+        )
+
+    counting_combo: (keys, count_callback) ->
+        # Shortcut for counting combos
+        @register_combo(
+            keys            : keys
+            is_counting     : true
+            is_unordered    : false
+            on_keydown      : count_callback
+        )
+
+    sequence_combo: (keys, callback) ->
+        @register_combo(
+            keys            : keys
+            on_keydown      : callback
+            is_sequence     : true
+        )
+
+    register_combo: (combo_dictionary) ->
+        # Allow a space dilineated string instead of array
+        if typeof combo_dictionary["keys"] is "string"
+            combo_dictionary["keys"] = combo_dictionary["keys"].split " "
+        for own property, value of @_defaults
+            if combo_dictionary[property] is undefined
+                combo_dictionary[property] = value
+        combo = new Combo combo_dictionary
+        
+        if _validate_combo combo
+            @_registered_combos.push combo
+            return combo
+
+    register_many: (combo_array) ->
+        # Will return an array of the combos actually registered
+        @register_combo(combo) for combo in combo_array
+
+    unregister_combo: (keys_or_combo) ->
+        return false unless keys_or_combo
+
+        unregister_combo = (combo) =>
+            for i in [0...@_registered_combos.length]
+                if combo is @_registered_combos[i]
+                    @_registered_combos.splice i, 1
+                    break
+
+        if keys_or_combo instanceof Combo
+            unregister_combo keys_or_combo
+        else
+            if typeof keys_or_combo is "string"
+                keys_or_combo = keys_or_combo.split " "
+            for combo in @_registered_combos
+                continue unless combo?
+                if (combo.is_unordered and _compare_arrays(keys_or_combo, combo.keys)) or (not combo.is_unordered and _compare_arrays_sorted(keys_or_combo, combo.keys))
+                    unregister_combo combo
+
+    unregister_many: (combo_array) ->
+        for combo in combo_array
+            @unregister_combo combo
+
+    # Other public methods
+
+    get_registered_combos: ->
+        return @_registered_combos
+
+    reset: ->
+        @_registered_combos = []
+
+    listen: ->
+        @_prevent_capture = false
+
+    stop_listening: ->
+        @_prevent_capture = true
+
+    get_meta_key: ->
+        # Helpful for debugging purposes
+        return _metakey
+
+##################
+# Helper Functions
+##################
+
+_decide_meta_key = ->
+    # If the useragent reports Mac OS X, assume cmd is metakey
+    if navigator.userAgent.indexOf("Mac OS X") != -1
+        _metakey = "cmd"
+    return
+
+_change_keycodes_by_browser = ->
+    if navigator.userAgent.indexOf("Opera") != -1
+        # Opera does weird stuff with command and control keys, let's fix that.
+        # Note: Opera cannot override meta + s browser default of save page.
+        # Note: Opera does some really strange stuff when cmd+alt+shift
+        # are held and a non-modifier key is pressed.
+        _keycode_dictionary["17"] = "cmd"
+    return
+
+_convert_key_to_readable = (k) ->
+    return _keycode_dictionary[k]
+
+_filter_array = (array, callback) ->
+  if array.filter
+    return array.filter(callback)
+  else
+    # For browsers without Array.prototype.filter like IE<9:
+    return (element for element in array when callback(element))
+
+_compare_arrays = (a1, a2) ->
+    # This will ignore the ordering of the arrays
+    # and simply check if they have the same contents.
+    return false unless a1.length is a2.length
+    for item in a1
+        continue if item in a2
+        return false
+    return true
+
+_compare_arrays_sorted = (a1, a2) ->
+    return false unless a1.length is a2.length
+    for i in [0...a1.length]
+        return false unless a1[i] is a2[i]
+    return true
+
+_is_array_in_array = (a1, a2) ->
+    # Returns true only if all of the contents of
+    # a1 are included in a2
+    for item in a1
+        return false unless item in a2
+    return true
+
+_index_of_in_array = Array.prototype.indexOf or (a, item) ->
+    for i in [0..a.length]
+        return i if a[i] is item
+    return -1
+
+_is_array_in_array_sorted = (a1, a2) ->
+    # Return true only if all of the contents of
+    # a1 are include in a2 and they appear in the
+    # same order in both.
+    prev = 0
+    for item in a1
+        index = _index_of_in_array.call a2, item
+        if index >= prev
+            prev = index
+        else
+            return false
+    return true
+
+_log_error = () ->
+    console.log arguments... if keypress.debug
+
+_key_is_valid = (key) ->
+    valid = false
+    for _, valid_key of _keycode_dictionary
+        if key is valid_key
+            valid = true
+            break
+    unless valid
+        for _, valid_key of _keycode_shifted_keys
+            if key is valid_key
+                valid = true
+                break
+    return valid
+
+_validate_combo = (combo) ->
+    validated = true
+
+    # Warn for lack of keys
+    unless combo.keys.length
+        _log_error "You're trying to bind a combo with no keys:", combo
+
+    # Convert "meta" to either "ctrl" or "cmd"
+    # Don't explicity use the command key, it breaks
+    # because it is the windows key in Windows, and
+    # cannot be hijacked.
+    for i in [0...combo.keys.length]
+        key = combo.keys[i]
+        # Check the name and replace if needed
+        alt_name = _keycode_alternate_names[key]
+        key = combo.keys[i] = alt_name if alt_name
+        if key is "meta"
+            combo.keys.splice i, 1, _metakey
+        if key is "cmd"
+            _log_error "Warning: use the \"meta\" key rather than \"cmd\" for Windows compatibility"
+
+    # Check that all keys in the combo are valid
+    for key in combo.keys
+        unless _key_is_valid key
+            _log_error "Do not recognize the key \"#{key}\""
+            validated = false
+
+    # We can only allow a single non-modifier key
+    # in combos that include the command key (this
+    # includes 'meta') because of the keyup bug.
+    if "meta" in combo.keys or "cmd" in combo.keys
+        non_modifier_keys = combo.keys.slice()
+        for mod_key in _modifier_keys
+            if (i = _index_of_in_array.call(non_modifier_keys, mod_key)) > -1
+                non_modifier_keys.splice(i, 1) 
+        if non_modifier_keys.length > 1
+            _log_error "META and CMD key combos cannot have more than 1 non-modifier keys", combo, non_modifier_keys
+            validated = false
+
+    # Tell the user if they are trying to use any
+    # combo properties that don't actually exist,
+    # but allow the combo
+    for property, value of combo
+        if _factory_defaults[property] is "undefined"
+            _log_error "The property #{property} is not a valid combo property. Your combo has still been registered."
+
+    return validated
+
+_convert_to_shifted_key = (key, e) ->
+    return false unless e.shiftKey
+    k = _keycode_shifted_keys[key]
+    return k if k?
+    return false
+
+##########################
+# Key Mapping Dictionaries
+##########################
+
+_modifier_event_mapping =
+    "cmd"   : "metaKey"
+    "ctrl"  : "ctrlKey"
+    "shift" : "shiftKey"
+    "alt"   : "altKey"
+
+_keycode_alternate_names =
+    "escape"        : "esc"
+    "control"       : "ctrl"
+    "command"       : "cmd"
+    "break"         : "pause"
+    "windows"       : "cmd"
+    "option"        : "alt"
+    "caps_lock"     : "caps"
+    "apostrophe"    : "\'"
+    "semicolon"     : ";"
+    "tilde"         : "~"
+    "accent"        : "`"
+    "scroll_lock"   : "scroll"
+    "num_lock"      : "num"
+
+_keycode_shifted_keys =
+    "/"     : "?"
+    "."     : ">"
+    ","     : "<"
+    "\'"    : "\""
+    ";"     : ":"
+    "["     : "{"
+    "]"     : "}"
+    "\\"    : "|"
+    "`"     : "~"
+    "="     : "+"
+    "-"     : "_"
+    "1"     : "!"
+    "2"     : "@"
+    "3"     : "#"
+    "4"     : "$"
+    "5"     : "%"
+    "6"     : "^"
+    "7"     : "&"
+    "8"     : "*"
+    "9"     : "("
+    "0"     : ")"
+
+_keycode_dictionary = 
+    0   : "\\"          # Firefox reports this keyCode when shift is held
+    8   : "backspace"
+    9   : "tab"
+    12  : "num"
+    13  : "enter"
+    16  : "shift"
+    17  : "ctrl"
+    18  : "alt"
+    19  : "pause"
+    20  : "caps"
+    27  : "esc"
+    32  : "space"
+    33  : "pageup"
+    34  : "pagedown"
+    35  : "end"
+    36  : "home"
+    37  : "left"
+    38  : "up"
+    39  : "right"
+    40  : "down"
+    44  : "print"
+    45  : "insert"
+    46  : "delete"
+    48  : "0"
+    49  : "1"
+    50  : "2"
+    51  : "3"
+    52  : "4"
+    53  : "5"
+    54  : "6"
+    55  : "7"
+    56  : "8"
+    57  : "9"
+    65  : "a"
+    66  : "b"
+    67  : "c"
+    68  : "d"
+    69  : "e"
+    70  : "f"
+    71  : "g"
+    72  : "h"
+    73  : "i"
+    74  : "j"
+    75  : "k"
+    76  : "l"
+    77  : "m"
+    78  : "n"
+    79  : "o"
+    80  : "p"
+    81  : "q"
+    82  : "r"
+    83  : "s"
+    84  : "t"
+    85  : "u"
+    86  : "v"
+    87  : "w"
+    88  : "x"
+    89  : "y"
+    90  : "z"
+    91  : "cmd"
+    92  : "cmd"
+    93  : "cmd"
+    96  : "num_0"
+    97  : "num_1"
+    98  : "num_2"
+    99  : "num_3"
+    100 : "num_4"
+    101 : "num_5"
+    102 : "num_6"
+    103 : "num_7"
+    104 : "num_8"
+    105 : "num_9"
+    106 : "num_multiply"
+    107 : "num_add"
+    108 : "num_enter"
+    109 : "num_subtract"
+    110 : "num_decimal"
+    111 : "num_divide" 
+    112 : "f1"
+    113 : "f2"
+    114 : "f3"
+    115 : "f4"
+    116 : "f5"
+    117 : "f6"
+    118 : "f7"
+    119 : "f8"
+    120 : "f9"
+    121 : "f10"
+    122 : "f11"
+    123 : "f12"
+    124 : "print"
+    144 : "num"
+    145 : "scroll"
+    186 : ";"
+    187 : "="
+    188 : ","
+    189 : "-"
+    190 : "."
+    191 : "/"
+    192 : "`"
+    219 : "["
+    220 : "\\"
+    221 : "]"
+    222 : "\'"
+    223 : "`"
+    224 : "cmd"
+    225 : "alt"
+    # Opera weirdness
+    57392   : "ctrl"
+    63289   : "num"
+    # Firefox weirdness
+    59 : ";"
+    61 : "-"
+    173 : "="
+
+# For testing only:
+keypress._keycode_dictionary = _keycode_dictionary
+keypress._is_array_in_array_sorted = _is_array_in_array_sorted
+
+############
+# Initialize
+############
+
+_decide_meta_key()
+_change_keycodes_by_browser()
+
+# Anonymous Module Definition
+if typeof define is "function" and define.amd
+    define [], ->
+        return keypress
+else if exports?
+    exports.keypress = keypress
+else
+    window.keypress = keypress