@codingame/monaco-vscode-api 31.0.1 → 32.0.0

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

@@ -1,3449 +0,0 @@
-
-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 { isEngineValid, areApiProposalsCompatible } 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, MODAL_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, ExtensionRuntimeActionType, VIEWLET_ID } from '../common/extensions.js';
-import { ExtensionsInput } from '../common/extensionsInput.js';
-import { IMeteredConnectionService } from '../../../../platform/meteredConnection/common/meteredConnection.service.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" && !this.productService.builtInExtensionsEnabledWithAutoUpdates?.some(id => id.toLowerCase() === this.identifier.id.toLowerCase())) {
-                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(9540, "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.type !== ExtensionType.System && !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,
-        meteredConnectionService
-    ) {
-        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.meteredConnectionService = meteredConnectionService;
-        this.localExtensions = null;
-        this.remoteExtensions = null;
-        this.webExtensions = null;
-        this.extensionsServers = [];
-        this._onChange = this._register(( new Emitter()));
-        this._onDidChangeExtensionsNotification = this._register(( new Emitter()));
-        this.onDidChangeExtensionsNotification = this._onDidChangeExtensionsNotification.event;
-        this._onReset = this._register(( 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.isAutoCheckUpdatesEnabled() && 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._register(this.meteredConnectionService.onDidChangeIsConnectionMetered(() => {
-            if (this.isAutoCheckUpdatesEnabled()) {
-                this.checkForUpdates("Connection is no longer metered");
-            }
-            if (isWeb && !this.isAutoUpdateEnabled()) {
-                this.autoUpdateBuiltinExtensions();
-            }
-        }));
-        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() {
-        if (this.meteredConnectionService.isConnectionMetered) {
-            return false;
-        }
-        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(9541, "Auto Update Extensions")),
-            message: isAutoUpdateEnabled ? ( localize(9542, "Do you want to enable auto update for all extensions?")) : ( localize(9543, "Do you want to disable auto update for all extensions?")),
-            detail: ( localize(
-                9544,
-                "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(9545, "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,
-                    query: computedNotificiations[0].query,
-                    action: computedNotificiations[0].action,
-                    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(
-                    9546,
-                    "Some extensions are disabled because they are not allowed by your system administrator."
-                )) : ( localize(
-                    9547,
-                    "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(
-                        9548,
-                        "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(9549, "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("-")
-                });
-            }
-        }
-        if (!this.configurationService.getValue(AutoRestartConfigurationKey)) {
-            const restartRequiredExtensions = this.local.filter(
-                e => e.runtimeState !== undefined && (e.runtimeState.action === ExtensionRuntimeActionType.RestartExtensions || e.runtimeState.action === ExtensionRuntimeActionType.ReloadWindow)
-            );
-            if (restartRequiredExtensions.length) {
-                const needsReload = ( restartRequiredExtensions.some(e => e.runtimeState?.action === ExtensionRuntimeActionType.ReloadWindow));
-                computedNotificiations.push({
-                    message: needsReload ? ( localize(9550, "Extensions require a window reload to take effect.")) : ( localize(9551, "Extensions require a restart to take effect.")),
-                    severity: Severity$1.Info,
-                    extensions: restartRequiredExtensions,
-                    query: "@restartrequired",
-                    action: {
-                        label: needsReload ? ( localize(9552, "Reload Window")) : ( localize(9553, "Restart Extensions")),
-                        run: () => {
-                            if (needsReload) {
-                                this.hostService.reload();
-                            } else {
-                                this.updateRunningExtensions();
-                            }
-                        }
-                    },
-                    key: "restartRequired:" + ( restartRequiredExtensions.sort((a, b) => a.identifier.id.localeCompare(b.identifier.id)).map(e => e.identifier.id.toLowerCase())).join("-")
-                });
-            }
-        }
-        const deprecatedExtensions = this.local.filter(
-            e => !!e.deprecationInfo && e.local && this.extensionEnablementService.isEnabled(e.local)
-        );
-        if (deprecatedExtensions.length) {
-            computedNotificiations.push({
-                message: ( localize(
-                    9554,
-                    "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}`));
-        }
-        const useModal = this.configurationService.getValue("extensions.allowOpenInModalEditor");
-        await this.editorService.openEditor(
-            this.instantiationService.createInstance(ExtensionsInput, extension),
-            options,
-            options?.sideByside ? SIDE_GROUP : useModal ? MODAL_GROUP : ACTIVE_GROUP
-        );
-    }
-    async openSearch(searchValue, preserveFocus) {
-        const viewPaneContainer = (await this.viewsService.openViewContainer(VIEWLET_ID, true))?.getViewPaneContainer();
-        if (!viewPaneContainer) {
-            this.logService.trace(
-                "ExtensionsWorkbenchService#openSearch: extension view pane container was not available"
-            );
-            return;
-        }
-        viewPaneContainer.search(searchValue);
-        if (!preserveFocus) {
-            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(9555, "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(9556, "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(9557, "reload window")) : ( localize(9558, "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(
-                        9559,
-                        "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(
-                                            9560,
-                                            "Please update {0} to enable the updated extension.",
-                                            this.productService.nameLong
-                                        ))
-                                    };
-                                }
-                                if (state.type === StateType.Downloaded) {
-                                    return {
-                                        action: ExtensionRuntimeActionType.ApplyUpdate,
-                                        reason: ( localize(
-                                            9561,
-                                            "Please update {0} to enable the updated extension.",
-                                            this.productService.nameLong
-                                        ))
-                                    };
-                                }
-                                if (state.type === StateType.Ready) {
-                                    return {
-                                        action: ExtensionRuntimeActionType.QuitAndInstall,
-                                        reason: ( localize(
-                                            9562,
-                                            "Please restart {0} to enable the updated extension.",
-                                            this.productService.nameLong
-                                        ))
-                                    };
-                                }
-                                return undefined;
-                            }
-                            return {
-                                action: reloadAction,
-                                reason: ( localize(9563, "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(9564, "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(
-                                            9565,
-                                            "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(9566, "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(9566, "Please {0} to enable this extension.", reloadActionLabel))
-                                };
-                            }
-                        }
-                    }
-                    return undefined;
-                } else {
-                    if (isSameExtensionRunning) {
-                        return {
-                            action: reloadAction,
-                            reason: ( localize(9567, "Please {0} to disable this extension.", reloadActionLabel))
-                        };
-                    }
-                }
-                return undefined;
-            }
-            else {
-                if (isEnabled && !this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
-                    return {
-                        action: reloadAction,
-                        reason: ( localize(9566, "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(9566, "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.local?.forceAutoUpdate && 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,
-                currentVersion: installed.isBuiltin ? installed.version : undefined
-            });
-        }
-        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(9568, "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(9569, "All Platforms")) : TargetPlatformToString(targetPlatform),
-                    id: targetPlatform
-                });
-            }
-        }
-        if (options.length > 1) {
-            const message = ( localize(9570, "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(9571, "Select folder to download the VSIX")),
-            canSelectFiles: false,
-            canSelectFolders: true,
-            canSelectMany: false,
-            openLabel: ( localize(9572, "Download"))
-        });
-        if (!result?.[0]) {
-            return;
-        }
-        this.progressService.withProgress({
-            location: ProgressLocation.Notification
-        }, async progress => {
-            try {
-                progress.report({
-                    message: ( localize(9573, "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(9574, "Successfully downloaded the VSIX")));
-            } catch (error) {
-                this.notificationService.error(( localize(9575, "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(9576, "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(9577, "pre-release"))})` : ""}`,
-                ariaLabel: `${v.isPreReleaseVersion ? "Pre-Release version" : "Release version"} ${v.version}`,
-                data: v
-            };
-        }));
-        const pick = await this.quickInputService.pick(picks, {
-            placeHolder: ( localize(9578, "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() {
-        if (this.meteredConnectionService.isConnectionMetered) {
-            return false;
-        }
-        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() {
-        if (this.meteredConnectionService.isConnectionMetered) {
-            return;
-        }
-        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() {
-        if (this.meteredConnectionService.isConnectionMetered) {
-            this.logService.trace("[Extensions]: Skipping auto-update because connection is metered");
-            return;
-        }
-        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;
-        }
-        if (extension.local?.forceAutoUpdate) {
-            return true;
-        }
-        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(
-                9579,
-                "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(
-            9580,
-            "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(9581, "The provided object is not an extension.")));
-        }
-        if (extension.isMalicious) {
-            return ( new MarkdownString()).appendText(( localize(9582, "This extension is reported to be problematic.")));
-        }
-        if (extension.deprecationInfo?.disallowInstall) {
-            return ( new MarkdownString()).appendText(( localize(9583, "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(9584, "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(
-                9585,
-                "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(
-            9585,
-            "Cannot install the '{0}' extension because it is not available in this setup.",
-            extension.displayName ?? extension.identifier.id
-        )));
-    }
-    async install(arg, installOptions = {}, progressLocation) {
-        const extension = await this._install(arg, installOptions, progressLocation);
-        if (!extension) {
-            throw ( new Error(( localize(9586, "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(9587, "Enable Extension")),
-                        message: ( localize(9588, "Would you like to enable '{0}' extension?", extension.displayName)),
-                        detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
-                        primaryButton: isString(installOptions.justification) ? ( localize(9589, "&&Enable Extension")) : ( localize(9590, "&&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 _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) {
-                    if (this.productService.builtInExtensionsEnabledWithAutoUpdates?.some(id => id.toLowerCase() === arg.toLowerCase())) {
-                        return extension;
-                    }
-                } else {
-                    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(9582, "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(
-                            9591,
-                            "If this issue persists, please report it at {0}",
-                            (reportIssueUri.toString())
-                        )) : "";
-                        if (installOptions.version) {
-                            const message = ( localize(
-                                9592,
-                                "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(
-                                9593,
-                                "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(9594, "&&Install Extension")) : ( localize(9595, "&&Install Extension and {0}", installOptions.justification.action)),
-                    run: () => true
-                });
-                if (!extension) {
-                    buttons.push({
-                        label: ( localize(9596, "Open Extension")),
-                        run: () => {
-                            this.open(extension);
-                            return false;
-                        }
-                    });
-                }
-                const result = await this.dialogService.prompt({
-                    title: ( localize(9597, "Install Extension")),
-                    message: extension ? ( localize(
-                        9598,
-                        "Would you like to install '{0}' extension from '{1}'?",
-                        extension.displayName,
-                        extension.publisherDisplayName
-                    )) : ( localize(9599, "Would you like to install the extension?")),
-                    detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
-                    cancelButton: true,
-                    buttons,
-                    checkbox: syncCheck ? {
-                        label: ( localize(9600, "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
-                    );
-                }
-            }
-        }
-        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(
-                    9601,
-                    "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(9602, "Uninstall Extension")),
-                type: Severity$1.Info,
-                message: ( localize(
-                    9603,
-                    "Would you like to Uninstall {0} from all profiles?",
-                    extension.displayName
-                )),
-                primaryButton: ( localize(9604, "Uninstall (All Profiles)"))
-            });
-            if (!confirmed) {
-                throw ( new CancellationError());
-            }
-        }
-        const extensionsToUninstall = [{
-            extension: extension.local
-        }];
-        if (this.productService.defaultChatAgent == null || !areSameExtensions(extension.identifier, {
-            id: this.productService.defaultChatAgent.extensionId
-        })) {
-            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(9605, "Uninstall Extension with Dependents")),
-                type: Severity$1.Warning,
-                message: this.getErrorMessageForUninstallingAnExtensionWithDependents(extension, dependents),
-                buttons: [{
-                    label: ( localize(9606, "Uninstall All")),
-                    run: () => true
-                }],
-                cancelButton: {
-                    run: () => false
-                }
-            });
-            if (!result) {
-                throw ( new CancellationError());
-            }
-        }
-        return this.withProgress({
-            location: ProgressLocation.Extensions,
-            title: ( localize(9607, "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(
-                9608,
-                "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(
-                9609,
-                "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(
-            9610,
-            "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(9611, "Installing '{0}' extension...", extension.displayName)) : ( localize(9612, "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(9613, "Disable Extension with Dependents")),
-                        type: Severity$1.Warning,
-                        message: this.getDependentsErrorMessageForDisablement(extension, allExtensions, dependents),
-                        buttons: [{
-                            label: ( localize(9614, "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(
-                9615,
-                "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(
-                9616,
-                "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(
-            9617,
-            "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)), ( __param(36, IMeteredConnectionService))], ExtensionsWorkbenchService));
-
-export { Extension, ExtensionsWorkbenchService };