@codingame/monaco-vscode-api 4.1.0 → 4.1.2

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

@@ -1,2182 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from '../../../../platform/actions/common/actions.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { IExtensionGalleryService, IExtensionManagementService, ExtensionsLocalizedLabel, PreferencesLocalizedLabel } from '../../../../platform/extensionManagement/common/extensionManagement.js';
-import { extensionsConfigurationNodeBase, IWorkbenchExtensionManagementService, IExtensionManagementServerService, IWorkbenchExtensionEnablementService } from '../../../services/extensionManagement/common/extensionManagement.js';
-import { IExtensionIgnoredRecommendationsService } from '../../../services/extensionRecommendations/common/extensionRecommendations.js';
-import { Extensions as Extensions$4 } from '../../../common/contributions.js';
-import { VIEWLET_ID, IExtensionsWorkbenchService, CONTEXT_HAS_GALLERY, AutoUpdateConfigurationKey, HasOutdatedExtensionsContext, OUTDATED_EXTENSIONS_VIEW_ID, SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID, INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID, extensionsSearchActionsMenu, LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID, WORKSPACE_RECOMMENDATIONS_VIEW_ID, THEME_ACTIONS_GROUP, INSTALL_ACTIONS_GROUP, UPDATE_ACTIONS_GROUP, TOGGLE_IGNORE_EXTENSION_ACTION_ID } from '../common/extensions.js';
-import { SearchExtensionsAction, PromptExtensionInstallFailureAction, ConfigureWorkspaceFolderRecommendedExtensionsAction, InstallSpecificVersionOfExtensionAction, ReinstallAction, SetColorThemeAction, SetFileIconThemeAction, SetProductIconThemeAction, ToggleAutoUpdateForExtensionAction, ToggleAutoUpdatesForPublisherAction, TogglePreReleaseExtensionAction, ClearLanguageAction, ConfigureWorkspaceRecommendedExtensionsAction } from './extensionsActions.js';
-import { ExtensionsInput } from '../common/extensionsInput.js';
-import { ExtensionEditor } from './extensionEditor.js';
-import { ExtensionsViewPaneContainer, StatusUpdater, MaliciousExtensionChecker, ExtensionsViewletViewsContribution, DefaultViewsContext, SearchHasTextContext } from './extensionsViewlet.js';
-import { Extensions as Extensions$2 } from '../../../../platform/configuration/common/configurationRegistry.js';
-import { Extensions as Extensions$3 } from '../../../../platform/jsonschemas/common/jsonContributionRegistry.js';
-import { ExtensionsConfigurationSchemaId, ExtensionsConfigurationSchema } from '../common/extensionsFileTemplate.js';
-import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { KeymapExtensions } from '../common/extensionsUtils.js';
-import { areSameExtensions, getIdAndVersion } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
-import { EditorPaneDescriptor } from '../../../browser/editor.js';
-import { URI } from '../../../../base/common/uri.js';
-import { ExtensionActivationProgress } from './extensionsActivationProgress.js';
-import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { ExtensionDependencyChecker } from './extensionsDependencyChecker.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
-import { Extensions as Extensions$1 } from '../../../common/views.js';
-import { IViewsService } from '../../../services/views/common/viewsService.js';
-import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { ContextKeyExpr, RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { Extensions } from '../../../../platform/quickinput/common/quickAccess.js';
-import { ManageExtensionsQuickAccessProvider, InstallExtensionQuickAccessProvider } from './extensionsQuickAccess.js';
-import './extensionRecommendationsService.js';
-import { CONTEXT_SYNC_ENABLEMENT } from '../../../services/userDataSync/common/userDataSync.js';
-import { CopyAction, CutAction, PasteAction } from '../../../../editor/contrib/clipboard/browser/clipboard.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import './extensionsWorkbenchService.js';
-import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
-import './extensionRecommendationNotificationService.js';
-import { IExtensionService, toExtensionDescription } from '../../../services/extensions/common/extensions.js';
-import { INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
-import { IHostService } from '../../../services/host/browser/host.js';
-import { WorkbenchStateContext, ResourceContextKey } from '../../../common/contextkeys.js';
-import { IWorkspaceExtensionsConfigService } from '../../../services/extensionRecommendations/common/workspaceExtensionsConfig.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { ShowRuntimeExtensionsAction } from './abstractRuntimeExtensionsEditor.js';
-import { ExtensionEnablementWorkspaceTrustTransitionParticipant } from './extensionEnablementWorkspaceTrustTransitionParticipant.js';
-import { extensionsViewIcon, installWorkspaceRecommendedIcon, filterIcon, clearSearchResultsIcon, refreshIcon, configureRecommendedIcon } from './extensionsIcons.js';
-import { EXTENSION_CATEGORIES } from '../../../../platform/extensions/common/extensions.js';
-import { Disposable, isDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { mnemonicButtonLabel } from '../../../../base/common/labels.js';
-import '../../../../base/common/arrays.js';
-import { Promises } from '../../../../base/common/async.js';
-import { EditorExtensions } from '../../../common/editor.js';
-import { WORKSPACE_TRUST_EXTENSION_SUPPORT } from '../../../services/workspaces/common/workspaceTrust.js';
-import { ExtensionsCompletionItemsProvider } from './extensionsCompletionItemsProvider.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { Event } from '../../../../base/common/event.js';
-import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
-import { UnsupportedExtensionsMigrationContrib } from './unsupportedExtensionsMigrationContribution.js';
-import { isWeb } from '../../../../base/common/platform.js';
-import { ExtensionStorageService } from '../../../../platform/extensionManagement/common/extensionStorage.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { CONTEXT_KEYBINDINGS_EDITOR } from '../../preferences/common/preferences.js';
-import { DeprecatedExtensionsChecker } from './deprecatedExtensionsChecker.js';
-import { IFileDialogService, IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-( Registry.as(Extensions.Quickaccess)).registerQuickAccessProvider({
-    ctor: ManageExtensionsQuickAccessProvider,
-    prefix: ManageExtensionsQuickAccessProvider.PREFIX,
-    placeholder: ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-        'manageExtensionsQuickAccessPlaceholder',
-        "Press Enter to manage extensions."
-    )),
-    helpEntries: [{ description: ( localizeWithPath(
-        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-        'manageExtensionsHelp',
-        "Manage Extensions"
-    )) }]
-});
-( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(ExtensionEditor, ExtensionEditor.ID, ( localizeWithPath(
-    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-    'extension',
-    "Extension"
-))), [
-    ( new SyncDescriptor(ExtensionsInput))
-]);
-( Registry.as(Extensions$1.ViewContainersRegistry)).registerViewContainer({
-    id: VIEWLET_ID,
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-        'extensions',
-        "Extensions"
-    )),
-    openCommandActionDescriptor: {
-        id: VIEWLET_ID,
-        mnemonicTitle: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-            { key: 'miViewExtensions', comment: ['&& denotes a mnemonic'] },
-            "E&&xtensions"
-        )),
-        keybindings: { primary: 2048  | 1024  | 54  },
-        order: 4,
-    },
-    ctorDescriptor: ( new SyncDescriptor(ExtensionsViewPaneContainer)),
-    icon: extensionsViewIcon,
-    order: 4,
-    rejectAddedViews: true,
-    alwaysUseContainerInfo: true,
-}, 0 );
-( Registry.as(Extensions$2.Configuration))
-    .registerConfiguration({
-    ...extensionsConfigurationNodeBase,
-    properties: {
-        'extensions.autoUpdate': {
-            enum: [true, 'onlyEnabledExtensions', 'onlySelectedExtensions', false,],
-            enumItemLabels: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'all',
-                    "All Extensions"
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'enabled',
-                    "Only Enabled Extensions"
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'selected',
-                    "Only Selected Extensions"
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'none',
-                    "None"
-                )),
-            ],
-            enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensions.autoUpdate.true',
-                    'Download and install updates automatically for all extensions except for those updates are ignored.'
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensions.autoUpdate.enabled',
-                    'Download and install updates automatically only for enabled extensions except for those updates are ignored. Disabled extensions are not updated automatically.'
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensions.autoUpdate.selected',
-                    'Download and install updates automatically only for selected extensions.'
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensions.autoUpdate.false',
-                    'Extensions are not automatically updated.'
-                )),
-            ],
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions.autoUpdate',
-                "Controls the automatic update behavior of extensions. The updates are fetched from a Microsoft online service."
-            )),
-            default: true,
-            scope: 1 ,
-            tags: ['usesOnlineServices']
-        },
-        'extensions.autoCheckUpdates': {
-            type: 'boolean',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsCheckUpdates',
-                "When enabled, automatically checks extensions for updates. If an extension has an update, it is marked as outdated in the Extensions view. The updates are fetched from a Microsoft online service."
-            )),
-            default: true,
-            scope: 1 ,
-            tags: ['usesOnlineServices']
-        },
-        'extensions.ignoreRecommendations': {
-            type: 'boolean',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsIgnoreRecommendations',
-                "When enabled, the notifications for extension recommendations will not be shown."
-            )),
-            default: false
-        },
-        'extensions.showRecommendationsOnlyOnDemand': {
-            type: 'boolean',
-            deprecationMessage: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsShowRecommendationsOnlyOnDemand_Deprecated',
-                "This setting is deprecated. Use extensions.ignoreRecommendations setting to control recommendation notifications. Use Extensions view's visibility actions to hide Recommended view by default."
-            )),
-            default: false,
-            tags: ['usesOnlineServices']
-        },
-        'extensions.closeExtensionDetailsOnViewChange': {
-            type: 'boolean',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsCloseExtensionDetailsOnViewChange',
-                "When enabled, editors with extension details will be automatically closed upon navigating away from the Extensions View."
-            )),
-            default: false
-        },
-        'extensions.confirmedUriHandlerExtensionIds': {
-            type: 'array',
-            items: {
-                type: 'string'
-            },
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'handleUriConfirmedExtensions',
-                "When an extension is listed here, a confirmation prompt will not be shown when that extension handles a URI."
-            )),
-            default: [],
-            scope: 1
-        },
-        'extensions.webWorker': {
-            type: ['boolean', 'string'],
-            enum: [true, false, 'auto'],
-            enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensionsWebWorker.true',
-                    "The Web Worker Extension Host will always be launched."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensionsWebWorker.false',
-                    "The Web Worker Extension Host will never be launched."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extensionsWebWorker.auto',
-                    "The Web Worker Extension Host will be launched when a web extension needs it."
-                )),
-            ],
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsWebWorker',
-                "Enable web worker extension host."
-            )),
-            default: 'auto'
-        },
-        'extensions.supportVirtualWorkspaces': {
-            type: 'object',
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions.supportVirtualWorkspaces',
-                "Override the virtual workspaces support of an extension."
-            )),
-            patternProperties: {
-                '([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$': {
-                    type: 'boolean',
-                    default: false
-                }
-            },
-            additionalProperties: false,
-            default: {},
-            defaultSnippets: [{
-                    'body': {
-                        'pub.name': false
-                    }
-                }]
-        },
-        'extensions.experimental.affinity': {
-            type: 'object',
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions.affinity',
-                "Configure an extension to execute in a different extension host process."
-            )),
-            patternProperties: {
-                '([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$': {
-                    type: 'integer',
-                    default: 1
-                }
-            },
-            additionalProperties: false,
-            default: {},
-            defaultSnippets: [{
-                    'body': {
-                        'pub.name': 1
-                    }
-                }]
-        },
-        [WORKSPACE_TRUST_EXTENSION_SUPPORT]: {
-            type: 'object',
-            scope: 1 ,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions.supportUntrustedWorkspaces',
-                "Override the untrusted workspace support of an extension. Extensions using `true` will always be enabled. Extensions using `limited` will always be enabled, and the extension will hide functionality that requires trust. Extensions using `false` will only be enabled only when the workspace is trusted."
-            )),
-            patternProperties: {
-                '([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$': {
-                    type: 'object',
-                    properties: {
-                        'supported': {
-                            type: ['boolean', 'string'],
-                            enum: [true, false, 'limited'],
-                            enumDescriptions: [
-                                ( localizeWithPath(
-                                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                    'extensions.supportUntrustedWorkspaces.true',
-                                    "Extension will always be enabled."
-                                )),
-                                ( localizeWithPath(
-                                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                    'extensions.supportUntrustedWorkspaces.false',
-                                    "Extension will only be enabled only when the workspace is trusted."
-                                )),
-                                ( localizeWithPath(
-                                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                    'extensions.supportUntrustedWorkspaces.limited',
-                                    "Extension will always be enabled, and the extension will hide functionality requiring trust."
-                                )),
-                            ],
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'extensions.supportUntrustedWorkspaces.supported',
-                                "Defines the untrusted workspace support setting for the extension."
-                            )),
-                        },
-                        'version': {
-                            type: 'string',
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'extensions.supportUntrustedWorkspaces.version',
-                                "Defines the version of the extension for which the override should be applied. If not specified, the override will be applied independent of the extension version."
-                            )),
-                        }
-                    }
-                }
-            }
-        },
-        'extensions.experimental.deferredStartupFinishedActivation': {
-            type: 'boolean',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsDeferredStartupFinishedActivation',
-                "When enabled, extensions which declare the `onStartupFinished` activation event will be activated after a timeout."
-            )),
-            default: false
-        },
-        'extensions.experimental.issueQuickAccess': {
-            type: 'boolean',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionsInQuickAccess',
-                "When enabled, extensions can be searched for via Quick Access and report issues from there."
-            )),
-            default: true
-        }
-    }
-});
-const jsonRegistry = ( Registry.as(Extensions$3.JSONContribution));
-jsonRegistry.registerSchema(ExtensionsConfigurationSchemaId, ExtensionsConfigurationSchema);
-CommandsRegistry.registerCommand('_extensions.manage', (accessor, extensionId, tab, preserveFocus, feature) => {
-    const extensionService = accessor.get(IExtensionsWorkbenchService);
-    const extension = extensionService.local.find(e => areSameExtensions(e.identifier, { id: extensionId }));
-    if (extension) {
-        extensionService.open(extension, { tab, preserveFocus, feature });
-    }
-    else {
-        throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensions.contribution', 'notFound', "Extension '{0}' not found.", extensionId));
-    }
-});
-CommandsRegistry.registerCommand('extension.open', async (accessor, extensionId, tab, preserveFocus, feature) => {
-    const extensionService = accessor.get(IExtensionsWorkbenchService);
-    const commandService = accessor.get(ICommandService);
-    const [extension] = await extensionService.getExtensions([{ id: extensionId }], CancellationToken.None);
-    if (extension) {
-        return extensionService.open(extension, { tab, preserveFocus, feature });
-    }
-    return commandService.executeCommand('_extensions.manage', extensionId, tab, preserveFocus, feature);
-});
-CommandsRegistry.registerCommand({
-    id: 'workbench.extensions.installExtension',
-    metadata: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-            'workbench.extensions.installExtension.description',
-            "Install the given extension"
-        )),
-        args: [
-            {
-                name: 'extensionIdOrVSIXUri',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'workbench.extensions.installExtension.arg.decription',
-                    "Extension id or VSIX resource uri"
-                )),
-                constraint: (value) => typeof value === 'string' || value instanceof URI,
-            },
-            {
-                name: 'options',
-                description: '(optional) Options for installing the extension. Object with the following properties: ' +
-                    '`installOnlyNewlyAddedFromExtensionPackVSIX`: When enabled, VS Code installs only newly added extensions from the extension pack VSIX. This option is considered only when installing VSIX. ',
-                isOptional: true,
-                schema: {
-                    'type': 'object',
-                    'properties': {
-                        'installOnlyNewlyAddedFromExtensionPackVSIX': {
-                            'type': 'boolean',
-                            'description': ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'workbench.extensions.installExtension.option.installOnlyNewlyAddedFromExtensionPackVSIX',
-                                "When enabled, VS Code installs only newly added extensions from the extension pack VSIX. This option is considered only while installing a VSIX."
-                            )),
-                            default: false
-                        },
-                        'installPreReleaseVersion': {
-                            'type': 'boolean',
-                            'description': ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'workbench.extensions.installExtension.option.installPreReleaseVersion',
-                                "When enabled, VS Code installs the pre-release version of the extension if available."
-                            )),
-                            default: false
-                        },
-                        'donotSync': {
-                            'type': 'boolean',
-                            'description': ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'workbench.extensions.installExtension.option.donotSync',
-                                "When enabled, VS Code do not sync this extension when Settings Sync is on."
-                            )),
-                            default: false
-                        },
-                        'justification': {
-                            'type': ['string', 'object'],
-                            'description': ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'workbench.extensions.installExtension.option.justification',
-                                "Justification for installing the extension. This is a string or an object that can be used to pass any information to the installation handlers. i.e. `{reason: 'This extension wants to open a URI', action: 'Open URI'}` will show a message box with the reason and action upon install."
-                            )),
-                        },
-                        'enable': {
-                            'type': 'boolean',
-                            'description': ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'workbench.extensions.installExtension.option.enable',
-                                "When enabled, the extension will be enabled if it is installed but disabled. If the extension is already enabled, this has no effect."
-                            )),
-                            default: false
-                        },
-                        'context': {
-                            'type': 'object',
-                            'description': ( localizeWithPath(
-                                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                'workbench.extensions.installExtension.option.context',
-                                "Context for the installation. This is a JSON object that can be used to pass any information to the installation handlers. i.e. `{skipWalkthrough: true}` will skip opening the walkthrough upon install."
-                            )),
-                        }
-                    }
-                }
-            }
-        ]
-    },
-    handler: async (accessor, arg, options) => {
-        const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-        const extensionManagementService = accessor.get(IWorkbenchExtensionManagementService);
-        const extensionGalleryService = accessor.get(IExtensionGalleryService);
-        try {
-            if (typeof arg === 'string') {
-                const [id, version] = getIdAndVersion(arg);
-                const extension = extensionsWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id, uuid: version }));
-                if (extension?.enablementState === 1 ) {
-                    const [gallery] = await extensionGalleryService.getExtensions([{ id, preRelease: options?.installPreReleaseVersion }], CancellationToken.None);
-                    if (gallery) {
-                        throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensions.contribution', 'notFound', "Extension '{0}' not found.", arg));
-                    }
-                    await extensionManagementService.installFromGallery(gallery, {
-                        isMachineScoped: options?.donotSync ? true : undefined,
-                        installPreReleaseVersion: options?.installPreReleaseVersion,
-                        installGivenVersion: !!version,
-                        context: options?.context
-                    });
-                }
-                else {
-                    await extensionsWorkbenchService.install(arg, {
-                        version,
-                        installPreReleaseVersion: options?.installPreReleaseVersion,
-                        context: options?.context,
-                        justification: options?.justification,
-                        enable: options?.enable,
-                        isMachineScoped: options?.donotSync ? true : undefined,
-                    }, 15 );
-                }
-            }
-            else {
-                const vsix = URI.revive(arg);
-                await extensionsWorkbenchService.install(vsix, { installOnlyNewlyAddedFromExtensionPack: options?.installOnlyNewlyAddedFromExtensionPackVSIX });
-            }
-        }
-        catch (e) {
-            onUnexpectedError(e);
-            throw e;
-        }
-    }
-});
-CommandsRegistry.registerCommand({
-    id: 'workbench.extensions.uninstallExtension',
-    metadata: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-            'workbench.extensions.uninstallExtension.description',
-            "Uninstall the given extension"
-        )),
-        args: [
-            {
-                name: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'workbench.extensions.uninstallExtension.arg.name',
-                    "Id of the extension to uninstall"
-                )),
-                schema: {
-                    'type': 'string'
-                }
-            }
-        ]
-    },
-    handler: async (accessor, id) => {
-        if (!id) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensions.contribution', 'id required', "Extension id required."));
-        }
-        const extensionManagementService = accessor.get(IExtensionManagementService);
-        const installed = await extensionManagementService.getInstalled();
-        const [extensionToUninstall] = installed.filter(e => areSameExtensions(e.identifier, { id }));
-        if (!extensionToUninstall) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensions.contribution', 'notInstalled', "Extension '{0}' is not installed. Make sure you use the full extension ID, including the publisher, e.g.: ms-dotnettools.csharp.", id));
-        }
-        if (extensionToUninstall.isBuiltin) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensions.contribution', 'builtin', "Extension '{0}' is a Built-in extension and cannot be installed", id));
-        }
-        try {
-            await extensionManagementService.uninstall(extensionToUninstall);
-        }
-        catch (e) {
-            onUnexpectedError(e);
-            throw e;
-        }
-    }
-});
-CommandsRegistry.registerCommand({
-    id: 'workbench.extensions.search',
-    metadata: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-            'workbench.extensions.search.description',
-            "Search for a specific extension"
-        )),
-        args: [
-            {
-                name: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'workbench.extensions.search.arg.name',
-                    "Query to use in search"
-                )),
-                schema: { 'type': 'string' }
-            }
-        ]
-    },
-    handler: async (accessor, query = '') => {
-        const paneCompositeService = accessor.get(IPaneCompositePartService);
-        const viewlet = await paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
-        if (!viewlet) {
-            return;
-        }
-        viewlet.getViewPaneContainer().search(query);
-        viewlet.focus();
-    }
-});
-function overrideActionForActiveExtensionEditorWebview(command, f) {
-    command?.addImplementation(105, 'extensions-editor', (accessor) => {
-        const editorService = accessor.get(IEditorService);
-        const editor = editorService.activeEditorPane;
-        if (editor instanceof ExtensionEditor) {
-            if (editor.activeWebview?.isFocused) {
-                f(editor.activeWebview);
-                return true;
-            }
-        }
-        return false;
-    });
-}
-overrideActionForActiveExtensionEditorWebview(CopyAction, webview => webview.copy());
-overrideActionForActiveExtensionEditorWebview(CutAction, webview => webview.cut());
-overrideActionForActiveExtensionEditorWebview(PasteAction, webview => webview.paste());
-const CONTEXT_HAS_LOCAL_SERVER = ( new RawContextKey('hasLocalServer', false));
-const CONTEXT_HAS_REMOTE_SERVER = ( new RawContextKey('hasRemoteServer', false));
-const CONTEXT_HAS_WEB_SERVER = ( new RawContextKey('hasWebServer', false));
-async function runAction(action) {
-    try {
-        await action.run();
-    }
-    finally {
-        if (isDisposable(action)) {
-            action.dispose();
-        }
-    }
-}
-let ExtensionsContributions = class ExtensionsContributions extends Disposable {
-    constructor(extensionManagementServerService, extensionGalleryService, contextKeyService, paneCompositeService, extensionsWorkbenchService, extensionEnablementService, instantiationService, dialogService, commandService) {
-        super();
-        this.extensionManagementServerService = extensionManagementServerService;
-        this.paneCompositeService = paneCompositeService;
-        this.extensionsWorkbenchService = extensionsWorkbenchService;
-        this.extensionEnablementService = extensionEnablementService;
-        this.instantiationService = instantiationService;
-        this.dialogService = dialogService;
-        this.commandService = commandService;
-        const hasGalleryContext = CONTEXT_HAS_GALLERY.bindTo(contextKeyService);
-        if (extensionGalleryService.isEnabled()) {
-            hasGalleryContext.set(true);
-        }
-        const hasLocalServerContext = CONTEXT_HAS_LOCAL_SERVER.bindTo(contextKeyService);
-        if (this.extensionManagementServerService.localExtensionManagementServer) {
-            hasLocalServerContext.set(true);
-        }
-        const hasRemoteServerContext = CONTEXT_HAS_REMOTE_SERVER.bindTo(contextKeyService);
-        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
-            hasRemoteServerContext.set(true);
-        }
-        const hasWebServerContext = CONTEXT_HAS_WEB_SERVER.bindTo(contextKeyService);
-        if (this.extensionManagementServerService.webExtensionManagementServer) {
-            hasWebServerContext.set(true);
-        }
-        this.registerGlobalActions();
-        this.registerContextMenuActions();
-        this.registerQuickAccessProvider();
-    }
-    registerQuickAccessProvider() {
-        if (this.extensionManagementServerService.localExtensionManagementServer
-            || this.extensionManagementServerService.remoteExtensionManagementServer
-            || this.extensionManagementServerService.webExtensionManagementServer) {
-            ( Registry.as(Extensions.Quickaccess)).registerQuickAccessProvider({
-                ctor: InstallExtensionQuickAccessProvider,
-                prefix: InstallExtensionQuickAccessProvider.PREFIX,
-                placeholder: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'installExtensionQuickAccessPlaceholder',
-                    "Type the name of an extension to install or search."
-                )),
-                helpEntries: [{ description: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'installExtensionQuickAccessHelp',
-                    "Install or Search Extensions"
-                )) }]
-            });
-        }
-    }
-    registerGlobalActions() {
-        this._register(MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
-            command: {
-                id: VIEWLET_ID,
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    { key: 'miPreferencesExtensions', comment: ['&& denotes a mnemonic'] },
-                    "&&Extensions"
-                ))
-            },
-            group: '2_configuration',
-            order: 3
-        }));
-        this._register(MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            command: {
-                id: VIEWLET_ID,
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'showExtensions',
-                    "Extensions"
-                ))
-            },
-            group: '2_configuration',
-            order: 3
-        }));
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.focusExtensionsView',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'focusExtensions',
-                'Focus on Extensions View'
-            )),
-            category: ExtensionsLocalizedLabel,
-            f1: true,
-            run: async (accessor) => {
-                await accessor.get(IPaneCompositePartService).openPaneComposite(VIEWLET_ID, 0 , true);
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.installExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'installExtensions',
-                'Install Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.or(
-                    CONTEXT_HAS_LOCAL_SERVER,
-                    CONTEXT_HAS_REMOTE_SERVER,
-                    CONTEXT_HAS_WEB_SERVER
-                ))))
-            },
-            run: async (accessor) => {
-                accessor.get(IViewsService).openViewContainer(VIEWLET_ID, true);
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showRecommendedKeymapExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showRecommendedKeymapExtensionsShort',
-                'Keymaps'
-            )),
-            category: PreferencesLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CONTEXT_HAS_GALLERY
-                }, {
-                    id: MenuId.EditorTitle,
-                    when: ( ContextKeyExpr.and(CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_HAS_GALLERY)),
-                    group: '2_keyboard_discover_actions'
-                }],
-            menuTitles: {
-                [MenuId.EditorTitle.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'importKeyboardShortcutsFroms',
-                    "Migrate Keyboard Shortcuts from..."
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@recommended:keymaps '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showLanguageExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showLanguageExtensionsShort',
-                'Language Extensions'
-            )),
-            category: PreferencesLocalizedLabel,
-            menu: {
-                id: MenuId.CommandPalette,
-                when: CONTEXT_HAS_GALLERY
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@recommended:languages '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.checkForUpdates',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'checkForUpdates',
-                'Check for Extension Updates'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))))
-                }, {
-                    id: MenuId.ViewContainerTitle,
-                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), CONTEXT_HAS_GALLERY)),
-                    group: '1_updates',
-                    order: 1
-                }],
-            run: async () => {
-                await this.extensionsWorkbenchService.checkForUpdates();
-                const outdated = this.extensionsWorkbenchService.outdated;
-                if (outdated.length) {
-                    return runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@outdated '));
-                }
-                else {
-                    return this.dialogService.info(( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'noUpdatesAvailable',
-                        "All extensions are up to date."
-                    )));
-                }
-            }
-        });
-        const autoUpdateExtensionsSubMenu = ( new MenuId('autoUpdateExtensionsSubMenu'));
-        MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
-            submenu: autoUpdateExtensionsSubMenu,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'configure auto updating extensions',
-                "Auto Update Extensions"
-            )),
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), CONTEXT_HAS_GALLERY)),
-            group: '1_updates',
-            order: 5,
-        });
-        this.registerExtensionAction({
-            id: 'configureExtensionsAutoUpdate.all',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'configureExtensionsAutoUpdate.all',
-                "All Extensions"
-            )),
-            toggled: ( ContextKeyExpr.and(( ContextKeyExpr.has(`config.${AutoUpdateConfigurationKey}`)), ( ContextKeyExpr.notEquals(`config.${AutoUpdateConfigurationKey}`, 'onlyEnabledExtensions')), ( ContextKeyExpr.notEquals(`config.${AutoUpdateConfigurationKey}`, 'onlySelectedExtensions')))),
-            menu: [{
-                    id: autoUpdateExtensionsSubMenu,
-                    order: 1,
-                }],
-            run: (accessor) => accessor.get(IConfigurationService).updateValue(AutoUpdateConfigurationKey, true)
-        });
-        this.registerExtensionAction({
-            id: 'configureExtensionsAutoUpdate.enabled',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'configureExtensionsAutoUpdate.enabled',
-                "Enabled Extensions"
-            )),
-            toggled: ( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, 'onlyEnabledExtensions')),
-            menu: [{
-                    id: autoUpdateExtensionsSubMenu,
-                    order: 2,
-                }],
-            run: (accessor) => accessor.get(IConfigurationService).updateValue(AutoUpdateConfigurationKey, 'onlyEnabledExtensions')
-        });
-        this.registerExtensionAction({
-            id: 'configureExtensionsAutoUpdate.selected',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'configureExtensionsAutoUpdate.selected',
-                "Selected Extensions"
-            )),
-            toggled: ( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, 'onlySelectedExtensions')),
-            menu: [{
-                    id: autoUpdateExtensionsSubMenu,
-                    order: 2,
-                }],
-            run: (accessor) => accessor.get(IConfigurationService).updateValue(AutoUpdateConfigurationKey, 'onlySelectedExtensions')
-        });
-        this.registerExtensionAction({
-            id: 'configureExtensionsAutoUpdate.none',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'configureExtensionsAutoUpdate.none',
-                "None"
-            )),
-            toggled: ( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, false)),
-            menu: [{
-                    id: autoUpdateExtensionsSubMenu,
-                    order: 3,
-                }],
-            run: (accessor) => accessor.get(IConfigurationService).updateValue(AutoUpdateConfigurationKey, false)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.updateAllExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'updateAll',
-                'Update All Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            precondition: HasOutdatedExtensionsContext,
-            menu: [
-                {
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))))
-                }, {
-                    id: MenuId.ViewContainerTitle,
-                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( ContextKeyExpr.or(( ( ContextKeyExpr.has(`config.${AutoUpdateConfigurationKey}`)).negate()), ( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, 'onlyEnabledExtensions')))))),
-                    group: '1_updates',
-                    order: 2
-                }, {
-                    id: MenuId.ViewTitle,
-                    when: ( ContextKeyExpr.equals('view', OUTDATED_EXTENSIONS_VIEW_ID)),
-                    group: 'navigation',
-                    order: 1
-                }
-            ],
-            icon: installWorkspaceRecommendedIcon,
-            run: async () => {
-                const outdated = this.extensionsWorkbenchService.outdated;
-                const results = await this.extensionsWorkbenchService.updateAll();
-                results.forEach((result) => {
-                    if (result.error) {
-                        const extension = outdated.find((extension) => areSameExtensions(extension.identifier, result.identifier));
-                        if (extension) {
-                            runAction(this.instantiationService.createInstance(PromptExtensionInstallFailureAction, extension, extension.latestVersion, 3 , result.error));
-                        }
-                    }
-                });
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.disableAutoUpdate',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'disableAutoUpdate',
-                'Disable Auto Update for All Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            f1: true,
-            precondition: CONTEXT_HAS_GALLERY,
-            run: (accessor) => accessor.get(IConfigurationService).updateValue(AutoUpdateConfigurationKey, false)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.enableAutoUpdate',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'enableAutoUpdate',
-                'Enable Auto Update for All Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            f1: true,
-            precondition: CONTEXT_HAS_GALLERY,
-            run: (accessor) => accessor.get(IConfigurationService).updateValue(AutoUpdateConfigurationKey, true)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.enableAll',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'enableAll',
-                'Enable All Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))
-                }, {
-                    id: MenuId.ViewContainerTitle,
-                    when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
-                    group: '2_enablement',
-                    order: 1
-                }],
-            run: async () => {
-                const extensionsToEnable = this.extensionsWorkbenchService.local.filter(e => !!e.local && this.extensionEnablementService.canChangeEnablement(e.local) && !this.extensionEnablementService.isEnabled(e.local));
-                if (extensionsToEnable.length) {
-                    await this.extensionsWorkbenchService.setEnablement(extensionsToEnable, 8 );
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.enableAllWorkspace',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'enableAllWorkspace',
-                'Enable All Extensions for this Workspace'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('empty')), ( ContextKeyExpr.or(
-                    CONTEXT_HAS_LOCAL_SERVER,
-                    CONTEXT_HAS_REMOTE_SERVER,
-                    CONTEXT_HAS_WEB_SERVER
-                ))))
-            },
-            run: async () => {
-                const extensionsToEnable = this.extensionsWorkbenchService.local.filter(e => !!e.local && this.extensionEnablementService.canChangeEnablement(e.local) && !this.extensionEnablementService.isEnabled(e.local));
-                if (extensionsToEnable.length) {
-                    await this.extensionsWorkbenchService.setEnablement(extensionsToEnable, 9 );
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.disableAll',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'disableAll',
-                'Disable All Installed Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))
-                }, {
-                    id: MenuId.ViewContainerTitle,
-                    when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
-                    group: '2_enablement',
-                    order: 2
-                }],
-            run: async () => {
-                const extensionsToDisable = this.extensionsWorkbenchService.local.filter(e => !e.isBuiltin && !!e.local && this.extensionEnablementService.isEnabled(e.local) && this.extensionEnablementService.canChangeEnablement(e.local));
-                if (extensionsToDisable.length) {
-                    await this.extensionsWorkbenchService.setEnablement(extensionsToDisable, 6 );
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.disableAllWorkspace',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'disableAllWorkspace',
-                'Disable All Installed Extensions for this Workspace'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('empty')), ( ContextKeyExpr.or(
-                    CONTEXT_HAS_LOCAL_SERVER,
-                    CONTEXT_HAS_REMOTE_SERVER,
-                    CONTEXT_HAS_WEB_SERVER
-                ))))
-            },
-            run: async () => {
-                const extensionsToDisable = this.extensionsWorkbenchService.local.filter(e => !e.isBuiltin && !!e.local && this.extensionEnablementService.isEnabled(e.local) && this.extensionEnablementService.canChangeEnablement(e.local));
-                if (extensionsToDisable.length) {
-                    await this.extensionsWorkbenchService.setEnablement(extensionsToDisable, 7 );
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'InstallFromVSIX',
-                'Install from VSIX...'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER))
-                }, {
-                    id: MenuId.ViewContainerTitle,
-                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( ContextKeyExpr.or(CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER)))),
-                    group: '3_install',
-                    order: 1
-                }],
-            run: async (accessor) => {
-                const fileDialogService = accessor.get(IFileDialogService);
-                const commandService = accessor.get(ICommandService);
-                const vsixPaths = await fileDialogService.showOpenDialog({
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'installFromVSIX',
-                        "Install from VSIX"
-                    )),
-                    filters: [{ name: 'VSIX Extensions', extensions: ['vsix'] }],
-                    canSelectFiles: true,
-                    canSelectMany: true,
-                    openLabel: mnemonicButtonLabel(( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        { key: 'installButton', comment: ['&& denotes a mnemonic'] },
-                        "&&Install"
-                    )))
-                });
-                if (vsixPaths) {
-                    await commandService.executeCommand(INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID, vsixPaths);
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'installVSIX',
-                "Install Extension VSIX"
-            )),
-            menu: [{
-                    id: MenuId.ExplorerContext,
-                    group: 'extensions',
-                    when: ( ContextKeyExpr.and(( ResourceContextKey.Extension.isEqualTo('.vsix')), ( ContextKeyExpr.or(CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER)))),
-                }],
-            run: async (accessor, resources) => {
-                const extensionService = accessor.get(IExtensionService);
-                const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const hostService = accessor.get(IHostService);
-                const notificationService = accessor.get(INotificationService);
-                const extensions = Array.isArray(resources) ? resources : [resources];
-                await Promises.settled(( extensions.map(async (vsix) => await extensionsWorkbenchService.install(vsix))))
-                    .then(async (extensions) => {
-                    for (const extension of extensions) {
-                        const requireReload = !(extension.local && extensionService.canAddExtension(toExtensionDescription(extension.local)));
-                        const message = requireReload ? ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                            'InstallVSIXAction.successReload',
-                            "Completed installing {0} extension from VSIX. Please reload Visual Studio Code to enable it.",
-                            extension.displayName || extension.name
-                        ))
-                            : ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                            'InstallVSIXAction.success',
-                            "Completed installing {0} extension from VSIX.",
-                            extension.displayName || extension.name
-                        ));
-                        const actions = requireReload ? [{
-                                label: ( localizeWithPath(
-                                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                                    'InstallVSIXAction.reloadNow',
-                                    "Reload Now"
-                                )),
-                                run: () => hostService.reload()
-                            }] : [];
-                        notificationService.prompt(Severity.Info, message, actions);
-                    }
-                });
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.installExtensionFromLocation',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'installExtensionFromLocation',
-                'Install Extension from Location...'
-            )),
-            category: Categories.Developer,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(CONTEXT_HAS_WEB_SERVER, CONTEXT_HAS_LOCAL_SERVER))
-                }],
-            run: async (accessor) => {
-                const extensionManagementService = accessor.get(IWorkbenchExtensionManagementService);
-                if (isWeb) {
-                    return ( new Promise((c, e) => {
-                        const quickInputService = accessor.get(IQuickInputService);
-                        const disposables = ( new DisposableStore());
-                        const quickPick = disposables.add(quickInputService.createQuickPick());
-                        quickPick.title = ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                            'installFromLocation',
-                            "Install Extension from Location"
-                        ));
-                        quickPick.customButton = true;
-                        quickPick.customLabel = ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                            'install button',
-                            "Install"
-                        ));
-                        quickPick.placeholder = ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                            'installFromLocationPlaceHolder',
-                            "Location of the web extension"
-                        ));
-                        quickPick.ignoreFocusOut = true;
-                        disposables.add(Event.any(quickPick.onDidAccept, quickPick.onDidCustom)(async () => {
-                            quickPick.hide();
-                            if (quickPick.value) {
-                                try {
-                                    await extensionManagementService.installFromLocation(( URI.parse(quickPick.value)));
-                                }
-                                catch (error) {
-                                    e(error);
-                                    return;
-                                }
-                            }
-                            c();
-                        }));
-                        disposables.add(quickPick.onDidHide(() => disposables.dispose()));
-                        quickPick.show();
-                    }));
-                }
-                else {
-                    const fileDialogService = accessor.get(IFileDialogService);
-                    const extensionLocation = await fileDialogService.showOpenDialog({
-                        canSelectFolders: true,
-                        canSelectFiles: false,
-                        canSelectMany: false,
-                        title: ( localizeWithPath(
-                            'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                            'installFromLocation',
-                            "Install Extension from Location"
-                        )),
-                    });
-                    if (extensionLocation?.[0]) {
-                        await extensionManagementService.installFromLocation(extensionLocation[0]);
-                    }
-                }
-            }
-        });
-        const extensionsFilterSubMenu = ( new MenuId('extensionsFilterSubMenu'));
-        MenuRegistry.appendMenuItem(extensionsSearchActionsMenu, {
-            submenu: extensionsFilterSubMenu,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'filterExtensions',
-                "Filter Extensions..."
-            )),
-            group: 'navigation',
-            order: 2,
-            icon: filterIcon,
-        });
-        const showFeaturedExtensionsId = 'extensions.filter.featured';
-        this.registerExtensionAction({
-            id: showFeaturedExtensionsId,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showFeaturedExtensions',
-                'Show Featured Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CONTEXT_HAS_GALLERY
-                }, {
-                    id: extensionsFilterSubMenu,
-                    when: CONTEXT_HAS_GALLERY,
-                    group: '1_predefined',
-                    order: 1,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'featured filter',
-                    "Featured"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@featured '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showPopularExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showPopularExtensions',
-                'Show Popular Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CONTEXT_HAS_GALLERY
-                }, {
-                    id: extensionsFilterSubMenu,
-                    when: CONTEXT_HAS_GALLERY,
-                    group: '1_predefined',
-                    order: 2,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'most popular filter',
-                    "Most Popular"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@popular '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showRecommendedExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showRecommendedExtensions',
-                'Show Recommended Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CONTEXT_HAS_GALLERY
-                }, {
-                    id: extensionsFilterSubMenu,
-                    when: CONTEXT_HAS_GALLERY,
-                    group: '1_predefined',
-                    order: 2,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'most popular recommended',
-                    "Recommended"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@recommended '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.recentlyPublishedExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'recentlyPublishedExtensions',
-                'Show Recently Published Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CONTEXT_HAS_GALLERY
-                }, {
-                    id: extensionsFilterSubMenu,
-                    when: CONTEXT_HAS_GALLERY,
-                    group: '1_predefined',
-                    order: 2,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'recently published filter',
-                    "Recently Published"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@recentlyPublished '))
-        });
-        const extensionsCategoryFilterSubMenu = ( new MenuId('extensionsCategoryFilterSubMenu'));
-        MenuRegistry.appendMenuItem(extensionsFilterSubMenu, {
-            submenu: extensionsCategoryFilterSubMenu,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'filter by category',
-                "Category"
-            )),
-            when: CONTEXT_HAS_GALLERY,
-            group: '2_categories',
-            order: 1,
-        });
-        EXTENSION_CATEGORIES.forEach((category, index) => {
-            this.registerExtensionAction({
-                id: `extensions.actions.searchByCategory.${category}`,
-                title: category,
-                menu: [{
-                        id: extensionsCategoryFilterSubMenu,
-                        when: CONTEXT_HAS_GALLERY,
-                        order: index,
-                    }],
-                run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, `@category:"${category.toLowerCase()}"`))
-            });
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.listBuiltInExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showBuiltInExtensions',
-                'Show Built-in Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))
-                }, {
-                    id: extensionsFilterSubMenu,
-                    group: '3_installed',
-                    order: 2,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'builtin filter',
-                    "Built-in"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@builtin '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.extensionUpdates',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensionUpdates',
-                'Show Extension Updates'
-            )),
-            category: ExtensionsLocalizedLabel,
-            precondition: CONTEXT_HAS_GALLERY,
-            f1: true,
-            menu: [{
-                    id: extensionsFilterSubMenu,
-                    group: '3_installed',
-                    when: CONTEXT_HAS_GALLERY,
-                    order: 1,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'extension updates filter',
-                    "Updates"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@updates'))
-        });
-        this.registerExtensionAction({
-            id: LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showWorkspaceUnsupportedExtensions',
-                'Show Extensions Unsupported By Workspace'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER)),
-                }, {
-                    id: extensionsFilterSubMenu,
-                    group: '3_installed',
-                    order: 5,
-                    when: ( ContextKeyExpr.or(CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER)),
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'workspace unsupported filter',
-                    "Workspace Unsupported"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@workspaceUnsupported'))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showEnabledExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showEnabledExtensions',
-                'Show Enabled Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))
-                }, {
-                    id: extensionsFilterSubMenu,
-                    group: '3_installed',
-                    order: 3,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'enabled filter',
-                    "Enabled"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@enabled '))
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showDisabledExtensions',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'showDisabledExtensions',
-                'Show Disabled Extensions'
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( ContextKeyExpr.or(
-                        CONTEXT_HAS_LOCAL_SERVER,
-                        CONTEXT_HAS_REMOTE_SERVER,
-                        CONTEXT_HAS_WEB_SERVER
-                    ))
-                }, {
-                    id: extensionsFilterSubMenu,
-                    group: '3_installed',
-                    order: 4,
-                }],
-            menuTitles: {
-                [extensionsFilterSubMenu.id]: ( localizeWithPath(
-                    'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                    'disabled filter',
-                    "Disabled"
-                ))
-            },
-            run: () => runAction(this.instantiationService.createInstance(SearchExtensionsAction, '@disabled '))
-        });
-        const extensionsSortSubMenu = ( new MenuId('extensionsSortSubMenu'));
-        MenuRegistry.appendMenuItem(extensionsFilterSubMenu, {
-            submenu: extensionsSortSubMenu,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'sorty by',
-                "Sort By"
-            )),
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.or(CONTEXT_HAS_GALLERY, DefaultViewsContext)))),
-            group: '4_sort',
-            order: 1,
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.clearExtensionsSearchResults',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'clearExtensionsSearchResults',
-                'Clear Extensions Search Results'
-            )),
-            category: ExtensionsLocalizedLabel,
-            icon: clearSearchResultsIcon,
-            f1: true,
-            precondition: SearchHasTextContext,
-            menu: {
-                id: extensionsSearchActionsMenu,
-                group: 'navigation',
-                order: 1,
-            },
-            run: async (accessor) => {
-                const viewPaneContainer = accessor.get(IViewsService).getActiveViewPaneContainerWithId(VIEWLET_ID);
-                if (viewPaneContainer) {
-                    const extensionsViewPaneContainer = viewPaneContainer;
-                    extensionsViewPaneContainer.search('');
-                    extensionsViewPaneContainer.focus();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.refreshExtension',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'refreshExtension',
-                'Refresh'
-            )),
-            category: ExtensionsLocalizedLabel,
-            icon: refreshIcon,
-            f1: true,
-            menu: {
-                id: MenuId.ViewContainerTitle,
-                when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
-                group: 'navigation',
-                order: 2
-            },
-            run: async (accessor) => {
-                const viewPaneContainer = accessor.get(IViewsService).getActiveViewPaneContainerWithId(VIEWLET_ID);
-                if (viewPaneContainer) {
-                    await viewPaneContainer.refresh();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.installWorkspaceRecommendedExtensions',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'installWorkspaceRecommendedExtensions',
-                "Install Workspace Recommended Extensions"
-            )),
-            icon: installWorkspaceRecommendedIcon,
-            menu: {
-                id: MenuId.ViewTitle,
-                when: ( ContextKeyExpr.equals('view', WORKSPACE_RECOMMENDATIONS_VIEW_ID)),
-                group: 'navigation',
-                order: 1
-            },
-            run: async (accessor) => {
-                const view = accessor.get(IViewsService).getActiveViewWithId(WORKSPACE_RECOMMENDATIONS_VIEW_ID);
-                return view.installWorkspaceRecommendations();
-            }
-        });
-        this.registerExtensionAction({
-            id: ConfigureWorkspaceFolderRecommendedExtensionsAction.ID,
-            title: ConfigureWorkspaceFolderRecommendedExtensionsAction.LABEL,
-            icon: configureRecommendedIcon,
-            menu: [{
-                    id: MenuId.CommandPalette,
-                    when: ( WorkbenchStateContext.notEqualsTo('empty')),
-                }, {
-                    id: MenuId.ViewTitle,
-                    when: ( ContextKeyExpr.equals('view', WORKSPACE_RECOMMENDATIONS_VIEW_ID)),
-                    group: 'navigation',
-                    order: 2
-                }],
-            run: () => runAction(this.instantiationService.createInstance(ConfigureWorkspaceFolderRecommendedExtensionsAction, ConfigureWorkspaceFolderRecommendedExtensionsAction.ID, ConfigureWorkspaceFolderRecommendedExtensionsAction.LABEL))
-        });
-        this.registerExtensionAction({
-            id: InstallSpecificVersionOfExtensionAction.ID,
-            title: { value: InstallSpecificVersionOfExtensionAction.LABEL, original: 'Install Specific Version of Extension...' },
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.or(
-                    CONTEXT_HAS_LOCAL_SERVER,
-                    CONTEXT_HAS_REMOTE_SERVER,
-                    CONTEXT_HAS_WEB_SERVER
-                ))))
-            },
-            run: () => runAction(this.instantiationService.createInstance(InstallSpecificVersionOfExtensionAction, InstallSpecificVersionOfExtensionAction.ID, InstallSpecificVersionOfExtensionAction.LABEL))
-        });
-        this.registerExtensionAction({
-            id: ReinstallAction.ID,
-            title: { value: ReinstallAction.LABEL, original: 'Reinstall Extension...' },
-            category: Categories.Developer,
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.or(CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER))))
-            },
-            run: () => runAction(this.instantiationService.createInstance(ReinstallAction, ReinstallAction.ID, ReinstallAction.LABEL))
-        });
-    }
-    registerContextMenuActions() {
-        this.registerExtensionAction({
-            id: SetColorThemeAction.ID,
-            title: SetColorThemeAction.TITLE,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: THEME_ACTIONS_GROUP,
-                order: 0,
-                when: ( ContextKeyExpr.and(ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ( ContextKeyExpr.has('extensionHasColorThemes'))))
-            },
-            run: async (accessor, extensionId) => {
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const instantiationService = accessor.get(IInstantiationService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id: extensionId }));
-                if (extension) {
-                    const action = instantiationService.createInstance(SetColorThemeAction);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: SetFileIconThemeAction.ID,
-            title: SetFileIconThemeAction.TITLE,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: THEME_ACTIONS_GROUP,
-                order: 0,
-                when: ( ContextKeyExpr.and(ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ( ContextKeyExpr.has('extensionHasFileIconThemes'))))
-            },
-            run: async (accessor, extensionId) => {
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const instantiationService = accessor.get(IInstantiationService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id: extensionId }));
-                if (extension) {
-                    const action = instantiationService.createInstance(SetFileIconThemeAction);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: SetProductIconThemeAction.ID,
-            title: SetProductIconThemeAction.TITLE,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: THEME_ACTIONS_GROUP,
-                order: 0,
-                when: ( ContextKeyExpr.and(ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ( ContextKeyExpr.has('extensionHasProductIconThemes'))))
-            },
-            run: async (accessor, extensionId) => {
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const instantiationService = accessor.get(IInstantiationService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id: extensionId }));
-                if (extension) {
-                    const action = instantiationService.createInstance(SetProductIconThemeAction);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showPreReleaseVersion',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'show pre-release version',
-                'Show Pre-Release Version'
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: INSTALL_ACTIONS_GROUP,
-                order: 0,
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.has('inExtensionEditor')), ( ContextKeyExpr.has('galleryExtensionHasPreReleaseVersion')), ContextKeyExpr.not('showPreReleaseVersion'), ContextKeyExpr.not('isBuiltinExtension')))
-            },
-            run: async (accessor, extensionId) => {
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = (await extensionWorkbenchService.getExtensions([{ id: extensionId }], CancellationToken.None))[0];
-                extensionWorkbenchService.open(extension, { showPreReleaseVersion: true });
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.showReleasedVersion',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'show released version',
-                'Show Release Version'
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: INSTALL_ACTIONS_GROUP,
-                order: 1,
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.has('inExtensionEditor')), ( ContextKeyExpr.has('galleryExtensionHasPreReleaseVersion')), ( ContextKeyExpr.has('extensionHasReleaseVersion')), ( ContextKeyExpr.has('showPreReleaseVersion')), ContextKeyExpr.not('isBuiltinExtension')))
-            },
-            run: async (accessor, extensionId) => {
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = (await extensionWorkbenchService.getExtensions([{ id: extensionId }], CancellationToken.None))[0];
-                extensionWorkbenchService.open(extension, { showPreReleaseVersion: false });
-            }
-        });
-        this.registerExtensionAction({
-            id: ToggleAutoUpdateForExtensionAction.ID,
-            title: ToggleAutoUpdateForExtensionAction.LABEL,
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: UPDATE_ACTIONS_GROUP,
-                order: 1,
-                when: ( ContextKeyExpr.and(ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ContextKeyExpr.not('isBuiltinExtension'), ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, 'onlySelectedExtensions')), ( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, false))))))
-            },
-            run: async (accessor, id) => {
-                const instantiationService = accessor.get(IInstantiationService);
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id }));
-                if (extension) {
-                    const action = instantiationService.createInstance(ToggleAutoUpdateForExtensionAction, false, []);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: ToggleAutoUpdatesForPublisherAction.ID,
-            title: { value: ToggleAutoUpdatesForPublisherAction.LABEL, original: 'Auto Update (Publisher)' },
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: UPDATE_ACTIONS_GROUP,
-                order: 2,
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('extensionStatus', 'installed')), ContextKeyExpr.not('isBuiltinExtension'), ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, 'onlySelectedExtensions')), ( ContextKeyExpr.equals(`config.${AutoUpdateConfigurationKey}`, false))))))
-            },
-            run: async (accessor, id) => {
-                const instantiationService = accessor.get(IInstantiationService);
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id }));
-                if (extension) {
-                    const action = instantiationService.createInstance(ToggleAutoUpdatesForPublisherAction);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.switchToPreRlease',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'enablePreRleaseLabel',
-                "Switch to Pre-Release Version"
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: INSTALL_ACTIONS_GROUP,
-                order: 2,
-                when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.has('galleryExtensionHasPreReleaseVersion')), ContextKeyExpr.not('installedExtensionIsOptedToPreRelease'), ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ContextKeyExpr.not('isBuiltinExtension')))
-            },
-            run: async (accessor, id) => {
-                const instantiationService = accessor.get(IInstantiationService);
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id }));
-                if (extension) {
-                    const action = instantiationService.createInstance(TogglePreReleaseExtensionAction);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.switchToRelease',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'disablePreRleaseLabel',
-                "Switch to Release Version"
-            )),
-            category: ExtensionsLocalizedLabel,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: INSTALL_ACTIONS_GROUP,
-                order: 2,
-                when: ( ContextKeyExpr.and(CONTEXT_HAS_GALLERY, ( ContextKeyExpr.has('galleryExtensionHasPreReleaseVersion')), ( ContextKeyExpr.has('installedExtensionIsOptedToPreRelease')), ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ContextKeyExpr.not('isBuiltinExtension')))
-            },
-            run: async (accessor, id) => {
-                const instantiationService = accessor.get(IInstantiationService);
-                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id }));
-                if (extension) {
-                    const action = instantiationService.createInstance(TogglePreReleaseExtensionAction);
-                    action.extension = extension;
-                    return action.run();
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: ClearLanguageAction.ID,
-            title: ClearLanguageAction.TITLE,
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: INSTALL_ACTIONS_GROUP,
-                order: 0,
-                when: ( ContextKeyExpr.and(ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.has('canSetLanguage')), ( ContextKeyExpr.has('isActiveLanguagePackExtension'))))
-            },
-            run: async (accessor, extensionId) => {
-                const instantiationService = accessor.get(IInstantiationService);
-                const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
-                const extension = (await extensionsWorkbenchService.getExtensions([{ id: extensionId }], CancellationToken.None))[0];
-                const action = instantiationService.createInstance(ClearLanguageAction);
-                action.extension = extension;
-                return action.run();
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.copyExtension',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.copyExtension',
-                'Copy'
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '1_copy'
-            },
-            run: async (accessor, extensionId) => {
-                const clipboardService = accessor.get(IClipboardService);
-                const extension = this.extensionsWorkbenchService.local.filter(e => areSameExtensions(e.identifier, { id: extensionId }))[0]
-                    || (await this.extensionsWorkbenchService.getExtensions([{ id: extensionId }], CancellationToken.None))[0];
-                if (extension) {
-                    const name = ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'extensionInfoName',
-                        'Name: {0}',
-                        extension.displayName
-                    ));
-                    const id = ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'extensionInfoId',
-                        'Id: {0}',
-                        extensionId
-                    ));
-                    const description = ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'extensionInfoDescription',
-                        'Description: {0}',
-                        extension.description
-                    ));
-                    const verision = ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'extensionInfoVersion',
-                        'Version: {0}',
-                        extension.version
-                    ));
-                    const publisher = ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'extensionInfoPublisher',
-                        'Publisher: {0}',
-                        extension.publisherDisplayName
-                    ));
-                    const link = extension.url ? ( localizeWithPath(
-                        'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                        'extensionInfoVSMarketplaceLink',
-                        'VS Marketplace Link: {0}',
-                        `${extension.url}`
-                    )) : null;
-                    const clipboardStr = `${name}\n${id}\n${description}\n${verision}\n${publisher}${link ? '\n' + link : ''}`;
-                    await clipboardService.writeText(clipboardStr);
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.copyExtensionId',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.copyExtensionId',
-                'Copy Extension ID'
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '1_copy'
-            },
-            run: async (accessor, id) => accessor.get(IClipboardService).writeText(id)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.configure',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.configure',
-                'Extension Settings'
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '2_configure',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('extensionStatus', 'installed')), ( ContextKeyExpr.has('extensionHasConfiguration')))),
-                order: 1
-            },
-            run: async (accessor, id) => accessor.get(IPreferencesService).openSettings({ jsonEditor: false, query: `@ext:${id}` })
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.configureKeybindings',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.configureKeybindings',
-                'Extension Keyboard Shortcuts'
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '2_configure',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('extensionStatus', 'installed')), ( ContextKeyExpr.has('extensionHasKeybindings')))),
-                order: 2
-            },
-            run: async (accessor, id) => accessor.get(IPreferencesService).openGlobalKeybindingSettings(false, { query: `@ext:${id}` })
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.toggleApplyToAllProfiles',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.toggleApplyToAllProfiles',
-                "Apply Extension to all Profiles"
-            )),
-            toggled: ( ContextKeyExpr.has('isApplicationScopedExtension')),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '2_configure',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('extensionStatus', 'installed')), ( ( ContextKeyExpr.has('isDefaultApplicationScopedExtension')).negate()), ( ( ContextKeyExpr.has('isBuiltinExtension')).negate()), ( ContextKeyExpr.equals('isWorkspaceScopedExtension', false)))),
-                order: 3
-            },
-            run: async (accessor, id) => {
-                const extension = this.extensionsWorkbenchService.local.find(e => areSameExtensions({ id }, e.identifier));
-                if (extension) {
-                    return this.extensionsWorkbenchService.toggleApplyExtensionToAllProfiles(extension);
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: TOGGLE_IGNORE_EXTENSION_ACTION_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.toggleIgnoreExtension',
-                "Sync This Extension"
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '2_configure',
-                when: ( ContextKeyExpr.and(CONTEXT_SYNC_ENABLEMENT, ( ContextKeyExpr.equals('isWorkspaceScopedExtension', false)))),
-                order: 4
-            },
-            run: async (accessor, id) => {
-                const extension = this.extensionsWorkbenchService.local.find(e => areSameExtensions({ id }, e.identifier));
-                if (extension) {
-                    return this.extensionsWorkbenchService.toggleExtensionIgnoredToSync(extension);
-                }
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.ignoreRecommendation',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.ignoreRecommendation',
-                "Ignore Recommendation"
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '3_recommendations',
-                when: ( ContextKeyExpr.has('isExtensionRecommended')),
-                order: 1
-            },
-            run: async (accessor, id) => accessor.get(IExtensionIgnoredRecommendationsService).toggleGlobalIgnoredRecommendation(id, true)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.undoIgnoredRecommendation',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.undoIgnoredRecommendation',
-                "Undo Ignored Recommendation"
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '3_recommendations',
-                when: ( ContextKeyExpr.has('isUserIgnoredRecommendation')),
-                order: 1
-            },
-            run: async (accessor, id) => accessor.get(IExtensionIgnoredRecommendationsService).toggleGlobalIgnoredRecommendation(id, false)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.addExtensionToWorkspaceRecommendations',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.addExtensionToWorkspaceRecommendations',
-                "Add to Workspace Recommendations"
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '3_recommendations',
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('empty')), ( ( ContextKeyExpr.has('isBuiltinExtension')).negate()), ( ( ContextKeyExpr.has('isExtensionWorkspaceRecommended')).negate()), ( ( ContextKeyExpr.has('isUserIgnoredRecommendation')).negate()), ( ContextKeyExpr.notEquals('extensionSource', 'resource')))),
-                order: 2
-            },
-            run: (accessor, id) => accessor.get(IWorkspaceExtensionsConfigService).toggleRecommendation(id)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.removeExtensionFromWorkspaceRecommendations',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.removeExtensionFromWorkspaceRecommendations',
-                "Remove from Workspace Recommendations"
-            )),
-            menu: {
-                id: MenuId.ExtensionContext,
-                group: '3_recommendations',
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('empty')), ( ( ContextKeyExpr.has('isBuiltinExtension')).negate()), ( ContextKeyExpr.has('isExtensionWorkspaceRecommended')))),
-                order: 2
-            },
-            run: (accessor, id) => accessor.get(IWorkspaceExtensionsConfigService).toggleRecommendation(id)
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.addToWorkspaceRecommendations',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.addToWorkspaceRecommendations',
-                "Add Extension to Workspace Recommendations"
-            )),
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions',
-                "Extensions"
-            )),
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('workspace')), ( ContextKeyExpr.equals('resourceScheme', Schemas.extension)))),
-            },
-            async run(accessor) {
-                const editorService = accessor.get(IEditorService);
-                const workspaceExtensionsConfigService = accessor.get(IWorkspaceExtensionsConfigService);
-                if (!(editorService.activeEditor instanceof ExtensionsInput)) {
-                    return;
-                }
-                const extensionId = editorService.activeEditor.extension.identifier.id.toLowerCase();
-                const recommendations = await workspaceExtensionsConfigService.getRecommendations();
-                if (recommendations.includes(extensionId)) {
-                    return;
-                }
-                await workspaceExtensionsConfigService.toggleRecommendation(extensionId);
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.addToWorkspaceFolderRecommendations',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.addToWorkspaceFolderRecommendations',
-                "Add Extension to Workspace Folder Recommendations"
-            )),
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions',
-                "Extensions"
-            )),
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('folder')), ( ContextKeyExpr.equals('resourceScheme', Schemas.extension)))),
-            },
-            run: () => this.commandService.executeCommand('workbench.extensions.action.addToWorkspaceRecommendations')
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.addToWorkspaceIgnoredRecommendations',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.addToWorkspaceIgnoredRecommendations',
-                "Add Extension to Workspace Ignored Recommendations"
-            )),
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions',
-                "Extensions"
-            )),
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('workspace')), ( ContextKeyExpr.equals('resourceScheme', Schemas.extension)))),
-            },
-            async run(accessor) {
-                const editorService = accessor.get(IEditorService);
-                const workspaceExtensionsConfigService = accessor.get(IWorkspaceExtensionsConfigService);
-                if (!(editorService.activeEditor instanceof ExtensionsInput)) {
-                    return;
-                }
-                const extensionId = editorService.activeEditor.extension.identifier.id.toLowerCase();
-                const unwantedRecommendations = await workspaceExtensionsConfigService.getUnwantedRecommendations();
-                if (unwantedRecommendations.includes(extensionId)) {
-                    return;
-                }
-                await workspaceExtensionsConfigService.toggleUnwantedRecommendation(extensionId);
-            }
-        });
-        this.registerExtensionAction({
-            id: 'workbench.extensions.action.addToWorkspaceFolderIgnoredRecommendations',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'workbench.extensions.action.addToWorkspaceFolderIgnoredRecommendations',
-                "Add Extension to Workspace Folder Ignored Recommendations"
-            )),
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions',
-                "Extensions"
-            )),
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('folder')), ( ContextKeyExpr.equals('resourceScheme', Schemas.extension)))),
-            },
-            run: () => this.commandService.executeCommand('workbench.extensions.action.addToWorkspaceIgnoredRecommendations')
-        });
-        this.registerExtensionAction({
-            id: ConfigureWorkspaceRecommendedExtensionsAction.ID,
-            title: { value: ConfigureWorkspaceRecommendedExtensionsAction.LABEL, original: 'Configure Recommended Extensions (Workspace)' },
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/extensions/browser/extensions.contribution',
-                'extensions',
-                "Extensions"
-            )),
-            menu: {
-                id: MenuId.CommandPalette,
-                when: ( WorkbenchStateContext.isEqualTo('workspace')),
-            },
-            run: () => runAction(this.instantiationService.createInstance(ConfigureWorkspaceRecommendedExtensionsAction, ConfigureWorkspaceRecommendedExtensionsAction.ID, ConfigureWorkspaceRecommendedExtensionsAction.LABEL))
-        });
-    }
-    registerExtensionAction(extensionActionOptions) {
-        const menus = extensionActionOptions.menu ? Array.isArray(extensionActionOptions.menu) ? extensionActionOptions.menu : [extensionActionOptions.menu] : [];
-        let menusWithOutTitles = [];
-        const menusWithTitles = [];
-        if (extensionActionOptions.menuTitles) {
-            for (let index = 0; index < menus.length; index++) {
-                const menu = menus[index];
-                const menuTitle = extensionActionOptions.menuTitles[menu.id.id];
-                if (menuTitle) {
-                    menusWithTitles.push({ id: menu.id, item: { ...menu, command: { id: extensionActionOptions.id, title: menuTitle } } });
-                }
-                else {
-                    menusWithOutTitles.push(menu);
-                }
-            }
-        }
-        else {
-            menusWithOutTitles = menus;
-        }
-        const disposables = ( new DisposableStore());
-        disposables.add(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    ...extensionActionOptions,
-                    menu: menusWithOutTitles
-                });
-            }
-            run(accessor, ...args) {
-                return extensionActionOptions.run(accessor, ...args);
-            }
-        }));
-        if (menusWithTitles.length) {
-            disposables.add(MenuRegistry.appendMenuItems(menusWithTitles));
-        }
-        return disposables;
-    }
-};
-ExtensionsContributions = ( __decorate([
-    ( __param(0, IExtensionManagementServerService)),
-    ( __param(1, IExtensionGalleryService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IPaneCompositePartService)),
-    ( __param(4, IExtensionsWorkbenchService)),
-    ( __param(5, IWorkbenchExtensionEnablementService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IDialogService)),
-    ( __param(8, ICommandService))
-], ExtensionsContributions));
-let ExtensionStorageCleaner = class ExtensionStorageCleaner {
-    constructor(extensionManagementService, storageService) {
-        ExtensionStorageService.removeOutdatedExtensionVersions(extensionManagementService, storageService);
-    }
-};
-ExtensionStorageCleaner = ( __decorate([
-    ( __param(0, IExtensionManagementService)),
-    ( __param(1, IStorageService))
-], ExtensionStorageCleaner));
-const workbenchRegistry = ( Registry.as(Extensions$4.Workbench));
-workbenchRegistry.registerWorkbenchContribution(ExtensionsContributions, 3 );
-workbenchRegistry.registerWorkbenchContribution(StatusUpdater, 4 );
-workbenchRegistry.registerWorkbenchContribution(MaliciousExtensionChecker, 4 );
-workbenchRegistry.registerWorkbenchContribution(KeymapExtensions, 3 );
-workbenchRegistry.registerWorkbenchContribution(ExtensionsViewletViewsContribution, 3 );
-workbenchRegistry.registerWorkbenchContribution(ExtensionActivationProgress, 4 );
-workbenchRegistry.registerWorkbenchContribution(ExtensionDependencyChecker, 4 );
-workbenchRegistry.registerWorkbenchContribution(ExtensionEnablementWorkspaceTrustTransitionParticipant, 3 );
-workbenchRegistry.registerWorkbenchContribution(ExtensionsCompletionItemsProvider, 3 );
-workbenchRegistry.registerWorkbenchContribution(UnsupportedExtensionsMigrationContrib, 4 );
-workbenchRegistry.registerWorkbenchContribution(DeprecatedExtensionsChecker, 4 );
-if (isWeb) {
-    workbenchRegistry.registerWorkbenchContribution(ExtensionStorageCleaner, 4 );
-}
-registerAction2(ShowRuntimeExtensionsAction);
-export { CONTEXT_HAS_LOCAL_SERVER, CONTEXT_HAS_REMOTE_SERVER, CONTEXT_HAS_WEB_SERVER };