rework "mapKey": map char if no key matched

somehow aligned to the philc/Vimium;
also for
  #39 (comment)

and fix a bug of mapping keys twice if InsertMode is active

content/base.d.ts

@@ -377,7 +377,7 @@ interface VEventModeTy {
   focusAndRun_ (this: void, cmd: 0, count: never, options: never, showBorder: 1): void;
   onWndBlur_ (this: void, onWndBlur2: ((this: void) => void) | null): void;
   setupSuppress_ (this: void, onExit?: (this: void) => void): void;
-  mapKey_ (this: void, key: string): string;
+  mapKey_ (this: void, char: string, event: EventControlKeys): string;
   scroll_ (this: void, event?: Partial<EventControlKeys> & { keyCode: kKeyCode }, wnd?: Window): void;
   /** return has_error */
   readonly keydownEvents_: {

content/frontend.ts

@@ -46,21 +46,31 @@ declare var VOther: BrowserType;
     return (vPort._port as Port).postMessage(request);
   }
 
+  function mapKey(this: void, /* not "" */ char: string, event: EventControlKeys): string {
+    let key = VKey.key_(event, char), mapped: string | undefined, chLower: string;
+    if (mappedKeys) {
+      mapped = mappedKeys[key];
+      key = mapped || ((mapped = mappedKeys[chLower = char.toLowerCase()])
+                        ? VKey.key_(event, char === chLower ? mapped : mapped.toUpperCase()) : key);
+    }
+    return key;
+  }
   function isEscape(event: KeyboardEvent): boolean {
     let ch: string | undefined;
     if (mappedKeys && event.keyCode !== kKeyCode.ime) {
       ch = VKey.char_(event);
-      ch = ch && mappedKeys[VKey.key_(event, ch)];
+      ch = ch && mapKey(ch, event);
     }
     return ch ? ch === "<esc>" || ch === "<c-[>" : VKey.isRawEscape_(event);
   }
-  function checkKey(key: string, keyCode: kKeyCode
+  function checkKey(char: string, code: kKeyCode, event: EventControlKeys
       ): HandlerResult.Nothing | HandlerResult.Prevent | HandlerResult.Esc {
     // when checkValidKey, Vimium C must be enabled, so passKeys won't be `""`
+    let key = VKey.key_(event, char);
     if (passKeys && (key in <SafeEnum> passKeys) !== isPassKeysReverted) {
       return esc(HandlerResult.Nothing);
     }
-    mappedKeys !== null && (key = mappedKeys[key] || key);
+    mappedKeys && (key = mapKey(char, event));
     if (key === "<esc>" || key === "<c-[>") {
       return nextKeys ? (esc(HandlerResult.ExitPassMode), HandlerResult.Prevent) : HandlerResult.Esc;
     }
@@ -74,7 +84,7 @@ declare var VOther: BrowserType;
     }
     currentKeys += key;
     if (j === KeyAction.cmd) {
-      post({ H: kFgReq.key, k: currentKeys, l: keyCode });
+      post({ H: kFgReq.key, k: currentKeys, l: code });
       isCmdTriggered = 1;
       return esc(HandlerResult.Prevent);
     } else {
@@ -117,10 +127,9 @@ declare var VOther: BrowserType;
     else if (InsertMode.isActive_()) {
       const g = InsertMode.global_;
       if (g ? !g.code ? isEscape(event) : key === g.code && VKey.getKeyStat_(event) === g.stat
-          : (keyChar = key > kKeyCode.maxNotFn && key < kKeyCode.minNotFn
-              ? VKey.key_(event, VKey.getKeyName_(event))
-              : isEscape(event) ? key - kKeyCode.esc ? "<c-[>" : "<esc>" : "")
-            && (action = checkKey(keyChar, key)) === HandlerResult.Esc
+          : key > kKeyCode.maxNotFn && key < kKeyCode.minNotFn
+          ? (action = checkKey(VKey.getKeyName_(event), key, event)) === HandlerResult.Esc
+          : isEscape(event)
       ) {
         if (InsertMode.lock_ === document.body && InsertMode.lock_ || !isTop && innerHeight < 3) {
           event.repeat && InsertMode.focusUpper_(key, true, event);
@@ -134,12 +143,12 @@ declare var VOther: BrowserType;
     else if (key > kKeyCode.maxNotPrintable || key === kKeyCode.backspace || key === kKeyCode.tab
         || key === kKeyCode.esc || key === kKeyCode.enter) {
       if (keyChar = VKey.char_(event)) {
-        keyChar = VKey.key_(event, keyChar);
-        action = checkKey(keyChar, key);
+        action = checkKey(keyChar, key, event);
         if (action === HandlerResult.Esc) {
           action = key === kKeyCode.esc ? onEscDown(event, key) : HandlerResult.Nothing;
         }
-        if (action === HandlerResult.Nothing && InsertMode.suppressType_ && keyChar.length === 1) {
+        if (action === HandlerResult.Nothing
+            && InsertMode.suppressType_ && keyChar.length < 2 && !VKey.getKeyStat_(event)) {
           action = HandlerResult.Prevent;
         }
       }
@@ -1350,7 +1359,7 @@ declare var VOther: BrowserType;
         showBorder && FrameMask.show_(FrameMaskType.ForcedSelf);
       }
     },
-    mapKey_ (this: void, key): string { return mappedKeys !== null && mappedKeys[key] || key; },
+    mapKey_: mapKey,
     scroll_ (this: void, event, wnd): void {
       if (!event || event.shiftKey || event.altKey) { return; }
       const { keyCode } = event as { keyCode: number }, c = (keyCode & 1) as BOOL;

content/link_hints.ts

@@ -81,6 +81,7 @@ var VHints = {
     newHintLength_: 0,
     tab_: 0
   } as HintsNS.KeyStatus,
+  doesMapKey_: false,
   keyCode_: kKeyCode.None,
   isActive_: false,
   noHUD_: false,
@@ -103,12 +104,13 @@ var VHints = {
       if (!VDom.isHTML_()) { return; }
     }
     a.setModeOpt_(count, options);
-    let str = options.characters ? options.characters + "" : VDom.cache_.linkHintCharacters;
+    let s0 = options.characters, str = s0 ? s0 + "" : VDom.cache_.linkHintCharacters;
     if (str.length < 3) {
       a.clean_(1);
       return VHud.tip_("Characters for LinkHints are too few.", 1000);
     }
     a.alphabetHints_.chars_ = str.toUpperCase();
+    a.doesMapKey_ = options.mapKey !== false;
 
     const arr: ViewBox = VDom.getViewBox_(1) as ViewBox;
     VDom.prepareCrop_();
@@ -987,7 +989,7 @@ var VHints = {
     ks.tab_ = ks.newHintLength_ = ks.known_ = alpha.countMax_ = 0;
     a.keyCode_ = kKeyCode.None;
     alpha.hintKeystroke_ = alpha.chars_ = "";
-    a.isActive_ = a.noHUD_ = a.tooHigh_ = false;
+    a.isActive_ = a.noHUD_ = a.tooHigh_ = a.doesMapKey_ = false;
     VKey.removeHandler_(a);
     VEvent.onWndBlur_(null);
     if (a.box_) {
@@ -1130,8 +1132,8 @@ alphabetHints_: {
         return [];
       }
       a.hintKeystroke_ = a.hintKeystroke_.slice(0, -1);
-    } else if ((keyChar = VKey.char_(e).toUpperCase()) && keyChar.length === 1
-        && (keyChar = VHints.options_.mapKey ? VEvent.mapKey_(keyChar) : keyChar).length === 1) {
+    } else if ((keyChar = VKey.char_(e)) && keyChar.length === 1
+        && (keyChar = (VHints.doesMapKey_ ? VEvent.mapKey_(keyChar, e) : keyChar).toUpperCase()).length === 1) {
       if (a.chars_.indexOf(keyChar) === -1) {
         return [];
       }

content/mode_visual.ts

@@ -173,8 +173,7 @@ var VVisual = {
       a.resetKeys_();
       return i === kKeyCode.ime || i === kKeyCode.menuKey ? HandlerResult.Nothing : HandlerResult.Suppress;
     }
-    let key0 = VKey.key_(event, ch)
-      , key = VEvent.mapKey_(key0)
+    let key = VEvent.mapKey_(ch, event)
       , obj: SafeDict<VisualAction> | null | VisualAction | undefined;
     if (obj = a.currentSeconds_) {
       obj = obj[key];
@@ -194,7 +193,9 @@ var VVisual = {
       count = a.currentCount_;
       a.currentCount_ = 0;
     }
-    if (obj == null) { return ch.length === 1 && ch === key0 ? HandlerResult.Prevent : HandlerResult.Suppress; }
+    if (obj == null) {
+      return ch.length === 1 && !VKey.getKeyStat_(event) ? HandlerResult.Prevent : HandlerResult.Suppress;
+    }
     VKey.prevent_(event);
     a.di_ = VisualModeNS.kDir.unknown; // make @di safe even when a user modifies the selection
     a.diType_ = VisualModeNS.DiType.UnsafeUnknown;