@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

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

@@ -0,0 +1,855 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as browser from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { printKeyboardEvent, printStandardKeyboardEvent, StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { parse } from '../../../../base/common/json.js';
+import { UserSettingsLabelProvider } from 'monaco-editor/esm/vs/base/common/keybindingLabels.js';
+import { KeybindingParser } from '../../../../base/common/keybindingParser.js';
+import { KeyCodeChord, ScanCodeChord } from 'monaco-editor/esm/vs/base/common/keybindings.js';
+import { KeyCodeUtils, ScanCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import { OS, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ICommandService, CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { AbstractKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/abstractKeybindingService.js';
+import { KeybindingResolver } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingResolver.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { ResolvedKeybindingItem } from 'monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+import { IKeyboardLayoutService } from '../../../../platform/keyboardLayout/common/keyboardLayout.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { commandsExtensionPoint } from '../../actions/common/menusExtensionPoint.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
+import { IHostService } from '../../host/browser/host.js';
+import { getAllUnboundCommands } from './unboundCommands.js';
+import { KeybindingIO, OutputBuilder } from '../common/keybindingIO.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
+function isValidContributedKeyBinding(keyBinding, rejects) {
+    if (!keyBinding) {
+        rejects.push(( nls.localize('nonempty', "expected non-empty value.")));
+        return false;
+    }
+    if (typeof keyBinding.command !== 'string') {
+        rejects.push(( nls.localize(
+            'requirestring',
+            "property `{0}` is mandatory and must be of type `string`",
+            'command'
+        )));
+        return false;
+    }
+    if (keyBinding.key && typeof keyBinding.key !== 'string') {
+        rejects.push(( nls.localize(
+            'optstring',
+            "property `{0}` can be omitted or must be of type `string`",
+            'key'
+        )));
+        return false;
+    }
+    if (keyBinding.when && typeof keyBinding.when !== 'string') {
+        rejects.push(( nls.localize(
+            'optstring',
+            "property `{0}` can be omitted or must be of type `string`",
+            'when'
+        )));
+        return false;
+    }
+    if (keyBinding.mac && typeof keyBinding.mac !== 'string') {
+        rejects.push(( nls.localize(
+            'optstring',
+            "property `{0}` can be omitted or must be of type `string`",
+            'mac'
+        )));
+        return false;
+    }
+    if (keyBinding.linux && typeof keyBinding.linux !== 'string') {
+        rejects.push(( nls.localize(
+            'optstring',
+            "property `{0}` can be omitted or must be of type `string`",
+            'linux'
+        )));
+        return false;
+    }
+    if (keyBinding.win && typeof keyBinding.win !== 'string') {
+        rejects.push(( nls.localize(
+            '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: ( nls.localize(
+                'vscode.extension.contributes.keybindings.command',
+                'Identifier of the command to run when keybinding is triggered.'
+            )),
+            type: 'string'
+        },
+        args: {
+            description: ( nls.localize(
+                'vscode.extension.contributes.keybindings.args',
+                "Arguments to pass to the command to execute."
+            ))
+        },
+        key: {
+            description: ( nls.localize(
+                '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: ( nls.localize(
+                'vscode.extension.contributes.keybindings.mac',
+                'Mac specific key or key sequence.'
+            )),
+            type: 'string'
+        },
+        linux: {
+            description: ( nls.localize(
+                'vscode.extension.contributes.keybindings.linux',
+                'Linux specific key or key sequence.'
+            )),
+            type: 'string'
+        },
+        win: {
+            description: ( nls.localize(
+                'vscode.extension.contributes.keybindings.win',
+                'Windows specific key or key sequence.'
+            )),
+            type: 'string'
+        },
+        when: {
+            description: ( nls.localize(
+                'vscode.extension.contributes.keybindings.when',
+                'Condition when the key is active.'
+            )),
+            type: 'string'
+        },
+    }
+};
+const keybindingsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'keybindings',
+    deps: [commandsExtensionPoint],
+    jsonSchema: {
+        description: ( nls.localize('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 = class WorkbenchKeybindingService extends AbstractKeybindingService {
+    constructor(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, 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.keyboardLayoutService.onDidChangeKeyboardLayout(() => {
+            this._keyboardMapper = this.keyboardLayoutService.getKeyboardMapper();
+            this.updateResolver();
+        });
+        this._cachedResolver = null;
+        this.userKeybindings = this._register(( new UserKeybindings(userDataProfileService, 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(dom.addDisposableListener(window, dom.EventType.KEY_DOWN, (e) => {
+            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);
+        }));
+        this._register(dom.addDisposableListener(window, dom.EventType.KEY_UP, (e) => {
+            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);
+        }));
+        this._register(browser.onDidChangeFullscreen(() => {
+            const keyboard = navigator.keyboard;
+            if (BrowserFeatures.keyboard === 2 ) {
+                return;
+            }
+            if (browser.isFullscreen()) {
+                keyboard?.lock(['Escape']);
+            }
+            else {
+                keyboard?.unlock();
+            }
+            this._cachedResolver = null;
+            this._onDidUpdateKeybindings.fire();
+        }));
+    }
+    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');
+    }
+    customKeybindingsCount() {
+        return this.userKeybindings.keybindings.length;
+    }
+    updateResolver() {
+        this._cachedResolver = null;
+        this._onDidUpdateKeybindings.fire();
+    }
+    _getResolver() {
+        if (!this._cachedResolver) {
+            const defaults = this._resolveKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
+            const overrides = this._resolveUserKeybindingItems(this.userKeybindings.keybindings, false);
+            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  && browser.isFullscreen()) {
+            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(( nls.localize(
+                '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.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._getDefaultKeybindings(defaultKeybindings)
+            + '\n\n'
+            + WorkbenchKeybindingService._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 '// ' + ( nls.localize('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 = ( __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, ILogService)),
+    ( __param(9, IKeyboardLayoutService))
+], WorkbenchKeybindingService));
+class UserKeybindings extends Disposable {
+    get keybindings() { return this._keybindings; }
+    constructor(userDataProfileService, fileService, logService) {
+        super();
+        this.userDataProfileService = userDataProfileService;
+        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 => e.join(this.whenCurrentProfileChanged(e))));
+    }
+    async whenCurrentProfileChanged(e) {
+        if (e.preserveData) {
+            if (await this.fileService.exists(e.previous.keybindingsResource)) {
+                await this.fileService.copy(e.previous.keybindingsResource, e.profile.keybindingsResource);
+            }
+        }
+        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 (objects.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 {
+    constructor() {
+        this.commandsSchemas = [];
+        this.commandsEnum = [];
+        this.removalCommandsEnum = [];
+        this.commandsEnumDescriptions = [];
+        this.schema = {
+            id: KeybindingsJsonSchema.schemaId,
+            type: 'array',
+            title: ( nls.localize('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': ( nls.localize('keybindings.json.command', "Name of the command to execute")),
+                },
+                'commandType': {
+                    'anyOf': [
+                        {
+                            $ref: '#/definitions/commandNames'
+                        },
+                        {
+                            'type': 'string',
+                            'enum': this.removalCommandsEnum,
+                            'enumDescriptions': this.commandsEnumDescriptions,
+                            'description': ( nls.localize(
+                                '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': ( nls.localize('keybindings.json.key', "Key or key sequence (separated by space)")),
+                    },
+                    'command': {
+                        'anyOf': [
+                            {
+                                'if': {
+                                    'type': 'array'
+                                },
+                                'then': {
+                                    'not': {
+                                        'type': 'array'
+                                    },
+                                    'errorMessage': ( nls.localize(
+                                        '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': ( nls.localize('keybindings.json.when', "Condition when the key is active."))
+                    },
+                    'args': {
+                        'description': ( nls.localize('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(description);
+                    this.removalCommandsEnum.push(`-${commandId}`);
+                }
+            }
+        };
+        const allCommands = CommandsRegistry.getCommands();
+        for (const [commandId, command] of allCommands) {
+            const commandDescription = command.description;
+            addKnownCommand(commandId, commandDescription ? commandDescription.description : undefined);
+            if (!commandDescription || !commandDescription.args || commandDescription.args.length !== 1 || !commandDescription.args[0].schema) {
+                continue;
+            }
+            const argsSchema = commandDescription.args[0].schema;
+            const argsRequired = ((typeof commandDescription.args[0].isOptional !== 'undefined')
+                ? (!commandDescription.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);
+    }
+}
+KeybindingsJsonSchema.schemaId = 'vscode://schemas/keybindings';
+export { WorkbenchKeybindingService };