You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: keydefs.rs
    path of file: ./repos/minus/src/input/definitions
    
    the code of the file until where you have to start completion: #![allow(dead_code)]

use super::{Token, MODIFIERS};
use std::collections::HashMap;

use crossterm::event::{KeyCode, KeyEvent, KeyEventState, KeyModifiers};
use once_cell::sync::Lazy;

static SPECIAL_KEYS: Lazy<HashMap<&str, KeyCode>> = Lazy::new(|| {
    let mut map = HashMap::new();

    map.insert("enter", KeyCode::Enter);
    map.insert("tab", KeyCode::Tab);
    map.insert("backtab", KeyCode::BackTab);
    map.insert("backspace", KeyCode::Backspace);
    map.insert("up", KeyCode::Up);
    map.insert("down", KeyCode::Down);
    map.insert("right", KeyCode::Right);
    map.insert("left", KeyCode::Left);
    map.insert("pageup", KeyCode::PageUp);
    map.insert("pagedown", KeyCode::PageDown);
    map.insert("home", KeyCode::Home);
    map.insert("end", KeyCode::End);
    map.insert("insert", KeyCode::Insert);
    map.insert("delete", KeyCode::Delete);
    map.insert("esc", KeyCode::Esc);
    map.insert("f1", KeyCode::F(1));
    map.insert("f2", KeyCode::F(2));
    map.insert("f3", KeyCode::F(3));
    map.insert("f4", KeyCode::F(4));
    map.insert("f5", KeyCode::F(5));
    map.insert("f6", KeyCode::F(6));
    map.insert("f7", KeyCode::F(7));
    map.insert("f8", KeyCode::F(8));
    ma
    
fn test_parse_key_event() {
    assert_eq!(
        parse_key_event("up"),
        KeyEvent {
            code: KeyCode::Up,
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("k"),
        KeyEvent {
            code: KeyCode::Char('k'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("j"),
        KeyEvent {
            code: KeyCode::Char('j'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("down"),
        KeyEvent {
            code: KeyCode::Down,
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("down"),
        KeyEvent {
            code: KeyCode::Down,
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("enter"),
        KeyEvent {
            code: KeyCode::Enter,
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("c-u"),
        KeyEvent {
            code: KeyCode::Char('u'),
            modifiers: KeyModifiers::CONTROL,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("c-d"),
        KeyEvent {
            code: KeyCode::Char('d'),
            modifiers: KeyModifiers::CONTROL,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("g"),
        KeyEvent {
            code: KeyCode::Char('g'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("s-g"),
        KeyEvent {
            code: KeyCode::Char('g'),
            modifiers: KeyModifiers::SHIFT,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("G"),
        KeyEvent {
            code: KeyCode::Char('G'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("pageup"),
        KeyEvent {
            code: KeyCode::PageUp,
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("pagedown"),
        KeyEvent {
            code: KeyCode::PageDown,
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("c-l"),
        KeyEvent {
            code: KeyCode::Char('l'),
            modifiers: KeyModifiers::CONTROL,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("q"),
        KeyEvent {
            code: KeyCode::Char('q'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("c-c"),
        KeyEvent {
            code: KeyCode::Char('c'),
            modifiers: KeyModifiers::CONTROL,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("/"),
        KeyEvent {
            code: KeyCode::Char('/'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("?"),
        KeyEvent {
            code: KeyCode::Char('?'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("n"),
        KeyEvent {
            code: KeyCode::Char('n'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("p"),
        KeyEvent {
            code: KeyCode::Char('p'),
            modifiers: KeyModifiers::NONE,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
    assert_eq!(
        parse_key_event("c-s-h"),
        KeyEvent {
            code: KeyCode::Char('h'),
            modifiers: KeyModifiers::CONTROL | KeyModifiers::SHIFT,
            kind: crossterm::event::KeyEventKind::Press,
            state: KeyEventState::NONE,
        }
    );
}