@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

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

@@ -0,0 +1,2063 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { registerAction2, MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IExtensionManagementService, ExtensionsLocalizedLabel, PreferencesLocalizedLabel, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { IWorkbenchExtensionManagementService, IExtensionManagementServerService, IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IExtensionIgnoredRecommendationsService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/extensionRecommendations';
+import { Extensions as Extensions$3 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.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, LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID, WORKSPACE_RECOMMENDATIONS_VIEW_ID, THEME_ACTIONS_GROUP, INSTALL_ACTIONS_GROUP, TOGGLE_IGNORE_EXTENSION_ACTION_ID } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { SearchExtensionsAction, PromptExtensionInstallFailureAction, ConfigureWorkspaceFolderRecommendedExtensionsAction, InstallSpecificVersionOfExtensionAction, ReinstallAction, SetColorThemeAction, SetFileIconThemeAction, SetProductIconThemeAction, SwitchToPreReleaseVersionAction, SwitchToReleasedVersionAction, ClearLanguageAction, ConfigureWorkspaceRecommendedExtensionsAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+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 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import * as JSONContributionRegistry from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { ExtensionsConfigurationSchemaId, ExtensionsConfigurationSchema } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensionsFileTemplate';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { KeymapExtensions } from '../common/extensionsUtils.js';
+import { areSameExtensions, getIdAndVersion } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ExtensionActivationProgress } from './extensionsActivationProgress.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { ExtensionDependencyChecker } from './extensionsDependencyChecker.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Extensions as Extensions$1, IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { ManageExtensionsQuickAccessProvider, InstallExtensionQuickAccessProvider } from './extensionsQuickAccess.js';
+import { CONTEXT_SYNC_ENABLEMENT } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync';
+import { CopyAction, CutAction, PasteAction } from 'monaco-editor/esm/vs/editor/contrib/clipboard/browser/clipboard.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { IExtensionService, toExtensionDescription } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { WorkbenchStateContext, ResourceContextKey } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { IWorkspaceExtensionsConfigService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ShowRuntimeExtensionsAction } from './abstractRuntimeExtensionsEditor.js';
+import { ExtensionEnablementWorkspaceTrustTransitionParticipant } from './extensionEnablementWorkspaceTrustTransitionParticipant.js';
+import { extensionsViewIcon, installWorkspaceRecommendedIcon, filterIcon, clearSearchResultsIcon, refreshIcon, configureRecommendedIcon } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+import { Disposable, DisposableStore, isDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { mnemonicButtonLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { WORKSPACE_TRUST_EXTENSION_SUPPORT } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceTrust';
+import { ExtensionsCompletionItemsProvider } from './extensionsCompletionItemsProvider.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { UnsupportedExtensionsMigrationContrib } from './unsupportedExtensionsMigrationContribution.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { ExtensionStorageService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionStorage';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { CONTEXT_KEYBINDINGS_EDITOR } from 'vscode/vscode/vs/workbench/contrib/preferences/common/preferences';
+import { DeprecatedExtensionsChecker } from './deprecatedExtensionsChecker.js';
+import { IFileDialogService, IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+( 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: { value: ( localizeWithPath(
+        'vs/workbench/contrib/extensions/browser/extensions.contribution',
+        'extensions',
+        "Extensions"
+    )), original: '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({
+    id: 'extensions',
+    order: 30,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/extensions/browser/extensions.contribution',
+        'extensionsConfigurationTitle',
+        "Extensions"
+    )),
+    type: 'object',
+    properties: {
+        'extensions.autoUpdate': {
+            enum: [true, 'onlyEnabledExtensions', 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',
+                    '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.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
+        }
+    }
+});
+const jsonRegistry = ( Registry.as(JSONContributionRegistry.Extensions.JSONContribution));
+jsonRegistry.registerSchema(ExtensionsConfigurationSchemaId, ExtensionsConfigurationSchema);
+CommandsRegistry.registerCommand('_extensions.manage', (accessor, extensionId, tab, preserveFocus) => {
+    const extensionService = accessor.get(IExtensionsWorkbenchService);
+    const extension = extensionService.local.find(e => areSameExtensions(e.identifier, { id: extensionId }));
+    if (extension) {
+        extensionService.open(extension, { tab, preserveFocus });
+    }
+    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) => {
+    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 });
+    }
+    return commandService.executeCommand('_extensions.manage', extensionId, tab, preserveFocus);
+});
+CommandsRegistry.registerCommand({
+    id: 'workbench.extensions.installExtension',
+    description: {
+        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
+                        },
+                        '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);
+        try {
+            if (typeof arg === 'string') {
+                const [id, version] = getIdAndVersion(arg);
+                const [extension] = await extensionsWorkbenchService.getExtensions([{ id, preRelease: options?.installPreReleaseVersion }], CancellationToken.None);
+                if (extension) {
+                    const installOptions = {
+                        isMachineScoped: options?.donotSync ? true : undefined,
+                        installPreReleaseVersion: options?.installPreReleaseVersion,
+                        installGivenVersion: !!version,
+                        context: options?.context
+                    };
+                    if (extension.gallery && extension.enablementState === 1 ) {
+                        await extensionManagementService.installFromGallery(extension.gallery, installOptions);
+                        return;
+                    }
+                    if (version) {
+                        await extensionsWorkbenchService.installVersion(extension, version, installOptions);
+                    }
+                    else {
+                        await extensionsWorkbenchService.install(extension, installOptions);
+                    }
+                }
+                else {
+                    throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensions.contribution', 'notFound', "Extension '{0}' not found.", arg));
+                }
+            }
+            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',
+    description: {
+        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',
+    description: {
+        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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'focusExtensions',
+                "Focus on Extensions View"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'installExtensions',
+                "Install Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showRecommendedKeymapExtensionsShort',
+                "Keymaps"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showLanguageExtensionsShort',
+                "Language Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'checkForUpdates',
+                "Check for Extension Updates"
+            )), original: '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')))),
+            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',
+                "Only 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.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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'updateAll',
+                "Update All Extensions"
+            )), original: '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: () => {
+                return Promise.all(( this.extensionsWorkbenchService.outdated.map(async (extension) => {
+                    try {
+                        await this.extensionsWorkbenchService.install(extension, extension.local?.preRelease ? { installPreReleaseVersion: true } : undefined);
+                    }
+                    catch (err) {
+                        runAction(this.instantiationService.createInstance(PromptExtensionInstallFailureAction, extension, extension.latestVersion, 3 , err));
+                    }
+                })));
+            }
+        });
+        this.registerExtensionAction({
+            id: 'workbench.extensions.action.disableAutoUpdate',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'disableAutoUpdate',
+                "Disable Auto Update for All Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'enableAutoUpdate',
+                "Enable Auto Update for All Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'enableAll',
+                "Enable All Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'enableAllWorkspace',
+                "Enable All Extensions for this Workspace"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'disableAll',
+                "Disable All Installed Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'disableAllWorkspace',
+                "Disable All Installed Extensions for this Workspace"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'InstallFromVSIX',
+                "Install from VSIX..."
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'installExtensionFromLocation',
+                "Install Extension from Location..."
+            )), original: '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) {
+                    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)(() => {
+                        quickPick.hide();
+                        if (quickPick.value) {
+                            extensionManagementService.installFromLocation(( URI.parse(quickPick.value)));
+                        }
+                    }));
+                    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]) {
+                        extensionManagementService.installFromLocation(extensionLocation[0]);
+                    }
+                }
+            }
+        });
+        const extensionsFilterSubMenu = ( new MenuId('extensionsFilterSubMenu'));
+        MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+            submenu: extensionsFilterSubMenu,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'filterExtensions',
+                "Filter Extensions..."
+            )),
+            when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
+            group: 'navigation',
+            order: 1,
+            icon: filterIcon,
+        });
+        const showFeaturedExtensionsId = 'extensions.filter.featured';
+        this.registerExtensionAction({
+            id: showFeaturedExtensionsId,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showFeaturedExtensions',
+                "Show Featured Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showPopularExtensions',
+                "Show Popular Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showRecommendedExtensions',
+                "Show Recommended Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'recentlyPublishedExtensions',
+                "Show Recently Published Extensions"
+            )), original: '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,
+        });
+        this.registerExtensionAction({
+            id: 'workbench.extensions.action.listBuiltInExtensions',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showBuiltInExtensions',
+                "Show Built-in Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'extensionUpdates',
+                "Show Extension Updates"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showWorkspaceUnsupportedExtensions',
+                "Show Extensions Unsupported By Workspace"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showEnabledExtensions',
+                "Show Enabled Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'showDisabledExtensions',
+                "Show Disabled Extensions"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'clearExtensionsSearchResults',
+                "Clear Extensions Search Results"
+            )), original: 'Clear Extensions Search Results' },
+            category: ExtensionsLocalizedLabel,
+            icon: clearSearchResultsIcon,
+            f1: true,
+            precondition: SearchHasTextContext,
+            menu: {
+                id: MenuId.ViewContainerTitle,
+                when: ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)),
+                group: 'navigation',
+                order: 3,
+            },
+            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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'refreshExtension',
+                "Refresh"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'show pre-release version',
+                "Show Pre-Release Version"
+            )), original: 'Show Pre-Release Version' },
+            menu: {
+                id: MenuId.ExtensionContext,
+                group: INSTALL_ACTIONS_GROUP,
+                order: 0,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.has('inExtensionEditor')), ( ContextKeyExpr.has('extensionHasPreReleaseVersion')), 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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'show released version',
+                "Show Release Version"
+            )), original: 'Show Release Version' },
+            menu: {
+                id: MenuId.ExtensionContext,
+                group: INSTALL_ACTIONS_GROUP,
+                order: 1,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.has('inExtensionEditor')), ( ContextKeyExpr.has('extensionHasPreReleaseVersion')), ( 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: SwitchToPreReleaseVersionAction.ID,
+            title: SwitchToPreReleaseVersionAction.TITLE,
+            menu: {
+                id: MenuId.ExtensionContext,
+                group: INSTALL_ACTIONS_GROUP,
+                order: 2,
+                when: ( ContextKeyExpr.and(
+                    ContextKeyExpr.not('installedExtensionIsPreReleaseVersion'),
+                    ContextKeyExpr.not('installedExtensionIsOptedTpPreRelease'),
+                    ( ContextKeyExpr.has('extensionHasPreReleaseVersion')),
+                    ContextKeyExpr.not('inExtensionEditor'),
+                    ( ContextKeyExpr.equals('extensionStatus', 'installed')),
+                    ContextKeyExpr.not('isBuiltinExtension')
+                ))
+            },
+            run: async (accessor, id) => {
+                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id }));
+                if (extension) {
+                    extensionWorkbenchService.open(extension, { showPreReleaseVersion: true });
+                    await extensionWorkbenchService.install(extension, { installPreReleaseVersion: true });
+                }
+            }
+        });
+        this.registerExtensionAction({
+            id: SwitchToReleasedVersionAction.ID,
+            title: SwitchToReleasedVersionAction.TITLE,
+            menu: {
+                id: MenuId.ExtensionContext,
+                group: INSTALL_ACTIONS_GROUP,
+                order: 3,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.has('installedExtensionIsPreReleaseVersion')), ( ContextKeyExpr.has('extensionHasPreReleaseVersion')), ( ContextKeyExpr.has('extensionHasReleaseVersion')), ContextKeyExpr.not('inExtensionEditor'), ( ContextKeyExpr.equals('extensionStatus', 'installed')), ContextKeyExpr.not('isBuiltinExtension')))
+            },
+            run: async (accessor, id) => {
+                const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+                const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id }));
+                if (extension) {
+                    extensionWorkbenchService.open(extension, { showPreReleaseVersion: false });
+                    await extensionWorkbenchService.install(extension, { installPreReleaseVersion: false });
+                }
+            }
+        });
+        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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.copyExtension',
+                "Copy"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.copyExtensionId',
+                "Copy Extension ID"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.configure',
+                "Extension Settings"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.configureKeybindings',
+                "Extension Keyboard Shortcuts"
+            )), original: '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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.toggleApplyToAllProfiles',
+                "Apply Extension to all Profiles"
+            )), original: `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()))),
+                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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.toggleIgnoreExtension',
+                "Sync This Extension"
+            )), original: `Sync This Extension` },
+            menu: {
+                id: MenuId.ExtensionContext,
+                group: '2_configure',
+                when: ( ContextKeyExpr.and(CONTEXT_SYNC_ENABLEMENT, ( ( ContextKeyExpr.has('inExtensionEditor')).negate()))),
+                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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.ignoreRecommendation',
+                "Ignore Recommendation"
+            )), original: `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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.undoIgnoredRecommendation',
+                "Undo Ignored Recommendation"
+            )), original: `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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.addExtensionToWorkspaceRecommendations',
+                "Add to Workspace Recommendations"
+            )), original: `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()))),
+                order: 2
+            },
+            run: (accessor, id) => accessor.get(IWorkspaceExtensionsConfigService).toggleRecommendation(id)
+        });
+        this.registerExtensionAction({
+            id: 'workbench.extensions.action.removeExtensionFromWorkspaceRecommendations',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.removeExtensionFromWorkspaceRecommendations',
+                "Remove from Workspace Recommendations"
+            )), original: `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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.addToWorkspaceRecommendations',
+                "Add Extension to Workspace Recommendations"
+            )), original: `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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.addToWorkspaceFolderRecommendations',
+                "Add Extension to Workspace Folder Recommendations"
+            )), original: `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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.addToWorkspaceIgnoredRecommendations',
+                "Add Extension to Workspace Ignored Recommendations"
+            )), original: `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: { value: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensions.contribution',
+                'workbench.extensions.action.addToWorkspaceFolderIgnoredRecommendations',
+                "Add Extension to Workspace Folder Ignored Recommendations"
+            )), original: `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$3.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 };