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

package/keybindings.js

@@ -1,14 +1,14 @@
 import { __decorate, __param } from './external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { WorkbenchKeybindingService } from 'vscode/vscode/vs/workbench/services/keybinding/browser/keybindingService';
+import { WorkbenchKeybindingService } from './vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
 import { IKeyboardLayoutService } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
-import { BrowserKeyboardLayoutService } from 'vscode/vscode/vs/workbench/services/keybinding/browser/keyboardLayoutService';
+import { BrowserKeyboardLayoutService } from './vscode/src/vs/workbench/services/keybinding/browser/keyboardLayoutService.js';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { CommandService } from 'vscode/vscode/vs/workbench/services/commands/common/commandService';
+import { CommandService } from './vscode/src/vs/workbench/services/commands/common/commandService.js';
 import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
@@ -25,9 +25,9 @@ import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/c
 import getServiceOverride$1, { initFile } from '@codingame/monaco-vscode-files-service-override';
 import { onRenderWorkbench } from 'vscode/lifecycle';
 import 'vscode/vscode/vs/workbench/browser/workbench.contribution';
-import 'vscode/vscode/vs/workbench/contrib/keybindings/browser/keybindings.contribution';
-import 'vscode/vscode/vs/workbench/contrib/preferences/browser/keybindingsEditorContribution';
-import 'vscode/vscode/vs/workbench/contrib/commands/common/commands.contribution';
+import './vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js';
+import './vscode/src/vs/workbench/contrib/preferences/browser/keybindingsEditorContribution.js';
+import './vscode/src/vs/workbench/contrib/commands/common/commands.contribution.js';
 import { getService } from 'vscode/services';
 
 const defaultUserKeybindindsFile = ( URI.from({ scheme: Schemas.vscodeUserData, path: '/User/keybindings.json' }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-keybindings-service-override",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,13 +18,13 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0",
-    "@codingame/monaco-vscode-files-service-override": "4.1.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "4.1.0",
-    "@codingame/monaco-vscode-extensions-service-override": "4.1.0",
-    "@codingame/monaco-vscode-environment-service-override": "4.1.0",
-    "@codingame/monaco-vscode-layout-service-override": "4.1.0",
-    "@codingame/monaco-vscode-host-service-override": "4.1.0",
-    "@codingame/monaco-vscode-base-service-override": "4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.1",
+    "@codingame/monaco-vscode-files-service-override": "4.1.1",
+    "@codingame/monaco-vscode-quickaccess-service-override": "4.1.1",
+    "@codingame/monaco-vscode-extensions-service-override": "4.1.1",
+    "@codingame/monaco-vscode-environment-service-override": "4.1.1",
+    "@codingame/monaco-vscode-layout-service-override": "4.1.1",
+    "@codingame/monaco-vscode-host-service-override": "4.1.1",
+    "@codingame/monaco-vscode-base-service-override": "4.1.1"
   }
 }

package/vscode/src/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -0,0 +1,50 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { OS } from 'vscode/vscode/vs/base/common/platform';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+
+function readKeyboardConfig(configurationService) {
+    const keyboard = configurationService.getValue('keyboard');
+    const dispatch = ((keyboard?.dispatch === 'keyCode' ? 1  : 0) );
+    const mapAltGrToCtrlAlt = Boolean(keyboard?.mapAltGrToCtrlAlt);
+    return { dispatch, mapAltGrToCtrlAlt };
+}
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const keyboardConfiguration = {
+    'id': 'keyboard',
+    'order': 15,
+    'type': 'object',
+    'title': ( localizeWithPath(
+        'vs/platform/keyboardLayout/common/keyboardConfig',
+        'keyboardConfigurationTitle',
+        "Keyboard"
+    )),
+    'properties': {
+        'keyboard.dispatch': {
+            scope: 1 ,
+            type: 'string',
+            enum: ['code', 'keyCode'],
+            default: 'code',
+            markdownDescription: ( localizeWithPath(
+                'vs/platform/keyboardLayout/common/keyboardConfig',
+                'dispatch',
+                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
+            )),
+            included: OS === 2  || OS === 3
+        },
+        'keyboard.mapAltGrToCtrlAlt': {
+            scope: 1 ,
+            type: 'boolean',
+            default: false,
+            markdownDescription: ( localizeWithPath(
+                'vs/platform/keyboardLayout/common/keyboardConfig',
+                'mapAltGrToCtrlAlt',
+                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
+            )),
+            included: OS === 1
+        }
+    }
+};
+configurationRegistry.registerConfiguration(keyboardConfiguration);
+
+export { readKeyboardConfig };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardMapper.js

