@codingame/monaco-vscode-api 23.2.2 → 24.1.0

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

@@ -0,0 +1,2976 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { index } from '../../../../base/common/arrays.js';
+import { ThrottledDelayer, Promises, createCancelablePromise } from '../../../../base/common/async.js';
+import { getErrorMessage, CancellationError, isCancellationError } from '../../../../base/common/errors.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { fromNow } from '../../../../base/common/date.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { Disposable, MutableDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { FileAccess } from '../../../../base/common/network.js';
+import { singlePagePager } from '../../../../base/common/paging.js';
+import { isWeb, language } from '../../../../base/common/platform.js';
+import { joinPath } from '../../../../base/common/resources.js';
+import { semverExports } from '../../../../../../../_virtual/semver.js';
+import { isBoolean, isUndefined, isDefined, isString } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.service.js';
+import { localize } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IDialogService, IFileDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { getExtensionGalleryManifestResourceUri, ExtensionGalleryResourceType } from '../../../../platform/extensionManagement/common/extensionGalleryManifest.js';
+import { IExtensionGalleryManifestService } from '../../../../platform/extensionManagement/common/extensionGalleryManifest.service.js';
+import { AllowedExtensionsConfigKey, WEB_EXTENSION_TAG, EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT, InstallOperation, TargetPlatformToString, EXTENSION_IDENTIFIER_REGEX, shouldRequireRepositorySignatureFor, ExtensionManagementError, ExtensionManagementErrorCode, isTargetPlatformCompatible } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IExtensionGalleryService, IAllowedExtensionsService } from '../../../../platform/extensionManagement/common/extensionManagement.service.js';
+import { getGalleryExtensionTelemetryData, getLocalExtensionTelemetryData, findMatchingMaliciousEntry, areSameExtensions, groupByExtension, getGalleryExtensionId } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { ExtensionType, TargetPlatform, ExtensionIdentifier, isApplicationScopedExtension } from '../../../../platform/extensions/common/extensions.js';
+import { areApiProposalsCompatible, isEngineValid } from '../../../../platform/extensions/common/extensionValidator.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { getLocale } from '../../../../platform/languagePacks/common/languagePacks.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { NotificationPriority } from '../../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { StateType } from '../../../../platform/update/common/update.js';
+import { IUpdateService } from '../../../../platform/update/common/update.service.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { IURLService } from '../../../../platform/url/common/url.service.js';
+import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.service.js';
+import { IIgnoredExtensionsManagementService } from '../../../../platform/userDataSync/common/ignoredExtensions.service.js';
+import { SyncResource } from '../../../../platform/userDataSync/common/userDataSync.js';
+import { IUserDataAutoSyncService, IUserDataSyncEnablementService } from '../../../../platform/userDataSync/common/userDataSync.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { EnablementState } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IExtensionManagementServerService } from '../../../services/extensionManagement/common/extensionManagement.service.js';
+import { IExtensionManifestPropertiesService } from '../../../services/extensions/common/extensionManifestPropertiesService.service.js';
+import { toExtension, toExtensionDescription } from '../../../services/extensions/common/extensions.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { IHostService } from '../../../services/host/browser/host.service.js';
+import { LifecyclePhase } from '../../../services/lifecycle/common/lifecycle.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.service.js';
+import { ILocaleService } from '../../../services/localization/common/locale.service.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.service.js';
+import { IViewsService } from '../../../services/views/common/viewsService.service.js';
+import { ShowCurrentReleaseNotesActionId } from '../../update/common/update.js';
+import { ExtensionState, HasOutdatedExtensionsContext, AutoUpdateConfigurationKey, AutoCheckUpdatesConfigurationKey, AutoRestartConfigurationKey, VIEWLET_ID, ExtensionRuntimeActionType } from '../common/extensions.js';
+import { ExtensionsInput } from '../common/extensionsInput.js';
+import Severity$1 from '../../../../base/common/severity.js';
+
+var ExtensionsWorkbenchService_1;
+let Extension = class Extension {
+    constructor(stateProvider, runtimeStateProvider, server, local, _gallery, resourceExtensionInfo, galleryService, telemetryService, logService, fileService, productService) {
+        this.stateProvider = stateProvider;
+        this.runtimeStateProvider = runtimeStateProvider;
+        this.server = server;
+        this.local = local;
+        this._gallery = _gallery;
+        this.resourceExtensionInfo = resourceExtensionInfo;
+        this.galleryService = galleryService;
+        this.telemetryService = telemetryService;
+        this.logService = logService;
+        this.fileService = fileService;
+        this.productService = productService;
+        this.enablementState = EnablementState.EnabledGlobally;
+        this.galleryResourcesCache = ( new Map());
+    }
+    get resourceExtension() {
+        if (this.resourceExtensionInfo) {
+            return this.resourceExtensionInfo.resourceExtension;
+        }
+        if (this.local?.isWorkspaceScoped) {
+            return {
+                type: 'resource',
+                identifier: this.local.identifier,
+                location: this.local.location,
+                manifest: this.local.manifest,
+                changelogUri: this.local.changelogUrl,
+                readmeUri: this.local.readmeUrl,
+            };
+        }
+        return undefined;
+    }
+    get gallery() {
+        return this._gallery;
+    }
+    set gallery(gallery) {
+        this._gallery = gallery;
+        this.galleryResourcesCache.clear();
+    }
+    get missingFromGallery() {
+        return !!this._missingFromGallery;
+    }
+    set missingFromGallery(missing) {
+        this._missingFromGallery = missing;
+    }
+    get type() {
+        return this.local ? this.local.type : ExtensionType.User;
+    }
+    get isBuiltin() {
+        return this.local ? this.local.isBuiltin : false;
+    }
+    get isWorkspaceScoped() {
+        if (this.local) {
+            return this.local.isWorkspaceScoped;
+        }
+        if (this.resourceExtensionInfo) {
+            return this.resourceExtensionInfo.isWorkspaceScoped;
+        }
+        return false;
+    }
+    get name() {
+        if (this.gallery) {
+            return this.gallery.name;
+        }
+        return this.getManifestFromLocalOrResource()?.name ?? '';
+    }
+    get displayName() {
+        if (this.gallery) {
+            return this.gallery.displayName || this.gallery.name;
+        }
+        return this.getManifestFromLocalOrResource()?.displayName ?? this.name;
+    }
+    get identifier() {
+        if (this.gallery) {
+            return this.gallery.identifier;
+        }
+        if (this.resourceExtension) {
+            return this.resourceExtension.identifier;
+        }
+        return this.local?.identifier ?? { id: '' };
+    }
+    get uuid() {
+        return this.gallery ? this.gallery.identifier.uuid : this.local?.identifier.uuid;
+    }
+    get publisher() {
+        if (this.gallery) {
+            return this.gallery.publisher;
+        }
+        return this.getManifestFromLocalOrResource()?.publisher ?? '';
+    }
+    get publisherDisplayName() {
+        if (this.gallery) {
+            return this.gallery.publisherDisplayName || this.gallery.publisher;
+        }
+        if (this.local?.publisherDisplayName) {
+            return this.local.publisherDisplayName;
+        }
+        return this.publisher;
+    }
+    get publisherUrl() {
+        return this.gallery?.publisherLink ? ( URI.parse(this.gallery.publisherLink)) : undefined;
+    }
+    get publisherDomain() {
+        return this.gallery?.publisherDomain;
+    }
+    get publisherSponsorLink() {
+        return this.gallery?.publisherSponsorLink ? ( URI.parse(this.gallery.publisherSponsorLink)) : undefined;
+    }
+    get version() {
+        return this.local ? this.local.manifest.version : this.latestVersion;
+    }
+    get private() {
+        return this.gallery ? this.gallery.private : this.local ? this.local.private : false;
+    }
+    get pinned() {
+        return !!this.local?.pinned;
+    }
+    get latestVersion() {
+        return this.gallery ? this.gallery.version : this.getManifestFromLocalOrResource()?.version ?? '';
+    }
+    get description() {
+        return this.gallery ? this.gallery.description : this.getManifestFromLocalOrResource()?.description ?? '';
+    }
+    get url() {
+        return this.gallery?.detailsLink;
+    }
+    get iconUrl() {
+        return this.galleryIconUrl || this.resourceExtensionIconUrl || this.localIconUrl || this.defaultIconUrl;
+    }
+    get iconUrlFallback() {
+        return this.gallery?.assets.icon?.fallbackUri;
+    }
+    get localIconUrl() {
+        if (this.local && this.local.manifest.icon) {
+            return ( FileAccess.uriToBrowserUri(joinPath(this.local.location, this.local.manifest.icon)).toString(true));
+        }
+        return undefined;
+    }
+    get resourceExtensionIconUrl() {
+        if (this.resourceExtension?.manifest.icon) {
+            return ( FileAccess.uriToBrowserUri(joinPath(this.resourceExtension.location, this.resourceExtension.manifest.icon)).toString(true));
+        }
+        return undefined;
+    }
+    get galleryIconUrl() {
+        return this.gallery?.assets.icon?.uri;
+    }
+    get defaultIconUrl() {
+        if (this.type === ExtensionType.System && this.local) {
+            if (this.local.manifest && this.local.manifest.contributes) {
+                if (Array.isArray(this.local.manifest.contributes.themes) && this.local.manifest.contributes.themes.length) {
+                    return ( ( FileAccess.asBrowserUri('vs/workbench/contrib/extensions/browser/media/theme-icon.png')).toString(true));
+                }
+                if (Array.isArray(this.local.manifest.contributes.grammars) && this.local.manifest.contributes.grammars.length) {
+                    return ( ( FileAccess.asBrowserUri('vs/workbench/contrib/extensions/browser/media/language-icon.svg')).toString(true));
+                }
+            }
+        }
+        return undefined;
+    }
+    get repository() {
+        return this.gallery && this.gallery.assets.repository ? this.gallery.assets.repository.uri : undefined;
+    }
+    get licenseUrl() {
+        return this.gallery && this.gallery.assets.license ? this.gallery.assets.license.uri : undefined;
+    }
+    get supportUrl() {
+        return this.gallery && this.gallery.supportLink ? this.gallery.supportLink : undefined;
+    }
+    get state() {
+        return this.stateProvider(this);
+    }
+    get isMalicious() {
+        return !!this.malicious || this.enablementState === EnablementState.DisabledByMalicious;
+    }
+    get maliciousInfoLink() {
+        return this.malicious?.learnMoreLink;
+    }
+    get installCount() {
+        return this.gallery ? this.gallery.installCount : undefined;
+    }
+    get rating() {
+        return this.gallery ? this.gallery.rating : undefined;
+    }
+    get ratingCount() {
+        return this.gallery ? this.gallery.ratingCount : undefined;
+    }
+    get ratingUrl() {
+        return this.gallery?.ratingLink;
+    }
+    get outdated() {
+        try {
+            if (!this.gallery || !this.local) {
+                return false;
+            }
+            if (this.type === ExtensionType.System && this.productService.quality === 'stable') {
+                return false;
+            }
+            if (!this.local.preRelease && this.gallery.properties.isPreReleaseVersion) {
+                return false;
+            }
+            if (semverExports.gt(this.latestVersion, this.version)) {
+                return true;
+            }
+            if (this.outdatedTargetPlatform) {
+                return true;
+            }
+        }
+        catch (error) {
+        }
+        return false;
+    }
+    get outdatedTargetPlatform() {
+        return !!this.local && !!this.gallery
+            && ![TargetPlatform.UNDEFINED, TargetPlatform.WEB].includes(this.local.targetPlatform)
+            && this.gallery.properties.targetPlatform !== TargetPlatform.WEB
+            && this.local.targetPlatform !== this.gallery.properties.targetPlatform
+            && semverExports.eq(this.latestVersion, this.version);
+    }
+    get runtimeState() {
+        return this.runtimeStateProvider(this);
+    }
+    get telemetryData() {
+        const { local, gallery } = this;
+        if (gallery) {
+            return getGalleryExtensionTelemetryData(gallery);
+        }
+        else if (local) {
+            return getLocalExtensionTelemetryData(local);
+        }
+        else {
+            return {};
+        }
+    }
+    get preview() {
+        return this.local?.manifest.preview ?? this.gallery?.preview ?? false;
+    }
+    get preRelease() {
+        return !!this.local?.preRelease;
+    }
+    get isPreReleaseVersion() {
+        if (this.local) {
+            return this.local.isPreReleaseVersion;
+        }
+        return !!this.gallery?.properties.isPreReleaseVersion;
+    }
+    get hasPreReleaseVersion() {
+        return this.gallery ? this.gallery.hasPreReleaseVersion : !!this.local?.hasPreReleaseVersion;
+    }
+    get hasReleaseVersion() {
+        return !!this.resourceExtension || !!this.gallery?.hasReleaseVersion;
+    }
+    getLocal() {
+        return this.local && !this.outdated ? this.local : undefined;
+    }
+    async getManifest(token) {
+        const local = this.getLocal();
+        if (local) {
+            return local.manifest;
+        }
+        if (this.gallery) {
+            return this.getGalleryManifest(token);
+        }
+        if (this.resourceExtension) {
+            return this.resourceExtension.manifest;
+        }
+        return null;
+    }
+    async getGalleryManifest(token = CancellationToken.None) {
+        if (this.gallery) {
+            let cache = this.galleryResourcesCache.get('manifest');
+            if (!cache) {
+                if (this.gallery.assets.manifest) {
+                    this.galleryResourcesCache.set('manifest', cache = this.galleryService.getManifest(this.gallery, token)
+                        .catch(e => {
+                        this.galleryResourcesCache.delete('manifest');
+                        throw e;
+                    }));
+                }
+                else {
+                    this.logService.error(( localize(7757, "Manifest is not found")), this.identifier.id);
+                }
+            }
+            return cache;
+        }
+        return null;
+    }
+    hasReadme() {
+        if (this.local && this.local.readmeUrl) {
+            return true;
+        }
+        if (this.gallery && this.gallery.assets.readme) {
+            return true;
+        }
+        if (this.resourceExtension?.readmeUri) {
+            return true;
+        }
+        return this.type === ExtensionType.System;
+    }
+    async getReadme(token) {
+        const local = this.getLocal();
+        if (local?.readmeUrl) {
+            const content = await this.fileService.readFile(local.readmeUrl);
+            return ( content.value.toString());
+        }
+        if (this.gallery) {
+            if (this.gallery.assets.readme) {
+                return this.galleryService.getReadme(this.gallery, token);
+            }
+            this.telemetryService.publicLog('extensions:NotFoundReadMe', this.telemetryData);
+        }
+        if (this.type === ExtensionType.System) {
+            return Promise.resolve(`# ${this.displayName || this.name}
+**Notice:** This extension is bundled with Visual Studio Code. It can be disabled but not uninstalled.
+## Features
+${this.description}
+`);
+        }
+        if (this.resourceExtension?.readmeUri) {
+            const content = await this.fileService.readFile(this.resourceExtension?.readmeUri);
+            return ( content.value.toString());
+        }
+        return Promise.reject(( new Error('not available')));
+    }
+    hasChangelog() {
+        if (this.local && this.local.changelogUrl) {
+            return true;
+        }
+        if (this.gallery && this.gallery.assets.changelog) {
+            return true;
+        }
+        return this.type === ExtensionType.System;
+    }
+    async getChangelog(token) {
+        const local = this.getLocal();
+        if (local?.changelogUrl) {
+            const content = await this.fileService.readFile(local.changelogUrl);
+            return ( content.value.toString());
+        }
+        if (this.gallery?.assets.changelog) {
+            return this.galleryService.getChangelog(this.gallery, token);
+        }
+        if (this.type === ExtensionType.System) {
+            return Promise.resolve(`Please check the [VS Code Release Notes](command:${ShowCurrentReleaseNotesActionId}) for changes to the built-in extensions.`);
+        }
+        return Promise.reject(( new Error('not available')));
+    }
+    get categories() {
+        const { local, gallery, resourceExtension } = this;
+        if (local && local.manifest.categories && !this.outdated) {
+            return local.manifest.categories;
+        }
+        if (gallery) {
+            return gallery.categories;
+        }
+        if (resourceExtension) {
+            return resourceExtension.manifest.categories ?? [];
+        }
+        return [];
+    }
+    get tags() {
+        const { gallery } = this;
+        if (gallery) {
+            return gallery.tags.filter(tag => !tag.startsWith('_'));
+        }
+        return [];
+    }
+    get dependencies() {
+        const { local, gallery, resourceExtension } = this;
+        if (local && local.manifest.extensionDependencies && !this.outdated) {
+            return local.manifest.extensionDependencies;
+        }
+        if (gallery) {
+            return gallery.properties.dependencies || [];
+        }
+        if (resourceExtension) {
+            return resourceExtension.manifest.extensionDependencies || [];
+        }
+        return [];
+    }
+    get extensionPack() {
+        const { local, gallery, resourceExtension } = this;
+        if (local && local.manifest.extensionPack && !this.outdated) {
+            return local.manifest.extensionPack;
+        }
+        if (gallery) {
+            return gallery.properties.extensionPack || [];
+        }
+        if (resourceExtension) {
+            return resourceExtension.manifest.extensionPack || [];
+        }
+        return [];
+    }
+    setExtensionsControlManifest(extensionsControlManifest) {
+        this.malicious = findMatchingMaliciousEntry(this.identifier, extensionsControlManifest.malicious);
+        this.deprecationInfo = extensionsControlManifest.deprecated ? extensionsControlManifest.deprecated[this.identifier.id.toLowerCase()] : undefined;
+    }
+    getManifestFromLocalOrResource() {
+        if (this.local) {
+            return this.local.manifest;
+        }
+        if (this.resourceExtension) {
+            return this.resourceExtension.manifest;
+        }
+        return null;
+    }
+};
+Extension = ( __decorate([
+    ( __param(6, IExtensionGalleryService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IFileService)),
+    ( __param(10, IProductService))
+], Extension));
+const EXTENSIONS_AUTO_UPDATE_KEY = 'extensions.autoUpdate';
+const EXTENSIONS_DONOT_AUTO_UPDATE_KEY = 'extensions.donotAutoUpdate';
+const EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY = 'extensions.dismissedNotifications';
+let Extensions = class Extensions extends Disposable {
+    get onChange() { return this._onChange.event; }
+    get onReset() { return this._onReset.event; }
+    constructor(server, stateProvider, runtimeStateProvider, isWorkspaceServer, galleryService, extensionEnablementService, workbenchExtensionManagementService, telemetryService, instantiationService) {
+        super();
+        this.server = server;
+        this.stateProvider = stateProvider;
+        this.runtimeStateProvider = runtimeStateProvider;
+        this.isWorkspaceServer = isWorkspaceServer;
+        this.galleryService = galleryService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.workbenchExtensionManagementService = workbenchExtensionManagementService;
+        this.telemetryService = telemetryService;
+        this.instantiationService = instantiationService;
+        this._onChange = this._register(( new Emitter()));
+        this._onReset = this._register(( new Emitter()));
+        this.installing = [];
+        this.uninstalling = [];
+        this.installed = [];
+        this._register(server.extensionManagementService.onInstallExtension(e => this.onInstallExtension(e)));
+        this._register(server.extensionManagementService.onDidInstallExtensions(e => this.onDidInstallExtensions(e)));
+        this._register(server.extensionManagementService.onUninstallExtension(e => this.onUninstallExtension(e.identifier)));
+        this._register(server.extensionManagementService.onDidUninstallExtension(e => this.onDidUninstallExtension(e)));
+        this._register(server.extensionManagementService.onDidUpdateExtensionMetadata(e => this.onDidUpdateExtensionMetadata(e.local)));
+        this._register(server.extensionManagementService.onDidChangeProfile(() => this.reset()));
+        this._register(extensionEnablementService.onEnablementChanged(e => this.onEnablementChanged(e)));
+        this._register(Event.any(this.onChange, this.onReset)(() => this._local = undefined));
+        if (this.isWorkspaceServer) {
+            this._register(this.workbenchExtensionManagementService.onInstallExtension(e => {
+                if (e.workspaceScoped) {
+                    this.onInstallExtension(e);
+                }
+            }));
+            this._register(this.workbenchExtensionManagementService.onDidInstallExtensions(e => {
+                const result = e.filter(e => e.workspaceScoped);
+                if (result.length) {
+                    this.onDidInstallExtensions(result);
+                }
+            }));
+            this._register(this.workbenchExtensionManagementService.onUninstallExtension(e => {
+                if (e.workspaceScoped) {
+                    this.onUninstallExtension(e.identifier);
+                }
+            }));
+            this._register(this.workbenchExtensionManagementService.onDidUninstallExtension(e => {
+                if (e.workspaceScoped) {
+                    this.onDidUninstallExtension(e);
+                }
+            }));
+        }
+    }
+    get local() {
+        if (!this._local) {
+            this._local = [];
+            for (const extension of this.installed) {
+                this._local.push(extension);
+            }
+            for (const extension of this.installing) {
+                if (!( this.installed.some(installed => areSameExtensions(installed.identifier, extension.identifier)))) {
+                    this._local.push(extension);
+                }
+            }
+        }
+        return this._local;
+    }
+    async queryInstalled(productVersion) {
+        await this.fetchInstalledExtensions(productVersion);
+        this._onChange.fire(undefined);
+        return this.local;
+    }
+    async syncInstalledExtensionsWithGallery(galleryExtensions, productVersion, flagExtensionsMissingFromGallery) {
+        const extensions = await this.mapInstalledExtensionWithCompatibleGalleryExtension(galleryExtensions, productVersion);
+        for (const [extension, gallery] of extensions) {
+            if (extension.local && !extension.local.identifier.uuid) {
+                extension.local = await this.updateMetadata(extension.local, gallery);
+            }
+            if (!extension.gallery || extension.gallery.version !== gallery.version || extension.gallery.properties.targetPlatform !== gallery.properties.targetPlatform) {
+                extension.gallery = gallery;
+                this._onChange.fire({ extension });
+            }
+        }
+        if (flagExtensionsMissingFromGallery) {
+            const extensionsToQuery = [];
+            for (const extension of this.local) {
+                if (extension.gallery) {
+                    continue;
+                }
+                if (extension.missingFromGallery) {
+                    continue;
+                }
+                if (!extension.identifier.uuid) {
+                    continue;
+                }
+                if (!( flagExtensionsMissingFromGallery.some(f => areSameExtensions(f, extension.identifier)))) {
+                    continue;
+                }
+                extensionsToQuery.push(extension);
+            }
+            if (extensionsToQuery.length) {
+                const queryResult = await this.galleryService.getExtensions(( extensionsToQuery.map(e => ({ ...e.identifier, version: e.version }))), CancellationToken.None);
+                const queriedIds = [];
+                const missingIds = [];
+                for (const extension of extensionsToQuery) {
+                    queriedIds.push(extension.identifier.id);
+                    const gallery = queryResult.find(g => areSameExtensions(g.identifier, extension.identifier));
+                    if (gallery) {
+                        extension.gallery = gallery;
+                    }
+                    else {
+                        extension.missingFromGallery = true;
+                        missingIds.push(extension.identifier.id);
+                    }
+                    this._onChange.fire({ extension });
+                }
+                this.telemetryService.publicLog2('extensions:missingFromGallery', {
+                    queriedIds: ( new TelemetryTrustedValue(queriedIds.join(';'))),
+                    missingIds: ( new TelemetryTrustedValue(missingIds.join(';')))
+                });
+            }
+        }
+    }
+    async mapInstalledExtensionWithCompatibleGalleryExtension(galleryExtensions, productVersion) {
+        const mappedExtensions = this.mapInstalledExtensionWithGalleryExtension(galleryExtensions);
+        const targetPlatform = await this.server.extensionManagementService.getTargetPlatform();
+        const compatibleGalleryExtensions = [];
+        const compatibleGalleryExtensionsToFetch = [];
+        await Promise.allSettled(( mappedExtensions.map(async ([extension, gallery]) => {
+            if (extension.local) {
+                if (await this.galleryService.isExtensionCompatible(gallery, extension.local.preRelease, targetPlatform, productVersion)) {
+                    compatibleGalleryExtensions.push(gallery);
+                }
+                else {
+                    compatibleGalleryExtensionsToFetch.push({ ...extension.local.identifier, preRelease: extension.local.preRelease });
+                }
+            }
+        })));
+        if (compatibleGalleryExtensionsToFetch.length) {
+            const result = await this.galleryService.getExtensions(compatibleGalleryExtensionsToFetch, { targetPlatform, compatible: true, queryAllVersions: true, productVersion }, CancellationToken.None);
+            compatibleGalleryExtensions.push(...result);
+        }
+        return this.mapInstalledExtensionWithGalleryExtension(compatibleGalleryExtensions);
+    }
+    mapInstalledExtensionWithGalleryExtension(galleryExtensions) {
+        const mappedExtensions = [];
+        const byUUID = ( new Map()), byID = ( new Map());
+        for (const gallery of galleryExtensions) {
+            byUUID.set(gallery.identifier.uuid, gallery);
+            byID.set(gallery.identifier.id.toLowerCase(), gallery);
+        }
+        for (const installed of this.installed) {
+            if (installed.uuid) {
+                const gallery = byUUID.get(installed.uuid);
+                if (gallery) {
+                    mappedExtensions.push([installed, gallery]);
+                    continue;
+                }
+            }
+            if (installed.local?.source !== 'resource') {
+                const gallery = byID.get(installed.identifier.id.toLowerCase());
+                if (gallery) {
+                    mappedExtensions.push([installed, gallery]);
+                }
+            }
+        }
+        return mappedExtensions;
+    }
+    async updateMetadata(localExtension, gallery) {
+        let isPreReleaseVersion = false;
+        if (localExtension.manifest.version !== gallery.version) {
+            this.telemetryService.publicLog2('galleryService:updateMetadata');
+            const galleryWithLocalVersion = (await this.galleryService.getExtensions([{ ...localExtension.identifier, version: localExtension.manifest.version }], CancellationToken.None))[0];
+            isPreReleaseVersion = !!galleryWithLocalVersion?.properties?.isPreReleaseVersion;
+        }
+        return this.workbenchExtensionManagementService.updateMetadata(localExtension, { id: gallery.identifier.uuid, publisherDisplayName: gallery.publisherDisplayName, publisherId: gallery.publisherId, isPreReleaseVersion });
+    }
+    canInstall(galleryExtension) {
+        return this.server.extensionManagementService.canInstall(galleryExtension);
+    }
+    onInstallExtension(event) {
+        const { source } = event;
+        if (source && !URI.isUri(source)) {
+            const extension = this.installed.find(e => areSameExtensions(e.identifier, source.identifier))
+                ?? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, undefined, source, undefined);
+            this.installing.push(extension);
+            this._onChange.fire({ extension });
+        }
+    }
+    async fetchInstalledExtensions(productVersion) {
+        const extensionsControlManifest = await this.server.extensionManagementService.getExtensionsControlManifest();
+        const all = await this.server.extensionManagementService.getInstalled(undefined, undefined, productVersion);
+        if (this.isWorkspaceServer) {
+            all.push(...(await this.workbenchExtensionManagementService.getInstalledWorkspaceExtensions(true)));
+        }
+        const installed = groupByExtension(all, r => r.identifier).reduce((result, extensions) => {
+            if (extensions.length === 1) {
+                result.push(extensions[0]);
+            }
+            else {
+                let workspaceExtension, userExtension, systemExtension;
+                for (const extension of extensions) {
+                    if (extension.isWorkspaceScoped) {
+                        workspaceExtension = extension;
+                    }
+                    else if (extension.type === ExtensionType.User) {
+                        userExtension = extension;
+                    }
+                    else {
+                        systemExtension = extension;
+                    }
+                }
+                const extension = workspaceExtension ?? userExtension ?? systemExtension;
+                if (extension) {
+                    result.push(extension);
+                }
+            }
+            return result;
+        }, []);
+        const byId = index(this.installed, e => e.local ? e.local.identifier.id : e.identifier.id);
+        this.installed = ( installed.map(local => {
+            const extension = byId[local.identifier.id] || this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined, undefined);
+            extension.local = local;
+            extension.enablementState = this.extensionEnablementService.getEnablementState(local);
+            extension.setExtensionsControlManifest(extensionsControlManifest);
+            return extension;
+        }));
+    }
+    async reset() {
+        this.installed = [];
+        this.installing = [];
+        this.uninstalling = [];
+        await this.fetchInstalledExtensions();
+        this._onReset.fire();
+    }
+    async onDidInstallExtensions(results) {
+        const extensions = [];
+        for (const event of results) {
+            const { local, source } = event;
+            const gallery = source && !URI.isUri(source) ? source : undefined;
+            const location = source && URI.isUri(source) ? source : undefined;
+            const installingExtension = gallery ? this.installing.filter(e => areSameExtensions(e.identifier, gallery.identifier))[0] : null;
+            this.installing = installingExtension ? this.installing.filter(e => e !== installingExtension) : this.installing;
+            let extension = installingExtension ? installingExtension
+                : (location || local) ? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined, undefined)
+                    : undefined;
+            if (extension) {
+                if (local) {
+                    const installed = this.installed.filter(e => areSameExtensions(e.identifier, extension.identifier))[0];
+                    if (installed) {
+                        extension = installed;
+                    }
+                    else {
+                        this.installed.push(extension);
+                    }
+                    extension.local = local;
+                    if (!extension.gallery) {
+                        extension.gallery = gallery;
+                    }
+                    extension.enablementState = this.extensionEnablementService.getEnablementState(local);
+                }
+                extensions.push(extension);
+            }
+            this._onChange.fire(!local || !extension ? undefined : { extension, operation: event.operation });
+        }
+        if (extensions.length) {
+            const manifest = await this.server.extensionManagementService.getExtensionsControlManifest();
+            for (const extension of extensions) {
+                extension.setExtensionsControlManifest(manifest);
+            }
+            this.matchInstalledExtensionsWithGallery(extensions);
+        }
+    }
+    async onDidUpdateExtensionMetadata(local) {
+        const extension = this.installed.find(e => areSameExtensions(e.identifier, local.identifier));
+        if (extension?.local) {
+            extension.local = local;
+            this._onChange.fire({ extension });
+        }
+    }
+    async matchInstalledExtensionsWithGallery(extensions) {
+        const toMatch = extensions.filter(e => e.local && !e.gallery && e.local.source !== 'resource');
+        if (!toMatch.length) {
+            return;
+        }
+        if (!this.galleryService.isEnabled()) {
+            return;
+        }
+        const galleryExtensions = await this.galleryService.getExtensions(( toMatch.map(e => ({ ...e.identifier, preRelease: e.local?.preRelease }))), { compatible: true, targetPlatform: await this.server.extensionManagementService.getTargetPlatform() }, CancellationToken.None);
+        for (const extension of extensions) {
+            const compatible = galleryExtensions.find(e => areSameExtensions(e.identifier, extension.identifier));
+            if (compatible) {
+                extension.gallery = compatible;
+                this._onChange.fire({ extension });
+            }
+        }
+    }
+    onUninstallExtension(identifier) {
+        const extension = this.installed.filter(e => areSameExtensions(e.identifier, identifier))[0];
+        if (extension) {
+            const uninstalling = this.uninstalling.filter(e => areSameExtensions(e.identifier, identifier))[0] || extension;
+            this.uninstalling = [uninstalling, ...this.uninstalling.filter(e => !areSameExtensions(e.identifier, identifier))];
+            this._onChange.fire(uninstalling ? { extension: uninstalling } : undefined);
+        }
+    }
+    onDidUninstallExtension({ identifier, error }) {
+        const uninstalled = this.uninstalling.find(e => areSameExtensions(e.identifier, identifier)) || this.installed.find(e => areSameExtensions(e.identifier, identifier));
+        this.uninstalling = this.uninstalling.filter(e => !areSameExtensions(e.identifier, identifier));
+        if (!error) {
+            this.installed = this.installed.filter(e => !areSameExtensions(e.identifier, identifier));
+        }
+        if (uninstalled) {
+            this._onChange.fire({ extension: uninstalled });
+        }
+    }
+    onEnablementChanged(platformExtensions) {
+        const extensions = this.local.filter(e => ( platformExtensions.some(p => areSameExtensions(e.identifier, p.identifier))));
+        for (const extension of extensions) {
+            if (extension.local) {
+                const enablementState = this.extensionEnablementService.getEnablementState(extension.local);
+                if (enablementState !== extension.enablementState) {
+                    extension.enablementState = enablementState;
+                    this._onChange.fire({ extension });
+                }
+            }
+        }
+    }
+    getExtensionState(extension) {
+        if (extension.gallery && ( this.installing.some(
+            e => !!e.gallery && areSameExtensions(e.gallery.identifier, extension.gallery.identifier)
+        ))) {
+            return ExtensionState.Installing;
+        }
+        if (( this.uninstalling.some(e => areSameExtensions(e.identifier, extension.identifier)))) {
+            return ExtensionState.Uninstalling;
+        }
+        const local = this.installed.filter(e => e === extension || (e.gallery && extension.gallery && areSameExtensions(e.gallery.identifier, extension.gallery.identifier)))[0];
+        return local ? ExtensionState.Installed : ExtensionState.Uninstalled;
+    }
+};
+Extensions = ( __decorate([
+    ( __param(4, IExtensionGalleryService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, IWorkbenchExtensionManagementService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IInstantiationService))
+], Extensions));
+let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Disposable {
+    static { ExtensionsWorkbenchService_1 = this; }
+    static { this.UpdatesCheckInterval = 1000 * 60 * 60 * 12; }
+    get onChange() { return this._onChange.event; }
+    get onReset() { return this._onReset.event; }
+    constructor(instantiationService, editorService, extensionManagementService, galleryService, extensionGalleryManifestService, configurationService, telemetryService, notificationService, urlService, extensionEnablementService, hostService, progressService, extensionManagementServerService, languageService, extensionsSyncManagementService, userDataAutoSyncService, productService, contextKeyService, extensionManifestPropertiesService, logService, extensionService, localeService, lifecycleService, fileService, userDataProfileService, userDataProfilesService, storageService, dialogService, userDataSyncEnablementService, updateService, uriIdentityService, workspaceContextService, viewsService, fileDialogService, quickInputService, allowedExtensionsService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.extensionManagementService = extensionManagementService;
+        this.galleryService = galleryService;
+        this.extensionGalleryManifestService = extensionGalleryManifestService;
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.hostService = hostService;
+        this.progressService = progressService;
+        this.extensionManagementServerService = extensionManagementServerService;
+        this.languageService = languageService;
+        this.extensionsSyncManagementService = extensionsSyncManagementService;
+        this.userDataAutoSyncService = userDataAutoSyncService;
+        this.productService = productService;
+        this.extensionManifestPropertiesService = extensionManifestPropertiesService;
+        this.logService = logService;
+        this.extensionService = extensionService;
+        this.localeService = localeService;
+        this.lifecycleService = lifecycleService;
+        this.fileService = fileService;
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.storageService = storageService;
+        this.dialogService = dialogService;
+        this.userDataSyncEnablementService = userDataSyncEnablementService;
+        this.updateService = updateService;
+        this.uriIdentityService = uriIdentityService;
+        this.workspaceContextService = workspaceContextService;
+        this.viewsService = viewsService;
+        this.fileDialogService = fileDialogService;
+        this.quickInputService = quickInputService;
+        this.allowedExtensionsService = allowedExtensionsService;
+        this.localExtensions = null;
+        this.remoteExtensions = null;
+        this.webExtensions = null;
+        this.extensionsServers = [];
+        this._onChange = this._register(( new Emitter()));
+        this._onDidChangeExtensionsNotification = ( new Emitter());
+        this.onDidChangeExtensionsNotification = this._onDidChangeExtensionsNotification.event;
+        this._onReset = ( new Emitter());
+        this.installing = [];
+        this.tasksInProgress = [];
+        this.autoRestartListenerDisposable = this._register(( new MutableDisposable()));
+        this.hasOutdatedExtensionsContextKey = HasOutdatedExtensionsContext.bindTo(contextKeyService);
+        if (extensionManagementServerService.localExtensionManagementServer) {
+            this.localExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.localExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), !extensionManagementServerService.remoteExtensionManagementServer));
+            this._register(this.localExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
+            this._register(this.localExtensions.onReset(e => this.reset()));
+            this.extensionsServers.push(this.localExtensions);
+        }
+        if (extensionManagementServerService.remoteExtensionManagementServer) {
+            this.remoteExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.remoteExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), true));
+            this._register(this.remoteExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
+            this._register(this.remoteExtensions.onReset(e => this.reset()));
+            this.extensionsServers.push(this.remoteExtensions);
+        }
+        if (extensionManagementServerService.webExtensionManagementServer) {
+            this.webExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.webExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), !(extensionManagementServerService.remoteExtensionManagementServer || extensionManagementServerService.localExtensionManagementServer)));
+            this._register(this.webExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
+            this._register(this.webExtensions.onReset(e => this.reset()));
+            this.extensionsServers.push(this.webExtensions);
+        }
+        this.updatesCheckDelayer = ( new ThrottledDelayer(ExtensionsWorkbenchService_1.UpdatesCheckInterval));
+        this.autoUpdateDelayer = ( new ThrottledDelayer(1000));
+        this._register(toDisposable(() => {
+            this.updatesCheckDelayer.cancel();
+            this.autoUpdateDelayer.cancel();
+        }));
+        urlService.registerHandler(this);
+        this.whenInitialized = this.initialize();
+    }
+    async initialize() {
+        await Promise.all([this.queryLocal(), this.extensionService.whenInstalledExtensionsRegistered()]);
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.onDidChangeRunningExtensions(this.extensionService.extensions, []);
+        this._register(this.extensionService.onDidChangeExtensions(({ added, removed }) => this.onDidChangeRunningExtensions(added, removed)));
+        await this.lifecycleService.when(LifecyclePhase.Eventually);
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.initializeAutoUpdate();
+        this.updateExtensionsNotificaiton();
+        this.reportInstalledExtensionsTelemetry();
+        this._register(this.storageService.onDidChangeValue(StorageScope.PROFILE, EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, this._store)(e => this.onDidDismissedNotificationsValueChange()));
+        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, EXTENSIONS_AUTO_UPDATE_KEY, this._store)(e => this.onDidSelectedExtensionToAutoUpdateValueChange()));
+        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, EXTENSIONS_DONOT_AUTO_UPDATE_KEY, this._store)(e => this.onDidSelectedExtensionToAutoUpdateValueChange()));
+        this._register(Event.debounce(this.onChange, () => undefined, 100)(() => {
+            this.updateExtensionsNotificaiton();
+            this.reportProgressFromOtherSources();
+        }));
+    }
+    initializeAutoUpdate() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AutoUpdateConfigurationKey)) {
+                if (this.isAutoUpdateEnabled()) {
+                    this.eventuallyAutoUpdateExtensions();
+                }
+            }
+            if (e.affectsConfiguration(AutoCheckUpdatesConfigurationKey)) {
+                if (this.isAutoCheckUpdatesEnabled()) {
+                    this.checkForUpdates(`Enabled auto check updates`);
+                }
+            }
+        }));
+        this._register(this.extensionEnablementService.onEnablementChanged(platformExtensions => {
+            if (this.getAutoUpdateValue() === 'onlyEnabledExtensions' && ( platformExtensions.some(e => this.extensionEnablementService.isEnabled(e)))) {
+                this.checkForUpdates('Extension enablement changed');
+            }
+        }));
+        this._register(Event.debounce(this.onChange, () => undefined, 100)(() => this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0)));
+        this._register(this.updateService.onStateChange(e => {
+            if ((e.type === StateType.CheckingForUpdates && e.explicit) || e.type === StateType.AvailableForDownload || e.type === StateType.Downloaded) {
+                this.telemetryService.publicLog2('extensions:updatecheckonproductupdate');
+                if (this.isAutoCheckUpdatesEnabled()) {
+                    this.checkForUpdates('Product update');
+                }
+            }
+        }));
+        this._register(this.allowedExtensionsService.onDidChangeAllowedExtensionsConfigValue(() => {
+            if (this.isAutoCheckUpdatesEnabled()) {
+                this.checkForUpdates('Allowed extensions changed');
+            }
+        }));
+        this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0);
+        this.eventuallyCheckForUpdates(true);
+        if (isWeb) {
+            this.syncPinnedBuiltinExtensions();
+            if (!this.isAutoUpdateEnabled()) {
+                this.autoUpdateBuiltinExtensions();
+            }
+        }
+        this.registerAutoRestartListener();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AutoRestartConfigurationKey)) {
+                this.registerAutoRestartListener();
+            }
+        }));
+    }
+    isAutoUpdateEnabled() {
+        return this.getAutoUpdateValue() !== false;
+    }
+    getAutoUpdateValue() {
+        const autoUpdate = this.configurationService.getValue(AutoUpdateConfigurationKey);
+        if (autoUpdate === 'onlySelectedExtensions') {
+            return false;
+        }
+        return isBoolean(autoUpdate) || autoUpdate === 'onlyEnabledExtensions' ? autoUpdate : true;
+    }
+    async updateAutoUpdateForAllExtensions(isAutoUpdateEnabled) {
+        const wasAutoUpdateEnabled = this.isAutoUpdateEnabled();
+        if (wasAutoUpdateEnabled === isAutoUpdateEnabled) {
+            return;
+        }
+        const result = await this.dialogService.confirm({
+            title: ( localize(7758, "Auto Update Extensions")),
+            message: isAutoUpdateEnabled
+                ? ( localize(7759, "Do you want to enable auto update for all extensions?"))
+                : ( localize(7760, "Do you want to disable auto update for all extensions?")),
+            detail: ( localize(
+                7761,
+                "This will reset any auto update settings you have set for individual extensions."
+            )),
+        });
+        if (!result.confirmed) {
+            return;
+        }
+        this.setEnabledAutoUpdateExtensions([]);
+        await this.configurationService.updateValue(AutoUpdateConfigurationKey, isAutoUpdateEnabled);
+        this.setDisabledAutoUpdateExtensions([]);
+        await this.updateExtensionsPinnedState(!isAutoUpdateEnabled);
+        this._onChange.fire(undefined);
+    }
+    registerAutoRestartListener() {
+        this.autoRestartListenerDisposable.value = undefined;
+        if (this.configurationService.getValue(AutoRestartConfigurationKey) === true) {
+            this.autoRestartListenerDisposable.value = this.hostService.onDidChangeFocus(focus => {
+                if (!focus && this.configurationService.getValue(AutoRestartConfigurationKey) === true) {
+                    this.updateRunningExtensions(undefined, true);
+                }
+            });
+        }
+    }
+    reportInstalledExtensionsTelemetry() {
+        const extensionIds = ( this.installed.filter(extension => !extension.isBuiltin &&
+            (extension.enablementState === EnablementState.EnabledWorkspace ||
+                extension.enablementState === EnablementState.EnabledGlobally))
+            .map(extension => ExtensionIdentifier.toKey(extension.identifier.id)));
+        this.telemetryService.publicLog2('installedExtensions', { extensionIds: ( new TelemetryTrustedValue(extensionIds.join(';'))), count: extensionIds.length });
+    }
+    async onDidChangeRunningExtensions(added, removed) {
+        const changedExtensions = [];
+        const extensionsToFetch = [];
+        for (const desc of added) {
+            const extension = this.installed.find(e => areSameExtensions({ id: desc.identifier.value, uuid: desc.uuid }, e.identifier));
+            if (extension) {
+                changedExtensions.push(extension);
+            }
+            else {
+                extensionsToFetch.push(desc);
+            }
+        }
+        const workspaceExtensions = [];
+        for (const desc of removed) {
+            if (this.workspaceContextService.isInsideWorkspace(desc.extensionLocation)) {
+                workspaceExtensions.push(desc);
+            }
+            else {
+                extensionsToFetch.push(desc);
+            }
+        }
+        if (extensionsToFetch.length) {
+            const extensions = await this.getExtensions(( extensionsToFetch.map(e => ({ id: e.identifier.value, uuid: e.uuid }))), CancellationToken.None);
+            changedExtensions.push(...extensions);
+        }
+        if (workspaceExtensions.length) {
+            const extensions = await this.getResourceExtensions(( workspaceExtensions.map(e => e.extensionLocation)), true);
+            changedExtensions.push(...extensions);
+        }
+        for (const changedExtension of changedExtensions) {
+            this._onChange.fire(changedExtension);
+        }
+    }
+    updateExtensionsPinnedState(pinned) {
+        return this.progressService.withProgress({
+            location: ProgressLocation.Extensions,
+            title: ( localize(7762, "Updating Extensions Auto Update State")),
+        }, () => this.extensionManagementService.resetPinnedStateForAllUserExtensions(pinned));
+    }
+    reset() {
+        for (const task of this.tasksInProgress) {
+            task.cancel();
+        }
+        this.tasksInProgress = [];
+        this.installing = [];
+        this.onDidChangeExtensions();
+        this._onReset.fire();
+    }
+    onDidChangeExtensions(extension) {
+        this._installed = undefined;
+        this._local = undefined;
+        this._onChange.fire(extension);
+    }
+    get local() {
+        if (!this._local) {
+            if (this.extensionsServers.length === 1) {
+                this._local = this.installed;
+            }
+            else {
+                this._local = [];
+                const byId = groupByExtension(this.installed, r => r.identifier);
+                for (const extensions of byId) {
+                    this._local.push(this.getPrimaryExtension(extensions));
+                }
+            }
+        }
+        return this._local;
+    }
+    get installed() {
+        if (!this._installed) {
+            this._installed = [];
+            for (const extensions of this.extensionsServers) {
+                for (const extension of extensions.local) {
+                    this._installed.push(extension);
+                }
+            }
+        }
+        return this._installed;
+    }
+    get outdated() {
+        return this.installed.filter(e => e.outdated && e.local && e.state === ExtensionState.Installed);
+    }
+    async queryLocal(server) {
+        if (server) {
+            if (this.localExtensions && this.extensionManagementServerService.localExtensionManagementServer === server) {
+                return this.localExtensions.queryInstalled(this.getProductVersion());
+            }
+            if (this.remoteExtensions && this.extensionManagementServerService.remoteExtensionManagementServer === server) {
+                return this.remoteExtensions.queryInstalled(this.getProductVersion());
+            }
+            if (this.webExtensions && this.extensionManagementServerService.webExtensionManagementServer === server) {
+                return this.webExtensions.queryInstalled(this.getProductVersion());
+            }
+        }
+        if (this.localExtensions) {
+            try {
+                await this.localExtensions.queryInstalled(this.getProductVersion());
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        if (this.remoteExtensions) {
+            try {
+                await this.remoteExtensions.queryInstalled(this.getProductVersion());
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        if (this.webExtensions) {
+            try {
+                await this.webExtensions.queryInstalled(this.getProductVersion());
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return this.local;
+    }
+    async queryGallery(arg1, arg2) {
+        if (!this.galleryService.isEnabled()) {
+            return singlePagePager([]);
+        }
+        const options = CancellationToken.isCancellationToken(arg1) ? {} : arg1;
+        const token = CancellationToken.isCancellationToken(arg1) ? arg1 : arg2;
+        options.text = options.text ? this.resolveQueryText(options.text) : options.text;
+        options.includePreRelease = isUndefined(options.includePreRelease) ? this.extensionManagementService.preferPreReleases : options.includePreRelease;
+        const extensionsControlManifest = await this.extensionManagementService.getExtensionsControlManifest();
+        const pager = await this.galleryService.query(options, token);
+        this.syncInstalledExtensionsWithGallery(pager.firstPage);
+        return {
+            firstPage: ( pager.firstPage.map(gallery => this.fromGallery(gallery, extensionsControlManifest))),
+            total: pager.total,
+            pageSize: pager.pageSize,
+            getPage: async (pageIndex, token) => {
+                const page = await pager.getPage(pageIndex, token);
+                this.syncInstalledExtensionsWithGallery(page);
+                return ( page.map(gallery => this.fromGallery(gallery, extensionsControlManifest)));
+            }
+        };
+    }
+    async getExtensions(extensionInfos, arg1, arg2) {
+        if (!this.galleryService.isEnabled()) {
+            return [];
+        }
+        extensionInfos.forEach(e => e.preRelease = e.preRelease ?? this.extensionManagementService.preferPreReleases);
+        const extensionsControlManifest = await this.extensionManagementService.getExtensionsControlManifest();
+        const galleryExtensions = await this.galleryService.getExtensions(extensionInfos, arg1, arg2);
+        this.syncInstalledExtensionsWithGallery(galleryExtensions);
+        return ( galleryExtensions.map(gallery => this.fromGallery(gallery, extensionsControlManifest)));
+    }
+    async getResourceExtensions(locations, isWorkspaceScoped) {
+        const resourceExtensions = await this.extensionManagementService.getExtensions(locations);
+        return ( resourceExtensions.map(
+            resourceExtension => this.getInstalledExtensionMatchingLocation(resourceExtension.location)
+                ?? this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, undefined, { resourceExtension, isWorkspaceScoped })
+        ));
+    }
+    onDidDismissedNotificationsValueChange() {
+        if (this.dismissedNotificationsValue !== this.getDismissedNotificationsValue() ) {
+            this._dismissedNotificationsValue = undefined;
+            this.updateExtensionsNotificaiton();
+        }
+    }
+    updateExtensionsNotificaiton() {
+        const computedNotificiations = this.computeExtensionsNotifications();
+        const dismissedNotifications = [];
+        let extensionsNotification;
+        if (computedNotificiations.length) {
+            for (const dismissedNotification of this.getDismissedNotifications()) {
+                if (( computedNotificiations.some(e => e.key === dismissedNotification))) {
+                    dismissedNotifications.push(dismissedNotification);
+                }
+            }
+            if (!dismissedNotifications.includes(computedNotificiations[0].key)) {
+                extensionsNotification = {
+                    message: computedNotificiations[0].message,
+                    severity: computedNotificiations[0].severity,
+                    extensions: computedNotificiations[0].extensions,
+                    key: computedNotificiations[0].key,
+                    dismiss: () => {
+                        this.setDismissedNotifications([...this.getDismissedNotifications(), computedNotificiations[0].key]);
+                        this.updateExtensionsNotificaiton();
+                    },
+                };
+            }
+        }
+        this.setDismissedNotifications(dismissedNotifications);
+        if (this.extensionsNotification?.key !== extensionsNotification?.key) {
+            this.extensionsNotification = extensionsNotification;
+            this._onDidChangeExtensionsNotification.fire(this.extensionsNotification);
+        }
+    }
+    computeExtensionsNotifications() {
+        const computedNotificiations = [];
+        const disallowedExtensions = this.local.filter(e => e.enablementState === EnablementState.DisabledByAllowlist);
+        if (disallowedExtensions.length) {
+            computedNotificiations.push({
+                message: this.configurationService.inspect(AllowedExtensionsConfigKey).policy
+                    ? ( localize(
+                    7763,
+                    "Some extensions are disabled because they are not allowed by your system administrator."
+                ))
+                    : ( localize(
+                    7764,
+                    "Some extensions are disabled because they are configured not to be allowed."
+                )),
+                severity: Severity$1.Warning,
+                extensions: disallowedExtensions,
+                key: 'disallowedExtensions:' + ( disallowedExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join('-'),
+            });
+        }
+        const invalidExtensions = this.local.filter(e => e.enablementState === EnablementState.DisabledByInvalidExtension && !e.isWorkspaceScoped);
+        if (invalidExtensions.length) {
+            if (( invalidExtensions.some(e => e.local && e.local.manifest.engines?.vscode &&
+                (!isEngineValid(e.local.manifest.engines.vscode, this.productService.version, this.productService.date) || areApiProposalsCompatible([...(e.local.manifest.enabledApiProposals ?? [])]))))) {
+                computedNotificiations.push({
+                    message: ( localize(
+                        7765,
+                        "Some extensions are disabled due to version incompatibility. Review and update them."
+                    )),
+                    severity: Severity$1.Warning,
+                    extensions: invalidExtensions,
+                    key: 'incompatibleExtensions:' + ( invalidExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => `${e.identifier.id.toLowerCase()}@${e.local?.manifest.version}`)).join('-'),
+                });
+            }
+            else {
+                computedNotificiations.push({
+                    message: ( localize(7766, "Invalid extensions detected. Review them.")),
+                    severity: Severity$1.Warning,
+                    extensions: invalidExtensions,
+                    key: 'invalidExtensions:' + ( invalidExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => `${e.identifier.id.toLowerCase()}@${e.local?.manifest.version}`)).join('-'),
+                });
+            }
+        }
+        const deprecatedExtensions = this.local.filter(e => !!e.deprecationInfo && e.local && this.extensionEnablementService.isEnabled(e.local));
+        if (deprecatedExtensions.length) {
+            computedNotificiations.push({
+                message: ( localize(
+                    7767,
+                    "Deprecated extensions detected. Review them and migrate to alternatives."
+                )),
+                severity: Severity$1.Warning,
+                extensions: deprecatedExtensions,
+                key: 'deprecatedExtensions:' + ( deprecatedExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join('-'),
+            });
+        }
+        return computedNotificiations;
+    }
+    getExtensionsNotification() {
+        return this.extensionsNotification;
+    }
+    resolveQueryText(text) {
+        text = text.replace(/@web/g, `tag:"${WEB_EXTENSION_TAG}"`);
+        const extensionRegex = /\bext:([^\s]+)\b/g;
+        if (extensionRegex.test(text)) {
+            text = text.replace(extensionRegex, (m, ext) => {
+                const lookup = this.productService.extensionKeywords || {};
+                const keywords = lookup[ext] || [];
+                const languageId = this.languageService.guessLanguageIdByFilepathOrFirstLine(URI.file(`.${ext}`));
+                const languageName = languageId && this.languageService.getLanguageName(languageId);
+                const languageTag = languageName ? ` tag:"${languageName}"` : '';
+                return `tag:"__ext_${ext}" tag:"__ext_.${ext}" ${( keywords.map(tag => `tag:"${tag}"`)).join(' ')}${languageTag} tag:"${ext}"`;
+            });
+        }
+        return text.substr(0, 350);
+    }
+    fromGallery(gallery, extensionsControlManifest) {
+        let extension = this.getInstalledExtensionMatchingGallery(gallery);
+        if (!extension) {
+            extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, gallery, undefined);
+            extension.setExtensionsControlManifest(extensionsControlManifest);
+        }
+        return extension;
+    }
+    getInstalledExtensionMatchingGallery(gallery) {
+        for (const installed of this.local) {
+            if (installed.identifier.uuid) {
+                if (installed.identifier.uuid === gallery.identifier.uuid) {
+                    return installed;
+                }
+            }
+            else if (installed.local?.source !== 'resource') {
+                if (areSameExtensions(installed.identifier, gallery.identifier)) {
+                    return installed;
+                }
+            }
+        }
+        return null;
+    }
+    getInstalledExtensionMatchingLocation(location) {
+        return this.local.find(e => e.local && this.uriIdentityService.extUri.isEqualOrParent(location, e.local?.location)) ?? null;
+    }
+    async open(extension, options) {
+        if (typeof extension === 'string') {
+            const id = extension;
+            extension = this.installed.find(e => areSameExtensions(e.identifier, { id })) ?? (await this.getExtensions([{ id: extension }], CancellationToken.None))[0];
+        }
+        if (!extension) {
+            throw ( new Error(`Extension not found. ${extension}`));
+        }
+        await this.editorService.openEditor(this.instantiationService.createInstance(ExtensionsInput, extension), options, options?.sideByside ? SIDE_GROUP : ACTIVE_GROUP);
+    }
+    async openSearch(searchValue, preserveFoucs) {
+        const viewPaneContainer = (await this.viewsService.openViewContainer(VIEWLET_ID, true))?.getViewPaneContainer();
+        viewPaneContainer.search(searchValue);
+        if (!preserveFoucs) {
+            viewPaneContainer.focus();
+        }
+    }
+    getExtensionRuntimeStatus(extension) {
+        const extensionsStatus = this.extensionService.getExtensionsStatus();
+        for (const id of ( Object.keys(extensionsStatus))) {
+            if (areSameExtensions({ id }, extension.identifier)) {
+                return extensionsStatus[id];
+            }
+        }
+        return undefined;
+    }
+    async updateRunningExtensions(message = ( localize(7768, "Changing extension enablement")), auto = false) {
+        const toAdd = [];
+        const toRemove = [];
+        const extensionsToCheck = [...this.local];
+        for (const extension of extensionsToCheck) {
+            const runtimeState = extension.runtimeState;
+            if (!runtimeState || runtimeState.action !== ExtensionRuntimeActionType.RestartExtensions) {
+                continue;
+            }
+            if (extension.state === ExtensionState.Uninstalled) {
+                toRemove.push(extension.identifier.id);
+                continue;
+            }
+            if (!extension.local) {
+                continue;
+            }
+            const isEnabled = this.extensionEnablementService.isEnabled(extension.local);
+            if (isEnabled) {
+                const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, extension.identifier));
+                if (runningExtension) {
+                    toRemove.push(runningExtension.identifier.value);
+                }
+                toAdd.push(extension.local);
+            }
+            else {
+                toRemove.push(extension.identifier.id);
+            }
+        }
+        for (const extension of this.extensionService.extensions) {
+            if (extension.isUnderDevelopment) {
+                continue;
+            }
+            if (( extensionsToCheck.some(
+                e => areSameExtensions({ id: extension.identifier.value, uuid: extension.uuid }, e.local?.identifier ?? e.identifier)
+            ))) {
+                continue;
+            }
+            toRemove.push(extension.identifier.value);
+        }
+        if (toAdd.length || toRemove.length) {
+            if (await this.extensionService.stopExtensionHosts(message, auto)) {
+                await this.extensionService.startExtensionHosts({ toAdd, toRemove });
+                if (auto) {
+                    this.notificationService.notify({
+                        severity: Severity$1.Info,
+                        message: ( localize(7769, "Extensions were auto restarted to enable updates.")),
+                        priority: NotificationPriority.SILENT
+                    });
+                }
+                this.telemetryService.publicLog2('extensions:autorestart', { count: toAdd.length + toRemove.length, auto });
+            }
+        }
+    }
+    getRuntimeState(extension) {
+        const isUninstalled = extension.state === ExtensionState.Uninstalled;
+        const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({ id: e.identifier.value }, extension.identifier));
+        const reloadAction = this.extensionManagementServerService.remoteExtensionManagementServer ? ExtensionRuntimeActionType.ReloadWindow : ExtensionRuntimeActionType.RestartExtensions;
+        const reloadActionLabel = reloadAction === ExtensionRuntimeActionType.ReloadWindow ? ( localize(7770, "reload window")) : ( localize(7771, "restart extensions"));
+        if (isUninstalled) {
+            const canRemoveRunningExtension = runningExtension && this.extensionService.canRemoveExtension(runningExtension);
+            const isSameExtensionRunning = runningExtension
+                && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension)))
+                && (!extension.resourceExtension || this.uriIdentityService.extUri.isEqual(extension.resourceExtension.location, runningExtension.extensionLocation));
+            if (!canRemoveRunningExtension && isSameExtensionRunning && !runningExtension.isUnderDevelopment) {
+                return { action: reloadAction, reason: ( localize(
+                    7772,
+                    "Please {0} to complete the uninstallation of this extension.",
+                    reloadActionLabel
+                )) };
+            }
+            return undefined;
+        }
+        if (extension.local) {
+            const isSameExtensionRunning = runningExtension && extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension));
+            const isEnabled = this.extensionEnablementService.isEnabled(extension.local);
+            if (runningExtension) {
+                if (isEnabled) {
+                    if (this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
+                        return undefined;
+                    }
+                    const runningExtensionServer = this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension));
+                    if (isSameExtensionRunning) {
+                        if (!runningExtension.isUnderDevelopment && (extension.version !== runningExtension.version || extension.local.targetPlatform !== runningExtension.targetPlatform)) {
+                            const productCurrentVersion = this.getProductCurrentVersion();
+                            const productUpdateVersion = this.getProductUpdateVersion();
+                            if (productUpdateVersion
+                                && !isEngineValid(extension.local.manifest.engines.vscode, productCurrentVersion.version, productCurrentVersion.date)
+                                && isEngineValid(extension.local.manifest.engines.vscode, productUpdateVersion.version, productUpdateVersion.date)) {
+                                const state = this.updateService.state;
+                                if (state.type === StateType.AvailableForDownload) {
+                                    return { action: ExtensionRuntimeActionType.DownloadUpdate, reason: ( localize(
+                                        7773,
+                                        "Please update {0} to enable the updated extension.",
+                                        this.productService.nameLong
+                                    )) };
+                                }
+                                if (state.type === StateType.Downloaded) {
+                                    return { action: ExtensionRuntimeActionType.ApplyUpdate, reason: ( localize(
+                                        7774,
+                                        "Please update {0} to enable the updated extension.",
+                                        this.productService.nameLong
+                                    )) };
+                                }
+                                if (state.type === StateType.Ready) {
+                                    return { action: ExtensionRuntimeActionType.QuitAndInstall, reason: ( localize(
+                                        7775,
+                                        "Please restart {0} to enable the updated extension.",
+                                        this.productService.nameLong
+                                    )) };
+                                }
+                                return undefined;
+                            }
+                            return { action: reloadAction, reason: ( localize(7776, "Please {0} to enable the updated extension.", reloadActionLabel)) };
+                        }
+                        if (this.extensionsServers.length > 1) {
+                            const extensionInOtherServer = this.installed.filter(e => areSameExtensions(e.identifier, extension.identifier) && e.server !== extension.server)[0];
+                            if (extensionInOtherServer) {
+                                if (runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                                    return { action: reloadAction, reason: ( localize(7777, "Please {0} to enable this extension locally.", reloadActionLabel)) };
+                                }
+                                if (runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
+                                    return { action: reloadAction, reason: ( localize(
+                                        7778,
+                                        "Please {0} to enable this extension in {1}.",
+                                        reloadActionLabel,
+                                        this.extensionManagementServerService.remoteExtensionManagementServer?.label
+                                    )) };
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        if (extension.server === this.extensionManagementServerService.localExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer) {
+                            if (this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local.manifest)) {
+                                return { action: reloadAction, reason: ( localize(7779, "Please {0} to enable this extension.", reloadActionLabel)) };
+                            }
+                        }
+                        if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer) {
+                            if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local.manifest)) {
+                                return { action: reloadAction, reason: ( localize(7779, "Please {0} to enable this extension.", reloadActionLabel)) };
+                            }
+                        }
+                    }
+                    return undefined;
+                }
+                else {
+                    if (isSameExtensionRunning) {
+                        return { action: reloadAction, reason: ( localize(7780, "Please {0} to disable this extension.", reloadActionLabel)) };
+                    }
+                }
+                return undefined;
+            }
+            else {
+                if (isEnabled && !this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
+                    return { action: reloadAction, reason: ( localize(7779, "Please {0} to enable this extension.", reloadActionLabel)) };
+                }
+                const otherServer = extension.server ? extension.server === this.extensionManagementServerService.localExtensionManagementServer ? this.extensionManagementServerService.remoteExtensionManagementServer : this.extensionManagementServerService.localExtensionManagementServer : null;
+                if (otherServer && extension.enablementState === EnablementState.DisabledByExtensionKind) {
+                    const extensionInOtherServer = this.local.filter(e => areSameExtensions(e.identifier, extension.identifier) && e.server === otherServer)[0];
+                    if (extensionInOtherServer && extensionInOtherServer.local && this.extensionEnablementService.isEnabled(extensionInOtherServer.local)) {
+                        return { action: reloadAction, reason: ( localize(7779, "Please {0} to enable this extension.", reloadActionLabel)) };
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    getPrimaryExtension(extensions) {
+        if (extensions.length === 1) {
+            return extensions[0];
+        }
+        const enabledExtensions = extensions.filter(e => e.local && this.extensionEnablementService.isEnabled(e.local));
+        if (enabledExtensions.length === 1) {
+            return enabledExtensions[0];
+        }
+        const extensionsToChoose = enabledExtensions.length ? enabledExtensions : extensions;
+        const manifest = extensionsToChoose.find(e => e.local && e.local.manifest)?.local?.manifest;
+        if (!manifest) {
+            return extensionsToChoose[0];
+        }
+        const extensionKinds = this.extensionManifestPropertiesService.getExtensionKind(manifest);
+        let extension = extensionsToChoose.find(extension => {
+            for (const extensionKind of extensionKinds) {
+                switch (extensionKind) {
+                    case 'ui':
+                        if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
+                    case 'workspace':
+                        if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
+                    case 'web':
+                        if (extension.server === this.extensionManagementServerService.webExtensionManagementServer) {
+                            return true;
+                        }
+                        return false;
+                }
+            }
+            return false;
+        });
+        if (!extension && this.extensionManagementServerService.localExtensionManagementServer) {
+            extension = extensionsToChoose.find(extension => {
+                for (const extensionKind of extensionKinds) {
+                    switch (extensionKind) {
+                        case 'workspace':
+                            if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                                return true;
+                            }
+                            return false;
+                        case 'web':
+                            if (extension.server === this.extensionManagementServerService.localExtensionManagementServer) {
+                                return true;
+                            }
+                            return false;
+                    }
+                }
+                return false;
+            });
+        }
+        if (!extension && this.extensionManagementServerService.webExtensionManagementServer) {
+            extension = extensionsToChoose.find(extension => {
+                for (const extensionKind of extensionKinds) {
+                    switch (extensionKind) {
+                        case 'web':
+                            if (extension.server === this.extensionManagementServerService.webExtensionManagementServer) {
+                                return true;
+                            }
+                            return false;
+                    }
+                }
+                return false;
+            });
+        }
+        if (!extension && this.extensionManagementServerService.remoteExtensionManagementServer) {
+            extension = extensionsToChoose.find(extension => {
+                for (const extensionKind of extensionKinds) {
+                    switch (extensionKind) {
+                        case 'web':
+                            if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
+                                return true;
+                            }
+                            return false;
+                    }
+                }
+                return false;
+            });
+        }
+        return extension || extensions[0];
+    }
+    getExtensionState(extension) {
+        if (( this.installing.some(
+            i => areSameExtensions(i.identifier, extension.identifier) && (!extension.server || i.server === extension.server)
+        ))) {
+            return ExtensionState.Installing;
+        }
+        if (this.remoteExtensions) {
+            const state = this.remoteExtensions.getExtensionState(extension);
+            if (state !== ExtensionState.Uninstalled) {
+                return state;
+            }
+        }
+        if (this.webExtensions) {
+            const state = this.webExtensions.getExtensionState(extension);
+            if (state !== ExtensionState.Uninstalled) {
+                return state;
+            }
+        }
+        if (this.localExtensions) {
+            return this.localExtensions.getExtensionState(extension);
+        }
+        return ExtensionState.Uninstalled;
+    }
+    async checkForUpdates(reason, onlyBuiltin) {
+        if (reason) {
+            this.logService.trace(`[Extensions]: Checking for updates. Reason: ${reason}`);
+        }
+        else {
+            this.logService.trace(`[Extensions]: Checking for updates`);
+        }
+        if (!this.galleryService.isEnabled()) {
+            return;
+        }
+        const extensions = [];
+        if (this.localExtensions) {
+            extensions.push(this.localExtensions);
+        }
+        if (this.remoteExtensions) {
+            extensions.push(this.remoteExtensions);
+        }
+        if (this.webExtensions) {
+            extensions.push(this.webExtensions);
+        }
+        if (!extensions.length) {
+            return;
+        }
+        const infos = [];
+        for (const installed of this.local) {
+            if (onlyBuiltin && !installed.isBuiltin) {
+                continue;
+            }
+            if (installed.isBuiltin && !installed.local?.pinned && (installed.type === ExtensionType.System || !installed.local?.identifier.uuid)) {
+                continue;
+            }
+            if (installed.local?.source === 'resource') {
+                continue;
+            }
+            infos.push({ ...installed.identifier, preRelease: !!installed.local?.preRelease });
+        }
+        if (infos.length) {
+            const targetPlatform = await extensions[0].server.extensionManagementService.getTargetPlatform();
+            this.telemetryService.publicLog2('galleryService:checkingForUpdates', {
+                count: infos.length,
+            });
+            this.logService.trace(`Checking updates for extensions`, ( infos.map(e => e.id)).join(', '));
+            const galleryExtensions = await this.galleryService.getExtensions(infos, { targetPlatform, compatible: true, productVersion: this.getProductVersion() }, CancellationToken.None);
+            if (galleryExtensions.length) {
+                await this.syncInstalledExtensionsWithGallery(galleryExtensions, infos);
+            }
+        }
+    }
+    async updateAll() {
+        const toUpdate = [];
+        this.outdated.forEach((extension) => {
+            if (extension.gallery) {
+                toUpdate.push({
+                    extension: extension.gallery,
+                    options: {
+                        operation: InstallOperation.Update,
+                        installPreReleaseVersion: extension.local?.isPreReleaseVersion,
+                        profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
+                        isApplicationScoped: extension.local?.isApplicationScoped,
+                        context: { [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true }
+                    }
+                });
+            }
+        });
+        return this.extensionManagementService.installGalleryExtensions(toUpdate);
+    }
+    async downloadVSIX(extensionId, versionKind) {
+        let version;
+        if (versionKind === 'any') {
+            version = await this.pickVersionToDownload(extensionId);
+            if (!version) {
+                return;
+            }
+        }
+        const extensionInfo = version ? { id: extensionId, version: version.version } : { id: extensionId, preRelease: versionKind === 'prerelease' };
+        const queryOptions = version ? {} : { compatible: true };
+        let [galleryExtension] = await this.galleryService.getExtensions([extensionInfo], queryOptions, CancellationToken.None);
+        if (!galleryExtension) {
+            throw ( new Error(( localize(7781, "Extension '{0}' not found.", extensionId))));
+        }
+        let targetPlatform = galleryExtension.properties.targetPlatform;
+        const options = [];
+        for (const targetPlatform of version?.targetPlatforms ?? galleryExtension.allTargetPlatforms) {
+            if (targetPlatform !== TargetPlatform.UNKNOWN && targetPlatform !== TargetPlatform.UNIVERSAL) {
+                options.push({
+                    label: targetPlatform === TargetPlatform.UNDEFINED ? ( localize(7782, "All Platforms")) : TargetPlatformToString(targetPlatform),
+                    id: targetPlatform
+                });
+            }
+        }
+        if (options.length > 1) {
+            const message = ( localize(7783, "Please select the platform for which you want to download the VSIX"));
+            const option = await this.quickInputService.pick(options.sort((a, b) => a.label.localeCompare(b.label)), { placeHolder: message });
+            if (!option) {
+                return;
+            }
+            targetPlatform = option.id;
+        }
+        if (targetPlatform !== galleryExtension.properties.targetPlatform) {
+            [galleryExtension] = await this.galleryService.getExtensions([extensionInfo], { ...queryOptions, targetPlatform }, CancellationToken.None);
+        }
+        const result = await this.fileDialogService.showOpenDialog({
+            title: ( localize(7784, "Select folder to download the VSIX")),
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            openLabel: ( localize(7785, "Download")),
+        });
+        if (!result?.[0]) {
+            return;
+        }
+        this.progressService.withProgress({ location: ProgressLocation.Notification }, async (progress) => {
+            try {
+                progress.report({ message: ( localize(7786, "Downloading VSIX...")) });
+                const name = `${galleryExtension.identifier.id}-${galleryExtension.version}${targetPlatform !== TargetPlatform.UNDEFINED && targetPlatform !== TargetPlatform.UNIVERSAL && targetPlatform !== TargetPlatform.UNKNOWN ? `-${targetPlatform}` : ''}.vsix`;
+                await this.galleryService.download(galleryExtension, this.uriIdentityService.extUri.joinPath(result[0], name), InstallOperation.None);
+                this.notificationService.info(( localize(7787, "Successfully downloaded the VSIX")));
+            }
+            catch (error) {
+                this.notificationService.error(( localize(7788, "Error while downloading the VSIX: {0}", getErrorMessage(error))));
+            }
+        });
+    }
+    async pickVersionToDownload(extensionId) {
+        const allVersions = await this.galleryService.getAllVersions({ id: extensionId });
+        if (!allVersions.length) {
+            await this.dialogService.info(( localize(7789, "This extension has no other versions.")));
+            return;
+        }
+        const picks = ( allVersions.map((v, i) => {
+            return {
+                id: v.version,
+                label: v.version,
+                description: `${fromNow(( new Date(Date.parse(v.date))), true)}${v.isPreReleaseVersion ? ` (${( localize(7790, "pre-release"))})` : ''}`,
+                ariaLabel: `${v.isPreReleaseVersion ? 'Pre-Release version' : 'Release version'} ${v.version}`,
+                data: v,
+            };
+        }));
+        const pick = await this.quickInputService.pick(picks, {
+            placeHolder: ( localize(7791, "Select Version to Download")),
+            matchOnDetail: true
+        });
+        return pick?.data;
+    }
+    async syncInstalledExtensionsWithGallery(gallery, flagExtensionsMissingFromGallery) {
+        const extensions = [];
+        if (this.localExtensions) {
+            extensions.push(this.localExtensions);
+        }
+        if (this.remoteExtensions) {
+            extensions.push(this.remoteExtensions);
+        }
+        if (this.webExtensions) {
+            extensions.push(this.webExtensions);
+        }
+        if (!extensions.length) {
+            return;
+        }
+        await Promise.allSettled(( extensions.map(
+            extensions => extensions.syncInstalledExtensionsWithGallery(gallery, this.getProductVersion(), flagExtensionsMissingFromGallery)
+        )));
+        if (this.outdated.length) {
+            this.logService.info(`Auto updating outdated extensions.`, ( this.outdated.map(e => e.identifier.id)).join(', '));
+            this.eventuallyAutoUpdateExtensions();
+        }
+    }
+    isAutoCheckUpdatesEnabled() {
+        return this.configurationService.getValue(AutoCheckUpdatesConfigurationKey);
+    }
+    eventuallyCheckForUpdates(immediate = false) {
+        this.updatesCheckDelayer.cancel();
+        this.updatesCheckDelayer.trigger(async () => {
+            if (this.isAutoCheckUpdatesEnabled()) {
+                await this.checkForUpdates();
+            }
+            this.eventuallyCheckForUpdates();
+        }, immediate ? 0 : this.getUpdatesCheckInterval()).then(undefined, err => null);
+    }
+    getUpdatesCheckInterval() {
+        if (this.productService.quality === 'insider' && this.getProductUpdateVersion()) {
+            return 1000 * 60 * 60 * 1;
+        }
+        return ExtensionsWorkbenchService_1.UpdatesCheckInterval;
+    }
+    eventuallyAutoUpdateExtensions() {
+        this.autoUpdateDelayer.trigger(() => this.autoUpdateExtensions())
+            .then(undefined, err => null);
+    }
+    async autoUpdateBuiltinExtensions() {
+        await this.checkForUpdates(undefined, true);
+        const toUpdate = this.outdated.filter(e => e.isBuiltin);
+        await Promises.settled(( toUpdate.map(
+            e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true } : undefined)
+        )));
+    }
+    async syncPinnedBuiltinExtensions() {
+        const infos = [];
+        for (const installed of this.local) {
+            if (installed.isBuiltin && installed.local?.pinned && installed.local?.identifier.uuid) {
+                infos.push({ ...installed.identifier, version: installed.version });
+            }
+        }
+        if (infos.length) {
+            const galleryExtensions = await this.galleryService.getExtensions(infos, CancellationToken.None);
+            if (galleryExtensions.length) {
+                await this.syncInstalledExtensionsWithGallery(galleryExtensions);
+            }
+        }
+    }
+    async autoUpdateExtensions() {
+        const toUpdate = [];
+        const disabledAutoUpdate = [];
+        const consentRequired = [];
+        for (const extension of this.outdated) {
+            if (!this.shouldAutoUpdateExtension(extension)) {
+                disabledAutoUpdate.push(extension.identifier.id);
+                continue;
+            }
+            if (await this.shouldRequireConsentToUpdate(extension)) {
+                consentRequired.push(extension.identifier.id);
+                continue;
+            }
+            toUpdate.push(extension);
+        }
+        if (disabledAutoUpdate.length) {
+            this.logService.trace('Auto update disabled for extensions', disabledAutoUpdate.join(', '));
+        }
+        if (consentRequired.length) {
+            this.logService.info('Auto update consent required for extensions', consentRequired.join(', '));
+        }
+        if (!toUpdate.length) {
+            return;
+        }
+        const productVersion = this.getProductVersion();
+        await Promises.settled(( toUpdate.map(
+            e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true, productVersion } : { productVersion })
+        )));
+    }
+    getProductVersion() {
+        return this.getProductUpdateVersion() ?? this.getProductCurrentVersion();
+    }
+    getProductCurrentVersion() {
+        return { version: this.productService.version, date: this.productService.date };
+    }
+    getProductUpdateVersion() {
+        switch (this.updateService.state.type) {
+            case StateType.AvailableForDownload:
+            case StateType.Downloaded:
+            case StateType.Updating:
+            case StateType.Ready: {
+                const version = this.updateService.state.update.productVersion;
+                if (version && semverExports.valid(version)) {
+                    return { version, date: this.updateService.state.update.timestamp ? ( new Date(this.updateService.state.update.timestamp)).toISOString() : undefined };
+                }
+            }
+        }
+        return undefined;
+    }
+    shouldAutoUpdateExtension(extension) {
+        if (extension.deprecationInfo?.disallowInstall) {
+            return false;
+        }
+        const autoUpdateValue = this.getAutoUpdateValue();
+        if (autoUpdateValue === false) {
+            const extensionsToAutoUpdate = this.getEnabledAutoUpdateExtensions();
+            const extensionId = extension.identifier.id.toLowerCase();
+            if (extensionsToAutoUpdate.includes(extensionId)) {
+                return true;
+            }
+            if (this.isAutoUpdateEnabledForPublisher(extension.publisher) && !extensionsToAutoUpdate.includes(`-${extensionId}`)) {
+                return true;
+            }
+            return false;
+        }
+        if (extension.pinned) {
+            return false;
+        }
+        const disabledAutoUpdateExtensions = this.getDisabledAutoUpdateExtensions();
+        if (disabledAutoUpdateExtensions.includes(extension.identifier.id.toLowerCase())) {
+            return false;
+        }
+        if (autoUpdateValue === true) {
+            return true;
+        }
+        if (autoUpdateValue === 'onlyEnabledExtensions') {
+            return extension.enablementState !== EnablementState.DisabledGlobally && extension.enablementState !== EnablementState.DisabledWorkspace;
+        }
+        return false;
+    }
+    async shouldRequireConsentToUpdate(extension) {
+        if (!extension.outdated) {
+            return;
+        }
+        if (!extension.gallery || !extension.local) {
+            return;
+        }
+        if (extension.local.identifier.uuid && extension.local.identifier.uuid !== extension.gallery.identifier.uuid) {
+            return localize(
+                7792,
+                "The marketplace metadata of this extension changed, likely due to a re-publish."
+            );
+        }
+        if (!extension.local.manifest.engines.vscode || extension.local.manifest.main || extension.local.manifest.browser) {
+            return;
+        }
+        if (isDefined(extension.gallery.properties?.executesCode)) {
+            if (!extension.gallery.properties.executesCode) {
+                return;
+            }
+        }
+        else {
+            const manifest = extension instanceof Extension
+                ? await extension.getGalleryManifest()
+                : await this.galleryService.getManifest(extension.gallery, CancellationToken.None);
+            if (!manifest?.main && !manifest?.browser) {
+                return;
+            }
+        }
+        return localize(
+            7793,
+            "The update for {0} extension introduces executable code, which is not present in the currently installed version.",
+            extension.displayName
+        );
+    }
+    isAutoUpdateEnabledFor(extensionOrPublisher) {
+        if (isString(extensionOrPublisher)) {
+            if (EXTENSION_IDENTIFIER_REGEX.test(extensionOrPublisher)) {
+                throw ( new Error('Expected publisher string, found extension identifier'));
+            }
+            if (this.isAutoUpdateEnabled()) {
+                return true;
+            }
+            return this.isAutoUpdateEnabledForPublisher(extensionOrPublisher);
+        }
+        return this.shouldAutoUpdateExtension(extensionOrPublisher);
+    }
+    isAutoUpdateEnabledForPublisher(publisher) {
+        const publishersToAutoUpdate = this.getPublishersToAutoUpdate();
+        return publishersToAutoUpdate.includes(publisher.toLowerCase());
+    }
+    async updateAutoUpdateEnablementFor(extensionOrPublisher, enable) {
+        if (this.isAutoUpdateEnabled()) {
+            if (isString(extensionOrPublisher)) {
+                throw ( new Error('Expected extension, found publisher string'));
+            }
+            const disabledAutoUpdateExtensions = this.getDisabledAutoUpdateExtensions();
+            const extensionId = extensionOrPublisher.identifier.id.toLowerCase();
+            const extensionIndex = disabledAutoUpdateExtensions.indexOf(extensionId);
+            if (enable) {
+                if (extensionIndex !== -1) {
+                    disabledAutoUpdateExtensions.splice(extensionIndex, 1);
+                }
+            }
+            else {
+                if (extensionIndex === -1) {
+                    disabledAutoUpdateExtensions.push(extensionId);
+                }
+            }
+            this.setDisabledAutoUpdateExtensions(disabledAutoUpdateExtensions);
+            if (enable && extensionOrPublisher.local && extensionOrPublisher.pinned) {
+                await this.extensionManagementService.updateMetadata(extensionOrPublisher.local, { pinned: false });
+            }
+            this._onChange.fire(extensionOrPublisher);
+        }
+        else {
+            const enabledAutoUpdateExtensions = this.getEnabledAutoUpdateExtensions();
+            if (isString(extensionOrPublisher)) {
+                if (EXTENSION_IDENTIFIER_REGEX.test(extensionOrPublisher)) {
+                    throw ( new Error('Expected publisher string, found extension identifier'));
+                }
+                extensionOrPublisher = extensionOrPublisher.toLowerCase();
+                if (this.isAutoUpdateEnabledFor(extensionOrPublisher) !== enable) {
+                    if (enable) {
+                        enabledAutoUpdateExtensions.push(extensionOrPublisher);
+                    }
+                    else {
+                        if (enabledAutoUpdateExtensions.includes(extensionOrPublisher)) {
+                            enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(extensionOrPublisher), 1);
+                        }
+                    }
+                }
+                this.setEnabledAutoUpdateExtensions(enabledAutoUpdateExtensions);
+                for (const e of this.installed) {
+                    if (e.publisher.toLowerCase() === extensionOrPublisher) {
+                        this._onChange.fire(e);
+                    }
+                }
+            }
+            else {
+                const extensionId = extensionOrPublisher.identifier.id.toLowerCase();
+                const enableAutoUpdatesForPublisher = this.isAutoUpdateEnabledFor(extensionOrPublisher.publisher.toLowerCase());
+                const enableAutoUpdatesForExtension = enabledAutoUpdateExtensions.includes(extensionId);
+                const disableAutoUpdatesForExtension = enabledAutoUpdateExtensions.includes(`-${extensionId}`);
+                if (enable) {
+                    if (disableAutoUpdatesForExtension) {
+                        enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(`-${extensionId}`), 1);
+                    }
+                    if (enableAutoUpdatesForPublisher) {
+                        if (enableAutoUpdatesForExtension) {
+                            enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(extensionId), 1);
+                        }
+                    }
+                    else {
+                        if (!enableAutoUpdatesForExtension) {
+                            enabledAutoUpdateExtensions.push(extensionId);
+                        }
+                    }
+                }
+                else {
+                    if (enableAutoUpdatesForExtension) {
+                        enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(extensionId), 1);
+                    }
+                    if (enableAutoUpdatesForPublisher) {
+                        if (!disableAutoUpdatesForExtension) {
+                            enabledAutoUpdateExtensions.push(`-${extensionId}`);
+                        }
+                    }
+                    else {
+                        if (disableAutoUpdatesForExtension) {
+                            enabledAutoUpdateExtensions.splice(enabledAutoUpdateExtensions.indexOf(`-${extensionId}`), 1);
+                        }
+                    }
+                }
+                this.setEnabledAutoUpdateExtensions(enabledAutoUpdateExtensions);
+                this._onChange.fire(extensionOrPublisher);
+            }
+        }
+        if (enable) {
+            this.autoUpdateExtensions();
+        }
+    }
+    onDidSelectedExtensionToAutoUpdateValueChange() {
+        if (this.enabledAuotUpdateExtensionsValue !== this.getEnabledAutoUpdateExtensionsValue()
+            || this.disabledAutoUpdateExtensionsValue !== this.getDisabledAutoUpdateExtensionsValue() ) {
+            const userExtensions = this.installed.filter(e => !e.isBuiltin);
+            const groupBy = (extensions) => {
+                const shouldAutoUpdate = [];
+                const shouldNotAutoUpdate = [];
+                for (const extension of extensions) {
+                    if (this.shouldAutoUpdateExtension(extension)) {
+                        shouldAutoUpdate.push(extension);
+                    }
+                    else {
+                        shouldNotAutoUpdate.push(extension);
+                    }
+                }
+                return [shouldAutoUpdate, shouldNotAutoUpdate];
+            };
+            const [wasShouldAutoUpdate, wasShouldNotAutoUpdate] = groupBy(userExtensions);
+            this._enabledAutoUpdateExtensionsValue = undefined;
+            this._disabledAutoUpdateExtensionsValue = undefined;
+            const [shouldAutoUpdate, shouldNotAutoUpdate] = groupBy(userExtensions);
+            for (const e of wasShouldAutoUpdate ?? []) {
+                if (shouldNotAutoUpdate?.includes(e)) {
+                    this._onChange.fire(e);
+                }
+            }
+            for (const e of wasShouldNotAutoUpdate ?? []) {
+                if (shouldAutoUpdate?.includes(e)) {
+                    this._onChange.fire(e);
+                }
+            }
+        }
+    }
+    async canInstall(extension) {
+        if (!(extension instanceof Extension)) {
+            return ( new MarkdownString()).appendText(( localize(7794, "The provided object is not an extension.")));
+        }
+        if (extension.isMalicious) {
+            return ( new MarkdownString()).appendText(( localize(7795, "This extension is reported to be problematic.")));
+        }
+        if (extension.deprecationInfo?.disallowInstall) {
+            return ( new MarkdownString()).appendText(( localize(7796, "This extension is disallowed to be installed.")));
+        }
+        if (extension.gallery) {
+            if (!extension.gallery.isSigned && shouldRequireRepositorySignatureFor(extension.private, await this.extensionGalleryManifestService.getExtensionGalleryManifest())) {
+                return ( new MarkdownString()).appendText(( localize(7797, "This extension is not signed.")));
+            }
+            const localResult = this.localExtensions ? await this.localExtensions.canInstall(extension.gallery) : undefined;
+            if (localResult === true) {
+                return true;
+            }
+            const remoteResult = this.remoteExtensions ? await this.remoteExtensions.canInstall(extension.gallery) : undefined;
+            if (remoteResult === true) {
+                return true;
+            }
+            const webResult = this.webExtensions ? await this.webExtensions.canInstall(extension.gallery) : undefined;
+            if (webResult === true) {
+                return true;
+            }
+            return localResult ?? remoteResult ?? webResult ?? ( new MarkdownString()).appendText(( localize(
+                7798,
+                "Cannot install the '{0}' extension because it is not available in this setup.",
+                extension.displayName ?? extension.identifier.id
+            )));
+        }
+        if (extension.resourceExtension && (await this.extensionManagementService.canInstall(extension.resourceExtension)) === true) {
+            return true;
+        }
+        return ( new MarkdownString()).appendText(( localize(
+            7798,
+            "Cannot install the '{0}' extension because it is not available in this setup.",
+            extension.displayName ?? extension.identifier.id
+        )));
+    }
+    async install(arg, installOptions = {}, progressLocation) {
+        let installable;
+        let extension;
+        let servers;
+        if (arg instanceof URI) {
+            installable = arg;
+        }
+        else {
+            let installableInfo;
+            let gallery;
+            if (isString(arg)) {
+                extension = this.local.find(e => areSameExtensions(e.identifier, { id: arg }));
+                if (!extension?.isBuiltin) {
+                    installableInfo = { id: arg, version: installOptions.version, preRelease: installOptions.installPreReleaseVersion ?? this.extensionManagementService.preferPreReleases };
+                }
+            }
+            else if (arg.gallery) {
+                extension = arg;
+                gallery = arg.gallery;
+                if (installOptions.version && installOptions.version !== gallery?.version) {
+                    installableInfo = { id: extension.identifier.id, version: installOptions.version };
+                }
+            }
+            else if (arg.resourceExtension) {
+                extension = arg;
+                installable = arg.resourceExtension;
+            }
+            if (installableInfo) {
+                const targetPlatform = extension?.server ? await extension.server.extensionManagementService.getTargetPlatform() : undefined;
+                gallery = (await this.galleryService.getExtensions([installableInfo], { targetPlatform }, CancellationToken.None)).at(0);
+            }
+            if (!extension && gallery) {
+                extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, gallery, undefined);
+                extension.setExtensionsControlManifest(await this.extensionManagementService.getExtensionsControlManifest());
+            }
+            if (extension?.isMalicious) {
+                throw ( new Error(( localize(7795, "This extension is reported to be problematic."))));
+            }
+            if (gallery) {
+                if (installOptions.installEverywhere) {
+                    servers = [];
+                    const installableServers = await this.extensionManagementService.getInstallableServers(gallery);
+                    for (const extensionsServer of this.extensionsServers) {
+                        if (installableServers.includes(extensionsServer.server) && !extensionsServer.local.find(e => areSameExtensions(e.identifier, gallery.identifier))) {
+                            servers.push(extensionsServer.server);
+                        }
+                    }
+                }
+                else if (installOptions.enable && extension?.local) {
+                    servers = [];
+                    if (extension.enablementState === EnablementState.DisabledByExtensionKind) {
+                        const [installableServer] = await this.extensionManagementService.getInstallableServers(gallery);
+                        if (installableServer) {
+                            servers.push(installableServer);
+                        }
+                    }
+                }
+            }
+            if (!servers || servers.length) {
+                if (!installable) {
+                    if (!gallery) {
+                        const id = isString(arg) ? arg : arg.identifier.id;
+                        const manifest = await this.extensionGalleryManifestService.getExtensionGalleryManifest();
+                        const reportIssueUri = manifest ? getExtensionGalleryManifestResourceUri(manifest, ExtensionGalleryResourceType.ContactSupportUri) : undefined;
+                        const reportIssueMessage = reportIssueUri ? ( localize(
+                            7799,
+                            "If this issue persists, please report it at {0}",
+                            (reportIssueUri.toString())
+                        )) : '';
+                        if (installOptions.version) {
+                            const message = ( localize(
+                                7800,
+                                "The extension '{0}' cannot be installed because the requested version '{1}' was not found.",
+                                id,
+                                installOptions.version
+                            ));
+                            throw ( new ExtensionManagementError(
+                                reportIssueMessage ? `${message} ${reportIssueMessage}` : message,
+                                ExtensionManagementErrorCode.NotFound
+                            ));
+                        }
+                        else {
+                            const message = ( localize(
+                                7801,
+                                "The extension '{0}' cannot be installed because it was not found.",
+                                id
+                            ));
+                            throw ( new ExtensionManagementError(
+                                reportIssueMessage ? `${message} ${reportIssueMessage}` : message,
+                                ExtensionManagementErrorCode.NotFound
+                            ));
+                        }
+                    }
+                    installable = gallery;
+                }
+                if (installOptions.version) {
+                    installOptions.installGivenVersion = true;
+                }
+                if (extension?.isWorkspaceScoped) {
+                    installOptions.isWorkspaceScoped = true;
+                }
+            }
+        }
+        if (installable) {
+            if (installOptions.justification) {
+                const syncCheck = isUndefined(installOptions.isMachineScoped) && this.userDataSyncEnablementService.isEnabled() && this.userDataSyncEnablementService.isResourceEnabled(SyncResource.Extensions);
+                const buttons = [];
+                buttons.push({
+                    label: isString(installOptions.justification) || !installOptions.justification.action
+                        ? ( localize(7802, "&&Install Extension"))
+                        : ( localize(7803, "&&Install Extension and {0}", installOptions.justification.action)), run: () => true
+                });
+                if (!extension) {
+                    buttons.push({ label: ( localize(7804, "Open Extension")), run: () => { this.open(extension); return false; } });
+                }
+                const result = await this.dialogService.prompt({
+                    title: ( localize(7805, "Install Extension")),
+                    message: extension ? ( localize(
+                        7806,
+                        "Would you like to install '{0}' extension from '{1}'?",
+                        extension.displayName,
+                        extension.publisherDisplayName
+                    )) : ( localize(7807, "Would you like to install the extension?")),
+                    detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
+                    cancelButton: true,
+                    buttons,
+                    checkbox: syncCheck ? {
+                        label: ( localize(7808, "Sync this extension")),
+                        checked: true,
+                    } : undefined,
+                });
+                if (!result.result) {
+                    throw ( new CancellationError());
+                }
+                if (syncCheck) {
+                    installOptions.isMachineScoped = !result.checkboxChecked;
+                }
+            }
+            if (installable instanceof URI) {
+                extension = await this.doInstall(undefined, () => this.installFromVSIX(installable, installOptions), progressLocation);
+            }
+            else if (extension) {
+                if (extension.resourceExtension) {
+                    extension = await this.doInstall(extension, () => this.extensionManagementService.installResourceExtension(installable, installOptions), progressLocation);
+                }
+                else {
+                    extension = await this.doInstall(extension, () => this.installFromGallery(extension, installable, installOptions, servers), progressLocation);
+                }
+            }
+        }
+        if (!extension) {
+            throw ( new Error(( localize(7809, "Unable to install extension"))));
+        }
+        if (installOptions.enable) {
+            if (extension.enablementState === EnablementState.DisabledWorkspace || extension.enablementState === EnablementState.DisabledGlobally) {
+                if (installOptions.justification) {
+                    const result = await this.dialogService.confirm({
+                        title: ( localize(7810, "Enable Extension")),
+                        message: ( localize(7811, "Would you like to enable '{0}' extension?", extension.displayName)),
+                        detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
+                        primaryButton: isString(installOptions.justification) ? ( localize(7812, "&&Enable Extension")) : ( localize(7813, "&&Enable Extension and {0}", installOptions.justification.action)),
+                    });
+                    if (!result.confirmed) {
+                        throw ( new CancellationError());
+                    }
+                }
+                await this.setEnablement(extension, extension.enablementState === EnablementState.DisabledWorkspace ? EnablementState.EnabledWorkspace : EnablementState.EnabledGlobally);
+            }
+            await this.waitUntilExtensionIsEnabled(extension);
+        }
+        return extension;
+    }
+    async installInServer(extension, server, installOptions) {
+        await this.doInstall(extension, async () => {
+            const local = extension.local;
+            if (!local) {
+                throw ( new Error('Extension not found'));
+            }
+            if (!extension.gallery) {
+                extension = (await this.getExtensions([{ ...extension.identifier, preRelease: local.preRelease }], CancellationToken.None))[0] ?? extension;
+            }
+            if (extension.gallery) {
+                return server.extensionManagementService.installFromGallery(extension.gallery, { installPreReleaseVersion: local.preRelease, ...installOptions });
+            }
+            const targetPlatform = await server.extensionManagementService.getTargetPlatform();
+            if (!isTargetPlatformCompatible(local.targetPlatform, [local.targetPlatform], targetPlatform)) {
+                throw ( new Error(( localize(
+                    7814,
+                    "Can't install '{0}' extension because it is not compatible.",
+                    extension.identifier.id
+                ))));
+            }
+            const vsix = await this.extensionManagementService.zip(local);
+            try {
+                return await server.extensionManagementService.install(vsix);
+            }
+            finally {
+                try {
+                    await this.fileService.del(vsix);
+                }
+                catch (error) {
+                    this.logService.error(error);
+                }
+            }
+        });
+    }
+    canSetLanguage(extension) {
+        if (!isWeb) {
+            return false;
+        }
+        if (!extension.gallery) {
+            return false;
+        }
+        const locale = getLocale(extension.gallery);
+        if (!locale) {
+            return false;
+        }
+        return true;
+    }
+    async setLanguage(extension) {
+        if (!this.canSetLanguage(extension)) {
+            throw ( new Error('Can not set language'));
+        }
+        const locale = getLocale(extension.gallery);
+        if (locale === language) {
+            return;
+        }
+        const localizedLanguageName = extension.gallery?.properties?.localizedLanguages?.[0];
+        return this.localeService.setLocale({ id: locale, galleryExtension: extension.gallery, extensionId: extension.identifier.id, label: localizedLanguageName ?? extension.displayName });
+    }
+    setEnablement(extensions, enablementState) {
+        extensions = Array.isArray(extensions) ? extensions : [extensions];
+        return this.promptAndSetEnablement(extensions, enablementState);
+    }
+    async uninstall(e) {
+        const extension = e.local ? e : this.local.find(local => areSameExtensions(local.identifier, e.identifier));
+        if (!extension?.local) {
+            throw ( new Error('Missing local'));
+        }
+        if (extension.local.isApplicationScoped && this.userDataProfilesService.profiles.length > 1) {
+            const { confirmed } = await this.dialogService.confirm({
+                title: ( localize(7815, "Uninstall Extension")),
+                type: Severity$1.Info,
+                message: ( localize(
+                    7816,
+                    "Would you like to Uninstall {0} from all profiles?",
+                    extension.displayName
+                )),
+                primaryButton: ( localize(7817, "Uninstall (All Profiles)"))
+            });
+            if (!confirmed) {
+                throw ( new CancellationError());
+            }
+        }
+        const extensionsToUninstall = [{ extension: extension.local }];
+        for (const packExtension of this.getAllPackedExtensions(extension, this.local)) {
+            if (packExtension.local && !( extensionsToUninstall.some(e => areSameExtensions(e.extension.identifier, packExtension.identifier)))) {
+                extensionsToUninstall.push({ extension: packExtension.local });
+            }
+        }
+        const dependents = [];
+        let extensionsFromAllProfiles;
+        for (const { extension } of extensionsToUninstall) {
+            const installedExtensions = [];
+            if (extension.isApplicationScoped && this.userDataProfilesService.profiles.length > 1) {
+                if (!extensionsFromAllProfiles) {
+                    extensionsFromAllProfiles = [];
+                    await Promise.allSettled(( this.userDataProfilesService.profiles.map(async (profile) => {
+                        const installed = await this.extensionManagementService.getInstalled(ExtensionType.User, profile.extensionsResource);
+                        for (const local of installed) {
+                            extensionsFromAllProfiles?.push([local, profile.extensionsResource]);
+                        }
+                    })));
+                }
+                installedExtensions.push(...extensionsFromAllProfiles);
+            }
+            else {
+                for (const { local } of this.local) {
+                    if (local) {
+                        installedExtensions.push([local, undefined]);
+                    }
+                }
+            }
+            for (const [local, profileLocation] of installedExtensions) {
+                if (areSameExtensions(local.identifier, extension.identifier)) {
+                    continue;
+                }
+                if (!local.manifest.extensionDependencies || local.manifest.extensionDependencies.length === 0) {
+                    continue;
+                }
+                if (extension.manifest.extensionPack?.some(id => areSameExtensions({ id }, local.identifier))) {
+                    continue;
+                }
+                if (( dependents.some(
+                    d => d.manifest.extensionPack?.some(id => areSameExtensions({ id }, local.identifier))
+                ))) {
+                    continue;
+                }
+                if (( local.manifest.extensionDependencies.some(dep => areSameExtensions(extension.identifier, { id: dep })))) {
+                    dependents.push(local);
+                    extensionsToUninstall.push({ extension: local, options: { profileLocation } });
+                }
+            }
+        }
+        if (dependents.length) {
+            const { result } = await this.dialogService.prompt({
+                title: ( localize(7818, "Uninstall Extension with Dependents")),
+                type: Severity$1.Warning,
+                message: this.getErrorMessageForUninstallingAnExtensionWithDependents(extension, dependents),
+                buttons: [{
+                        label: ( localize(7819, "Uninstall All")),
+                        run: () => true
+                    }],
+                cancelButton: {
+                    run: () => false
+                }
+            });
+            if (!result) {
+                throw ( new CancellationError());
+            }
+        }
+        return this.withProgress({
+            location: ProgressLocation.Extensions,
+            title: ( localize(7820, 'Uninstalling extension...')),
+            source: `${extension.identifier.id}`
+        }, () => this.extensionManagementService.uninstallExtensions(extensionsToUninstall).then(() => undefined));
+    }
+    getAllPackedExtensions(extension, installed, checked = []) {
+        if (( checked.some(e => areSameExtensions(e.identifier, extension.identifier)))) {
+            return [];
+        }
+        checked.push(extension);
+        const extensionsPack = extension.extensionPack ?? [];
+        if (extensionsPack.length) {
+            const packedExtensions = [];
+            for (const i of installed) {
+                if (!i.isBuiltin && ( extensionsPack.some(id => areSameExtensions({ id }, i.identifier)))) {
+                    packedExtensions.push(i);
+                }
+            }
+            const packOfPackedExtensions = [];
+            for (const packedExtension of packedExtensions) {
+                packOfPackedExtensions.push(...this.getAllPackedExtensions(packedExtension, installed, checked));
+            }
+            return [...packedExtensions, ...packOfPackedExtensions];
+        }
+        return [];
+    }
+    getErrorMessageForUninstallingAnExtensionWithDependents(extension, dependents) {
+        if (dependents.length === 1) {
+            return localize(
+                7821,
+                "Cannot uninstall '{0}' extension alone. '{1}' extension depends on this. Do you want to uninstall all these extensions?",
+                extension.displayName,
+                dependents[0].manifest.displayName
+            );
+        }
+        if (dependents.length === 2) {
+            return localize(
+                7822,
+                "Cannot uninstall '{0}' extension alone. '{1}' and '{2}' extensions depend on this. Do you want to uninstall all these extensions?",
+                extension.displayName,
+                dependents[0].manifest.displayName,
+                dependents[1].manifest.displayName
+            );
+        }
+        return localize(
+            7823,
+            "Cannot uninstall '{0}' extension alone. '{1}', '{2}' and other extensions depend on this. Do you want to uninstall all these extensions?",
+            extension.displayName,
+            dependents[0].manifest.displayName,
+            dependents[1].manifest.displayName
+        );
+    }
+    isExtensionIgnoredToSync(extension) {
+        return extension.local ? !this.isInstalledExtensionSynced(extension.local)
+            : this.extensionsSyncManagementService.hasToNeverSyncExtension(extension.identifier.id);
+    }
+    async togglePreRelease(extension) {
+        if (!extension.local) {
+            return;
+        }
+        if (extension.preRelease !== extension.isPreReleaseVersion) {
+            await this.extensionManagementService.updateMetadata(extension.local, { preRelease: !extension.preRelease });
+            return;
+        }
+        await this.install(extension, { installPreReleaseVersion: !extension.preRelease, preRelease: !extension.preRelease });
+    }
+    async toggleExtensionIgnoredToSync(extension) {
+        const extensionsIncludingPackedExtensions = [extension, ...this.getAllPackedExtensions(extension, this.local)];
+        for (const e of extensionsIncludingPackedExtensions) {
+            const isIgnored = this.isExtensionIgnoredToSync(e);
+            if (e.local && isIgnored && e.local.isMachineScoped) {
+                await this.extensionManagementService.updateMetadata(e.local, { isMachineScoped: false });
+            }
+            else {
+                await this.extensionsSyncManagementService.updateIgnoredExtensions(e.identifier.id, !isIgnored);
+            }
+        }
+        await this.userDataAutoSyncService.triggerSync(['IgnoredExtensionsUpdated']);
+    }
+    async toggleApplyExtensionToAllProfiles(extension) {
+        const extensionsIncludingPackedExtensions = [extension, ...this.getAllPackedExtensions(extension, this.local)];
+        const allExtensionServers = this.getAllExtensionServers();
+        await Promise.allSettled(( extensionsIncludingPackedExtensions.map(async (e) => {
+            if (!e.local || isApplicationScopedExtension(e.local.manifest) || e.isBuiltin) {
+                return;
+            }
+            const isApplicationScoped = e.local.isApplicationScoped;
+            await Promise.all(( allExtensionServers.map(async (extensionServer) => {
+                const local = extensionServer.local.find(local => areSameExtensions(e.identifier, local.identifier))?.local;
+                if (local && local.isApplicationScoped === isApplicationScoped) {
+                    await this.extensionManagementService.toggleApplicationScope(local, this.userDataProfileService.currentProfile.extensionsResource);
+                }
+            })));
+        })));
+    }
+    getAllExtensionServers() {
+        const extensions = [];
+        if (this.localExtensions) {
+            extensions.push(this.localExtensions);
+        }
+        if (this.remoteExtensions) {
+            extensions.push(this.remoteExtensions);
+        }
+        if (this.webExtensions) {
+            extensions.push(this.webExtensions);
+        }
+        return extensions;
+    }
+    isInstalledExtensionSynced(extension) {
+        if (extension.isMachineScoped) {
+            return false;
+        }
+        if (this.extensionsSyncManagementService.hasToAlwaysSyncExtension(extension.identifier.id)) {
+            return true;
+        }
+        return !this.extensionsSyncManagementService.hasToNeverSyncExtension(extension.identifier.id);
+    }
+    doInstall(extension, installTask, progressLocation) {
+        const title = extension ? ( localize(7824, "Installing '{0}' extension...", extension.displayName)) : ( localize(7825, 'Installing extension...'));
+        return this.withProgress({
+            location: progressLocation ?? ProgressLocation.Extensions,
+            title
+        }, async () => {
+            try {
+                if (extension) {
+                    this.installing.push(extension);
+                    this._onChange.fire(extension);
+                }
+                const local = await installTask();
+                return await this.waitAndGetInstalledExtension(local.identifier);
+            }
+            finally {
+                if (extension) {
+                    this.installing = this.installing.filter(e => e !== extension);
+                    this._onChange.fire(undefined);
+                }
+            }
+        });
+    }
+    async installFromVSIX(vsix, installOptions) {
+        const manifest = await this.extensionManagementService.getManifest(vsix);
+        const existingExtension = this.local.find(local => areSameExtensions(local.identifier, { id: getGalleryExtensionId(manifest.publisher, manifest.name) }));
+        if (existingExtension) {
+            installOptions = installOptions || {};
+            if (existingExtension.latestVersion === manifest.version) {
+                installOptions.pinned = installOptions.pinned ?? (existingExtension.local?.pinned || !this.shouldAutoUpdateExtension(existingExtension));
+            }
+            else {
+                installOptions.installGivenVersion = true;
+            }
+        }
+        return this.extensionManagementService.installVSIX(vsix, manifest, installOptions);
+    }
+    installFromGallery(extension, gallery, installOptions, servers) {
+        installOptions = installOptions ?? {};
+        installOptions.pinned = installOptions.pinned ?? (extension.local?.pinned || !this.shouldAutoUpdateExtension(extension));
+        if (extension.local && !servers) {
+            installOptions.productVersion = this.getProductVersion();
+            installOptions.operation = InstallOperation.Update;
+            return this.extensionManagementService.updateFromGallery(gallery, extension.local, installOptions);
+        }
+        else {
+            return this.extensionManagementService.installFromGallery(gallery, installOptions, servers);
+        }
+    }
+    async waitAndGetInstalledExtension(identifier) {
+        let installedExtension = this.local.find(local => areSameExtensions(local.identifier, identifier));
+        if (!installedExtension) {
+            await Event.toPromise(Event.filter(this.onChange, e => !!e && ( this.local.some(local => areSameExtensions(local.identifier, identifier)))));
+        }
+        installedExtension = this.local.find(local => areSameExtensions(local.identifier, identifier));
+        if (!installedExtension) {
+            throw ( new Error('Extension should have been installed'));
+        }
+        return installedExtension;
+    }
+    async waitUntilExtensionIsEnabled(extension) {
+        if (this.extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension.identifier.id))) {
+            return;
+        }
+        if (!extension.local || !this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
+            return;
+        }
+        await ( new Promise((c, e) => {
+            const disposable = this.extensionService.onDidChangeExtensions(() => {
+                try {
+                    if (this.extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension.identifier.id))) {
+                        disposable.dispose();
+                        c();
+                    }
+                }
+                catch (error) {
+                    e(error);
+                }
+            });
+        }));
+    }
+    promptAndSetEnablement(extensions, enablementState) {
+        const enable = enablementState === EnablementState.EnabledGlobally || enablementState === EnablementState.EnabledWorkspace;
+        if (enable) {
+            const allDependenciesAndPackedExtensions = this.getExtensionsRecursively(extensions, this.local, enablementState, { dependencies: true, pack: true });
+            return this.checkAndSetEnablement(extensions, allDependenciesAndPackedExtensions, enablementState);
+        }
+        else {
+            const packedExtensions = this.getExtensionsRecursively(extensions, this.local, enablementState, { dependencies: false, pack: true });
+            if (packedExtensions.length) {
+                return this.checkAndSetEnablement(extensions, packedExtensions, enablementState);
+            }
+            return this.checkAndSetEnablement(extensions, [], enablementState);
+        }
+    }
+    async checkAndSetEnablement(extensions, otherExtensions, enablementState) {
+        const allExtensions = [...extensions, ...otherExtensions];
+        const enable = enablementState === EnablementState.EnabledGlobally || enablementState === EnablementState.EnabledWorkspace;
+        if (!enable) {
+            for (const extension of extensions) {
+                const dependents = this.getDependentsAfterDisablement(extension, allExtensions, this.local);
+                if (dependents.length) {
+                    const { result } = await this.dialogService.prompt({
+                        title: ( localize(7826, "Disable Extension with Dependents")),
+                        type: Severity$1.Warning,
+                        message: this.getDependentsErrorMessageForDisablement(extension, allExtensions, dependents),
+                        buttons: [{
+                                label: ( localize(7827, 'Disable All')),
+                                run: () => true
+                            }],
+                        cancelButton: {
+                            run: () => false
+                        }
+                    });
+                    if (!result) {
+                        throw ( new CancellationError());
+                    }
+                    await this.checkAndSetEnablement(dependents, [extension], enablementState);
+                }
+            }
+        }
+        return this.doSetEnablement(allExtensions, enablementState);
+    }
+    getExtensionsRecursively(extensions, installed, enablementState, options, checked = []) {
+        const toCheck = extensions.filter(e => checked.indexOf(e) === -1);
+        if (toCheck.length) {
+            for (const extension of toCheck) {
+                checked.push(extension);
+            }
+            const extensionsToEanbleOrDisable = installed.filter(i => {
+                if (checked.indexOf(i) !== -1) {
+                    return false;
+                }
+                const enable = enablementState === EnablementState.EnabledGlobally || enablementState === EnablementState.EnabledWorkspace;
+                const isExtensionEnabled = i.enablementState === EnablementState.EnabledGlobally || i.enablementState === EnablementState.EnabledWorkspace;
+                if (enable === isExtensionEnabled) {
+                    return false;
+                }
+                return (enable || !i.isBuiltin)
+                    && (options.dependencies || options.pack)
+                    && ( extensions.some(extension => (options.dependencies && ( extension.dependencies.some(id => areSameExtensions({ id }, i.identifier))))
+                        || (options.pack && ( extension.extensionPack.some(id => areSameExtensions({ id }, i.identifier))))));
+            });
+            if (extensionsToEanbleOrDisable.length) {
+                extensionsToEanbleOrDisable.push(...this.getExtensionsRecursively(extensionsToEanbleOrDisable, installed, enablementState, options, checked));
+            }
+            return extensionsToEanbleOrDisable;
+        }
+        return [];
+    }
+    getDependentsAfterDisablement(extension, extensionsToDisable, installed) {
+        return installed.filter(i => {
+            if (i.dependencies.length === 0) {
+                return false;
+            }
+            if (i === extension) {
+                return false;
+            }
+            if (!this.extensionEnablementService.isEnabledEnablementState(i.enablementState)) {
+                return false;
+            }
+            if (extensionsToDisable.indexOf(i) !== -1) {
+                return false;
+            }
+            return ( i.dependencies.some(dep => ( [extension, ...extensionsToDisable].some(d => areSameExtensions(d.identifier, { id: dep })))));
+        });
+    }
+    getDependentsErrorMessageForDisablement(extension, allDisabledExtensions, dependents) {
+        for (const e of [extension, ...allDisabledExtensions]) {
+            const dependentsOfTheExtension = dependents.filter(d => ( d.dependencies.some(id => areSameExtensions({ id }, e.identifier))));
+            if (dependentsOfTheExtension.length) {
+                return this.getErrorMessageForDisablingAnExtensionWithDependents(e, dependentsOfTheExtension);
+            }
+        }
+        return '';
+    }
+    getErrorMessageForDisablingAnExtensionWithDependents(extension, dependents) {
+        if (dependents.length === 1) {
+            return localize(
+                7828,
+                "Cannot disable '{0}' extension alone. '{1}' extension depends on this. Do you want to disable all these extensions?",
+                extension.displayName,
+                dependents[0].displayName
+            );
+        }
+        if (dependents.length === 2) {
+            return localize(
+                7829,
+                "Cannot disable '{0}' extension alone. '{1}' and '{2}' extensions depend on this. Do you want to disable all these extensions?",
+                extension.displayName,
+                dependents[0].displayName,
+                dependents[1].displayName
+            );
+        }
+        return localize(
+            7830,
+            "Cannot disable '{0}' extension alone. '{1}', '{2}' and other extensions depend on this. Do you want to disable all these extensions?",
+            extension.displayName,
+            dependents[0].displayName,
+            dependents[1].displayName
+        );
+    }
+    async doSetEnablement(extensions, enablementState) {
+        return await this.extensionEnablementService.setEnablement(( extensions.map(e => e.local)), enablementState);
+    }
+    reportProgressFromOtherSources() {
+        if (( this.installed.some(
+            e => e.state === ExtensionState.Installing || e.state === ExtensionState.Uninstalling
+        ))) {
+            if (!this._activityCallBack) {
+                this.withProgress({ location: ProgressLocation.Extensions }, () => ( new Promise(resolve => this._activityCallBack = resolve)));
+            }
+        }
+        else {
+            this._activityCallBack?.();
+            this._activityCallBack = undefined;
+        }
+    }
+    withProgress(options, task) {
+        return this.progressService.withProgress(options, async () => {
+            const cancelableTask = createCancelablePromise(() => task());
+            this.tasksInProgress.push(cancelableTask);
+            try {
+                return await cancelableTask;
+            }
+            finally {
+                const index = this.tasksInProgress.indexOf(cancelableTask);
+                if (index !== -1) {
+                    this.tasksInProgress.splice(index, 1);
+                }
+            }
+        });
+    }
+    onError(err) {
+        if (isCancellationError(err)) {
+            return;
+        }
+        const message = err && err.message || '';
+        if (/getaddrinfo ENOTFOUND|getaddrinfo ENOENT|connect EACCES|connect ECONNREFUSED/.test(message)) {
+            return;
+        }
+        this.notificationService.error(err);
+    }
+    handleURL(uri, options) {
+        if (!/^extension/.test(uri.path)) {
+            return Promise.resolve(false);
+        }
+        this.onOpenExtensionUrl(uri);
+        return Promise.resolve(true);
+    }
+    onOpenExtensionUrl(uri) {
+        const match = /^extension\/([^/]+)$/.exec(uri.path);
+        if (!match) {
+            return;
+        }
+        const extensionId = match[1];
+        this.queryLocal().then(async (local) => {
+            let extension = local.find(local => areSameExtensions(local.identifier, { id: extensionId }));
+            if (!extension) {
+                [extension] = await this.getExtensions([{ id: extensionId }], { source: 'uri' }, CancellationToken.None);
+            }
+            if (extension) {
+                await this.hostService.focus(mainWindow);
+                await this.open(extension);
+            }
+        }).then(undefined, error => this.onError(error));
+    }
+    getPublishersToAutoUpdate() {
+        return this.getEnabledAutoUpdateExtensions().filter(id => !EXTENSION_IDENTIFIER_REGEX.test(id));
+    }
+    getEnabledAutoUpdateExtensions() {
+        try {
+            const parsedValue = JSON.parse(this.enabledAuotUpdateExtensionsValue);
+            if (Array.isArray(parsedValue)) {
+                return parsedValue;
+            }
+        }
+        catch (e) {  }
+        return [];
+    }
+    setEnabledAutoUpdateExtensions(enabledAutoUpdateExtensions) {
+        this.enabledAuotUpdateExtensionsValue = JSON.stringify(enabledAutoUpdateExtensions);
+    }
+    get enabledAuotUpdateExtensionsValue() {
+        if (!this._enabledAutoUpdateExtensionsValue) {
+            this._enabledAutoUpdateExtensionsValue = this.getEnabledAutoUpdateExtensionsValue();
+        }
+        return this._enabledAutoUpdateExtensionsValue;
+    }
+    set enabledAuotUpdateExtensionsValue(enabledAuotUpdateExtensionsValue) {
+        if (this.enabledAuotUpdateExtensionsValue !== enabledAuotUpdateExtensionsValue) {
+            this._enabledAutoUpdateExtensionsValue = enabledAuotUpdateExtensionsValue;
+            this.setEnabledAutoUpdateExtensionsValue(enabledAuotUpdateExtensionsValue);
+        }
+    }
+    getEnabledAutoUpdateExtensionsValue() {
+        return this.storageService.get(EXTENSIONS_AUTO_UPDATE_KEY, StorageScope.APPLICATION, '[]');
+    }
+    setEnabledAutoUpdateExtensionsValue(value) {
+        this.storageService.store(EXTENSIONS_AUTO_UPDATE_KEY, value, StorageScope.APPLICATION, StorageTarget.USER);
+    }
+    getDisabledAutoUpdateExtensions() {
+        try {
+            const parsedValue = JSON.parse(this.disabledAutoUpdateExtensionsValue);
+            if (Array.isArray(parsedValue)) {
+                return parsedValue;
+            }
+        }
+        catch (e) {  }
+        return [];
+    }
+    setDisabledAutoUpdateExtensions(disabledAutoUpdateExtensions) {
+        this.disabledAutoUpdateExtensionsValue = JSON.stringify(disabledAutoUpdateExtensions);
+    }
+    get disabledAutoUpdateExtensionsValue() {
+        if (!this._disabledAutoUpdateExtensionsValue) {
+            this._disabledAutoUpdateExtensionsValue = this.getDisabledAutoUpdateExtensionsValue();
+        }
+        return this._disabledAutoUpdateExtensionsValue;
+    }
+    set disabledAutoUpdateExtensionsValue(disabledAutoUpdateExtensionsValue) {
+        if (this.disabledAutoUpdateExtensionsValue !== disabledAutoUpdateExtensionsValue) {
+            this._disabledAutoUpdateExtensionsValue = disabledAutoUpdateExtensionsValue;
+            this.setDisabledAutoUpdateExtensionsValue(disabledAutoUpdateExtensionsValue);
+        }
+    }
+    getDisabledAutoUpdateExtensionsValue() {
+        return this.storageService.get(EXTENSIONS_DONOT_AUTO_UPDATE_KEY, StorageScope.APPLICATION, '[]');
+    }
+    setDisabledAutoUpdateExtensionsValue(value) {
+        this.storageService.store(EXTENSIONS_DONOT_AUTO_UPDATE_KEY, value, StorageScope.APPLICATION, StorageTarget.USER);
+    }
+    getDismissedNotifications() {
+        try {
+            const parsedValue = JSON.parse(this.dismissedNotificationsValue);
+            if (Array.isArray(parsedValue)) {
+                return parsedValue;
+            }
+        }
+        catch (e) {  }
+        return [];
+    }
+    setDismissedNotifications(dismissedNotifications) {
+        this.dismissedNotificationsValue = JSON.stringify(dismissedNotifications);
+    }
+    get dismissedNotificationsValue() {
+        if (!this._dismissedNotificationsValue) {
+            this._dismissedNotificationsValue = this.getDismissedNotificationsValue();
+        }
+        return this._dismissedNotificationsValue;
+    }
+    set dismissedNotificationsValue(dismissedNotificationsValue) {
+        if (this.dismissedNotificationsValue !== dismissedNotificationsValue) {
+            this._dismissedNotificationsValue = dismissedNotificationsValue;
+            this.setDismissedNotificationsValue(dismissedNotificationsValue);
+        }
+    }
+    getDismissedNotificationsValue() {
+        return this.storageService.get(EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, StorageScope.PROFILE, '[]');
+    }
+    setDismissedNotificationsValue(value) {
+        this.storageService.store(EXTENSIONS_DISMISSED_NOTIFICATIONS_KEY, value, StorageScope.PROFILE, StorageTarget.USER);
+    }
+};
+ExtensionsWorkbenchService = ExtensionsWorkbenchService_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IWorkbenchExtensionManagementService)),
+    ( __param(3, IExtensionGalleryService)),
+    ( __param(4, IExtensionGalleryManifestService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IURLService)),
+    ( __param(9, IWorkbenchExtensionEnablementService)),
+    ( __param(10, IHostService)),
+    ( __param(11, IProgressService)),
+    ( __param(12, IExtensionManagementServerService)),
+    ( __param(13, ILanguageService)),
+    ( __param(14, IIgnoredExtensionsManagementService)),
+    ( __param(15, IUserDataAutoSyncService)),
+    ( __param(16, IProductService)),
+    ( __param(17, IContextKeyService)),
+    ( __param(18, IExtensionManifestPropertiesService)),
+    ( __param(19, ILogService)),
+    ( __param(20, IExtensionService)),
+    ( __param(21, ILocaleService)),
+    ( __param(22, ILifecycleService)),
+    ( __param(23, IFileService)),
+    ( __param(24, IUserDataProfileService)),
+    ( __param(25, IUserDataProfilesService)),
+    ( __param(26, IStorageService)),
+    ( __param(27, IDialogService)),
+    ( __param(28, IUserDataSyncEnablementService)),
+    ( __param(29, IUpdateService)),
+    ( __param(30, IUriIdentityService)),
+    ( __param(31, IWorkspaceContextService)),
+    ( __param(32, IViewsService)),
+    ( __param(33, IFileDialogService)),
+    ( __param(34, IQuickInputService)),
+    ( __param(35, IAllowedExtensionsService))
+], ExtensionsWorkbenchService));
+
+export { Extension, ExtensionsWorkbenchService };