@codingame/monaco-vscode-keybindings-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js

@@ -46,96 +46,97 @@ import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/s
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { OutputBuilder, KeybindingIO } from '../common/keybindingIO.js';
 import { getAllUnboundCommands } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/keybinding/browser/unboundCommands';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
 
 var WorkbenchKeybindingService_1;
 function isValidContributedKeyBinding(keyBinding, rejects) {
     if (!keyBinding) {
-        rejects.push(( localize(14116, "expected non-empty value.")));
+        rejects.push(( localize(14505, "expected non-empty value.")));
         return false;
     }
-    if (typeof keyBinding.command !== 'string') {
+    if (typeof keyBinding.command !== "string") {
         rejects.push(( localize(
-            14117,
+            14506,
             "property `{0}` is mandatory and must be of type `string`",
-            'command'
+            "command"
         )));
         return false;
     }
-    if (keyBinding.key && typeof keyBinding.key !== 'string') {
-        rejects.push(( localize(14118, "property `{0}` can be omitted or must be of type `string`", 'key')));
+    if (keyBinding.key && typeof keyBinding.key !== "string") {
+        rejects.push(( localize(14507, "property `{0}` can be omitted or must be of type `string`", "key")));
         return false;
     }
-    if (keyBinding.when && typeof keyBinding.when !== 'string') {
-        rejects.push(( localize(14118, "property `{0}` can be omitted or must be of type `string`", 'when')));
+    if (keyBinding.when && typeof keyBinding.when !== "string") {
+        rejects.push(( localize(14507, "property `{0}` can be omitted or must be of type `string`", "when")));
         return false;
     }
-    if (keyBinding.mac && typeof keyBinding.mac !== 'string') {
-        rejects.push(( localize(14118, "property `{0}` can be omitted or must be of type `string`", 'mac')));
+    if (keyBinding.mac && typeof keyBinding.mac !== "string") {
+        rejects.push(( localize(14507, "property `{0}` can be omitted or must be of type `string`", "mac")));
         return false;
     }
-    if (keyBinding.linux && typeof keyBinding.linux !== 'string') {
+    if (keyBinding.linux && typeof keyBinding.linux !== "string") {
         rejects.push(( localize(
-            14118,
+            14507,
             "property `{0}` can be omitted or must be of type `string`",
-            'linux'
+            "linux"
         )));
         return false;
     }
-    if (keyBinding.win && typeof keyBinding.win !== 'string') {
-        rejects.push(( localize(14118, "property `{0}` can be omitted or must be of type `string`", 'win')));
+    if (keyBinding.win && typeof keyBinding.win !== "string") {
+        rejects.push(( localize(14507, "property `{0}` can be omitted or must be of type `string`", "win")));
         return false;
     }
     return true;
 }
 const keybindingType = {
-    type: 'object',
-    default: { command: '', key: '' },
-    required: ['command', 'key'],
+    type: "object",
+    default: {
+        command: "",
+        key: ""
+    },
+    required: ["command", "key"],
     properties: {
         command: {
-            description: ( localize(14119, 'Identifier of the command to run when keybinding is triggered.')),
-            type: 'string'
+            description: ( localize(14508, "Identifier of the command to run when keybinding is triggered.")),
+            type: "string"
         },
         args: {
-            description: ( localize(14120, "Arguments to pass to the command to execute."))
+            description: ( localize(14509, "Arguments to pass to the command to execute."))
         },
         key: {
             description: ( localize(
-                14121,
-                'Key or key sequence (separate keys with plus-sign and sequences with space, e.g. Ctrl+O and Ctrl+L L for a chord).'
+                14510,
+                "Key or key sequence (separate keys with plus-sign and sequences with space, e.g. Ctrl+O and Ctrl+L L for a chord)."
             )),
-            type: 'string'
+            type: "string"
         },
         mac: {
-            description: ( localize(14122, 'Mac specific key or key sequence.')),
-            type: 'string'
+            description: ( localize(14511, "Mac specific key or key sequence.")),
+            type: "string"
         },
         linux: {
-            description: ( localize(14123, 'Linux specific key or key sequence.')),
-            type: 'string'
+            description: ( localize(14512, "Linux specific key or key sequence.")),
+            type: "string"
         },
         win: {
-            description: ( localize(14124, 'Windows specific key or key sequence.')),
-            type: 'string'
+            description: ( localize(14513, "Windows specific key or key sequence.")),
+            type: "string"
         },
         when: {
-            description: ( localize(14125, 'Condition when the key is active.')),
-            type: 'string'
-        },
+            description: ( localize(14514, "Condition when the key is active.")),
+            type: "string"
+        }
     }
 };
 const keybindingsExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'keybindings',
+    extensionPoint: "keybindings",
     deps: [commandsExtensionPoint],
     jsonSchema: {
-        description: ( localize(14126, "Contributes keybindings.")),
-        oneOf: [
-            keybindingType,
-            {
-                type: 'array',
-                items: keybindingType
-            }
-        ]
+        description: ( localize(14515, "Contributes keybindings.")),
+        oneOf: [keybindingType, {
+            type: "array",
+            items: keybindingType
+        }]
     }
 });
 const NUMPAD_PRINTABLE_SCANCODES = [
@@ -167,12 +168,30 @@ otherMacNumpadMapping.set(ScanCode.Numpad8, KeyCode.Digit8);
 otherMacNumpadMapping.set(ScanCode.Numpad9, KeyCode.Digit9);
 otherMacNumpadMapping.set(ScanCode.Numpad0, KeyCode.Digit0);
 let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchKeybindingService extends AbstractKeybindingService {
-    constructor(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, uriIdentityService, logService, keyboardLayoutService) {
-        super(contextKeyService, commandService, telemetryService, notificationService, logService);
+    constructor(
+        contextKeyService,
+        commandService,
+        telemetryService,
+        notificationService,
+        userDataProfileService,
+        hostService,
+        extensionService,
+        fileService,
+        uriIdentityService,
+        logService,
+        keyboardLayoutService
+    ) {
+        super(
+            contextKeyService,
+            commandService,
+            telemetryService,
+            notificationService,
+            logService
+        );
         this.hostService = hostService;
         this.keyboardLayoutService = keyboardLayoutService;
         this._contributions = [];
-        this.isComposingGlobalContextKey = contextKeyService.createKey('isComposing', false);
+        this.isComposingGlobalContextKey = contextKeyService.createKey(EditorContextKeys.isComposing.key, false);
         this.kbsJsonSchema = ( new KeybindingsJsonSchema());
         this.updateKeybindingsJsonSchema();
         this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper();
@@ -189,20 +208,36 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             }
         });
         this._register(this.userKeybindings.onDidChange(() => {
-            logService.debug('User keybindings changed');
+            logService.debug("User keybindings changed");
             this.updateResolver();
         }));
-        keybindingsExtPoint.setHandler((extensions) => {
+        keybindingsExtPoint.setHandler(extensions => {
             const keybindings = [];
             for (const extension of extensions) {
-                this._handleKeybindingsExtensionPointUser(extension.description.identifier, extension.description.isBuiltin, extension.value, extension.collector, keybindings);
+                this._handleKeybindingsExtensionPointUser(
+                    extension.description.identifier,
+                    extension.description.isBuiltin,
+                    extension.value,
+                    extension.collector,
+                    keybindings
+                );
             }
             KeybindingsRegistry.setExtensionKeybindings(keybindings);
             this.updateResolver();
         });
         this.updateKeybindingsJsonSchema();
-        this._register(extensionService.onDidRegisterExtensions(() => this.updateKeybindingsJsonSchema()));
-        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => disposables.add(this._registerKeyListeners(window)), { window: mainWindow, disposables: this._store }));
+        this._register(
+            extensionService.onDidRegisterExtensions(() => this.updateKeybindingsJsonSchema())
+        );
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, (
+            {
+                window,
+                disposables
+            }
+        ) => disposables.add(this._registerKeyListeners(window)), {
+            window: mainWindow,
+            disposables: this._store
+        }));
         this._register(onDidChangeFullscreen(windowId => {
             if (windowId !== mainWindow.vscodeWindowId) {
                 return;
@@ -210,7 +245,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             if (BrowserFeatures.keyboard === KeyboardSupport.None) {
                 return;
             }
-            this.lockKeyCodes(isFullscreen(mainWindow) ? ['Escape'] : []);
+            this.lockKeyCodes(isFullscreen(mainWindow) ? ["Escape"] : []);
             this._cachedResolver = null;
             this._onDidUpdateKeybindings.fire();
         }));
@@ -219,8 +254,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         const keyboard = mainWindow.navigator.keyboard;
         if (keyCodes.length > 0) {
             keyboard?.lock(keyCodes);
-        }
-        else {
+        } else {
             keyboard?.unlock();
         }
     }
@@ -231,7 +265,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
     }
     _registerKeyListeners(window) {
         const disposables = ( new DisposableStore());
-        disposables.add(addDisposableListener(window, EventType.KEY_DOWN, (e) => {
+        disposables.add(addDisposableListener(window, EventType.KEY_DOWN, e => {
             if (this._keybindingHoldMode) {
                 return;
             }
@@ -245,7 +279,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             }
             this.isComposingGlobalContextKey.set(false);
         }));
-        disposables.add(addDisposableListener(window, EventType.KEY_UP, (e) => {
+        disposables.add(addDisposableListener(window, EventType.KEY_UP, e => {
             this._resetKeybindingHoldMode();
             this.isComposingGlobalContextKey.set(e.isComposing);
             const keyEvent = ( new StandardKeyboardEvent(e));
@@ -259,7 +293,10 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
     }
     registerSchemaContribution(contribution) {
         const listener = contribution.onDidChange?.(() => this.updateKeybindingsJsonSchema());
-        const entry = { listener, contribution };
+        const entry = {
+            listener,
+            contribution
+        };
         this._contributions.push(entry);
         this.updateKeybindingsJsonSchema();
         return toDisposable(() => {
@@ -272,26 +309,28 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         this.kbsJsonSchema.updateSchema(this._contributions.flatMap(x => x.contribution.getSchemaAdditions()));
     }
     _printKeybinding(keybinding) {
-        return UserSettingsLabelProvider.toLabel(OS, keybinding.chords, (chord) => {
+        return UserSettingsLabelProvider.toLabel(OS, keybinding.chords, chord => {
             if (chord instanceof KeyCodeChord) {
                 return ( KeyCodeUtils.toString(chord.keyCode));
             }
             return ( ScanCodeUtils.toString(chord.scanCode));
-        }) || '[null]';
+        }) || "[null]";
     }
     _printResolvedKeybinding(resolvedKeybinding) {
-        return ( resolvedKeybinding.getDispatchChords().map(x => x || '[null]')).join(' ');
+        return ( resolvedKeybinding.getDispatchChords().map(x => x || "[null]")).join(" ");
     }
     _printResolvedKeybindings(output, input, resolvedKeybindings) {
         const padLength = 35;
-        const firstRow = `${input.padStart(padLength, ' ')} => `;
+        const firstRow = `${input.padStart(padLength, " ")} => `;
         if (resolvedKeybindings.length === 0) {
-            output.push(`${firstRow}${'[NO BINDING]'.padStart(padLength, ' ')}`);
+            output.push(`${firstRow}${"[NO BINDING]".padStart(padLength, " ")}`);
             return;
         }
         for (const resolvedKeybinding of resolvedKeybindings) {
             {
-                output.push(`${firstRow}${this._printResolvedKeybinding(resolvedKeybinding).padStart(padLength, ' ')}`);
+                output.push(
+                    `${firstRow}${this._printResolvedKeybinding(resolvedKeybinding).padStart(padLength, " ")}`
+                );
             }
         }
     }
@@ -316,7 +355,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             if (!item.keybinding) {
                 continue;
             }
-            const input = item._sourceKey ?? 'Impossible: missing source key, but has keybinding';
+            const input = item._sourceKey ?? "Impossible: missing source key, but has keybinding";
             if (( seenBindings.has(input))) {
                 continue;
             }
@@ -324,13 +363,13 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
             this._printResolvedKeybindings(result, input, resolvedKeybindings);
         }
-        return result.join('\n');
+        return result.join("\n");
     }
     _dumpDebugInfo() {
-        const layoutInfo = JSON.stringify(this.keyboardLayoutService.getCurrentKeyboardLayout(), null, '\t');
+        const layoutInfo = JSON.stringify(this.keyboardLayoutService.getCurrentKeyboardLayout(), null, "\t");
         const mapperInfo = this._keyboardMapper.dumpDebugInfo();
         const resolvedKeybindings = this._dumpResolveKeybindingDebugInfo();
-        const rawMapping = JSON.stringify(this.keyboardLayoutService.getRawKeyboardMapping(), null, '\t');
+        const rawMapping = JSON.stringify(this.keyboardLayoutService.getRawKeyboardMapping(), null, "\t");
         return `Layout info:\n${layoutInfo}\n\n${resolvedKeybindings}\n\n${mapperInfo}\n\nRaw mapping:\n${rawMapping}`;
     }
     _dumpDebugInfoJSON() {
@@ -338,7 +377,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             layout: this.keyboardLayoutService.getCurrentKeyboardLayout(),
             rawMapping: this.keyboardLayoutService.getRawKeyboardMapping()
         };
-        return JSON.stringify(info, null, '\t');
+        return JSON.stringify(info, null, "\t");
     }
     enableKeybindingHoldMode(commandId) {
         if (this._currentlyDispatchingCommandId !== commandId) {
@@ -374,7 +413,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         if (!this._cachedResolver) {
             const defaults = this._resolveKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
             const overrides = this.getUserKeybindingItems();
-            this._cachedResolver = ( new KeybindingResolver(defaults, overrides, (str) => this._log(str)));
+            this._cachedResolver = ( new KeybindingResolver(defaults, overrides, str => this._log(str)));
         }
         return this._cachedResolver;
     }
@@ -397,8 +436,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
                     item.extensionId,
                     item.isBuiltinExtension
                 ));
-            }
-            else {
+            } else {
                 if (this._assertBrowserConflicts(keybinding)) {
                     continue;
                 }
@@ -426,8 +464,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             const when = item.when || undefined;
             if (!item.keybinding) {
                 result[resultLen++] = ( new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false));
-            }
-            else {
+            } else {
                 const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
                 for (const resolvedKeybinding of resolvedKeybindings) {
                     result[resultLen++] = ( new ResolvedKeybindingItem(
@@ -504,8 +541,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             for (let i = 0, len = keybindings.length; i < len; i++) {
                 this._handleKeybinding(extensionId, isBuiltin, i + 1, keybindings[i], collector, result);
             }
-        }
-        else {
+        } else {
             this._handleKeybinding(extensionId, isBuiltin, 1, keybindings, collector, result);
         }
     }
@@ -519,10 +555,10 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         }
         if (rejects.length > 0) {
             collector.error(( localize(
-                14127,
+                14516,
                 "Invalid `contributes.{0}`: {1}",
                 keybindingsExtPoint.name,
-                rejects.join('\n')
+                rejects.join("\n")
             )));
         }
     }
@@ -531,13 +567,11 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             if (win) {
                 return win;
             }
-        }
-        else if (OS === OperatingSystem.Macintosh) {
+        } else if (OS === OperatingSystem.Macintosh) {
             if (mac) {
                 return mac;
             }
-        }
-        else {
+        } else {
             if (linux) {
                 return linux;
             }
@@ -545,7 +579,15 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         return key;
     }
     _asCommandRule(extensionId, isBuiltin, idx, binding) {
-        const { command, args, when, key, mac, linux, win } = binding;
+        const {
+            command,
+            args,
+            when,
+            key,
+            mac,
+            linux,
+            win
+        } = binding;
         const keybinding = WorkbenchKeybindingService_1.bindToCurrentPlatform(key, mac, linux, win);
         if (!keybinding) {
             return undefined;
@@ -553,8 +595,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         let weight;
         if (isBuiltin) {
             weight = KeybindingWeight.BuiltinExtension + idx;
-        }
-        else {
+        } else {
             weight = KeybindingWeight.ExternalExtension + idx;
         }
         const commandAction = MenuRegistry.getCommand(command);
@@ -562,11 +603,9 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         let fullWhen;
         if (when && precondition) {
             fullWhen = ( ContextKeyExpr.and(precondition, ContextKeyExpr.deserialize(when)));
-        }
-        else if (when) {
+        } else if (when) {
             fullWhen = ContextKeyExpr.deserialize(when);
-        }
-        else if (precondition) {
+        } else if (precondition) {
             fullWhen = precondition;
         }
         const desc = {
@@ -584,30 +623,27 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         const resolver = this._getResolver();
         const defaultKeybindings = resolver.getDefaultKeybindings();
         const boundCommands = resolver.getDefaultBoundCommands();
-        return (WorkbenchKeybindingService_1._getDefaultKeybindings(defaultKeybindings)
-            + '\n\n'
-            + WorkbenchKeybindingService_1._getAllCommandsAsComment(boundCommands));
+        return (WorkbenchKeybindingService_1._getDefaultKeybindings(defaultKeybindings) + "\n\n" + WorkbenchKeybindingService_1._getAllCommandsAsComment(boundCommands));
     }
     static _getDefaultKeybindings(defaultKeybindings) {
         const out = ( new OutputBuilder());
-        out.writeLine('[');
+        out.writeLine("[");
         const lastIndex = defaultKeybindings.length - 1;
         defaultKeybindings.forEach((k, index) => {
             KeybindingIO.writeKeybindingItem(out, k);
             if (index !== lastIndex) {
-                out.writeLine(',');
-            }
-            else {
+                out.writeLine(",");
+            } else {
                 out.writeLine();
             }
         });
-        out.writeLine(']');
+        out.writeLine("]");
         return ( out.toString());
     }
     static _getAllCommandsAsComment(boundCommands) {
         const unboundCommands = getAllUnboundCommands(boundCommands);
-        const pretty = unboundCommands.sort().join('\n// - ');
-        return '// ' + ( localize(14128, "Here are other available commands: ")) + '\n// - ' + pretty;
+        const pretty = unboundCommands.sort().join("\n// - ");
+        return "// " + ( localize(14517, "Here are other available commands: ")) + "\n// - " + pretty;
     }
     mightProducePrintableCharacter(event) {
         if (event.ctrlKey || event.metaKey || event.altKey) {
@@ -641,21 +677,11 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         return true;
     }
 };
-WorkbenchKeybindingService = WorkbenchKeybindingService_1 = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, ICommandService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IUserDataProfileService)),
-    ( __param(5, IHostService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, IFileService)),
-    ( __param(8, IUriIdentityService)),
-    ( __param(9, ILogService)),
-    ( __param(10, IKeyboardLayoutService))
-], WorkbenchKeybindingService));
+WorkbenchKeybindingService = WorkbenchKeybindingService_1 = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, ICommandService)), ( __param(2, ITelemetryService)), ( __param(3, INotificationService)), ( __param(4, IUserDataProfileService)), ( __param(5, IHostService)), ( __param(6, IExtensionService)), ( __param(7, IFileService)), ( __param(8, IUriIdentityService)), ( __param(9, ILogService)), ( __param(10, IKeyboardLayoutService))], WorkbenchKeybindingService));
 class UserKeybindings extends Disposable {
-    get keybindings() { return this._keybindings; }
+    get keybindings() {
+        return this._keybindings;
+    }
     constructor(userDataProfileService, uriIdentityService, fileService, logService) {
         super();
         this.userDataProfileService = userDataProfileService;
@@ -672,13 +698,16 @@ class UserKeybindings extends Disposable {
                 this._onDidChange.fire();
             }
         }), 50)));