@@ -0,0 +1,24 @@
+class CachedKeyboardMapper {
+    constructor(actual) {
+        this._actual = actual;
+        this._cache = ( new Map());
+    }
+    dumpDebugInfo() {
+        return this._actual.dumpDebugInfo();
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        return this._actual.resolveKeyboardEvent(keyboardEvent);
+    }
+    resolveKeybinding(keybinding) {
+        const hashCode = keybinding.getHashCode();
+        const resolved = this._cache.get(hashCode);
+        if (!resolved) {
+            const r = this._actual.resolveKeybinding(keybinding);
+            this._cache.set(hashCode, r);
+            return r;
+        }
+        return resolved;
+    }
+}
+
+export { CachedKeyboardMapper };

package/vscode/src/vs/workbench/contrib/commands/common/commands.contribution.js

@@ -0,0 +1,146 @@
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+
+class RunCommands extends Action2 {
+    constructor() {
+        super({
+            id: 'runCommands',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/commands/common/commands.contribution',
+                'runCommands',
+                "Run Commands"
+            )),
+            f1: false,
+            metadata: {
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/commands/common/commands.contribution',
+                    'runCommands.description',
+                    "Run several commands"
+                )),
+                args: [
+                    {
+                        name: 'args',
+                        schema: {
+                            type: 'object',
+                            required: ['commands'],
+                            properties: {
+                                commands: {
+                                    type: 'array',
+                                    description: ( localizeWithPath(
+                                        'vs/workbench/contrib/commands/common/commands.contribution',
+                                        'runCommands.commands',
+                                        "Commands to run"
+                                    )),
+                                    items: {
+                                        anyOf: [
+                                            {
+                                                $ref: 'vscode://schemas/keybindings#/definitions/commandNames'
+                                            },
+                                            {
+                                                type: 'string',
+                                            },
+                                            {
+                                                type: 'object',
+                                                required: ['command'],
+                                                properties: {
+                                                    command: {
+                                                        'anyOf': [
+                                                            {
+                                                                $ref: 'vscode://schemas/keybindings#/definitions/commandNames'
+                                                            },
+                                                            {
+                                                                type: 'string'
+                                                            },
+                                                        ]
+                                                    }
+                                                },
+                                                $ref: 'vscode://schemas/keybindings#/definitions/commandsSchemas'
+                                            }
+                                        ]
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+        });
+    }
+    async run(accessor, args) {
+        const notificationService = accessor.get(INotificationService);
+        if (!this._isCommandArgs(args)) {
+            notificationService.error(( localizeWithPath(
+                'vs/workbench/contrib/commands/common/commands.contribution',
+                'runCommands.invalidArgs',
+                "'runCommands' has received an argument with incorrect type. Please, review the argument passed to the command."
+            )));
+            return;
+        }
+        if (args.commands.length === 0) {
+            notificationService.warn(( localizeWithPath(
+                'vs/workbench/contrib/commands/common/commands.contribution',
+                'runCommands.noCommandsToRun',
+                "'runCommands' has not received commands to run. Did you forget to pass commands in the 'runCommands' argument?"
+            )));
+            return;
+        }
+        const commandService = accessor.get(ICommandService);
+        const logService = accessor.get(ILogService);
+        let i = 0;
+        try {
+            for (; i < args.commands.length; ++i) {
+                const cmd = args.commands[i];
+                logService.debug(`runCommands: executing ${i}-th command: ${JSON.stringify(cmd)}`);
+                const r = await this._runCommand(commandService, cmd);
+                logService.debug(`runCommands: executed ${i}-th command with return value: ${JSON.stringify(r)}`);
+            }
+        }
+        catch (err) {
+            logService.debug(`runCommands: executing ${i}-th command resulted in an error: ${err instanceof Error ? err.message : JSON.stringify(err)}`);
+            notificationService.error(err);
+        }
+    }
+    _isCommandArgs(args) {
+        if (!args || typeof args !== 'object') {
+            return false;
+        }
+        if (!('commands' in args) || !Array.isArray(args.commands)) {
+            return false;
+        }
+        for (const cmd of args.commands) {
+            if (typeof cmd === 'string') {
+                continue;
+            }
+            if (typeof cmd === 'object' && typeof cmd.command === 'string') {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    _runCommand(commandService, cmd) {
+        let commandID, commandArgs;
+        if (typeof cmd === 'string') {
+            commandID = cmd;
+        }
+        else {
+            commandID = cmd.command;
+            commandArgs = cmd.args;
+        }
+        if (commandArgs === undefined) {
+            return commandService.executeCommand(commandID);
+        }
+        else {
+            if (Array.isArray(commandArgs)) {
+                return commandService.executeCommand(commandID, ...commandArgs);
+            }
+            else {
+                return commandService.executeCommand(commandID, commandArgs);
+            }
+        }
+    }
+}
+registerAction2(RunCommands);

package/vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js

@@ -0,0 +1,29 @@
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { showWindowLogActionId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
+
+class ToggleKeybindingsLogAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleKeybindingsLog',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/keybindings/browser/keybindings.contribution',
+                'toggleKeybindingsLog',
+                "Toggle Keyboard Shortcuts Troubleshooting"
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const logging = accessor.get(IKeybindingService).toggleLogging();
+        if (logging) {
+            const commandService = accessor.get(ICommandService);
+            commandService.executeCommand(showWindowLogActionId);
+        }
+    }
+}
+registerAction2(ToggleKeybindingsLogAction);

package/vscode/src/vs/workbench/contrib/preferences/browser/keybindingsEditorContribution.js

@@ -0,0 +1,250 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { SnippetController2 } from 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+import { SmartSnippetInserter } from '../common/smartSnippetInserter.js';
+import { DefineKeybindingOverlayWidget } from 'vscode/vscode/vs/workbench/contrib/preferences/browser/keybindingWidgets';
+import { parseTree } from 'vscode/vscode/vs/base/common/json';
+import { WindowsNativeResolvedKeybinding } from '../../../services/keybinding/common/windowsKeyboardMapper.js';
+import { themeColorFromId } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { overviewRulerError, overviewRulerInfo } from 'vscode/vscode/vs/editor/common/core/editorColorRegistry';
+import { OverviewRulerLane } from 'vscode/vscode/vs/editor/common/model';
+import { KeybindingParser } from 'vscode/vscode/vs/base/common/keybindingParser';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { DEFINE_KEYBINDING_EDITOR_CONTRIB_ID } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+
+var KeybindingEditorDecorationsRenderer_1;
+const NLS_KB_LAYOUT_ERROR_MESSAGE = ( localizeWithPath(
+    'vs/workbench/contrib/preferences/browser/keybindingsEditorContribution',
+    'defineKeybinding.kbLayoutErrorMessage',
+    "You won't be able to produce this key combination under your current keyboard layout."
+));
+let DefineKeybindingEditorContribution = class DefineKeybindingEditorContribution extends Disposable {
+    constructor(_editor, _instantiationService, _userDataProfileService) {
+        super();
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._userDataProfileService = _userDataProfileService;
+        this._keybindingDecorationRenderer = this._register(( new MutableDisposable()));
+        this._defineWidget = this._register(this._instantiationService.createInstance(DefineKeybindingOverlayWidget, this._editor));
+        this._register(this._editor.onDidChangeModel(e => this._update()));
+        this._update();
+    }
+    _update() {
+        this._keybindingDecorationRenderer.value = isInterestingEditorModel(this._editor, this._userDataProfileService)
+            ? this._instantiationService.createInstance(KeybindingEditorDecorationsRenderer, this._editor)
+            : undefined;
+    }
+    showDefineKeybindingWidget() {
+        if (isInterestingEditorModel(this._editor, this._userDataProfileService)) {
+            this._defineWidget.start().then(keybinding => this._onAccepted(keybinding));
+        }
+    }
+    _onAccepted(keybinding) {
+        this._editor.focus();
+        if (keybinding && this._editor.hasModel()) {
+            const regexp = ( new RegExp(/\\/g));
+            const backslash = regexp.test(keybinding);
+            if (backslash) {
+                keybinding = keybinding.slice(0, -1) + '\\\\';
+            }
+            let snippetText = [
+                '{',
+                '\t"key": ' + JSON.stringify(keybinding) + ',',
+                '\t"command": "${1:commandId}",',
+                '\t"when": "${2:editorTextFocus}"',
+                '}$0'
+            ].join('\n');
+            const smartInsertInfo = SmartSnippetInserter.insertSnippet(this._editor.getModel(), this._editor.getPosition());
+            snippetText = smartInsertInfo.prepend + snippetText + smartInsertInfo.append;
+            this._editor.setPosition(smartInsertInfo.position);
+            SnippetController2.get(this._editor)?.insert(snippetText, { overwriteBefore: 0, overwriteAfter: 0 });
+        }
+    }
+};
+DefineKeybindingEditorContribution = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IUserDataProfileService))
+], DefineKeybindingEditorContribution));
+let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = class KeybindingEditorDecorationsRenderer extends Disposable {
+    constructor(_editor, _keybindingService) {
+        super();
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this._dec = this._editor.createDecorationsCollection();
+        this._updateDecorations = this._register(( new RunOnceScheduler(() => this._updateDecorationsNow(), 500)));
+        const model = assertIsDefined(this._editor.getModel());
+        this._register(model.onDidChangeContent(() => this._updateDecorations.schedule()));
+        this._register(this._keybindingService.onDidUpdateKeybindings(() => this._updateDecorations.schedule()));
+        this._register({
+            dispose: () => {
+                this._dec.clear();
+                this._updateDecorations.cancel();
+            }
+        });
+        this._updateDecorations.schedule();
+    }
+    _updateDecorationsNow() {
+        const model = assertIsDefined(this._editor.getModel());
+        const newDecorations = [];
+        const root = parseTree(model.getValue());
+        if (root && Array.isArray(root.children)) {
+            for (let i = 0, len = root.children.length; i < len; i++) {
+                const entry = root.children[i];
+                const dec = this._getDecorationForEntry(model, entry);
+                if (dec !== null) {
+                    newDecorations.push(dec);
+                }
+            }
+        }
+        this._dec.set(newDecorations);
+    }
+    _getDecorationForEntry(model, entry) {
+        if (!Array.isArray(entry.children)) {
+            return null;
+        }
+        for (let i = 0, len = entry.children.length; i < len; i++) {
+            const prop = entry.children[i];
+            if (prop.type !== 'property') {
+                continue;
+            }
+            if (!Array.isArray(prop.children) || prop.children.length !== 2) {
+                continue;
+            }
+            const key = prop.children[0];
+            if (key.value !== 'key') {
+                continue;
+            }
+            const value = prop.children[1];
+            if (value.type !== 'string') {
+                continue;
+            }
+            const resolvedKeybindings = this._keybindingService.resolveUserBinding(value.value);
+            if (resolvedKeybindings.length === 0) {
+                return this._createDecoration(true, null, null, model, value);
+            }
+            const resolvedKeybinding = resolvedKeybindings[0];
+            let usLabel = null;
+            if (resolvedKeybinding instanceof WindowsNativeResolvedKeybinding) {
+                usLabel = resolvedKeybinding.getUSLabel();
+            }
+            if (!resolvedKeybinding.isWYSIWYG()) {
+                const uiLabel = resolvedKeybinding.getLabel();
+                if (typeof uiLabel === 'string' && value.value.toLowerCase() === uiLabel.toLowerCase()) {
+                    return null;
+                }
+                return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
+            }
+            if (/abnt_|oem_/.test(value.value)) {
+                return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
+            }
+            const expectedUserSettingsLabel = resolvedKeybinding.getUserSettingsLabel();
+            if (typeof expectedUserSettingsLabel === 'string' && !KeybindingEditorDecorationsRenderer_1._userSettingsFuzzyEquals(value.value, expectedUserSettingsLabel)) {
+                return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
+            }
+            return null;
+        }
+        return null;
+    }
+    static _userSettingsFuzzyEquals(a, b) {
+        a = a.trim().toLowerCase();
+        b = b.trim().toLowerCase();
+        if (a === b) {
+            return true;
+        }
+        const aKeybinding = KeybindingParser.parseKeybinding(a);
+        const bKeybinding = KeybindingParser.parseKeybinding(b);
+        if (aKeybinding === null && bKeybinding === null) {
+            return true;
+        }
+        if (!aKeybinding || !bKeybinding) {
+            return false;
+        }
+        return aKeybinding.equals(bKeybinding);
+    }
+    _createDecoration(isError, uiLabel, usLabel, model, keyNode) {
+        let msg;
+        let className;
+        let overviewRulerColor;
+        if (isError) {
+            msg = ( new MarkdownString()).appendText(NLS_KB_LAYOUT_ERROR_MESSAGE);
+            className = 'keybindingError';
+            overviewRulerColor = themeColorFromId(overviewRulerError);
+        }
+        else {
+            if (usLabel && uiLabel !== usLabel) {
+                msg = ( new MarkdownString(( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keybindingsEditorContribution',
+                    {
+                        key: 'defineKeybinding.kbLayoutLocalAndUSMessage',
+                        comment: [
+                            'Please translate maintaining the stars (*) around the placeholders such that they will be rendered in bold.',
+                            'The placeholders will contain a keyboard combination e.g. Ctrl+Shift+/'
+                        ]
+                    },
+                    "**{0}** for your current keyboard layout (**{1}** for US standard).",
+                    uiLabel,
+                    usLabel
+                ))));
+            }
+            else {
+                msg = ( new MarkdownString(( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keybindingsEditorContribution',
+                    {
+                        key: 'defineKeybinding.kbLayoutLocalMessage',
+                        comment: [
+                            'Please translate maintaining the stars (*) around the placeholder such that it will be rendered in bold.',
+                            'The placeholder will contain a keyboard combination e.g. Ctrl+Shift+/'
+                        ]
+                    },
+                    "**{0}** for your current keyboard layout.",
+                    uiLabel
+                ))));
+            }
+            className = 'keybindingInfo';
+            overviewRulerColor = themeColorFromId(overviewRulerInfo);
+        }
+        const startPosition = model.getPositionAt(keyNode.offset);
+        const endPosition = model.getPositionAt(keyNode.offset + keyNode.length);
+        const range = ( new Range(
+            startPosition.lineNumber,
+            startPosition.column,
+            endPosition.lineNumber,
+            endPosition.column
+        ));
+        return {
+            range: range,
+            options: {
+                description: 'keybindings-widget',
+                stickiness: 1 ,
+                className: className,
+                hoverMessage: msg,
+                overviewRuler: {
+                    color: overviewRulerColor,
+                    position: OverviewRulerLane.Right
+                }
+            }
+        };
+    }
+};
+KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = ( __decorate([
+    ( __param(1, IKeybindingService))
+], KeybindingEditorDecorationsRenderer));
+function isInterestingEditorModel(editor, userDataProfileService) {
+    const model = editor.getModel();
+    if (!model) {
+        return false;
+    }
+    return isEqual(model.uri, userDataProfileService.currentProfile.keybindingsResource);
+}
+registerEditorContribution(DEFINE_KEYBINDING_EDITOR_CONTRIB_ID, DefineKeybindingEditorContribution, 1 );
+
+export { KeybindingEditorDecorationsRenderer };