@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/preferences/browser/preferences.contribution.js

@@ -0,0 +1,1154 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import './media/preferences.css.js';
+import { registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { Context } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId, 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 } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { InputFocusedContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { PICK_WORKSPACE_FOLDER_COMMAND_ID } from '../../../browser/actions/workspaceCommands.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { Extensions } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { WorkbenchStateContext, ResourceContextKey } from '../../../common/contextkeys.js';
+import { ExplorerRootContext, ExplorerFolderContext } from '../../files/common/files.js';
+import { KeybindingsEditor } from './keybindingsEditor.js';
+import { ConfigureLanguageBasedSettingsAction } from './preferencesActions.js';
+import { SettingsEditorContribution } from './preferencesEditor.js';
+import { preferencesOpenSettingsIcon } from './preferencesIcons.js';
+import { SettingsEditor2 } from './settingsEditor2.js';
+import { CONTEXT_SETTINGS_EDITOR, SETTINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS, CONTEXT_SETTINGS_SEARCH_FOCUS, CONTEXT_TOC_ROW_FOCUS, CONTEXT_SETTINGS_ROW_FOCUS, SETTINGS_EDITOR_COMMAND_SHOW_CONTEXT_MENU, CONTEXT_SETTINGS_JSON_EDITOR, CONTEXT_KEYBINDINGS_EDITOR, KEYBINDINGS_EDITOR_SHOW_DEFAULT_KEYBINDINGS, KEYBINDINGS_EDITOR_SHOW_EXTENSION_KEYBINDINGS, KEYBINDINGS_EDITOR_SHOW_USER_KEYBINDINGS, KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS, CONTEXT_KEYBINDINGS_SEARCH_FOCUS, KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_HISTORY, KEYBINDINGS_EDITOR_COMMAND_DEFINE, CONTEXT_KEYBINDING_FOCUS, CONTEXT_WHEN_FOCUS, KEYBINDINGS_EDITOR_COMMAND_ADD, KEYBINDINGS_EDITOR_COMMAND_DEFINE_WHEN, KEYBINDINGS_EDITOR_COMMAND_REMOVE, KEYBINDINGS_EDITOR_COMMAND_RESET, KEYBINDINGS_EDITOR_COMMAND_SEARCH, KEYBINDINGS_EDITOR_COMMAND_RECORD_SEARCH_KEYS, KEYBINDINGS_EDITOR_COMMAND_SORTBY_PRECEDENCE, KEYBINDINGS_EDITOR_COMMAND_SHOW_SIMILAR, KEYBINDINGS_EDITOR_COMMAND_COPY, KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND, KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND_TITLE, KEYBINDINGS_EDITOR_COMMAND_FOCUS_KEYBINDINGS, KEYBINDINGS_EDITOR_COMMAND_REJECT_WHEN, KEYBINDINGS_EDITOR_COMMAND_ACCEPT_WHEN, CONTEXT_SETTINGS_EDITOR_IN_USER_TAB } from '../common/preferences.js';
+import { PreferencesContribution } from '../common/preferencesContribution.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { KeybindingsEditorInput } from '../../../services/preferences/browser/keybindingsEditorInput.js';
+import { IPreferencesService, DEFINE_KEYBINDING_EDITOR_CONTRIB_ID } from '../../../services/preferences/common/preferences.js';
+import { SettingsEditor2Input } from '../../../services/preferences/common/preferencesEditorInput.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+const SETTINGS_EDITOR_COMMAND_SEARCH = 'settings.action.search';
+const SETTINGS_EDITOR_COMMAND_FOCUS_FILE = 'settings.action.focusSettingsFile';
+const SETTINGS_EDITOR_COMMAND_FOCUS_SETTINGS_FROM_SEARCH = 'settings.action.focusSettingsFromSearch';
+const SETTINGS_EDITOR_COMMAND_FOCUS_SETTINGS_LIST = 'settings.action.focusSettingsList';
+const SETTINGS_EDITOR_COMMAND_FOCUS_TOC = 'settings.action.focusTOC';
+const SETTINGS_EDITOR_COMMAND_FOCUS_CONTROL = 'settings.action.focusSettingControl';
+const SETTINGS_EDITOR_COMMAND_FOCUS_UP = 'settings.action.focusLevelUp';
+const SETTINGS_EDITOR_COMMAND_SWITCH_TO_JSON = 'settings.switchToJSON';
+const SETTINGS_EDITOR_COMMAND_SWITCH_TO_APPLICATION_JSON = 'settings.switchToApplicationJSON';
+const SETTINGS_EDITOR_COMMAND_SWITCH_TO_CURRENT_PROFILE_JSON = 'settings.switchToCurrentProfileJSON';
+const SETTINGS_EDITOR_COMMAND_FILTER_ONLINE = 'settings.filterByOnline';
+const SETTINGS_COMMAND_OPEN_SETTINGS = 'workbench.action.openSettings';
+const SETTINGS_COMMAND_FILTER_TELEMETRY = 'settings.filterByTelemetry';
+( (Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(SettingsEditor2, SettingsEditor2.ID, ( (nls.localize('settingsEditor2', "Settings Editor 2")))), [
+    ( (new SyncDescriptor(SettingsEditor2Input)))
+]);
+( (Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(KeybindingsEditor, KeybindingsEditor.ID, ( (nls.localize('keybindingsEditor', "Keybindings Editor")))), [
+    ( (new SyncDescriptor(KeybindingsEditorInput)))
+]);
+const OPEN_USER_SETTINGS_UI_TITLE = { value: ( (nls.localize('openSettings2', "Open Settings (UI)"))), original: 'Open Settings (UI)' };
+const OPEN_USER_SETTINGS_JSON_TITLE = { value: ( (nls.localize('openUserSettingsJson', "Open User Settings (JSON)"))), original: 'Open User Settings (JSON)' };
+const OPEN_CURRENT_PROFILE_SETTINGS_JSON_TITLE = { value: ( (nls.localize('openCurrentProfileSettingsJson', "Open Current Profile Settings (JSON)"))), original: 'Open Current Profile Settings (JSON)' };
+const category = { value: ( (nls.localize('preferences', "Preferences"))), original: 'Preferences' };
+function sanitizeOpenSettingsArgs(args) {
+    if (!isObject(args)) {
+        args = {};
+    }
+    return {
+        openToSide: args.openToSide,
+        query: args.query
+    };
+}
+let PreferencesActionsContribution = class PreferencesActionsContribution extends Disposable {
+    constructor(environmentService, userDataProfileService, preferencesService, workspaceContextService, labelService, extensionService, userDataProfilesService) {
+        super();
+        this.environmentService = environmentService;
+        this.userDataProfileService = userDataProfileService;
+        this.preferencesService = preferencesService;
+        this.workspaceContextService = workspaceContextService;
+        this.labelService = labelService;
+        this.extensionService = extensionService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.registerSettingsActions();
+        this.registerKeybindingsActions();
+        this.updatePreferencesEditorMenuItem();
+        this._register(workspaceContextService.onDidChangeWorkbenchState(() => this.updatePreferencesEditorMenuItem()));
+        this._register(workspaceContextService.onDidChangeWorkspaceFolders(() => this.updatePreferencesEditorMenuItemForWorkspaceFolders()));
+    }
+    registerSettingsActions() {
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_COMMAND_OPEN_SETTINGS,
+                    title: ( (nls.localize('settings', "Settings"))),
+                    keybinding: {
+                        weight: 200 ,
+                        when: null,
+                        primary: 2048  | 87 ,
+                    },
+                    menu: {
+                        id: MenuId.GlobalActivity,
+                        group: '2_configuration',
+                        order: 1
+                    }
+                });
+            }
+            run(accessor, args) {
+                const opts = typeof args === 'string' ? { query: args } : sanitizeOpenSettingsArgs(args);
+                return accessor.get(IPreferencesService).openSettings(opts);
+            }
+        });
+        MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+            command: {
+                id: SETTINGS_COMMAND_OPEN_SETTINGS,
+                title: ( (nls.localize(
+                    { key: 'miOpenSettings', comment: ['&& denotes a mnemonic'] },
+                    "&&Settings"
+                )))
+            },
+            group: '2_configuration',
+            order: 1
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openSettings2',
+                    title: { value: ( (nls.localize('openSettings2', "Open Settings (UI)"))), original: 'Open Settings (UI)' },
+                    category,
+                    f1: true,
+                });
+            }
+            run(accessor, args) {
+                args = sanitizeOpenSettingsArgs(args);
+                return accessor.get(IPreferencesService).openSettings({ jsonEditor: false, ...args });
+            }
+        });
+        const that = this;
+        const registerOpenSettingsJsonCommandDisposable = this._register(( (new MutableDisposable())));
+        const registerOpenSettingsJsonCommand = () => {
+            registerOpenSettingsJsonCommandDisposable.value = registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: 'workbench.action.openSettingsJson',
+                        title: that.userDataProfileService.currentProfile.isDefault ? OPEN_USER_SETTINGS_JSON_TITLE : OPEN_CURRENT_PROFILE_SETTINGS_JSON_TITLE,
+                        category,
+                        f1: true,
+                    });
+                }
+                run(accessor, args) {
+                    args = sanitizeOpenSettingsArgs(args);
+                    return accessor.get(IPreferencesService).openSettings({ jsonEditor: true, ...args });
+                }
+            });
+        };
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openGlobalSettings',
+                    title: { value: ( (nls.localize('openGlobalSettings', "Open User Settings"))), original: 'Open User Settings' },
+                    category,
+                    f1: true,
+                });
+            }
+            run(accessor, args) {
+                args = sanitizeOpenSettingsArgs(args);
+                return accessor.get(IPreferencesService).openUserSettings(args);
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openRawDefaultSettings',
+                    title: { value: ( (nls.localize('openRawDefaultSettings', "Open Default Settings (JSON)"))), original: 'Open Default Settings (JSON)' },
+                    category,
+                    f1: true,
+                });
+            }
+            run(accessor) {
+                return accessor.get(IPreferencesService).openRawDefaultSettings();
+            }
+        });
+        const registerOpenUserSettingsEditorFromJsonActionDisposable = this._register(( (new MutableDisposable())));
+        const registerOpenUserSettingsEditorFromJsonAction = () => {
+            let when = ( (ContextKeyExpr.and( (ResourceContextKey.Resource.isEqualTo(
+                 (this.userDataProfileService.currentProfile.settingsResource.toString())
+            )), ContextKeyExpr.not('isInDiffEditor'))));
+            if (!this.userDataProfileService.currentProfile.isDefault) {
+                when = ( (ContextKeyExpr.or(
+                    when,
+                     (ContextKeyExpr.and( (ResourceContextKey.Resource.isEqualTo(
+                         (this.userDataProfilesService.defaultProfile.settingsResource.toString())
+                    )), ContextKeyExpr.not('isInDiffEditor')))
+                )));
+            }
+            registerOpenUserSettingsEditorFromJsonActionDisposable.value = registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: '_workbench.openUserSettingsEditor',
+                        title: OPEN_USER_SETTINGS_UI_TITLE,
+                        icon: preferencesOpenSettingsIcon,
+                        menu: [{
+                                id: MenuId.EditorTitle,
+                                when,
+                                group: 'navigation',
+                                order: 1
+                            }]
+                    });
+                }
+                run(accessor, args) {
+                    args = sanitizeOpenSettingsArgs(args);
+                    return accessor.get(IPreferencesService).openUserSettings({ jsonEditor: false, ...args });
+                }
+            });
+        };
+        const openJsonFromSettingsEditorDisposableStore = this._register(( (new DisposableStore())));
+        const registerOpenJsonFromSettingsEditorAction = () => {
+            openJsonFromSettingsEditorDisposableStore.clear();
+            if (!this.userDataProfileService.currentProfile.isDefault) {
+                const submenuId = MenuId.for('PreferencesSubMenu');
+                openJsonFromSettingsEditorDisposableStore.add(registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: SETTINGS_EDITOR_COMMAND_SWITCH_TO_CURRENT_PROFILE_JSON,
+                            title: OPEN_CURRENT_PROFILE_SETTINGS_JSON_TITLE,
+                            menu: [{ id: submenuId, order: 1 }]
+                        });
+                    }
+                    run(accessor) {
+                        const editorPane = accessor.get(IEditorService).activeEditorPane;
+                        if (editorPane instanceof SettingsEditor2) {
+                            return editorPane.switchToSettingsFile();
+                        }
+                        return null;
+                    }
+                }));
+                openJsonFromSettingsEditorDisposableStore.add(registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: SETTINGS_EDITOR_COMMAND_SWITCH_TO_APPLICATION_JSON,
+                            title: OPEN_USER_SETTINGS_JSON_TITLE,
+                            menu: [{ id: submenuId, order: 2 }]
+                        });
+                    }
+                    run(accessor) {
+                        const editorPane = accessor.get(IEditorService).activeEditorPane;
+                        if (editorPane instanceof SettingsEditor2) {
+                            return editorPane.switchToApplicationSettingsFile();
+                        }
+                        return null;
+                    }
+                }));
+                openJsonFromSettingsEditorDisposableStore.add(MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+                    title: { value: ( (nls.localize('openSettingsJson', "Open Settings (JSON)"))), original: 'Open Settings (JSON)' },
+                    submenu: submenuId,
+                    icon: preferencesOpenSettingsIcon,
+                    when: ( (ContextKeyExpr.and(
+                        CONTEXT_SETTINGS_EDITOR,
+                        CONTEXT_SETTINGS_EDITOR_IN_USER_TAB,
+                         (CONTEXT_SETTINGS_JSON_EDITOR.toNegated())
+                    ))),
+                    group: 'navigation',
+                    order: 1
+                }));
+            }
+            let openSettingsJsonWhen = ( (ContextKeyExpr.and(
+                CONTEXT_SETTINGS_EDITOR,
+                 (CONTEXT_SETTINGS_JSON_EDITOR.toNegated())
+            )));
+            if (!this.userDataProfileService.currentProfile.isDefault) {
+                openSettingsJsonWhen = ( (ContextKeyExpr.and(
+                    openSettingsJsonWhen,
+                     (CONTEXT_SETTINGS_EDITOR_IN_USER_TAB.toNegated())
+                )));
+            }
+            openJsonFromSettingsEditorDisposableStore.add(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: SETTINGS_EDITOR_COMMAND_SWITCH_TO_JSON,
+                        title: { value: ( (nls.localize('openSettingsJson', "Open Settings (JSON)"))), original: 'Open Settings (JSON)' },
+                        icon: preferencesOpenSettingsIcon,
+                        menu: [{
+                                id: MenuId.EditorTitle,
+                                when: openSettingsJsonWhen,
+                                group: 'navigation',
+                                order: 1
+                            }]
+                    });
+                }
+                run(accessor) {
+                    const editorPane = accessor.get(IEditorService).activeEditorPane;
+                    if (editorPane instanceof SettingsEditor2) {
+                        return editorPane.switchToSettingsFile();
+                    }
+                    return null;
+                }
+            }));
+        };
+        registerOpenUserSettingsEditorFromJsonAction();
+        registerOpenJsonFromSettingsEditorAction();
+        registerOpenSettingsJsonCommand();
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => {
+            registerOpenUserSettingsEditorFromJsonAction();
+            registerOpenJsonFromSettingsEditorAction();
+            registerOpenSettingsJsonCommand();
+        }));
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: ConfigureLanguageBasedSettingsAction.ID,
+                    title: ConfigureLanguageBasedSettingsAction.LABEL,
+                    category,
+                    f1: true,
+                });
+            }
+            run(accessor) {
+                return accessor.get(IInstantiationService).createInstance(ConfigureLanguageBasedSettingsAction, ConfigureLanguageBasedSettingsAction.ID, ConfigureLanguageBasedSettingsAction.LABEL.value).run();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openAccessibilitySettings',
+                    title: { value: ( (nls.localize('openAccessibilitySettings', "Open Accessibility Settings"))), original: 'Open Accessibility Settings' },
+                    category,
+                    menu: {
+                        id: MenuId.CommandPalette,
+                        when: ( (WorkbenchStateContext.notEqualsTo('empty')))
+                    }
+                });
+            }
+            async run(accessor) {
+                await accessor.get(IPreferencesService).openSettings({ jsonEditor: false, query: '@tag:accessibility' });
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openFolderSettings',
+                    title: { value: ( (nls.localize('openFolderSettings', "Open Folder Settings"))), original: 'Open Folder Settings' },
+                    category,
+                    menu: {
+                        id: MenuId.CommandPalette,
+                        when: ( (WorkbenchStateContext.isEqualTo('workspace')))
+                    }
+                });
+            }
+            async run(accessor, args) {
+                const commandService = accessor.get(ICommandService);
+                const preferencesService = accessor.get(IPreferencesService);
+                const workspaceFolder = await commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID);
+                if (workspaceFolder) {
+                    args = sanitizeOpenSettingsArgs(args);
+                    await preferencesService.openFolderSettings({ folderUri: workspaceFolder.uri, ...args });
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openFolderSettingsFile',
+                    title: { value: ( (nls.localize('openFolderSettingsFile', "Open Folder Settings (JSON)"))), original: 'Open Folder Settings (JSON)' },
+                    category,
+                    menu: {
+                        id: MenuId.CommandPalette,
+                        when: ( (WorkbenchStateContext.isEqualTo('workspace')))
+                    }
+                });
+            }
+            async run(accessor, args) {
+                const commandService = accessor.get(ICommandService);
+                const preferencesService = accessor.get(IPreferencesService);
+                const workspaceFolder = await commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID);
+                if (workspaceFolder) {
+                    args = sanitizeOpenSettingsArgs(args);
+                    await preferencesService.openFolderSettings({ folderUri: workspaceFolder.uri, jsonEditor: true, ...args });
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: '_workbench.action.openFolderSettings',
+                    title: { value: ( (nls.localize('openFolderSettings', "Open Folder Settings"))), original: 'Open Folder Settings' },
+                    category,
+                    menu: {
+                        id: MenuId.ExplorerContext,
+                        group: '2_workspace',
+                        order: 20,
+                        when: ( (ContextKeyExpr.and(ExplorerRootContext, ExplorerFolderContext)))
+                    }
+                });
+            }
+            run(accessor, resource) {
+                return accessor.get(IPreferencesService).openFolderSettings({ folderUri: resource });
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FILTER_ONLINE,
+                    title: ( (nls.localize(
+                        { key: 'miOpenOnlineSettings', comment: ['&& denotes a mnemonic'] },
+                        "&&Online Services Settings"
+                    ))),
+                    menu: {
+                        id: MenuId.MenubarPreferencesMenu,
+                        group: '3_settings',
+                        order: 1,
+                    }
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof SettingsEditor2) {
+                    editorPane.focusSearch(`@tag:usesOnlineServices`);
+                }
+                else {
+                    accessor.get(IPreferencesService).openSettings({ jsonEditor: false, query: '@tag:usesOnlineServices' });
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_COMMAND_FILTER_TELEMETRY,
+                    title: ( (nls.localize(
+                        { key: 'miOpenTelemetrySettings', comment: ['&& denotes a mnemonic'] },
+                        "&&Telemetry Settings"
+                    )))
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof SettingsEditor2) {
+                    editorPane.focusSearch(`@tag:telemetry`);
+                }
+                else {
+                    accessor.get(IPreferencesService).openSettings({ jsonEditor: false, query: '@tag:telemetry' });
+                }
+            }
+        });
+        this.registerSettingsEditorActions();
+        this.extensionService.whenInstalledExtensionsRegistered()
+            .then(() => {
+            const remoteAuthority = this.environmentService.remoteAuthority;
+            this.labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority) || remoteAuthority;
+        });
+    }
+    registerSettingsEditorActions() {
+        function getPreferencesEditor(accessor) {
+            const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+            if (activeEditorPane instanceof SettingsEditor2) {
+                return activeEditorPane;
+            }
+            return null;
+        }
+        function settingsEditorFocusSearch(accessor) {
+            const preferencesEditor = getPreferencesEditor(accessor);
+            preferencesEditor?.focusSearch();
+        }
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_SEARCH,
+                    precondition: CONTEXT_SETTINGS_EDITOR,
+                    keybinding: {
+                        primary: 2048  | 36 ,
+                        weight: 100 ,
+                        when: null
+                    },
+                    category,
+                    f1: true,
+                    title: { value: ( (nls.localize('settings.focusSearch', "Focus Settings Search"))), original: 'Focus Settings Search' }
+                });
+            }
+            run(accessor) { settingsEditorFocusSearch(accessor); }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS,
+                    precondition: CONTEXT_SETTINGS_EDITOR,
+                    keybinding: {
+                        primary: 9 ,
+                        weight: 100 ,
+                        when: CONTEXT_SETTINGS_SEARCH_FOCUS
+                    },
+                    category,
+                    f1: true,
+                    title: { value: ( (nls.localize('settings.clearResults', "Clear Settings Search Results"))), original: 'Clear Settings Search Results' }
+                });
+            }
+            run(accessor) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                preferencesEditor?.clearSearchResults();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FOCUS_FILE,
+                    precondition: ( (ContextKeyExpr.and(CONTEXT_SETTINGS_SEARCH_FOCUS,  (Context.Visible.toNegated())))),
+                    keybinding: {
+                        primary: 18 ,
+                        weight: 100 ,
+                        when: null
+                    },
+                    title: ( (nls.localize('settings.focusFile', "Focus settings file")))
+                });
+            }
+            run(accessor, args) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                preferencesEditor?.focusSettings();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FOCUS_SETTINGS_FROM_SEARCH,
+                    precondition: ( (ContextKeyExpr.and(CONTEXT_SETTINGS_SEARCH_FOCUS,  (Context.Visible.toNegated())))),
+                    keybinding: {
+                        primary: 18 ,
+                        weight: 200 ,
+                        when: null
+                    },
+                    title: ( (nls.localize('settings.focusFile', "Focus settings file")))
+                });
+            }
+            run(accessor, args) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                preferencesEditor?.focusSettings();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FOCUS_SETTINGS_LIST,
+                    precondition: ( (ContextKeyExpr.and(CONTEXT_SETTINGS_EDITOR, CONTEXT_TOC_ROW_FOCUS))),
+                    keybinding: {
+                        primary: 3 ,
+                        weight: 200 ,
+                        when: null
+                    },
+                    title: ( (nls.localize('settings.focusSettingsList', "Focus settings list")))
+                });
+            }
+            run(accessor) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                if (preferencesEditor instanceof SettingsEditor2) {
+                    preferencesEditor.focusSettings();
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FOCUS_TOC,
+                    precondition: CONTEXT_SETTINGS_EDITOR,
+                    f1: true,
+                    keybinding: [
+                        {
+                            primary: 15 ,
+                            weight: 200 ,
+                            when: CONTEXT_SETTINGS_ROW_FOCUS
+                        }
+                    ],
+                    category,
+                    title: { value: ( (nls.localize('settings.focusSettingsTOC', "Focus Settings Table of Contents"))), original: 'Focus Settings Table of Contents' }
+                });
+            }
+            run(accessor) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                if (!(preferencesEditor instanceof SettingsEditor2)) {
+                    return;
+                }
+                preferencesEditor.focusTOC();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FOCUS_CONTROL,
+                    precondition: ( (ContextKeyExpr.and(CONTEXT_SETTINGS_EDITOR, CONTEXT_SETTINGS_ROW_FOCUS))),
+                    keybinding: {
+                        primary: 3 ,
+                        weight: 200 ,
+                    },
+                    title: ( (nls.localize('settings.focusSettingControl', "Focus Setting Control")))
+                });
+            }
+            run(accessor) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                if (!(preferencesEditor instanceof SettingsEditor2)) {
+                    return;
+                }
+                if (document.activeElement?.classList.contains('monaco-list')) {
+                    preferencesEditor.focusSettings(true);
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_SHOW_CONTEXT_MENU,
+                    precondition: CONTEXT_SETTINGS_EDITOR,
+                    keybinding: {
+                        primary: 1024  | 67 ,
+                        weight: 200 ,
+                        when: null
+                    },
+                    f1: true,
+                    category,
+                    title: { value: ( (nls.localize('settings.showContextMenu', "Show Setting Context Menu"))), original: 'Show Setting Context Menu' }
+                });
+            }
+            run(accessor) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                if (preferencesEditor instanceof SettingsEditor2) {
+                    preferencesEditor.showContextMenu();
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_FOCUS_UP,
+                    precondition: ( (ContextKeyExpr.and(
+                        CONTEXT_SETTINGS_EDITOR,
+                         (CONTEXT_SETTINGS_SEARCH_FOCUS.toNegated()),
+                         (CONTEXT_SETTINGS_JSON_EDITOR.toNegated())
+                    ))),
+                    keybinding: {
+                        primary: 9 ,
+                        weight: 200 ,
+                        when: null
+                    },
+                    f1: true,
+                    category,
+                    title: { value: ( (nls.localize('settings.focusLevelUp', "Move Focus Up One Level"))), original: 'Move Focus Up One Level' }
+                });
+            }
+            run(accessor) {
+                const preferencesEditor = getPreferencesEditor(accessor);
+                if (!(preferencesEditor instanceof SettingsEditor2)) {
+                    return;
+                }
+                if (preferencesEditor.currentFocusContext === 3 ) {
+                    preferencesEditor.focusSettings();
+                }
+                else if (preferencesEditor.currentFocusContext === 2 ) {
+                    preferencesEditor.focusTOC();
+                }
+                else if (preferencesEditor.currentFocusContext === 1 ) {
+                    preferencesEditor.focusSearch();
+                }
+            }
+        });
+    }
+    registerKeybindingsActions() {
+        const that = this;
+        const category = { value: ( (nls.localize('preferences', "Preferences"))), original: 'Preferences' };
+        const registerOpenGlobalKeybindingsActionDisposable = this._register(( (new MutableDisposable())));
+        const registerOpenGlobalKeybindingsAction = () => {
+            registerOpenGlobalKeybindingsActionDisposable.value = registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: 'workbench.action.openGlobalKeybindings',
+                        title: { value: ( (nls.localize('openGlobalKeybindings', "Open Keyboard Shortcuts"))), original: 'Open Keyboard Shortcuts' },
+                        category,
+                        icon: preferencesOpenSettingsIcon,
+                        keybinding: {
+                            when: null,
+                            weight: 200 ,
+                            primary: KeyChord(2048  | 41 , 2048  | 49 )
+                        },
+                        menu: [
+                            { id: MenuId.CommandPalette },
+                            {
+                                id: MenuId.EditorTitle,
+                                when: ( (ResourceContextKey.Resource.isEqualTo(
+                                     (that.userDataProfileService.currentProfile.keybindingsResource.toString())
+                                ))),
+                                group: 'navigation',
+                                order: 1,
+                            }
+                        ]
+                    });
+                }
+                run(accessor, args) {
+                    const query = typeof args === 'string' ? args : undefined;
+                    return accessor.get(IPreferencesService).openGlobalKeybindingSettings(false, { query });
+                }
+            });
+        };
+        registerOpenGlobalKeybindingsAction();
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => registerOpenGlobalKeybindingsAction()));
+        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
+            command: {
+                id: 'workbench.action.openGlobalKeybindings',
+                title: { value: ( (nls.localize('Keyboard Shortcuts', "Keyboard Shortcuts"))), original: 'Keyboard Shortcuts' }
+            },
+            group: '2_configuration',
+            order: 3
+        });
+        MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+            command: {
+                id: 'workbench.action.openGlobalKeybindings',
+                title: { value: ( (nls.localize('Keyboard Shortcuts', "Keyboard Shortcuts"))), original: 'Keyboard Shortcuts' }
+            },
+            group: '2_configuration',
+            order: 3
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openDefaultKeybindingsFile',
+                    title: { value: ( (nls.localize('openDefaultKeybindingsFile', "Open Default Keyboard Shortcuts (JSON)"))), original: 'Open Default Keyboard Shortcuts (JSON)' },
+                    category,
+                    menu: { id: MenuId.CommandPalette }
+                });
+            }
+            run(accessor) {
+                return accessor.get(IPreferencesService).openDefaultKeybindingsFile();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.openGlobalKeybindingsFile',
+                    title: { value: ( (nls.localize('openGlobalKeybindingsFile', "Open Keyboard Shortcuts (JSON)"))), original: 'Open Keyboard Shortcuts (JSON)' },
+                    category,
+                    icon: preferencesOpenSettingsIcon,
+                    menu: [
+                        { id: MenuId.CommandPalette },
+                        {
+                            id: MenuId.EditorTitle,
+                            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+                            group: 'navigation',
+                        }
+                    ]
+                });
+            }
+            run(accessor) {
+                return accessor.get(IPreferencesService).openGlobalKeybindingSettings(true);
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: KEYBINDINGS_EDITOR_SHOW_DEFAULT_KEYBINDINGS,
+                    title: { value: ( (nls.localize('showDefaultKeybindings', "Show System Keybindings"))), original: 'Show System Keyboard Shortcuts' },
+                    menu: [
+                        {
+                            id: MenuId.EditorTitle,
+                            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+                            group: '1_keyboard_preferences_actions'
+                        }
+                    ]
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.search('@source:system');
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: KEYBINDINGS_EDITOR_SHOW_EXTENSION_KEYBINDINGS,
+                    title: { value: ( (nls.localize('showExtensionKeybindings', "Show Extension Keybindings"))), original: 'Show Extension Keyboard Shortcuts' },
+                    menu: [
+                        {
+                            id: MenuId.EditorTitle,
+                            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+                            group: '1_keyboard_preferences_actions'
+                        }
+                    ]
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.search('@source:extension');
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: KEYBINDINGS_EDITOR_SHOW_USER_KEYBINDINGS,
+                    title: { value: ( (nls.localize('showUserKeybindings', "Show User Keybindings"))), original: 'Show User Keyboard Shortcuts' },
+                    menu: [
+                        {
+                            id: MenuId.EditorTitle,
+                            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+                            group: '1_keyboard_preferences_actions'
+                        }
+                    ]
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.search('@source:user');
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS,
+                    title: ( (nls.localize('clear', "Clear Search Results"))),
+                    keybinding: {
+                        weight: 200 ,
+                        when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDINGS_SEARCH_FOCUS))),
+                        primary: 9 ,
+                    }
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.clearSearchResults();
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_HISTORY,
+                    title: ( (nls.localize('clearHistory', "Clear Keyboard Shortcuts Search History"))),
+                    category,
+                    menu: [
+                        {
+                            id: MenuId.CommandPalette,
+                            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+                        }
+                    ]
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.clearKeyboardShortcutSearchHistory();
+                }
+            }
+        });
+        this.registerKeybindingEditorActions();
+    }
+    registerKeybindingEditorActions() {
+        const that = this;
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_DEFINE,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(
+                CONTEXT_KEYBINDINGS_EDITOR,
+                CONTEXT_KEYBINDING_FOCUS,
+                 (CONTEXT_WHEN_FOCUS.toNegated())
+            ))),
+            primary: 3 ,
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.defineKeybinding(editorPane.activeKeybindingEntry, false);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_ADD,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDING_FOCUS))),
+            primary: KeyChord(2048  | 41 , 2048  | 31 ),
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.defineKeybinding(editorPane.activeKeybindingEntry, true);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_DEFINE_WHEN,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDING_FOCUS))),
+            primary: KeyChord(2048  | 41 , 2048  | 35 ),
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor && editorPane.activeKeybindingEntry.keybindingItem.keybinding) {
+                    editorPane.defineWhenExpression(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_REMOVE,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(
+                CONTEXT_KEYBINDINGS_EDITOR,
+                CONTEXT_KEYBINDING_FOCUS,
+                 (InputFocusedContext.toNegated())
+            ))),
+            primary: 20 ,
+            mac: {
+                primary: 2048  | 1
+            },
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.removeKeybinding(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_RESET,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDING_FOCUS))),
+            primary: 0,
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.resetKeybinding(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_SEARCH,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+            primary: 2048  | 36 ,
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.focusSearch();
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_RECORD_SEARCH_KEYS,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDINGS_SEARCH_FOCUS))),
+            primary: 512  | 41 ,
+            mac: { primary: 2048  | 512  | 41  },
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.recordSearchKeys();
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_SORTBY_PRECEDENCE,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR))),
+            primary: 512  | 46 ,
+            mac: { primary: 2048  | 512  | 46  },
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.toggleSortByPrecedence();
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_SHOW_SIMILAR,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDING_FOCUS))),
+            primary: 0,
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.showSimilarKeybindings(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_COPY,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(
+                CONTEXT_KEYBINDINGS_EDITOR,
+                CONTEXT_KEYBINDING_FOCUS,
+                 (CONTEXT_WHEN_FOCUS.negate())
+            ))),
+            primary: 2048  | 33 ,
+            handler: async (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    await editorPane.copyKeybinding(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDING_FOCUS))),
+            primary: 0,
+            handler: async (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    await editorPane.copyKeybindingCommand(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND_TITLE,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDING_FOCUS))),
+            primary: 0,
+            handler: async (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    await editorPane.copyKeybindingCommandTitle(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_FOCUS_KEYBINDINGS,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDINGS_SEARCH_FOCUS))),
+            primary: 2048  | 18 ,
+            handler: (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.focusKeybindings();
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_REJECT_WHEN,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(
+                CONTEXT_KEYBINDINGS_EDITOR,
+                CONTEXT_WHEN_FOCUS,
+                 (Context.Visible.toNegated())
+            ))),
+            primary: 9 ,
+            handler: async (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.rejectWhenExpression(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        KeybindingsRegistry.registerCommandAndKeybindingRule({
+            id: KEYBINDINGS_EDITOR_COMMAND_ACCEPT_WHEN,
+            weight: 200 ,
+            when: ( (ContextKeyExpr.and(
+                CONTEXT_KEYBINDINGS_EDITOR,
+                CONTEXT_WHEN_FOCUS,
+                 (Context.Visible.toNegated())
+            ))),
+            primary: 3 ,
+            handler: async (accessor, args) => {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof KeybindingsEditor) {
+                    editorPane.acceptWhenExpression(editorPane.activeKeybindingEntry);
+                }
+            }
+        });
+        const profileScopedActionDisposables = this._register(( (new DisposableStore())));
+        const registerProfileScopedActions = () => {
+            profileScopedActionDisposables.clear();
+            profileScopedActionDisposables.add(registerAction2(class DefineKeybindingAction extends Action2 {
+                constructor() {
+                    const when = ( (ResourceContextKey.Resource.isEqualTo(
+                         (that.userDataProfileService.currentProfile.keybindingsResource.toString())
+                    )));
+                    super({
+                        id: 'editor.action.defineKeybinding',
+                        title: { value: ( (nls.localize('defineKeybinding.start', "Define Keybinding"))), original: 'Define Keybinding' },
+                        f1: true,
+                        precondition: when,
+                        keybinding: {
+                            weight: 200 ,
+                            when,
+                            primary: KeyChord(2048  | 41 , 2048  | 41 )
+                        },
+                        menu: {
+                            id: MenuId.EditorContent,
+                            when,
+                        }
+                    });
+                }
+                async run(accessor) {
+                    const codeEditor = accessor.get(IEditorService).activeTextEditorControl;
+                    if (isCodeEditor(codeEditor)) {
+                        codeEditor.getContribution(DEFINE_KEYBINDING_EDITOR_CONTRIB_ID)?.showDefineKeybindingWidget();
+                    }
+                }
+            }));
+        };
+        registerProfileScopedActions();
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => registerProfileScopedActions()));
+    }
+    updatePreferencesEditorMenuItem() {
+        const commandId = '_workbench.openWorkspaceSettingsEditor';
+        if (this.workspaceContextService.getWorkbenchState() === 3  && !CommandsRegistry.getCommand(commandId)) {
+            CommandsRegistry.registerCommand(commandId, () => this.preferencesService.openWorkspaceSettings({ jsonEditor: false }));
+            MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+                command: {
+                    id: commandId,
+                    title: OPEN_USER_SETTINGS_UI_TITLE,
+                    icon: preferencesOpenSettingsIcon
+                },
+                when: ( (ContextKeyExpr.and( (ResourceContextKey.Resource.isEqualTo(
+                     (this.preferencesService.workspaceSettingsResource.toString())
+                )),  (WorkbenchStateContext.isEqualTo('workspace')), ContextKeyExpr.not('isInDiffEditor')))),
+                group: 'navigation',
+                order: 1
+            });
+        }
+        this.updatePreferencesEditorMenuItemForWorkspaceFolders();
+    }
+    updatePreferencesEditorMenuItemForWorkspaceFolders() {
+        for (const folder of this.workspaceContextService.getWorkspace().folders) {
+            const commandId = `_workbench.openFolderSettings.${( ( folder.uri.toString()))}`;
+            if (!CommandsRegistry.getCommand(commandId)) {
+                CommandsRegistry.registerCommand(commandId, () => {
+                    if (this.workspaceContextService.getWorkbenchState() === 2 ) {
+                        return this.preferencesService.openWorkspaceSettings({ jsonEditor: false });
+                    }
+                    else {
+                        return this.preferencesService.openFolderSettings({ folderUri: folder.uri, jsonEditor: false });
+                    }
+                });
+                MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+                    command: {
+                        id: commandId,
+                        title: OPEN_USER_SETTINGS_UI_TITLE,
+                        icon: preferencesOpenSettingsIcon
+                    },
+                    when: ( (ContextKeyExpr.and( (ResourceContextKey.Resource.isEqualTo(
+                         (this.preferencesService.getFolderSettingsResource(folder.uri).toString())
+                    )), ContextKeyExpr.not('isInDiffEditor')))),
+                    group: 'navigation',
+                    order: 1
+                });
+            }
+        }
+    }
+};
+PreferencesActionsContribution = ( (__decorate([
+    ( (__param(0, IWorkbenchEnvironmentService))),
+    ( (__param(1, IUserDataProfileService))),
+    ( (__param(2, IPreferencesService))),
+    ( (__param(3, IWorkspaceContextService))),
+    ( (__param(4, ILabelService))),
+    ( (__param(5, IExtensionService))),
+    ( (__param(6, IUserDataProfilesService)))
+], PreferencesActionsContribution)));
+const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
+workbenchContributionsRegistry.registerWorkbenchContribution(PreferencesActionsContribution, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(PreferencesContribution, 1 );
+registerEditorContribution(SettingsEditorContribution.ID, SettingsEditorContribution, 1 );