-        this._register(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userDataProfileService.currentProfile.keybindingsResource))(() => {
-            logService.debug('Keybindings file changed');
+        this._register(Event.filter(
+            this.fileService.onDidFilesChange,
+            e => e.contains(this.userDataProfileService.currentProfile.keybindingsResource)
+        )(() => {
+            logService.debug("Keybindings file changed");
             this.reloadConfigurationScheduler.schedule();
         }));
-        this._register(this.fileService.onDidRunOperation((e) => {
+        this._register(this.fileService.onDidRunOperation(e => {
             if (e.operation === FileOperation.WRITE && ( e.resource.toString()) === ( this.userDataProfileService.currentProfile.keybindingsResource.toString())) {
-                logService.debug('Keybindings file written');
+                logService.debug("Keybindings file written");
                 this.reloadConfigurationScheduler.schedule();
             }
         }));
@@ -694,8 +723,12 @@ class UserKeybindings extends Disposable {
     }
     watch() {
         this.watchDisposables.clear();
-        this.watchDisposables.add(this.fileService.watch(dirname(this.userDataProfileService.currentProfile.keybindingsResource)));
-        this.watchDisposables.add(this.fileService.watch(this.userDataProfileService.currentProfile.keybindingsResource));
+        this.watchDisposables.add(
+            this.fileService.watch(dirname(this.userDataProfileService.currentProfile.keybindingsResource))
+        );
+        this.watchDisposables.add(
+            this.fileService.watch(this.userDataProfileService.currentProfile.keybindingsResource)
+        );
     }
     async initialize() {
         await this.reload();
@@ -706,24 +739,25 @@ class UserKeybindings extends Disposable {
             return false;
         }
         this._rawKeybindings = newKeybindings;
-        this._keybindings = ( this._rawKeybindings.map((k) => KeybindingIO.readUserKeybindingItem(k)));
+        this._keybindings = ( this._rawKeybindings.map(k => KeybindingIO.readUserKeybindingItem(k)));
         return true;
     }
     async readUserKeybindings() {
         try {
             const content = await this.fileService.readFile(this.userDataProfileService.currentProfile.keybindingsResource);
             const value = parse(( content.value.toString()));
-            return Array.isArray(value)
-                ? value.filter(v => v && typeof v === 'object' )
-                : [];
-        }
-        catch (e) {
+            return Array.isArray(value) ? value.filter(
+                v => v && typeof v === "object"
+            ) : [];
+        } catch (e) {
             return [];
         }
     }
 }
 class KeybindingsJsonSchema {
-    static { this.schemaId = 'vscode://schemas/keybindings'; }
+    static {
+        this.schemaId = "vscode://schemas/keybindings";
+    }
     constructor() {
         this.commandsSchemas = [];
         this.commandsEnum = [];
@@ -731,96 +765,95 @@ class KeybindingsJsonSchema {
         this.commandsEnumDescriptions = [];
         this.schema = {
             id: KeybindingsJsonSchema.schemaId,
-            type: 'array',
-            title: ( localize(14129, "Keybindings configuration")),
+            type: "array",
+            title: ( localize(14518, "Keybindings configuration")),
             allowTrailingCommas: true,
             allowComments: true,
             definitions: {
-                'editorGroupsSchema': {
-                    'type': 'array',
-                    'items': {
-                        'type': 'object',
-                        'properties': {
-                            'groups': {
-                                '$ref': '#/definitions/editorGroupsSchema',
-                                'default': [{}, {}]
+                "editorGroupsSchema": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "groups": {
+                                "$ref": "#/definitions/editorGroupsSchema",
+                                "default": [{}, {}]
                             },
-                            'size': {
-                                'type': 'number',
-                                'default': 0.5
+                            "size": {
+                                "type": "number",
+                                "default": 0.5
                             }
                         }
                     }
                 },
-                'commandNames': {
-                    'type': 'string',
-                    'enum': this.commandsEnum,
-                    'enumDescriptions': this.commandsEnumDescriptions,
-                    'description': ( localize(14130, "Name of the command to execute")),
+                "commandNames": {
+                    "type": "string",
+                    "enum": this.commandsEnum,
+                    "enumDescriptions": this.commandsEnumDescriptions,
+                    "description": ( localize(14519, "Name of the command to execute"))
                 },
-                'commandType': {
-                    'anyOf': [
-                        {
-                            $ref: '#/definitions/commandNames'
-                        },
-                        {
-                            'type': 'string',
-                            'enum': this.removalCommandsEnum,
-                            'enumDescriptions': this.commandsEnumDescriptions,
-                            'description': ( localize(14131, "Name of the command to remove keyboard shortcut for")),
-                        },
-                        {
-                            'type': 'string'
-                        },
-                    ]
+                "commandType": {
+                    "anyOf": [{
+                        $ref: "#/definitions/commandNames"
+                    }, {
+                        "type": "string",
+                        "enum": this.removalCommandsEnum,
+                        "enumDescriptions": this.commandsEnumDescriptions,
+                        "description": ( localize(14520, "Name of the command to remove keyboard shortcut for"))
+                    }, {
+                        "type": "string"
+                    }]
                 },
-                'commandsSchemas': {
-                    'allOf': this.commandsSchemas
+                "commandsSchemas": {
+                    "allOf": this.commandsSchemas
                 }
             },
             items: {
-                'required': ['key'],
-                'type': 'object',
-                'defaultSnippets': [{ 'body': { 'key': '$1', 'command': '$2', 'when': '$3' } }],
-                'properties': {
-                    'key': {
-                        'type': 'string',
-                        'description': ( localize(14132, "Key or key sequence (separated by space)")),
+                "required": ["key"],
+                "type": "object",
+                "defaultSnippets": [{
+                    "body": {
+                        "key": "$1",
+                        "command": "$2",
+                        "when": "$3"
+                    }
+                }],
+                "properties": {
+                    "key": {
+                        "type": "string",
+                        "description": ( localize(14521, "Key or key sequence (separated by space)"))
                     },
-                    'command': {
-                        'anyOf': [
-                            {
-                                'if': {
-                                    'type': 'array'
-                                },
-                                'then': {
-                                    'not': {
-                                        'type': 'array'
-                                    },
-                                    'errorMessage': ( localize(
-                                        14133,
-                                        "Incorrect type. Expected \"{0}\". The field 'command' does not support running multiple commands. Use command 'runCommands' to pass it multiple commands to run.",
-                                        'string'
-                                    ))
+                    "command": {
+                        "anyOf": [{
+                            "if": {
+                                "type": "array"
+                            },
+                            "then": {
+                                "not": {
+                                    "type": "array"
                                 },
-                                'else': {
-                                    '$ref': '#/definitions/commandType'
-                                }
+                                "errorMessage": ( localize(
+                                    14522,
+                                    "Incorrect type. Expected \"{0}\". The field 'command' does not support running multiple commands. Use command 'runCommands' to pass it multiple commands to run.",
+                                    "string"
+                                ))
                             },
-                            {
-                                '$ref': '#/definitions/commandType'
+                            "else": {
+                                "$ref": "#/definitions/commandType"
                             }
-                        ]
+                        }, {
+                            "$ref": "#/definitions/commandType"
+                        }]
                     },
-                    'when': {
-                        'type': 'string',
-                        'description': ( localize(14134, "Condition when the key is active."))
+                    "when": {
+                        "type": "string",
+                        "description": ( localize(14523, "Condition when the key is active."))
                     },
-                    'args': {
-                        'description': ( localize(14135, "Arguments to pass to the command to execute."))
+                    "args": {
+                        "description": ( localize(14524, "Arguments to pass to the command to execute."))
                     }
                 },
-                '$ref': '#/definitions/commandsSchemas'
+                "$ref": "#/definitions/commandsSchemas"
             }
         };
         this.schemaRegistry = ( Registry.as(Extensions.JSONContribution));
@@ -837,9 +870,10 @@ class KeybindingsJsonSchema {
                 if (!( knownCommands.has(commandId))) {
                     knownCommands.add(commandId);
                     this.commandsEnum.push(commandId);
-                    this.commandsEnumDescriptions.push(description === undefined
-                        ? ''
-                        : (isLocalizedString(description) ? description.value : description));
+                    this.commandsEnumDescriptions.push(
+                        description === undefined ?
+                        "" : (isLocalizedString(description) ? description.value : description)
+                    );
                     this.removalCommandsEnum.push(`-${commandId}`);
                 }
             }
@@ -847,25 +881,28 @@ class KeybindingsJsonSchema {
         const allCommands = CommandsRegistry.getCommands();
         for (const [commandId, command] of allCommands) {
             const commandMetadata = command.metadata;
-            addKnownCommand(commandId, commandMetadata?.description ?? MenuRegistry.getCommand(commandId)?.title);
+            addKnownCommand(
+                commandId,
+                commandMetadata?.description ?? MenuRegistry.getCommand(commandId)?.title
+            );
             if (!commandMetadata || !commandMetadata.args || commandMetadata.args.length !== 1 || !commandMetadata.args[0].schema) {
                 continue;
             }
             const argsSchema = commandMetadata.args[0].schema;
-            const argsRequired = ((typeof commandMetadata.args[0].isOptional !== 'undefined')
-                ? (!commandMetadata.args[0].isOptional)
-                : (Array.isArray(argsSchema.required) && argsSchema.required.length > 0));
+            const argsRequired = ((typeof commandMetadata.args[0].isOptional !== "undefined") ? (!commandMetadata.args[0].isOptional) : (Array.isArray(argsSchema.required) && argsSchema.required.length > 0));
             const addition = {
-                'if': {
-                    'required': ['command'],
-                    'properties': {
-                        'command': { 'const': commandId }
+                "if": {
+                    "required": ["command"],
+                    "properties": {
+                        "command": {
+                            "const": commandId
+                        }
                     }
                 },
-                'then': {
-                    'required': [].concat(argsRequired ? ['args'] : []),
-                    'properties': {
-                        'args': argsSchema
+                "then": {
+                    "required": [].concat(argsRequired ? ["args"] : []),
+                    "properties": {
+                        "args": argsSchema
                     }
                 }
             };