@codingame/monaco-vscode-keybindings-service-override 11.1.2 → 12.0.1

package/vscode/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.js

@@ -1,5 +1,8 @@
-import { IMMUTABLE_CODE_TO_KEY_CODE, ScanCodeUtils, KeyCodeUtils, IMMUTABLE_KEY_CODE_TO_CODE } from 'vscode/vscode/vs/base/common/keyCodes';
+
+import { CharCode } from 'vscode/vscode/vs/base/common/charCode';
+import { IMMUTABLE_CODE_TO_KEY_CODE, KeyCode, ScanCode, ScanCodeUtils, KeyCodeUtils, IMMUTABLE_KEY_CODE_TO_CODE } from 'vscode/vscode/vs/base/common/keyCodes';
 import { ScanCodeChord, KeyCodeChord } from 'vscode/vscode/vs/base/common/keybindings';
+import { OperatingSystem } from 'vscode/vscode/vs/base/common/platform';
 import { BaseResolvedKeybinding } from 'vscode/vscode/vs/platform/keybinding/common/baseResolvedKeybinding';
 
 const CHAR_CODE_TO_KEY_CODE = [];
@@ -24,7 +27,7 @@ class NativeResolvedKeybinding extends BaseResolvedKeybinding {
         if (!binding) {
             return true;
         }
-        if (IMMUTABLE_CODE_TO_KEY_CODE[binding.scanCode] !== -1 ) {
+        if (IMMUTABLE_CODE_TO_KEY_CODE[binding.scanCode] !== KeyCode.DependsOnKbLayout) {
             return true;
         }
         const a = this._mapper.getAriaLabelForScanCodeChord(binding);
@@ -41,16 +44,16 @@ class NativeResolvedKeybinding extends BaseResolvedKeybinding {
         return this._mapper.getDispatchStrForScanCodeChord(chord);
     }
     _getSingleModifierChordDispatch(chord) {
-        if (((chord.scanCode === 157  || chord.scanCode === 161) ) && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
+        if ((chord.scanCode === ScanCode.ControlLeft || chord.scanCode === ScanCode.ControlRight) && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
             return 'ctrl';
         }
-        if (((chord.scanCode === 159  || chord.scanCode === 163) ) && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
+        if ((chord.scanCode === ScanCode.AltLeft || chord.scanCode === ScanCode.AltRight) && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
             return 'alt';
         }
-        if (((chord.scanCode === 158  || chord.scanCode === 162) ) && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
+        if ((chord.scanCode === ScanCode.ShiftLeft || chord.scanCode === ScanCode.ShiftRight) && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
             return 'shift';
         }
-        if (((chord.scanCode === 160  || chord.scanCode === 164) ) && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
+        if ((chord.scanCode === ScanCode.MetaLeft || chord.scanCode === ScanCode.MetaRight) && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
             return 'meta';
         }
         return null;
@@ -92,7 +95,7 @@ class ScanCodeCombo {
         if (charCode === 0) {
             return ' --- ';
         }
-        if (charCode >= 768  && charCode <= 879 ) {
+        if (charCode >= CharCode.U_Combining_Grave_Accent && charCode <= CharCode.U_Combining_Latin_Small_Letter_X) {
             return 'U+' + ( charCode.toString(16));
         }
         return '  ' + String.fromCharCode(charCode) + '  ';
@@ -117,8 +120,8 @@ class ScanCodeKeyCodeMapper {
         this._keyCodeToScanCode = [];
     }
     registrationComplete() {
-        this._moveToEnd(56 );
-        this._moveToEnd(106 );
+        this._moveToEnd(ScanCode.IntlHash);
+        this._moveToEnd(ScanCode.IntlBackslash);
     }
     _moveToEnd(scanCode) {
         for (let mod = 0; mod < 8; mod++) {
@@ -145,13 +148,13 @@ class ScanCodeKeyCodeMapper {
         }
     }
     registerIfUnknown(scanCodeCombo, keyCodeCombo) {
-        if (keyCodeCombo.keyCode === 0 ) {
+        if (keyCodeCombo.keyCode === KeyCode.Unknown) {
             return;
         }
         const scanCodeComboEncoded = this._encodeScanCodeCombo(scanCodeCombo);
         const keyCodeComboEncoded = this._encodeKeyCodeCombo(keyCodeCombo);
-        const keyCodeIsDigit = ((keyCodeCombo.keyCode >= 21  && keyCodeCombo.keyCode <= 30) );
-        const keyCodeIsLetter = ((keyCodeCombo.keyCode >= 31  && keyCodeCombo.keyCode <= 56) );
+        const keyCodeIsDigit = (keyCodeCombo.keyCode >= KeyCode.Digit0 && keyCodeCombo.keyCode <= KeyCode.Digit9);
+        const keyCodeIsLetter = (keyCodeCombo.keyCode >= KeyCode.KeyA && keyCodeCombo.keyCode <= KeyCode.KeyZ);
         const existingKeyCodeCombos = this._scanCodeToKeyCode[scanCodeComboEncoded];
         if (keyCodeIsDigit || keyCodeIsLetter) {
             if (existingKeyCodeCombos) {
@@ -207,18 +210,18 @@ class ScanCodeKeyCodeMapper {
         return result;
     }
     guessStableKeyCode(scanCode) {
-        if (scanCode >= 36  && scanCode <= 45 ) {
+        if (scanCode >= ScanCode.Digit1 && scanCode <= ScanCode.Digit0) {
             switch (scanCode) {
-                case 36 : return 22 ;
-                case 37 : return 23 ;
-                case 38 : return 24 ;
-                case 39 : return 25 ;
-                case 40 : return 26 ;
-                case 41 : return 27 ;
-                case 42 : return 28 ;
-                case 43 : return 29 ;
-                case 44 : return 30 ;
-                case 45 : return 21 ;
+                case ScanCode.Digit1: return KeyCode.Digit1;
+                case ScanCode.Digit2: return KeyCode.Digit2;
+                case ScanCode.Digit3: return KeyCode.Digit3;
+                case ScanCode.Digit4: return KeyCode.Digit4;
+                case ScanCode.Digit5: return KeyCode.Digit5;
+                case ScanCode.Digit6: return KeyCode.Digit6;
+                case ScanCode.Digit7: return KeyCode.Digit7;
+                case ScanCode.Digit8: return KeyCode.Digit8;
+                case ScanCode.Digit9: return KeyCode.Digit9;
+                case ScanCode.Digit0: return KeyCode.Digit0;
             }
         }
         const keyCodeCombos1 = this.lookupScanCodeCombo(( new ScanCodeCombo(false, false, false, scanCode)));
@@ -232,7 +235,7 @@ class ScanCodeKeyCodeMapper {
                 return keyCode1;
             }
         }
-        return -1 ;
+        return KeyCode.DependsOnKbLayout;
     }
     _encodeScanCodeCombo(scanCodeCombo) {
         return this._encode(scanCodeCombo.ctrlKey, scanCodeCombo.shiftKey, scanCodeCombo.altKey, scanCodeCombo.scanCode);
@@ -280,18 +283,18 @@ class MacLinuxKeyboardMapper {
                 }
             }
         };
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+        for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
             this._scanCodeToLabel[scanCode] = null;
         }
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+        for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
             this._scanCodeToDispatch[scanCode] = null;
         }
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+        for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
             const keyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
-            if (keyCode !== -1 ) {
+            if (keyCode !== KeyCode.DependsOnKbLayout) {
                 _registerAllCombos(0, 0, 0, scanCode, keyCode);
                 this._scanCodeToLabel[scanCode] = ( KeyCodeUtils.toString(keyCode));
-                if (keyCode === 0  || keyCode === 5  || keyCode === 57  || keyCode === 6  || keyCode === 4 ) {
+                if (keyCode === KeyCode.Unknown || keyCode === KeyCode.Ctrl || keyCode === KeyCode.Meta || keyCode === KeyCode.Alt || keyCode === KeyCode.Shift) {
                     this._scanCodeToDispatch[scanCode] = null;
                 }
                 else {
@@ -305,16 +308,16 @@ class MacLinuxKeyboardMapper {
             for (const strScanCode in rawMappings) {
                 if (rawMappings.hasOwnProperty(strScanCode)) {
                     const scanCode = ScanCodeUtils.toEnum(strScanCode);
-                    if (scanCode === 0 ) {
+                    if (scanCode === ScanCode.None) {
                         continue;
                     }
-                    if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
+                    if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== KeyCode.DependsOnKbLayout) {
                         continue;
                     }
                     const rawMapping = rawMappings[strScanCode];
                     const value = MacLinuxKeyboardMapper.getCharCode(rawMapping.value);
-                    if (value >= 97  && value <= 122 ) {
-                        const upperCaseValue = 65  + ((value - 97) );
+                    if (value >= CharCode.a && value <= CharCode.z) {
+                        const upperCaseValue = CharCode.A + (value - CharCode.a);
                         producesLatinLetter[upperCaseValue] = true;
                     }
                 }
@@ -329,42 +332,42 @@ class MacLinuxKeyboardMapper {
                     };
                 }
             };
-            _registerLetterIfMissing(65 , 10 , 'a', 'A');
-            _registerLetterIfMissing(66 , 11 , 'b', 'B');
-            _registerLetterIfMissing(67 , 12 , 'c', 'C');
-            _registerLetterIfMissing(68 , 13 , 'd', 'D');
-            _registerLetterIfMissing(69 , 14 , 'e', 'E');
-            _registerLetterIfMissing(70 , 15 , 'f', 'F');
-            _registerLetterIfMissing(71 , 16 , 'g', 'G');
-            _registerLetterIfMissing(72 , 17 , 'h', 'H');
-            _registerLetterIfMissing(73 , 18 , 'i', 'I');
-            _registerLetterIfMissing(74 , 19 , 'j', 'J');
-            _registerLetterIfMissing(75 , 20 , 'k', 'K');
-            _registerLetterIfMissing(76 , 21 , 'l', 'L');
-            _registerLetterIfMissing(77 , 22 , 'm', 'M');
-            _registerLetterIfMissing(78 , 23 , 'n', 'N');
-            _registerLetterIfMissing(79 , 24 , 'o', 'O');
-            _registerLetterIfMissing(80 , 25 , 'p', 'P');
-            _registerLetterIfMissing(81 , 26 , 'q', 'Q');
-            _registerLetterIfMissing(82 , 27 , 'r', 'R');
-            _registerLetterIfMissing(83 , 28 , 's', 'S');
-            _registerLetterIfMissing(84 , 29 , 't', 'T');
-            _registerLetterIfMissing(85 , 30 , 'u', 'U');
-            _registerLetterIfMissing(86 , 31 , 'v', 'V');
-            _registerLetterIfMissing(87 , 32 , 'w', 'W');
-            _registerLetterIfMissing(88 , 33 , 'x', 'X');
-            _registerLetterIfMissing(89 , 34 , 'y', 'Y');
-            _registerLetterIfMissing(90 , 35 , 'z', 'Z');
+            _registerLetterIfMissing(CharCode.A, ScanCode.KeyA, 'a', 'A');
+            _registerLetterIfMissing(CharCode.B, ScanCode.KeyB, 'b', 'B');
+            _registerLetterIfMissing(CharCode.C, ScanCode.KeyC, 'c', 'C');
+            _registerLetterIfMissing(CharCode.D, ScanCode.KeyD, 'd', 'D');
+            _registerLetterIfMissing(CharCode.E, ScanCode.KeyE, 'e', 'E');
+            _registerLetterIfMissing(CharCode.F, ScanCode.KeyF, 'f', 'F');
+            _registerLetterIfMissing(CharCode.G, ScanCode.KeyG, 'g', 'G');
+            _registerLetterIfMissing(CharCode.H, ScanCode.KeyH, 'h', 'H');
+            _registerLetterIfMissing(CharCode.I, ScanCode.KeyI, 'i', 'I');
+            _registerLetterIfMissing(CharCode.J, ScanCode.KeyJ, 'j', 'J');
+            _registerLetterIfMissing(CharCode.K, ScanCode.KeyK, 'k', 'K');
+            _registerLetterIfMissing(CharCode.L, ScanCode.KeyL, 'l', 'L');
+            _registerLetterIfMissing(CharCode.M, ScanCode.KeyM, 'm', 'M');
+            _registerLetterIfMissing(CharCode.N, ScanCode.KeyN, 'n', 'N');
+            _registerLetterIfMissing(CharCode.O, ScanCode.KeyO, 'o', 'O');
+            _registerLetterIfMissing(CharCode.P, ScanCode.KeyP, 'p', 'P');
+            _registerLetterIfMissing(CharCode.Q, ScanCode.KeyQ, 'q', 'Q');
+            _registerLetterIfMissing(CharCode.R, ScanCode.KeyR, 'r', 'R');
+            _registerLetterIfMissing(CharCode.S, ScanCode.KeyS, 's', 'S');
+            _registerLetterIfMissing(CharCode.T, ScanCode.KeyT, 't', 'T');
+            _registerLetterIfMissing(CharCode.U, ScanCode.KeyU, 'u', 'U');
+            _registerLetterIfMissing(CharCode.V, ScanCode.KeyV, 'v', 'V');
+            _registerLetterIfMissing(CharCode.W, ScanCode.KeyW, 'w', 'W');
+            _registerLetterIfMissing(CharCode.X, ScanCode.KeyX, 'x', 'X');
+            _registerLetterIfMissing(CharCode.Y, ScanCode.KeyY, 'y', 'Y');
+            _registerLetterIfMissing(CharCode.Z, ScanCode.KeyZ, 'z', 'Z');
         }
         const mappings = [];
         let mappingsLen = 0;
         for (const strScanCode in rawMappings) {
             if (rawMappings.hasOwnProperty(strScanCode)) {
                 const scanCode = ScanCodeUtils.toEnum(strScanCode);
-                if (scanCode === 0 ) {
+                if (scanCode === ScanCode.None) {
                     continue;
                 }
-                if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
+                if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== KeyCode.DependsOnKbLayout) {
                     continue;
                 }
                 this._codeInfo[scanCode] = rawMappings[strScanCode];
@@ -382,11 +385,11 @@ class MacLinuxKeyboardMapper {
                 };
                 mappings[mappingsLen++] = mapping;
                 this._scanCodeToDispatch[scanCode] = `[${( ScanCodeUtils.toString(scanCode))}]`;
-                if (value >= 97  && value <= 122 ) {
-                    const upperCaseValue = 65  + ((value - 97) );
+                if (value >= CharCode.a && value <= CharCode.z) {
+                    const upperCaseValue = CharCode.A + (value - CharCode.a);
                     this._scanCodeToLabel[scanCode] = String.fromCharCode(upperCaseValue);
                 }
-                else if (value >= 65  && value <= 90 ) {
+                else if (value >= CharCode.A && value <= CharCode.Z) {
                     this._scanCodeToLabel[scanCode] = String.fromCharCode(value);
                 }
                 else if (value) {
@@ -493,29 +496,29 @@ class MacLinuxKeyboardMapper {
                 _registerIfUnknown(1, 1, 1, scanCode, 1, 1, 1, keyCode);
             }
         }
-        _registerAllCombos(0, 0, 0, 36 , 22 );
-        _registerAllCombos(0, 0, 0, 37 , 23 );
-        _registerAllCombos(0, 0, 0, 38 , 24 );
-        _registerAllCombos(0, 0, 0, 39 , 25 );
-        _registerAllCombos(0, 0, 0, 40 , 26 );
-        _registerAllCombos(0, 0, 0, 41 , 27 );
-        _registerAllCombos(0, 0, 0, 42 , 28 );
-        _registerAllCombos(0, 0, 0, 43 , 29 );
-        _registerAllCombos(0, 0, 0, 44 , 30 );
-        _registerAllCombos(0, 0, 0, 45 , 21 );
+        _registerAllCombos(0, 0, 0, ScanCode.Digit1, KeyCode.Digit1);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit2, KeyCode.Digit2);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit3, KeyCode.Digit3);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit4, KeyCode.Digit4);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit5, KeyCode.Digit5);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit6, KeyCode.Digit6);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit7, KeyCode.Digit7);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit8, KeyCode.Digit8);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit9, KeyCode.Digit9);
+        _registerAllCombos(0, 0, 0, ScanCode.Digit0, KeyCode.Digit0);
         this._scanCodeKeyCodeMapper.registrationComplete();
     }
     dumpDebugInfo() {
         const result = [];
         const immutableSamples = [
-            88 ,
-            104
+            ScanCode.ArrowUp,
+            ScanCode.Numpad0
         ];
         let cnt = 0;
         result.push(`isUSStandard: ${this._isUSStandard}`);
         result.push(`----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------`);
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
-            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
+        for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
+            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== KeyCode.DependsOnKbLayout) {
                 if (immutableSamples.indexOf(scanCode) === -1) {
                     continue;
                 }
@@ -538,7 +541,7 @@ class MacLinuxKeyboardMapper {
                     altKey: scanCodeCombo.altKey,
                     metaKey: false,
                     altGraphKey: false,
-                    keyCode: -1 ,
+                    keyCode: KeyCode.DependsOnKbLayout,
                     code: ( ScanCodeUtils.toString(scanCode))
                 });
                 const outScanCodeCombo = ( scanCodeCombo.toString());
@@ -596,14 +599,8 @@ class MacLinuxKeyboardMapper {
         return str;
     }
     keyCodeChordToScanCodeChord(chord) {
-        if (chord.keyCode === 3 ) {
-            return [( new ScanCodeChord(
-                chord.ctrlKey,
-                chord.shiftKey,
-                chord.altKey,
-                chord.metaKey,
-                46
-            ))];
+        if (chord.keyCode === KeyCode.Enter) {
+            return [( new ScanCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, ScanCode.Enter))];
         }
         const scanCodeCombos = this._scanCodeKeyCodeMapper.lookupKeyCodeCombo(( new KeyCodeCombo(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.keyCode)));
         const result = [];
@@ -626,15 +623,15 @@ class MacLinuxKeyboardMapper {
         if (chord.isDuplicateModifierCase()) {
             return '';
         }
-        if (this._OS === 2 ) {
+        if (this._OS === OperatingSystem.Macintosh) {
             switch (chord.scanCode) {
-                case 86 :
+                case ScanCode.ArrowLeft:
                     return '←';
-                case 88 :
+                case ScanCode.ArrowUp:
                     return '↑';
-                case 85 :
+                case ScanCode.ArrowRight:
                     return '→';
-                case 87 :
+                case ScanCode.ArrowDown:
                     return '↓';
             }
         }
@@ -678,11 +675,11 @@ class MacLinuxKeyboardMapper {
             return '';
         }
         const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[chord.scanCode];
-        if (immutableKeyCode !== -1 ) {
+        if (immutableKeyCode !== KeyCode.DependsOnKbLayout) {
             return KeyCodeUtils.toUserSettingsUS(immutableKeyCode).toLowerCase();
         }
         const constantKeyCode = this._scanCodeKeyCodeMapper.guessStableKeyCode(chord.scanCode);
-        if (constantKeyCode !== -1 ) {
+        if (constantKeyCode !== KeyCode.DependsOnKbLayout) {
             const reverseChords = this.keyCodeChordToScanCodeChord(( new KeyCodeChord(
                 chord.ctrlKey,
                 chord.shiftKey,
@@ -704,25 +701,26 @@ class MacLinuxKeyboardMapper {
             return null;
         }
         const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[chord.scanCode];
-        if (immutableKeyCode !== -1 ) {
+        if (immutableKeyCode !== KeyCode.DependsOnKbLayout) {
             return KeyCodeUtils.toElectronAccelerator(immutableKeyCode);
         }
         const constantKeyCode = this._scanCodeKeyCodeMapper.guessStableKeyCode(chord.scanCode);
-        if (this._OS === 3  && !this._isUSStandard) {
-            const isOEMKey = ((constantKeyCode === 85
-                || constantKeyCode === 86
-                || constantKeyCode === 87
-                || constantKeyCode === 88
-                || constantKeyCode === 89
-                || constantKeyCode === 90
-                || constantKeyCode === 91
-                || constantKeyCode === 92
-                || constantKeyCode === 93  || constantKeyCode === 94) );
+        if (this._OS === OperatingSystem.Linux && !this._isUSStandard) {
+            const isOEMKey = (constantKeyCode === KeyCode.Semicolon
+                || constantKeyCode === KeyCode.Equal
+                || constantKeyCode === KeyCode.Comma
+                || constantKeyCode === KeyCode.Minus
+                || constantKeyCode === KeyCode.Period
+                || constantKeyCode === KeyCode.Slash
+                || constantKeyCode === KeyCode.Backquote
+                || constantKeyCode === KeyCode.BracketLeft
+                || constantKeyCode === KeyCode.Backslash
+                || constantKeyCode === KeyCode.BracketRight);
             if (isOEMKey) {
                 return null;
             }
         }
-        if (constantKeyCode !== -1 ) {
+        if (constantKeyCode !== KeyCode.DependsOnKbLayout) {
             return KeyCodeUtils.toElectronAccelerator(constantKeyCode);
         }
         return null;
@@ -750,41 +748,41 @@ class MacLinuxKeyboardMapper {
     }
     resolveKeyboardEvent(keyboardEvent) {
         let code = ScanCodeUtils.toEnum(keyboardEvent.code);
-        if (code === 94 ) {
-            code = 46 ;
+        if (code === ScanCode.NumpadEnter) {
+            code = ScanCode.Enter;
         }
         const keyCode = keyboardEvent.keyCode;
-        if (((keyCode === 15) )
-            || ((keyCode === 16) )
-            || ((keyCode === 17) )
-            || ((keyCode === 18) )
-            || ((keyCode === 20) )
-            || ((keyCode === 19) )
-            || ((keyCode === 14) )
-            || ((keyCode === 13) )
-            || ((keyCode === 12) )
-            || ((keyCode === 11) )
-            || ((keyCode === 1) )) {
+        if ((keyCode === KeyCode.LeftArrow)
+            || (keyCode === KeyCode.UpArrow)
+            || (keyCode === KeyCode.RightArrow)
+            || (keyCode === KeyCode.DownArrow)
+            || (keyCode === KeyCode.Delete)
+            || (keyCode === KeyCode.Insert)
+            || (keyCode === KeyCode.Home)
+            || (keyCode === KeyCode.End)
+            || (keyCode === KeyCode.PageDown)
+            || (keyCode === KeyCode.PageUp)
+            || (keyCode === KeyCode.Backspace)) {
             const immutableScanCode = IMMUTABLE_KEY_CODE_TO_CODE[keyCode];
-            if (immutableScanCode !== -1 ) {
+            if (immutableScanCode !== ScanCode.DependsOnKbLayout) {
                 code = immutableScanCode;
             }
         }
         else {
-            if (((code === 95) )
-                || ((code === 96) )
-                || ((code === 97) )
-                || ((code === 98) )
-                || ((code === 99) )
-                || ((code === 100) )
-                || ((code === 101) )
-                || ((code === 102) )
-                || ((code === 103) )
-                || ((code === 104) )
-                || ((code === 105) )) {
+            if ((code === ScanCode.Numpad1)
+                || (code === ScanCode.Numpad2)
+                || (code === ScanCode.Numpad3)
+                || (code === ScanCode.Numpad4)
+                || (code === ScanCode.Numpad5)
+                || (code === ScanCode.Numpad6)
+                || (code === ScanCode.Numpad7)
+                || (code === ScanCode.Numpad8)
+                || (code === ScanCode.Numpad9)
+                || (code === ScanCode.Numpad0)
+                || (code === ScanCode.NumpadDecimal)) {
                 if (keyCode >= 0) {
                     const immutableScanCode = IMMUTABLE_KEY_CODE_TO_CODE[keyCode];
-                    if (immutableScanCode !== -1 ) {
+                    if (immutableScanCode !== ScanCode.DependsOnKbLayout) {
                         code = immutableScanCode;
                     }
                 }
@@ -810,13 +808,13 @@ class MacLinuxKeyboardMapper {
     }
     static _redirectCharCode(charCode) {
         switch (charCode) {
-            case 12290 : return 46 ;
-            case 12300 : return 91 ;
-            case 12301 : return 93 ;
-            case 12304 : return 91 ;
-            case 12305 : return 93 ;
-            case 65307 : return 59 ;
-            case 65292 : return 44 ;
+            case CharCode.U_IDEOGRAPHIC_FULL_STOP: return CharCode.Period;
+            case CharCode.U_LEFT_CORNER_BRACKET: return CharCode.OpenSquareBracket;
+            case CharCode.U_RIGHT_CORNER_BRACKET: return CharCode.CloseSquareBracket;
+            case CharCode.U_LEFT_BLACK_LENTICULAR_BRACKET: return CharCode.OpenSquareBracket;
+            case CharCode.U_RIGHT_BLACK_LENTICULAR_BRACKET: return CharCode.CloseSquareBracket;
+            case CharCode.U_FULLWIDTH_SEMICOLON: return CharCode.Semicolon;
+            case CharCode.U_FULLWIDTH_COMMA: return CharCode.Comma;
         }
         return charCode;
     }
@@ -833,17 +831,17 @@ class MacLinuxKeyboardMapper {
         }
         const charCode = char.charCodeAt(0);
         switch (charCode) {
-            case 768 : return 96 ;
-            case 769 : return 180 ;
-            case 770 : return 94 ;
-            case 771 : return 732 ;
-            case 772 : return 175 ;
-            case 773 : return 8254 ;
-            case 774 : return 728 ;
-            case 775 : return 729 ;
-            case 776 : return 168 ;
-            case 778 : return 730 ;
-            case 779 : return 733 ;
+            case CharCode.U_Combining_Grave_Accent: return CharCode.U_GRAVE_ACCENT;
+            case CharCode.U_Combining_Acute_Accent: return CharCode.U_ACUTE_ACCENT;
+            case CharCode.U_Combining_Circumflex_Accent: return CharCode.U_CIRCUMFLEX;
+            case CharCode.U_Combining_Tilde: return CharCode.U_SMALL_TILDE;
+            case CharCode.U_Combining_Macron: return CharCode.U_MACRON;
+            case CharCode.U_Combining_Overline: return CharCode.U_OVERLINE;
+            case CharCode.U_Combining_Breve: return CharCode.U_BREVE;
+            case CharCode.U_Combining_Dot_Above: return CharCode.U_DOT_ABOVE;
+            case CharCode.U_Combining_Diaeresis: return CharCode.U_DIAERESIS;
+            case CharCode.U_Combining_Ring_Above: return CharCode.U_RING_ABOVE;
+            case CharCode.U_Combining_Double_Acute_Accent: return CharCode.U_DOUBLE_ACUTE_ACCENT;
         }
         return charCode;
     }
@@ -855,34 +853,34 @@ class MacLinuxKeyboardMapper {
         }
         CHAR_CODE_TO_KEY_CODE[charCode] = { keyCode: keyCode, shiftKey: shiftKey };
     }
-    for (let chCode = 65 ; chCode <= 90 ; chCode++) {
-        define(chCode, 31  + ((chCode - 65) ), true);
-    }
-    for (let chCode = 97 ; chCode <= 122 ; chCode++) {
-        define(chCode, 31  + ((chCode - 97) ), false);
-    }
-    define(59 , 85 , false);
-    define(58 , 85 , true);
-    define(61 , 86 , false);
-    define(43 , 86 , true);
-    define(44 , 87 , false);
-    define(60 , 87 , true);
-    define(45 , 88 , false);
-    define(95 , 88 , true);
-    define(46 , 89 , false);
-    define(62 , 89 , true);
-    define(47 , 90 , false);
-    define(63 , 90 , true);
-    define(96 , 91 , false);
-    define(126 , 91 , true);
-    define(91 , 92 , false);
-    define(123 , 92 , true);
-    define(92 , 93 , false);
-    define(124 , 93 , true);
-    define(93 , 94 , false);
-    define(125 , 94 , true);
-    define(39 , 95 , false);
-    define(34 , 95 , true);
+    for (let chCode = CharCode.A; chCode <= CharCode.Z; chCode++) {
+        define(chCode, KeyCode.KeyA + (chCode - CharCode.A), true);
+    }
+    for (let chCode = CharCode.a; chCode <= CharCode.z; chCode++) {
+        define(chCode, KeyCode.KeyA + (chCode - CharCode.a), false);
+    }
+    define(CharCode.Semicolon, KeyCode.Semicolon, false);
+    define(CharCode.Colon, KeyCode.Semicolon, true);
+    define(CharCode.Equals, KeyCode.Equal, false);
+    define(CharCode.Plus, KeyCode.Equal, true);
+    define(CharCode.Comma, KeyCode.Comma, false);
+    define(CharCode.LessThan, KeyCode.Comma, true);
+    define(CharCode.Dash, KeyCode.Minus, false);
+    define(CharCode.Underline, KeyCode.Minus, true);
+    define(CharCode.Period, KeyCode.Period, false);
+    define(CharCode.GreaterThan, KeyCode.Period, true);
+    define(CharCode.Slash, KeyCode.Slash, false);
+    define(CharCode.QuestionMark, KeyCode.Slash, true);
+    define(CharCode.BackTick, KeyCode.Backquote, false);
+    define(CharCode.Tilde, KeyCode.Backquote, true);
+    define(CharCode.OpenSquareBracket, KeyCode.BracketLeft, false);
+    define(CharCode.OpenCurlyBrace, KeyCode.BracketLeft, true);
+    define(CharCode.Backslash, KeyCode.Backslash, false);
+    define(CharCode.Pipe, KeyCode.Backslash, true);
+    define(CharCode.CloseSquareBracket, KeyCode.BracketRight, false);
+    define(CharCode.CloseCurlyBrace, KeyCode.BracketRight, true);
+    define(CharCode.SingleQuote, KeyCode.Quote, false);
+    define(CharCode.DoubleQuote, KeyCode.Quote, true);
 })();
 
 export { MacLinuxKeyboardMapper, NativeResolvedKeybinding };

package/vscode/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.d.ts

@@ -0,0 +1,49 @@
+import { KeyCode, ScanCode } from "vscode/vscode/vs/base/common/keyCodes";
+import { ResolvedKeybinding, KeyCodeChord, SingleModifierChord, ScanCodeChord, Keybinding } from "vscode/vscode/vs/base/common/keybindings";
+import { IKeyboardEvent } from "vscode/vscode/vs/platform/keybinding/common/keybinding";
+import { IKeyboardMapper } from "../../../../platform/keyboardLayout/common/keyboardMapper.js";
+import { BaseResolvedKeybinding } from "vscode/vscode/vs/platform/keybinding/common/baseResolvedKeybinding";
+import { IWindowsKeyboardMapping } from "@codingame/monaco-vscode-40cada32-7e9c-528a-81fc-766e4da54147-common/vscode/vs/platform/keyboardLayout/common/keyboardLayout";
+export interface IScanCodeMapping {
+    scanCode: ScanCode;
+    keyCode: KeyCode;
+    value: string;
+    withShift: string;
+    withAltGr: string;
+    withShiftAltGr: string;
+}
+export declare class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding<KeyCodeChord> {
+    private readonly _mapper;
+    constructor(mapper: WindowsKeyboardMapper, chords: KeyCodeChord[]);
+    protected _getLabel(chord: KeyCodeChord): string | null;
+    private _getUSLabelForKeybinding;
+    getUSLabel(): string | null;
+    protected _getAriaLabel(chord: KeyCodeChord): string | null;
+    protected _getElectronAccelerator(chord: KeyCodeChord): string | null;
+    protected _getUserSettingsLabel(chord: KeyCodeChord): string | null;
+    protected _isWYSIWYG(chord: KeyCodeChord): boolean;
+    private __isWYSIWYG;
+    protected _getChordDispatch(chord: KeyCodeChord): string | null;
+    protected _getSingleModifierChordDispatch(chord: KeyCodeChord): SingleModifierChord | null;
+    private static getProducedCharCode;
+    static getProducedChar(chord: ScanCodeChord, mapping: IScanCodeMapping): string;
+}
+export declare class WindowsKeyboardMapper implements IKeyboardMapper {
+    private readonly _isUSStandard;
+    private readonly _mapAltGrToCtrlAlt;
+    private readonly _codeInfo;
+    private readonly _scanCodeToKeyCode;
+    private readonly _keyCodeToLabel;
+    private readonly _keyCodeExists;
+    constructor(_isUSStandard: boolean, rawMappings: IWindowsKeyboardMapping, _mapAltGrToCtrlAlt: boolean);
+    dumpDebugInfo(): string;
+    private _leftPad;
+    getUILabelForKeyCode(keyCode: KeyCode): string;
+    getAriaLabelForKeyCode(keyCode: KeyCode): string;
+    getUserSettingsLabelForKeyCode(keyCode: KeyCode): string;
+    getElectronAcceleratorForKeyBinding(chord: KeyCodeChord): string | null;
+    private _getLabelForKeyCode;
+    resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): WindowsNativeResolvedKeybinding;
+    private _resolveChord;
+    resolveKeybinding(keybinding: Keybinding): ResolvedKeybinding[];
+}