@codingame/monaco-vscode-keybindings-service-override 4.0.0 → 4.1.0

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

@@ -1,947 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { onDidChangeFullscreen, isFullscreen } from 'vscode/vscode/vs/base/browser/browser';
-import { BrowserFeatures } from 'vscode/vscode/vs/base/browser/canIUse';
-import { onDidRegisterWindow, addDisposableListener, EventType, trackFocus, getWindow } from 'vscode/vscode/vs/base/browser/dom';
-import { StandardKeyboardEvent, printKeyboardEvent, printStandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
-import { DeferredPromise, RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
-import { parse } from 'vscode/vscode/vs/base/common/json';
-import { UserSettingsLabelProvider } from 'vscode/vscode/vs/base/common/keybindingLabels';
-import { KeybindingParser } from 'vscode/vscode/vs/base/common/keybindingParser';
-import { KeyCodeChord, ScanCodeChord } from 'vscode/vscode/vs/base/common/keybindings';
-import { KeyCodeUtils, ScanCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE } from 'vscode/vscode/vs/base/common/keyCodes';
-import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { equals } from 'vscode/vscode/vs/base/common/objects';
-import { OS, isMacintosh } from 'vscode/vscode/vs/base/common/platform';
-import { dirname } from 'vscode/vscode/vs/base/common/resources';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { MenuRegistry } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ICommandService, CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { Extensions } from 'vscode/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
-import { AbstractKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/abstractKeybindingService';
-import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { KeybindingResolver } from 'vscode/vscode/vs/platform/keybinding/common/keybindingResolver';
-import { KeybindingsRegistry } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
-import { ResolvedKeybindingItem } from 'vscode/vscode/vs/platform/keybinding/common/resolvedKeybindingItem';
-import { IKeyboardLayoutService } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { isLocalizedString } from 'vscode/vscode/vs/platform/action/common/action';
-import { commandsExtensionPoint } from '../../actions/common/menusExtensionPoint.js';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { getAllUnboundCommands } from 'vscode/vscode/vs/workbench/services/keybinding/browser/unboundCommands';
-import { KeybindingIO, OutputBuilder } from '../common/keybindingIO.js';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
-
-var WorkbenchKeybindingService_1;
-function isValidContributedKeyBinding(keyBinding, rejects) {
-    if (!keyBinding) {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'nonempty',
-            "expected non-empty value."
-        )));
-        return false;
-    }
-    if (typeof keyBinding.command !== 'string') {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'requirestring',
-            "property `{0}` is mandatory and must be of type `string`",
-            'command'
-        )));
-        return false;
-    }
-    if (keyBinding.key && typeof keyBinding.key !== 'string') {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'optstring',
-            "property `{0}` can be omitted or must be of type `string`",
-            'key'
-        )));
-        return false;
-    }
-    if (keyBinding.when && typeof keyBinding.when !== 'string') {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'optstring',
-            "property `{0}` can be omitted or must be of type `string`",
-            'when'
-        )));
-        return false;
-    }
-    if (keyBinding.mac && typeof keyBinding.mac !== 'string') {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'optstring',
-            "property `{0}` can be omitted or must be of type `string`",
-            'mac'
-        )));
-        return false;
-    }
-    if (keyBinding.linux && typeof keyBinding.linux !== 'string') {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'optstring',
-            "property `{0}` can be omitted or must be of type `string`",
-            'linux'
-        )));
-        return false;
-    }
-    if (keyBinding.win && typeof keyBinding.win !== 'string') {
-        rejects.push(( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'optstring',
-            "property `{0}` can be omitted or must be of type `string`",
-            'win'
-        )));
-        return false;
-    }
-    return true;
-}
-const keybindingType = {
-    type: 'object',
-    default: { command: '', key: '' },
-    properties: {
-        command: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.command',
-                'Identifier of the command to run when keybinding is triggered.'
-            )),
-            type: 'string'
-        },
-        args: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.args',
-                "Arguments to pass to the command to execute."
-            ))
-        },
-        key: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.key',
-                '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'
-        },
-        mac: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.mac',
-                'Mac specific key or key sequence.'
-            )),
-            type: 'string'
-        },
-        linux: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.linux',
-                'Linux specific key or key sequence.'
-            )),
-            type: 'string'
-        },
-        win: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.win',
-                'Windows specific key or key sequence.'
-            )),
-            type: 'string'
-        },
-        when: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'vscode.extension.contributes.keybindings.when',
-                'Condition when the key is active.'
-            )),
-            type: 'string'
-        },
-    }
-};
-const keybindingsExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'keybindings',
-    deps: [commandsExtensionPoint],
-    jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'vscode.extension.contributes.keybindings',
-            "Contributes keybindings."
-        )),
-        oneOf: [
-            keybindingType,
-            {
-                type: 'array',
-                items: keybindingType
-            }
-        ]
-    }
-});
-const NUMPAD_PRINTABLE_SCANCODES = [
-    90 ,
-    91 ,
-    92 ,
-    93 ,
-    95 ,
-    96 ,
-    97 ,
-    98 ,
-    99 ,
-    100 ,
-    101 ,
-    102 ,
-    103 ,
-    104 ,
-    105
-];
-const otherMacNumpadMapping = ( new Map());
-otherMacNumpadMapping.set(95 , 22 );
-otherMacNumpadMapping.set(96 , 23 );
-otherMacNumpadMapping.set(97 , 24 );
-otherMacNumpadMapping.set(98 , 25 );
-otherMacNumpadMapping.set(99 , 26 );
-otherMacNumpadMapping.set(100 , 27 );
-otherMacNumpadMapping.set(101 , 28 );
-otherMacNumpadMapping.set(102 , 29 );
-otherMacNumpadMapping.set(103 , 30 );
-otherMacNumpadMapping.set(104 , 21 );
-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);
-        this.hostService = hostService;
-        this.keyboardLayoutService = keyboardLayoutService;
-        this._contributions = [];
-        this.isComposingGlobalContextKey = contextKeyService.createKey('isComposing', false);
-        this.kbsJsonSchema = ( new KeybindingsJsonSchema());
-        this.updateKeybindingsJsonSchema();
-        this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper();
-        this._register(this.keyboardLayoutService.onDidChangeKeyboardLayout(() => {
-            this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper();
-            this.updateResolver();
-        }));
-        this._keybindingHoldMode = null;
-        this._cachedResolver = null;
-        this.userKeybindings = this._register(( new UserKeybindings(userDataProfileService, uriIdentityService, fileService, logService)));
-        this.userKeybindings.initialize().then(() => {
-            if (this.userKeybindings.keybindings.length) {
-                this.updateResolver();
-            }
-        });
-        this._register(this.userKeybindings.onDidChange(() => {
-            logService.debug('User keybindings changed');
-            this.updateResolver();
-        }));
-        keybindingsExtPoint.setHandler((extensions) => {
-            const keybindings = [];
-            for (const extension of extensions) {
-                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(onDidChangeFullscreen(windowId => {
-            if (windowId !== mainWindow.vscodeWindowId) {
-                return;
-            }
-            const keyboard = navigator.keyboard;
-            if (BrowserFeatures.keyboard === 2 ) {
-                return;
-            }
-            if (isFullscreen(mainWindow)) {
-                keyboard?.lock(['Escape']);
-            }
-            else {
-                keyboard?.unlock();
-            }
-            this._cachedResolver = null;
-            this._onDidUpdateKeybindings.fire();
-        }));
-    }
-    _registerKeyListeners(window) {
-        const disposables = ( new DisposableStore());
-        disposables.add(addDisposableListener(window, EventType.KEY_DOWN, (e) => {
-            if (this._keybindingHoldMode) {
-                return;
-            }
-            this.isComposingGlobalContextKey.set(e.isComposing);
-            const keyEvent = ( new StandardKeyboardEvent(e));
-            this._log(`/ Received  keydown event - ${printKeyboardEvent(e)}`);
-            this._log(`| Converted keydown event - ${printStandardKeyboardEvent(keyEvent)}`);
-            const shouldPreventDefault = this._dispatch(keyEvent, keyEvent.target);
-            if (shouldPreventDefault) {
-                keyEvent.preventDefault();
-            }
-            this.isComposingGlobalContextKey.set(false);
-        }));
-        disposables.add(addDisposableListener(window, EventType.KEY_UP, (e) => {
-            this._resetKeybindingHoldMode();
-            this.isComposingGlobalContextKey.set(e.isComposing);
-            const keyEvent = ( new StandardKeyboardEvent(e));
-            const shouldPreventDefault = this._singleModifierDispatch(keyEvent, keyEvent.target);
-            if (shouldPreventDefault) {
-                keyEvent.preventDefault();
-            }
-            this.isComposingGlobalContextKey.set(false);
-        }));
-        return disposables;
-    }
-    registerSchemaContribution(contribution) {
-        this._contributions.push(contribution);
-        if (contribution.onDidChange) {
-            this._register(contribution.onDidChange(() => this.updateKeybindingsJsonSchema()));
-        }
-        this.updateKeybindingsJsonSchema();
-    }
-    updateKeybindingsJsonSchema() {
-        this.kbsJsonSchema.updateSchema(this._contributions.flatMap(x => x.getSchemaAdditions()));
-    }
-    _printKeybinding(keybinding) {
-        return UserSettingsLabelProvider.toLabel(OS, keybinding.chords, (chord) => {
-            if (chord instanceof KeyCodeChord) {
-                return ( KeyCodeUtils.toString(chord.keyCode));
-            }
-            return ( ScanCodeUtils.toString(chord.scanCode));
-        }) || '[null]';
-    }
-    _printResolvedKeybinding(resolvedKeybinding) {
-        return ( resolvedKeybinding.getDispatchChords().map(x => x || '[null]')).join(' ');
-    }
-    _printResolvedKeybindings(output, input, resolvedKeybindings) {
-        const padLength = 35;
-        const firstRow = `${input.padStart(padLength, ' ')} => `;
-        if (resolvedKeybindings.length === 0) {
-            output.push(`${firstRow}${'[NO BINDING]'.padStart(padLength, ' ')}`);
-            return;
-        }
-        for (const resolvedKeybinding of resolvedKeybindings) {
-            {
-                output.push(`${firstRow}${this._printResolvedKeybinding(resolvedKeybinding).padStart(padLength, ' ')}`);
-            }
-        }
-    }
-    _dumpResolveKeybindingDebugInfo() {
-        const seenBindings = ( new Set());
-        const result = [];
-        result.push(`Default Resolved Keybindings (unique only):`);
-        for (const item of KeybindingsRegistry.getDefaultKeybindings()) {
-            if (!item.keybinding) {
-                continue;
-            }
-            const input = this._printKeybinding(item.keybinding);
-            if (( seenBindings.has(input))) {
-                continue;
-            }
-            seenBindings.add(input);
-            const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
-            this._printResolvedKeybindings(result, input, resolvedKeybindings);
-        }
-        result.push(`User Resolved Keybindings (unique only):`);
-        for (const item of this.userKeybindings.keybindings) {
-            if (!item.keybinding) {
-                continue;
-            }
-            const input = item._sourceKey ?? 'Impossible: missing source key, but has keybinding';
-            if (( seenBindings.has(input))) {
-                continue;
-            }
-            seenBindings.add(input);
-            const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
-            this._printResolvedKeybindings(result, input, resolvedKeybindings);
-        }
-        return result.join('\n');
-    }
-    _dumpDebugInfo() {
-        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');
-        return `Layout info:\n${layoutInfo}\n\n${resolvedKeybindings}\n\n${mapperInfo}\n\nRaw mapping:\n${rawMapping}`;
-    }
-    _dumpDebugInfoJSON() {
-        const info = {
-            layout: this.keyboardLayoutService.getCurrentKeyboardLayout(),
-            rawMapping: this.keyboardLayoutService.getRawKeyboardMapping()
-        };
-        return JSON.stringify(info, null, '\t');
-    }
-    enableKeybindingHoldMode(commandId) {
-        if (this._currentlyDispatchingCommandId !== commandId) {
-            return undefined;
-        }
-        this._keybindingHoldMode = ( new DeferredPromise());
-        const focusTracker = trackFocus(getWindow(undefined));
-        const listener = focusTracker.onDidBlur(() => this._resetKeybindingHoldMode());
-        this._keybindingHoldMode.p.finally(() => {
-            listener.dispose();
-            focusTracker.dispose();
-        });
-        this._log(`+ Enabled hold-mode for ${commandId}.`);
-        return this._keybindingHoldMode.p;
-    }
-    _resetKeybindingHoldMode() {
-        if (this._keybindingHoldMode) {
-            this._keybindingHoldMode?.complete();
-            this._keybindingHoldMode = null;
-        }
-    }
-    customKeybindingsCount() {
-        return this.userKeybindings.keybindings.length;
-    }
-    updateResolver() {
-        this._cachedResolver = null;
-        this._onDidUpdateKeybindings.fire();
-    }
-    getUserKeybindingItems() {
-        return this._resolveUserKeybindingItems(this.userKeybindings.keybindings, false);
-    }
-    _getResolver() {
-        if (!this._cachedResolver) {
-            const defaults = this._resolveKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
-            const overrides = this.getUserKeybindingItems();
-            this._cachedResolver = ( new KeybindingResolver(defaults, overrides, (str) => this._log(str)));
-        }
-        return this._cachedResolver;
-    }
-    _documentHasFocus() {
-        return this.hostService.hasFocus;
-    }
-    _resolveKeybindingItems(items, isDefault) {
-        const result = [];
-        let resultLen = 0;
-        for (const item of items) {
-            const when = item.when || undefined;
-            const keybinding = item.keybinding;
-            if (!keybinding) {
-                result[resultLen++] = ( new ResolvedKeybindingItem(
-                    undefined,
-                    item.command,
-                    item.commandArgs,
-                    when,
-                    isDefault,
-                    item.extensionId,
-                    item.isBuiltinExtension
-                ));
-            }
-            else {
-                if (this._assertBrowserConflicts(keybinding)) {
-                    continue;
-                }
-                const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(keybinding);
-                for (let i = resolvedKeybindings.length - 1; i >= 0; i--) {
-                    const resolvedKeybinding = resolvedKeybindings[i];
-                    result[resultLen++] = ( new ResolvedKeybindingItem(
-                        resolvedKeybinding,
-                        item.command,
-                        item.commandArgs,
-                        when,
-                        isDefault,
-                        item.extensionId,
-                        item.isBuiltinExtension
-                    ));
-                }
-            }
-        }
-        return result;
-    }
-    _resolveUserKeybindingItems(items, isDefault) {
-        const result = [];
-        let resultLen = 0;
-        for (const item of items) {
-            const when = item.when || undefined;
-            if (!item.keybinding) {
-                result[resultLen++] = ( new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false));
-            }
-            else {
-                const resolvedKeybindings = this._keyboardMapper.resolveKeybinding(item.keybinding);
-                for (const resolvedKeybinding of resolvedKeybindings) {
-                    result[resultLen++] = ( new ResolvedKeybindingItem(
-                        resolvedKeybinding,
-                        item.command,
-                        item.commandArgs,
-                        when,
-                        isDefault,
-                        null,
-                        false
-                    ));
-                }
-            }
-        }
-        return result;
-    }
-    _assertBrowserConflicts(keybinding) {
-        if (BrowserFeatures.keyboard === 0 ) {
-            return false;
-        }
-        if (BrowserFeatures.keyboard === 1  && isFullscreen(mainWindow)) {
-            return false;
-        }
-        for (const chord of keybinding.chords) {
-            if (!chord.metaKey && !chord.altKey && !chord.ctrlKey && !chord.shiftKey) {
-                continue;
-            }
-            const modifiersMask = 2048  | 512  | 1024 ;
-            let partModifiersMask = 0;
-            if (chord.metaKey) {
-                partModifiersMask |= 2048 ;
-            }
-            if (chord.shiftKey) {
-                partModifiersMask |= 1024 ;
-            }
-            if (chord.altKey) {
-                partModifiersMask |= 512 ;
-            }
-            if (chord.ctrlKey && OS === 2 ) {
-                partModifiersMask |= 256 ;
-            }
-            if ((partModifiersMask & modifiersMask) === ((2048  | 512) )) {
-                if (chord instanceof ScanCodeChord && ((chord.scanCode === 86  || chord.scanCode === 85) )) {
-                    return true;
-                }
-                if (chord instanceof KeyCodeChord && ((chord.keyCode === 15  || chord.keyCode === 17) )) {
-                    return true;
-                }
-            }
-            if ((partModifiersMask & modifiersMask) === 2048 ) {
-                if (chord instanceof ScanCodeChord && ((chord.scanCode >= 36  && chord.scanCode <= 45) )) {
-                    return true;
-                }
-                if (chord instanceof KeyCodeChord && ((chord.keyCode >= 21  && chord.keyCode <= 30) )) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    resolveKeybinding(kb) {
-        return this._keyboardMapper.resolveKeybinding(kb);
-    }
-    resolveKeyboardEvent(keyboardEvent) {
-        this.keyboardLayoutService.validateCurrentKeyboardMapping(keyboardEvent);
-        return this._keyboardMapper.resolveKeyboardEvent(keyboardEvent);
-    }
-    resolveUserBinding(userBinding) {
-        const keybinding = KeybindingParser.parseKeybinding(userBinding);
-        return (keybinding ? this._keyboardMapper.resolveKeybinding(keybinding) : []);
-    }
-    _handleKeybindingsExtensionPointUser(extensionId, isBuiltin, keybindings, collector, result) {
-        if (Array.isArray(keybindings)) {
-            for (let i = 0, len = keybindings.length; i < len; i++) {
-                this._handleKeybinding(extensionId, isBuiltin, i + 1, keybindings[i], collector, result);
-            }
-        }
-        else {
-            this._handleKeybinding(extensionId, isBuiltin, 1, keybindings, collector, result);
-        }
-    }
-    _handleKeybinding(extensionId, isBuiltin, idx, keybindings, collector, result) {
-        const rejects = [];
-        if (isValidContributedKeyBinding(keybindings, rejects)) {
-            const rule = this._asCommandRule(extensionId, isBuiltin, idx++, keybindings);
-            if (rule) {
-                result.push(rule);
-            }
-        }
-        if (rejects.length > 0) {
-            collector.error(( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'invalid.keybindings',
-                "Invalid `contributes.{0}`: {1}",
-                keybindingsExtPoint.name,
-                rejects.join('\n')
-            )));
-        }
-    }
-    static bindToCurrentPlatform(key, mac, linux, win) {
-        if (OS === 1  && win) {
-            if (win) {
-                return win;
-            }
-        }
-        else if (OS === 2 ) {
-            if (mac) {
-                return mac;
-            }
-        }
-        else {
-            if (linux) {
-                return linux;
-            }
-        }
-        return key;
-    }
-    _asCommandRule(extensionId, isBuiltin, idx, binding) {
-        const { command, args, when, key, mac, linux, win } = binding;
-        const keybinding = WorkbenchKeybindingService_1.bindToCurrentPlatform(key, mac, linux, win);
-        if (!keybinding) {
-            return undefined;
-        }
-        let weight;
-        if (isBuiltin) {
-            weight = 300  + idx;
-        }
-        else {
-            weight = 400  + idx;
-        }
-        const commandAction = MenuRegistry.getCommand(command);
-        const precondition = commandAction && commandAction.precondition;
-        let fullWhen;
-        if (when && precondition) {
-            fullWhen = ( ContextKeyExpr.and(precondition, ContextKeyExpr.deserialize(when)));
-        }
-        else if (when) {
-            fullWhen = ContextKeyExpr.deserialize(when);
-        }
-        else if (precondition) {
-            fullWhen = precondition;
-        }
-        const desc = {
-            id: command,
-            args,
-            when: fullWhen,
-            weight: weight,
-            keybinding: KeybindingParser.parseKeybinding(keybinding),
-            extensionId: extensionId.value,
-            isBuiltinExtension: isBuiltin
-        };
-        return desc;
-    }
-    getDefaultKeybindingsContent() {
-        const resolver = this._getResolver();
-        const defaultKeybindings = resolver.getDefaultKeybindings();
-        const boundCommands = resolver.getDefaultBoundCommands();
-        return (WorkbenchKeybindingService_1._getDefaultKeybindings(defaultKeybindings)
-            + '\n\n'
-            + WorkbenchKeybindingService_1._getAllCommandsAsComment(boundCommands));
-    }
-    static _getDefaultKeybindings(defaultKeybindings) {
-        const out = ( new OutputBuilder());
-        out.writeLine('[');
-        const lastIndex = defaultKeybindings.length - 1;
-        defaultKeybindings.forEach((k, index) => {
-            KeybindingIO.writeKeybindingItem(out, k);
-            if (index !== lastIndex) {
-                out.writeLine(',');
-            }
-            else {
-                out.writeLine();
-            }
-        });
-        out.writeLine(']');
-        return ( out.toString());
-    }
-    static _getAllCommandsAsComment(boundCommands) {
-        const unboundCommands = getAllUnboundCommands(boundCommands);
-        const pretty = unboundCommands.sort().join('\n// - ');
-        return '// ' + ( localizeWithPath(
-            'vs/workbench/services/keybinding/browser/keybindingService',
-            'unboundCommands',
-            "Here are other available commands: "
-        )) + '\n// - ' + pretty;
-    }
-    mightProducePrintableCharacter(event) {
-        if (event.ctrlKey || event.metaKey || event.altKey) {
-            return false;
-        }
-        const code = ScanCodeUtils.toEnum(event.code);
-        if (NUMPAD_PRINTABLE_SCANCODES.indexOf(code) !== -1) {
-            if (event.keyCode === IMMUTABLE_CODE_TO_KEY_CODE[code]) {
-                return true;
-            }
-            if (isMacintosh && event.keyCode === otherMacNumpadMapping.get(code)) {
-                return true;
-            }
-            return false;
-        }
-        const keycode = IMMUTABLE_CODE_TO_KEY_CODE[code];
-        if (keycode !== -1) {
-            return false;
-        }
-        const mapping = this.keyboardLayoutService.getRawKeyboardMapping();
-        if (!mapping) {
-            return false;
-        }
-        const keyInfo = mapping[event.code];
-        if (!keyInfo) {
-            return false;
-        }
-        if (!keyInfo.value || /\s/.test(keyInfo.value)) {
-            return false;
-        }
-        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));
-class UserKeybindings extends Disposable {
-    get keybindings() { return this._keybindings; }
-    constructor(userDataProfileService, uriIdentityService, fileService, logService) {
-        super();
-        this.userDataProfileService = userDataProfileService;
-        this.uriIdentityService = uriIdentityService;
-        this.fileService = fileService;
-        this._rawKeybindings = [];
-        this._keybindings = [];
-        this.watchDisposables = this._register(( new DisposableStore()));
-        this._onDidChange = this._register(( new Emitter()));
-        this.onDidChange = this._onDidChange.event;
-        this.watch();
-        this.reloadConfigurationScheduler = this._register(( new RunOnceScheduler(() => this.reload().then(changed => {
-            if (changed) {
-                this._onDidChange.fire();
-            }
-        }), 50)));
-        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) => {
-            if (e.operation === 4  && ( e.resource.toString()) === ( this.userDataProfileService.currentProfile.keybindingsResource.toString())) {
-                logService.debug('Keybindings file written');
-                this.reloadConfigurationScheduler.schedule();
-            }
-        }));
-        this._register(userDataProfileService.onDidChangeCurrentProfile(e => {
-            if (!this.uriIdentityService.extUri.isEqual(e.previous.keybindingsResource, e.profile.keybindingsResource)) {
-                e.join(this.whenCurrentProfileChanged());
-            }
-        }));
-    }
-    async whenCurrentProfileChanged() {
-        this.watch();
-        this.reloadConfigurationScheduler.schedule();
-    }
-    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));
-    }
-    async initialize() {
-        await this.reload();
-    }
-    async reload() {
-        const newKeybindings = await this.readUserKeybindings();
-        if (equals(this._rawKeybindings, newKeybindings)) {
-            return false;
-        }
-        this._rawKeybindings = newKeybindings;
-        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 [];
-        }
-    }
-}
-class KeybindingsJsonSchema {
-    static { this.schemaId = 'vscode://schemas/keybindings'; }
-    constructor() {
-        this.commandsSchemas = [];
-        this.commandsEnum = [];
-        this.removalCommandsEnum = [];
-        this.commandsEnumDescriptions = [];
-        this.schema = {
-            id: KeybindingsJsonSchema.schemaId,
-            type: 'array',
-            title: ( localizeWithPath(
-                'vs/workbench/services/keybinding/browser/keybindingService',
-                'keybindings.json.title',
-                "Keybindings configuration"
-            )),
-            allowTrailingCommas: true,
-            allowComments: true,
-            definitions: {
-                'editorGroupsSchema': {
-                    'type': 'array',
-                    'items': {
-                        'type': 'object',
-                        'properties': {
-                            'groups': {
-                                '$ref': '#/definitions/editorGroupsSchema',
-                                'default': [{}, {}]
-                            },
-                            'size': {
-                                'type': 'number',
-                                'default': 0.5
-                            }
-                        }
-                    }
-                },
-                'commandNames': {
-                    'type': 'string',
-                    'enum': this.commandsEnum,
-                    'enumDescriptions': this.commandsEnumDescriptions,
-                    'description': ( localizeWithPath(
-                        'vs/workbench/services/keybinding/browser/keybindingService',
-                        'keybindings.json.command',
-                        "Name of the command to execute"
-                    )),
-                },
-                'commandType': {
-                    'anyOf': [
-                        {
-                            $ref: '#/definitions/commandNames'
-                        },
-                        {
-                            'type': 'string',
-                            'enum': this.removalCommandsEnum,
-                            'enumDescriptions': this.commandsEnumDescriptions,
-                            'description': ( localizeWithPath(
-                                'vs/workbench/services/keybinding/browser/keybindingService',
-                                'keybindings.json.removalCommand',
-                                "Name of the command to remove keyboard shortcut for"
-                            )),
-                        },
-                        {
-                            'type': 'string'
-                        },
-                    ]
-                },
-                'commandsSchemas': {
-                    'allOf': this.commandsSchemas
-                }
-            },
-            items: {
-                'required': ['key'],
-                'type': 'object',
-                'defaultSnippets': [{ 'body': { 'key': '$1', 'command': '$2', 'when': '$3' } }],
-                'properties': {
-                    'key': {
-                        'type': 'string',
-                        'description': ( localizeWithPath(
-                            'vs/workbench/services/keybinding/browser/keybindingService',
-                            'keybindings.json.key',
-                            "Key or key sequence (separated by space)"
-                        )),
-                    },
-                    'command': {
-                        'anyOf': [
-                            {
-                                'if': {
-                                    'type': 'array'
-                                },
-                                'then': {
-                                    'not': {
-                                        'type': 'array'
-                                    },
-                                    'errorMessage': ( localizeWithPath(
-                                        'vs/workbench/services/keybinding/browser/keybindingService',
-                                        'keybindings.commandsIsArray',
-                                        "Incorrect type. Expected \"{0}\". The field 'command' does not support running multiple commands. Use command 'runCommands' to pass it multiple commands to run.",
-                                        'string'
-                                    ))
-                                },
-                                'else': {
-                                    '$ref': '#/definitions/commandType'
-                                }
-                            },
-                            {
-                                '$ref': '#/definitions/commandType'
-                            }
-                        ]
-                    },
-                    'when': {
-                        'type': 'string',
-                        'description': ( localizeWithPath(
-                            'vs/workbench/services/keybinding/browser/keybindingService',
-                            'keybindings.json.when',
-                            "Condition when the key is active."
-                        ))
-                    },
-                    'args': {
-                        'description': ( localizeWithPath(
-                            'vs/workbench/services/keybinding/browser/keybindingService',
-                            'keybindings.json.args',
-                            "Arguments to pass to the command to execute."
-                        ))
-                    }
-                },
-                '$ref': '#/definitions/commandsSchemas'
-            }
-        };
-        this.schemaRegistry = ( Registry.as(Extensions.JSONContribution));
-        this.schemaRegistry.registerSchema(KeybindingsJsonSchema.schemaId, this.schema);
-    }
-    updateSchema(additionalContributions) {
-        this.commandsSchemas.length = 0;
-        this.commandsEnum.length = 0;
-        this.removalCommandsEnum.length = 0;
-        this.commandsEnumDescriptions.length = 0;
-        const knownCommands = ( new Set());
-        const addKnownCommand = (commandId, description) => {
-            if (!/^_/.test(commandId)) {
-                if (!( knownCommands.has(commandId))) {
-                    knownCommands.add(commandId);
-                    this.commandsEnum.push(commandId);
-                    this.commandsEnumDescriptions.push(isLocalizedString(description) ? description.value : description);
-                    this.removalCommandsEnum.push(`-${commandId}`);
-                }
-            }
-        };
-        const allCommands = CommandsRegistry.getCommands();
-        for (const [commandId, command] of allCommands) {
-            const commandMetadata = command.metadata;
-            addKnownCommand(commandId, commandMetadata?.description);
-            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 addition = {
-                'if': {
-                    'required': ['command'],
-                    'properties': {
-                        'command': { 'const': commandId }
-                    }
-                },
-                'then': {
-                    'required': [].concat(argsRequired ? ['args'] : []),
-                    'properties': {
-                        'args': argsSchema
-                    }
-                }
-            };
-            this.commandsSchemas.push(addition);
-        }
-        const menuCommands = MenuRegistry.getCommands();
-        for (const commandId of ( menuCommands.keys())) {
-            addKnownCommand(commandId);
-        }
-        this.commandsSchemas.push(...additionalContributions);
-        this.schemaRegistry.notifySchemaChanged(KeybindingsJsonSchema.schemaId);
-    }
-}
-
-export { WorkbenchKeybindingService };