@codingame/monaco-vscode-api 4.1.0 → 4.1.2

package/vscode/src/vs/platform/extensionManagement/common/abstractExtensionManagementService.js

@@ -1,748 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { distinct, isNonEmptyArray } from '../../../base/common/arrays.js';
-import { Barrier, createCancelablePromise } from '../../../base/common/async.js';
-import { CancellationToken } from '../../../base/common/cancellation.js';
-import { getErrorMessage, CancellationError } from '../../../base/common/errors.js';
-import { Emitter, Event } from '../../../base/common/event.js';
-import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
-import { isWeb } from '../../../base/common/platform.js';
-import { isDefined } from '../../../base/common/types.js';
-import { URI } from '../../../base/common/uri.js';
-import { localizeWithPath } from '../../../nls.js';
-import { isTargetPlatformCompatible, ExtensionManagementError, ExtensionManagementErrorCode, TargetPlatformToString, IExtensionGalleryService, ExtensionGalleryError, EXTENSION_INSTALL_DEP_PACK_CONTEXT } from './extensionManagement.js';
-import { areSameExtensions, getGalleryExtensionTelemetryData, ExtensionKey, getLocalExtensionTelemetryData } from './extensionManagementUtil.js';
-import { isApplicationScopedExtension } from '../../extensions/common/extensions.js';
-import { ILogService } from '../../log/common/log.js';
-import { IProductService } from '../../product/common/productService.js';
-import { ITelemetryService } from '../../telemetry/common/telemetry.js';
-import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
-import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.js';
-let AbstractExtensionManagementService = class AbstractExtensionManagementService extends Disposable {
-    get onInstallExtension() { return this._onInstallExtension.event; }
-    get onDidInstallExtensions() { return this._onDidInstallExtensions.event; }
-    get onUninstallExtension() { return this._onUninstallExtension.event; }
-    get onDidUninstallExtension() { return this._onDidUninstallExtension.event; }
-    get onDidUpdateExtensionMetadata() { return this._onDidUpdateExtensionMetadata.event; }
-    constructor(galleryService, telemetryService, uriIdentityService, logService, productService, userDataProfilesService) {
-        super();
-        this.galleryService = galleryService;
-        this.telemetryService = telemetryService;
-        this.uriIdentityService = uriIdentityService;
-        this.logService = logService;
-        this.productService = productService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.lastReportTimestamp = 0;
-        this.installingExtensions = ( new Map());
-        this.uninstallingExtensions = ( new Map());
-        this._onInstallExtension = this._register(( new Emitter()));
-        this._onDidInstallExtensions = this._register(( new Emitter()));
-        this._onUninstallExtension = this._register(( new Emitter()));
-        this._onDidUninstallExtension = this._register(( new Emitter()));
-        this._onDidUpdateExtensionMetadata = this._register(( new Emitter()));
-        this.participants = [];
-        this._register(toDisposable(() => {
-            this.installingExtensions.forEach(({ task }) => task.cancel());
-            this.uninstallingExtensions.forEach(promise => promise.cancel());
-            this.installingExtensions.clear();
-            this.uninstallingExtensions.clear();
-        }));
-    }
-    async canInstall(extension) {
-        const currentTargetPlatform = await this.getTargetPlatform();
-        return ( extension.allTargetPlatforms.some(
-            targetPlatform => isTargetPlatformCompatible(targetPlatform, extension.allTargetPlatforms, currentTargetPlatform)
-        ));
-    }
-    async installFromGallery(extension, options = {}) {
-        try {
-            const results = await this.installGalleryExtensions([{ extension, options }]);
-            const result = results.find(({ identifier }) => areSameExtensions(identifier, extension.identifier));
-            if (result?.local) {
-                return result?.local;
-            }
-            if (result?.error) {
-                throw result.error;
-            }
-            throw new ExtensionManagementError(`Unknown error while installing extension ${extension.identifier.id}`, ExtensionManagementErrorCode.Unknown);
-        }
-        catch (error) {
-            throw toExtensionManagementError(error);
-        }
-    }
-    async installGalleryExtensions(extensions) {
-        if (!this.galleryService.isEnabled()) {
-            throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'MarketPlaceDisabled', "Marketplace is not enabled"), ExtensionManagementErrorCode.NotAllowed);
-        }
-        const results = [];
-        const installableExtensions = [];
-        await Promise.allSettled(( extensions.map(async ({ extension, options }) => {
-            try {
-                const compatible = await this.checkAndGetCompatibleVersion(extension, !!options?.installGivenVersion, !!options?.installPreReleaseVersion, options.productVersion ?? { version: this.productService.version, date: this.productService.date });
-                installableExtensions.push({ ...compatible, options });
-            }
-            catch (error) {
-                results.push({ identifier: extension.identifier, operation: 2 , source: extension, error });
-            }
-        })));
-        if (installableExtensions.length) {
-            results.push(...(await this.installExtensions(installableExtensions)));
-        }
-        for (const result of results) {
-            if (result.error) {
-                this.logService.error(`Failed to install extension.`, result.identifier.id);
-                this.logService.error(result.error);
-                if (result.source && !URI.isUri(result.source)) {
-                    reportTelemetry(this.telemetryService, 'extensionGallery:install', { extensionData: getGalleryExtensionTelemetryData(result.source), error: result.error });
-                }
-            }
-        }
-        return results;
-    }
-    async uninstall(extension, options = {}) {
-        this.logService.trace('ExtensionManagementService#uninstall', extension.identifier.id);
-        return this.uninstallExtension(extension, options);
-    }
-    async toggleAppliationScope(extension, fromProfileLocation) {
-        if (isApplicationScopedExtension(extension.manifest) || extension.isBuiltin) {
-            return extension;
-        }
-        if (extension.isApplicationScoped) {
-            let local = await this.updateMetadata(extension, { isApplicationScoped: false }, this.userDataProfilesService.defaultProfile.extensionsResource);
-            if (!this.uriIdentityService.extUri.isEqual(fromProfileLocation, this.userDataProfilesService.defaultProfile.extensionsResource)) {
-                local = await this.copyExtension(extension, this.userDataProfilesService.defaultProfile.extensionsResource, fromProfileLocation);
-            }
-            for (const profile of this.userDataProfilesService.profiles) {
-                const existing = (await this.getInstalled(1 , profile.extensionsResource))
-                    .find(e => areSameExtensions(e.identifier, extension.identifier));
-                if (existing) {
-                    this._onDidUpdateExtensionMetadata.fire(existing);
-                }
-                else {
-                    this._onDidUninstallExtension.fire({ identifier: extension.identifier, profileLocation: profile.extensionsResource });
-                }
-            }
-            return local;
-        }
-        else {
-            const local = this.uriIdentityService.extUri.isEqual(fromProfileLocation, this.userDataProfilesService.defaultProfile.extensionsResource)
-                ? await this.updateMetadata(extension, { isApplicationScoped: true }, this.userDataProfilesService.defaultProfile.extensionsResource)
-                : await this.copyExtension(extension, fromProfileLocation, this.userDataProfilesService.defaultProfile.extensionsResource, { isApplicationScoped: true });
-            this._onDidInstallExtensions.fire([{ identifier: local.identifier, operation: 2 , local, profileLocation: this.userDataProfilesService.defaultProfile.extensionsResource, applicationScoped: true }]);
-            return local;
-        }
-    }
-    getExtensionsControlManifest() {
-        const now = ( new Date()).getTime();
-        if (!this.extensionsControlManifest || now - this.lastReportTimestamp > 1000 * 60 * 5) {
-            this.extensionsControlManifest = this.updateControlCache();
-            this.lastReportTimestamp = now;
-        }
-        return this.extensionsControlManifest;
-    }
-    registerParticipant(participant) {
-        this.participants.push(participant);
-    }
-    async installExtensions(extensions) {
-        const results = [];
-        const installingExtensionsMap = ( new Map());
-        const alreadyRequestedInstallations = [];
-        const successResults = [];
-        const getInstallExtensionTaskKey = (extension, profileLocation) => `${( ExtensionKey.create(extension).toString())}-${( profileLocation.toString())}`;
-        const createInstallExtensionTask = (manifest, extension, options) => {
-            const installExtensionTask = this.createInstallExtensionTask(manifest, extension, options);
-            const key = URI.isUri(extension) ? extension.path : `${extension.identifier.id.toLowerCase()}-${( options.profileLocation.toString())}`;
-            installingExtensionsMap.set(key, { task: installExtensionTask, manifest });
-            this._onInstallExtension.fire({ identifier: installExtensionTask.identifier, source: extension, profileLocation: options.profileLocation });
-            this.logService.info('Installing extension:', installExtensionTask.identifier.id);
-            if (!URI.isUri(extension)) {
-                this.installingExtensions.set(getInstallExtensionTaskKey(extension, options.profileLocation), { task: installExtensionTask, waitingTasks: [] });
-            }
-        };
-        try {
-            for (const { manifest, extension, options } of extensions) {
-                const isApplicationScoped = options.isApplicationScoped || options.isBuiltin || isApplicationScopedExtension(manifest);
-                const installExtensionTaskOptions = {
-                    ...options,
-                    installOnlyNewlyAddedFromExtensionPack: options.installOnlyNewlyAddedFromExtensionPack ?? !URI.isUri(extension) ,
-                    isApplicationScoped,
-                    profileLocation: isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : options.profileLocation ?? this.getCurrentExtensionsManifestLocation(),
-                    productVersion: options.productVersion ?? { version: this.productService.version, date: this.productService.date }
-                };
-                const existingInstallExtensionTask = !URI.isUri(extension) ? this.installingExtensions.get(getInstallExtensionTaskKey(extension, installExtensionTaskOptions.profileLocation)) : undefined;
-                if (existingInstallExtensionTask) {
-                    this.logService.info('Extension is already requested to install', existingInstallExtensionTask.task.identifier.id);
-                    alreadyRequestedInstallations.push(existingInstallExtensionTask.task.waitUntilTaskIsFinished());
-                }
-                else {
-                    createInstallExtensionTask(manifest, extension, installExtensionTaskOptions);
-                }
-            }
-            await Promise.all(( [...( installingExtensionsMap.values())].map(async ({ task, manifest }) => {
-                if (task.options.donotIncludePackAndDependencies) {
-                    this.logService.info('Installing the extension without checking dependencies and pack', task.identifier.id);
-                }
-                else {
-                    try {
-                        const allDepsAndPackExtensionsToInstall = await this.getAllDepsAndPackExtensions(task.identifier, manifest, !!task.options.installOnlyNewlyAddedFromExtensionPack, !!task.options.installPreReleaseVersion, task.options.profileLocation, task.options.productVersion);
-                        const installed = await this.getInstalled(undefined, task.options.profileLocation, task.options.productVersion);
-                        const options = { ...task.options, donotIncludePackAndDependencies: true, context: { ...task.options.context, [EXTENSION_INSTALL_DEP_PACK_CONTEXT]: true } };
-                        for (const { gallery, manifest } of distinct(allDepsAndPackExtensionsToInstall, ({ gallery }) => gallery.identifier.id)) {
-                            if (( installingExtensionsMap.has(`${gallery.identifier.id.toLowerCase()}-${( options.profileLocation.toString())}`))) {
-                                continue;
-                            }
-                            const existingInstallingExtension = this.installingExtensions.get(getInstallExtensionTaskKey(gallery, options.profileLocation));
-                            if (existingInstallingExtension) {
-                                if (this.canWaitForTask(task, existingInstallingExtension.task)) {
-                                    const identifier = existingInstallingExtension.task.identifier;
-                                    this.logService.info('Waiting for already requested installing extension', identifier.id, task.identifier.id);
-                                    existingInstallingExtension.waitingTasks.push(task);
-                                    alreadyRequestedInstallations.push(Event.toPromise(Event.filter(this.onDidInstallExtensions, results => ( results.some(result => areSameExtensions(result.identifier, identifier))))).then(results => {
-                                        this.logService.info('Finished waiting for already requested installing extension', identifier.id, task.identifier.id);
-                                        const result = results.find(result => areSameExtensions(result.identifier, identifier));
-                                        if (!result?.local) {
-                                            throw new Error(`Extension ${identifier.id} is not installed`);
-                                        }
-                                    }));
-                                }
-                            }
-                            else if (!( installed.some(({ identifier }) => areSameExtensions(identifier, gallery.identifier)))) {
-                                createInstallExtensionTask(manifest, gallery, options);
-                            }
-                        }
-                    }
-                    catch (error) {
-                        if (URI.isUri(task.source)) {
-                            if (isNonEmptyArray(manifest.extensionDependencies)) {
-                                this.logService.warn(`Cannot install dependencies of extension:`, task.identifier.id, error.message);
-                            }
-                            if (isNonEmptyArray(manifest.extensionPack)) {
-                                this.logService.warn(`Cannot install packed extensions of extension:`, task.identifier.id, error.message);
-                            }
-                        }
-                        else {
-                            this.logService.error('Error while preparing to install dependencies and extension packs of the extension:', task.identifier.id);
-                            throw error;
-                        }
-                    }
-                }
-            })));
-            await this.joinAllSettled(( [...( installingExtensionsMap.values())].map(async ({ task }) => {
-                const startTime = ( new Date()).getTime();
-                try {
-                    const local = await task.run();
-                    await this.joinAllSettled(( this.participants.map(
-                        participant => participant.postInstall(local, task.source, task.options, CancellationToken.None)
-                    )));
-                    if (!URI.isUri(task.source)) {
-                        const isUpdate = task.operation === 3 ;
-                        const durationSinceUpdate = isUpdate ? undefined : (( new Date()).getTime() - task.source.lastUpdated) / 1000;
-                        reportTelemetry(this.telemetryService, isUpdate ? 'extensionGallery:update' : 'extensionGallery:install', {
-                            extensionData: getGalleryExtensionTelemetryData(task.source),
-                            verificationStatus: task.verificationStatus,
-                            duration: ( new Date()).getTime() - startTime,
-                            durationSinceUpdate
-                        });
-                        if (isWeb && task.operation !== 3 ) {
-                            try {
-                                await this.galleryService.reportStatistic(local.manifest.publisher, local.manifest.name, local.manifest.version, "install" );
-                            }
-                            catch (error) {  }
-                        }
-                    }
-                    successResults.push({ local, identifier: task.identifier, operation: task.operation, source: task.source, context: task.options.context, profileLocation: task.profileLocation, applicationScoped: local.isApplicationScoped });
-                }
-                catch (error) {
-                    this.logService.error('Error while installing the extension', task.identifier.id, getErrorMessage(error));
-                    throw error;
-                }
-            })));
-            if (alreadyRequestedInstallations.length) {
-                await this.joinAllSettled(alreadyRequestedInstallations);
-            }
-            for (const result of successResults) {
-                this.logService.info(`Extension installed successfully:`, result.identifier.id);
-                results.push(result);
-            }
-            return results;
-        }
-        catch (error) {
-            if (successResults.length) {
-                this.logService.info('Rollback: Uninstalling installed extensions', getErrorMessage(error));
-                await Promise.allSettled(( successResults.map(async ({ local, profileLocation }) => {
-                    try {
-                        await this.createUninstallExtensionTask(local, { versionOnly: true, profileLocation }).run();
-                        this.logService.info('Rollback: Uninstalled extension', local.identifier.id);
-                    }
-                    catch (error) {
-                        this.logService.warn('Rollback: Error while uninstalling extension', local.identifier.id, getErrorMessage(error));
-                    }
-                })));
-            }
-            for (const { task } of ( installingExtensionsMap.values())) {
-                task.cancel();
-                results.push({ identifier: task.identifier, operation: 2 , source: task.source, context: task.options.context, profileLocation: task.profileLocation, error });
-            }
-            throw error;
-        }
-        finally {
-            for (const { task } of ( installingExtensionsMap.values())) {
-                if (task.source && !URI.isUri(task.source)) {
-                    this.installingExtensions.delete(getInstallExtensionTaskKey(task.source, task.profileLocation));
-                }
-            }
-            if (results.length) {
-                this._onDidInstallExtensions.fire(results);
-            }
-        }
-    }
-    canWaitForTask(taskToWait, taskToWaitFor) {
-        for (const [, { task, waitingTasks }] of this.installingExtensions.entries()) {
-            if (task === taskToWait) {
-                if (waitingTasks.includes(taskToWaitFor)) {
-                    return false;
-                }
-                if (( waitingTasks.some(waitingTask => this.canWaitForTask(waitingTask, taskToWaitFor)))) {
-                    return false;
-                }
-            }
-            if (task === taskToWaitFor && waitingTasks[0] && !this.canWaitForTask(taskToWait, waitingTasks[0])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    async joinAllSettled(promises) {
-        const results = [];
-        const errors = [];
-        const promiseResults = await Promise.allSettled(promises);
-        for (const r of promiseResults) {
-            if (r.status === 'fulfilled') {
-                results.push(r.value);
-            }
-            else {
-                errors.push(r.reason);
-            }
-        }
-        if (errors.length) {
-            throw joinErrors(errors);
-        }
-        return results;
-    }
-    async getAllDepsAndPackExtensions(extensionIdentifier, manifest, getOnlyNewlyAddedFromExtensionPack, installPreRelease, profile, productVersion) {
-        if (!this.galleryService.isEnabled()) {
-            return [];
-        }
-        const installed = await this.getInstalled(undefined, profile, productVersion);
-        const knownIdentifiers = [];
-        const allDependenciesAndPacks = [];
-        const collectDependenciesAndPackExtensionsToInstall = async (extensionIdentifier, manifest) => {
-            knownIdentifiers.push(extensionIdentifier);
-            const dependecies = manifest.extensionDependencies || [];
-            const dependenciesAndPackExtensions = [...dependecies];
-            if (manifest.extensionPack) {
-                const existing = getOnlyNewlyAddedFromExtensionPack ? installed.find(e => areSameExtensions(e.identifier, extensionIdentifier)) : undefined;
-                for (const extension of manifest.extensionPack) {
-                    if (!(existing && existing.manifest.extensionPack && ( existing.manifest.extensionPack.some(old => areSameExtensions({ id: old }, { id: extension }))))) {
-                        if (dependenciesAndPackExtensions.every(e => !areSameExtensions({ id: e }, { id: extension }))) {
-                            dependenciesAndPackExtensions.push(extension);
-                        }
-                    }
-                }
-            }
-            if (dependenciesAndPackExtensions.length) {
-                const ids = dependenciesAndPackExtensions.filter(id => knownIdentifiers.every(galleryIdentifier => !areSameExtensions(galleryIdentifier, { id })));
-                if (ids.length) {
-                    const galleryExtensions = await this.galleryService.getExtensions(( ids.map(id => ({ id, preRelease: installPreRelease }))), CancellationToken.None);
-                    for (const galleryExtension of galleryExtensions) {
-                        if (knownIdentifiers.find(identifier => areSameExtensions(identifier, galleryExtension.identifier))) {
-                            continue;
-                        }
-                        const isDependency = ( dependecies.some(id => areSameExtensions({ id }, galleryExtension.identifier)));
-                        let compatible;
-                        try {
-                            compatible = await this.checkAndGetCompatibleVersion(galleryExtension, false, installPreRelease, productVersion);
-                        }
-                        catch (error) {
-                            if (!isDependency) {
-                                this.logService.info('Skipping the packed extension as it cannot be installed', galleryExtension.identifier.id, getErrorMessage(error));
-                                continue;
-                            }
-                            else {
-                                throw error;
-                            }
-                        }
-                        allDependenciesAndPacks.push({ gallery: compatible.extension, manifest: compatible.manifest });
-                        await collectDependenciesAndPackExtensionsToInstall(compatible.extension.identifier, compatible.manifest);
-                    }
-                }
-            }
-        };
-        await collectDependenciesAndPackExtensionsToInstall(extensionIdentifier, manifest);
-        return allDependenciesAndPacks;
-    }
-    async checkAndGetCompatibleVersion(extension, sameVersion, installPreRelease, productVersion) {
-        let compatibleExtension;
-        const extensionsControlManifest = await this.getExtensionsControlManifest();
-        if (( extensionsControlManifest.malicious.some(identifier => areSameExtensions(extension.identifier, identifier)))) {
-            throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'malicious extension', "Can't install '{0}' extension since it was reported to be problematic.", extension.identifier.id), ExtensionManagementErrorCode.Malicious);
-        }
-        const deprecationInfo = extensionsControlManifest.deprecated[extension.identifier.id.toLowerCase()];
-        if (deprecationInfo?.extension?.autoMigrate) {
-            this.logService.info(`The '${extension.identifier.id}' extension is deprecated, fetching the compatible '${deprecationInfo.extension.id}' extension instead.`);
-            compatibleExtension = (await this.galleryService.getExtensions([{ id: deprecationInfo.extension.id, preRelease: deprecationInfo.extension.preRelease }], { targetPlatform: await this.getTargetPlatform(), compatible: true, productVersion }, CancellationToken.None))[0];
-            if (!compatibleExtension) {
-                throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundDeprecatedReplacementExtension', "Can't install '{0}' extension since it was deprecated and the replacement extension '{1}' can't be found.", extension.identifier.id, deprecationInfo.extension.id), ExtensionManagementErrorCode.Deprecated);
-            }
-        }
-        else {
-            if (!(await this.canInstall(extension))) {
-                const targetPlatform = await this.getTargetPlatform();
-                throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'incompatible platform', "The '{0}' extension is not available in {1} for {2}.", extension.identifier.id, this.productService.nameLong, TargetPlatformToString(targetPlatform)), ExtensionManagementErrorCode.IncompatibleTargetPlatform);
-            }
-            compatibleExtension = await this.getCompatibleVersion(extension, sameVersion, installPreRelease, productVersion);
-            if (!compatibleExtension) {
-                if (!installPreRelease && extension.properties.isPreReleaseVersion && (await this.galleryService.getExtensions([extension.identifier], CancellationToken.None))[0]) {
-                    throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundReleaseExtension', "Can't install release version of '{0}' extension because it has no release version.", extension.displayName ?? extension.identifier.id), ExtensionManagementErrorCode.ReleaseVersionNotFound);
-                }
-                throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundCompatibleDependency', "Can't install '{0}' extension because it is not compatible with the current version of {1} (version {2}).", extension.identifier.id, this.productService.nameLong, this.productService.version), ExtensionManagementErrorCode.Incompatible);
-            }
-        }
-        this.logService.info('Getting Manifest...', compatibleExtension.identifier.id);
-        const manifest = await this.galleryService.getManifest(compatibleExtension, CancellationToken.None);
-        if (manifest === null) {
-            throw new ExtensionManagementError(`Missing manifest for extension ${compatibleExtension.identifier.id}`, ExtensionManagementErrorCode.Invalid);
-        }
-        if (manifest.version !== compatibleExtension.version) {
-            throw new ExtensionManagementError(`Cannot install '${compatibleExtension.identifier.id}' extension because of version mismatch in Marketplace`, ExtensionManagementErrorCode.Invalid);
-        }
-        return { extension: compatibleExtension, manifest };
-    }
-    async getCompatibleVersion(extension, sameVersion, includePreRelease, productVersion) {
-        const targetPlatform = await this.getTargetPlatform();
-        let compatibleExtension = null;
-        if (!sameVersion && extension.hasPreReleaseVersion && extension.properties.isPreReleaseVersion !== includePreRelease) {
-            compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, preRelease: includePreRelease }], { targetPlatform, compatible: true, productVersion }, CancellationToken.None))[0] || null;
-        }
-        if (!compatibleExtension && (await this.galleryService.isExtensionCompatible(extension, includePreRelease, targetPlatform, productVersion))) {
-            compatibleExtension = extension;
-        }
-        if (!compatibleExtension) {
-            if (sameVersion) {
-                compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, version: extension.version }], { targetPlatform, compatible: true, productVersion }, CancellationToken.None))[0] || null;
-            }
-            else {
-                compatibleExtension = await this.galleryService.getCompatibleExtension(extension, includePreRelease, targetPlatform, productVersion);
-            }
-        }
-        return compatibleExtension;
-    }
-    async uninstallExtension(extension, options) {
-        const uninstallOptions = {
-            ...options,
-            profileLocation: extension.isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : options.profileLocation ?? this.getCurrentExtensionsManifestLocation()
-        };
-        const getUninstallExtensionTaskKey = (identifier) => `${identifier.id.toLowerCase()}${uninstallOptions.versionOnly ? `-${extension.manifest.version}` : ''}${uninstallOptions.profileLocation ? `@${( uninstallOptions.profileLocation.toString())}` : ''}`;
-        const uninstallExtensionTask = this.uninstallingExtensions.get(getUninstallExtensionTaskKey(extension.identifier));
-        if (uninstallExtensionTask) {
-            this.logService.info('Extensions is already requested to uninstall', extension.identifier.id);
-            return uninstallExtensionTask.waitUntilTaskIsFinished();
-        }
-        const createUninstallExtensionTask = (extension) => {
-            const uninstallExtensionTask = this.createUninstallExtensionTask(extension, uninstallOptions);
-            this.uninstallingExtensions.set(getUninstallExtensionTaskKey(uninstallExtensionTask.extension.identifier), uninstallExtensionTask);
-            if (uninstallOptions.profileLocation) {
-                this.logService.info('Uninstalling extension from the profile:', `${extension.identifier.id}@${extension.manifest.version}`, ( uninstallOptions.profileLocation.toString()));
-            }
-            else {
-                this.logService.info('Uninstalling extension:', `${extension.identifier.id}@${extension.manifest.version}`);
-            }
-            this._onUninstallExtension.fire({ identifier: extension.identifier, profileLocation: uninstallOptions.profileLocation, applicationScoped: extension.isApplicationScoped });
-            return uninstallExtensionTask;
-        };
-        const postUninstallExtension = (extension, error) => {
-            if (error) {
-                if (uninstallOptions.profileLocation) {
-                    this.logService.error('Failed to uninstall extension from the profile:', `${extension.identifier.id}@${extension.manifest.version}`, ( uninstallOptions.profileLocation.toString()), error.message);
-                }
-                else {
-                    this.logService.error('Failed to uninstall extension:', `${extension.identifier.id}@${extension.manifest.version}`, error.message);
-                }
-            }
-            else {
-                if (uninstallOptions.profileLocation) {
-                    this.logService.info('Successfully uninstalled extension from the profile', `${extension.identifier.id}@${extension.manifest.version}`, ( uninstallOptions.profileLocation.toString()));
-                }
-                else {
-                    this.logService.info('Successfully uninstalled extension:', `${extension.identifier.id}@${extension.manifest.version}`);
-                }
-            }
-            reportTelemetry(this.telemetryService, 'extensionGallery:uninstall', { extensionData: getLocalExtensionTelemetryData(extension), error });
-            this._onDidUninstallExtension.fire({ identifier: extension.identifier, error: error?.code, profileLocation: uninstallOptions.profileLocation, applicationScoped: extension.isApplicationScoped });
-        };
-        const allTasks = [];
-        const processedTasks = [];
-        try {
-            allTasks.push(createUninstallExtensionTask(extension));
-            const installed = await this.getInstalled(1 , uninstallOptions.profileLocation);
-            if (uninstallOptions.donotIncludePack) {
-                this.logService.info('Uninstalling the extension without including packed extension', `${extension.identifier.id}@${extension.manifest.version}`);
-            }
-            else {
-                const packedExtensions = this.getAllPackExtensionsToUninstall(extension, installed);
-                for (const packedExtension of packedExtensions) {
-                    if (( this.uninstallingExtensions.has(getUninstallExtensionTaskKey(packedExtension.identifier)))) {
-                        this.logService.info('Extensions is already requested to uninstall', packedExtension.identifier.id);
-                    }
-                    else {
-                        allTasks.push(createUninstallExtensionTask(packedExtension));
-                    }
-                }
-            }
-            if (uninstallOptions.donotCheckDependents) {
-                this.logService.info('Uninstalling the extension without checking dependents', `${extension.identifier.id}@${extension.manifest.version}`);
-            }
-            else {
-                this.checkForDependents(( allTasks.map(task => task.extension)), installed, extension);
-            }
-            await this.joinAllSettled(( allTasks.map(async (task) => {
-                try {
-                    await task.run();
-                    await this.joinAllSettled(( this.participants.map(
-                        participant => participant.postUninstall(task.extension, uninstallOptions, CancellationToken.None)
-                    )));
-                    if (task.extension.identifier.uuid) {
-                        try {
-                            await this.galleryService.reportStatistic(task.extension.manifest.publisher, task.extension.manifest.name, task.extension.manifest.version, "uninstall" );
-                        }
-                        catch (error) {  }
-                    }
-                    postUninstallExtension(task.extension);
-                }
-                catch (e) {
-                    const error = e instanceof ExtensionManagementError ? e : ( new ExtensionManagementError(getErrorMessage(e), ExtensionManagementErrorCode.Internal));
-                    postUninstallExtension(task.extension, error);
-                    throw error;
-                }
-                finally {
-                    processedTasks.push(task);
-                }
-            })));
-        }
-        catch (e) {
-            const error = e instanceof ExtensionManagementError ? e : ( new ExtensionManagementError(getErrorMessage(e), ExtensionManagementErrorCode.Internal));
-            for (const task of allTasks) {
-                try {
-                    task.cancel();
-                }
-                catch (error) {  }
-                if (!processedTasks.includes(task)) {
-                    postUninstallExtension(task.extension, error);
-                }
-            }
-            throw error;
-        }
-        finally {
-            for (const task of allTasks) {
-                if (!this.uninstallingExtensions.delete(getUninstallExtensionTaskKey(task.extension.identifier))) {
-                    this.logService.warn('Uninstallation task is not found in the cache', task.extension.identifier.id);
-                }
-            }
-        }
-    }
-    checkForDependents(extensionsToUninstall, installed, extensionToUninstall) {
-        for (const extension of extensionsToUninstall) {
-            const dependents = this.getDependents(extension, installed);
-            if (dependents.length) {
-                const remainingDependents = dependents.filter(dependent => !( extensionsToUninstall.some(e => areSameExtensions(e.identifier, dependent.identifier))));
-                if (remainingDependents.length) {
-                    throw new Error(this.getDependentsErrorMessage(extension, remainingDependents, extensionToUninstall));
-                }
-            }
-        }
-    }
-    getDependentsErrorMessage(dependingExtension, dependents, extensionToUninstall) {
-        if (extensionToUninstall === dependingExtension) {
-            if (dependents.length === 1) {
-                return ( localizeWithPath(
-                    'vs/platform/extensionManagement/common/abstractExtensionManagementService',
-                    'singleDependentError',
-                    "Cannot uninstall '{0}' extension. '{1}' extension depends on this.",
-                    extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
-                    dependents[0].manifest.displayName || dependents[0].manifest.name
-                ));
-            }
-            if (dependents.length === 2) {
-                return ( localizeWithPath(
-                    'vs/platform/extensionManagement/common/abstractExtensionManagementService',
-                    'twoDependentsError',
-                    "Cannot uninstall '{0}' extension. '{1}' and '{2}' extensions depend on this.",
-                    extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
-                    dependents[0].manifest.displayName || dependents[0].manifest.name,
-                    dependents[1].manifest.displayName || dependents[1].manifest.name
-                ));
-            }
-            return ( localizeWithPath(
-                'vs/platform/extensionManagement/common/abstractExtensionManagementService',
-                'multipleDependentsError',
-                "Cannot uninstall '{0}' extension. '{1}', '{2}' and other extension depend on this.",
-                extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
-                dependents[0].manifest.displayName || dependents[0].manifest.name,
-                dependents[1].manifest.displayName || dependents[1].manifest.name
-            ));
-        }
-        if (dependents.length === 1) {
-            return ( localizeWithPath(
-                'vs/platform/extensionManagement/common/abstractExtensionManagementService',
-                'singleIndirectDependentError',
-                "Cannot uninstall '{0}' extension . It includes uninstalling '{1}' extension and '{2}' extension depends on this.",
-                extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
-                dependingExtension.manifest.displayName
-                    || dependingExtension.manifest.name,
-                dependents[0].manifest.displayName || dependents[0].manifest.name
-            ));
-        }
-        if (dependents.length === 2) {
-            return ( localizeWithPath(
-                'vs/platform/extensionManagement/common/abstractExtensionManagementService',
-                'twoIndirectDependentsError',
-                "Cannot uninstall '{0}' extension. It includes uninstalling '{1}' extension and '{2}' and '{3}' extensions depend on this.",
-                extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
-                dependingExtension.manifest.displayName
-                    || dependingExtension.manifest.name,
-                dependents[0].manifest.displayName || dependents[0].manifest.name,
-                dependents[1].manifest.displayName || dependents[1].manifest.name
-            ));
-        }
-        return ( localizeWithPath(
-            'vs/platform/extensionManagement/common/abstractExtensionManagementService',
-            'multipleIndirectDependentsError',
-            "Cannot uninstall '{0}' extension. It includes uninstalling '{1}' extension and '{2}', '{3}' and other extensions depend on this.",
-            extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
-            dependingExtension.manifest.displayName
-                || dependingExtension.manifest.name,
-            dependents[0].manifest.displayName || dependents[0].manifest.name,
-            dependents[1].manifest.displayName || dependents[1].manifest.name
-        ));
-    }
-    getAllPackExtensionsToUninstall(extension, installed, checked = []) {
-        if (checked.indexOf(extension) !== -1) {
-            return [];
-        }
-        checked.push(extension);
-        const extensionsPack = extension.manifest.extensionPack ? extension.manifest.extensionPack : [];
-        if (extensionsPack.length) {
-            const packedExtensions = installed.filter(i => !i.isBuiltin && ( extensionsPack.some(id => areSameExtensions({ id }, i.identifier))));
-            const packOfPackedExtensions = [];
-            for (const packedExtension of packedExtensions) {
-                packOfPackedExtensions.push(...this.getAllPackExtensionsToUninstall(packedExtension, installed, checked));
-            }
-            return [...packedExtensions, ...packOfPackedExtensions];
-        }
-        return [];
-    }
-    getDependents(extension, installed) {
-        return installed.filter(e => e.manifest.extensionDependencies && ( e.manifest.extensionDependencies.some(id => areSameExtensions({ id }, extension.identifier))));
-    }
-    async updateControlCache() {
-        try {
-            this.logService.trace('ExtensionManagementService.updateControlCache');
-            return await this.galleryService.getExtensionsControlManifest();
-        }
-        catch (err) {
-            this.logService.trace('ExtensionManagementService.refreshControlCache - failed to get extension control manifest', getErrorMessage(err));
-            return { malicious: [], deprecated: {}, search: [] };
-        }
-    }
-};
-AbstractExtensionManagementService = ( __decorate([
-    ( __param(0, IExtensionGalleryService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IProductService)),
-    ( __param(5, IUserDataProfilesService))
-], AbstractExtensionManagementService));
-function joinErrors(errorOrErrors) {
-    const errors = Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors];
-    if (errors.length === 1) {
-        return errors[0] instanceof Error ? errors[0] : ( new Error(errors[0]));
-    }
-    return errors.reduce((previousValue, currentValue) => {
-        return ( new Error(
-            `${previousValue.message}${previousValue.message ? ',' : ''}${currentValue instanceof Error ? currentValue.message : currentValue}`
-        ));
-    }, ( new Error('')));
-}
-function toExtensionManagementError(error) {
-    if (error instanceof ExtensionManagementError) {
-        return error;
-    }
-    if (error instanceof ExtensionGalleryError) {
-        const e = ( new ExtensionManagementError(error.message, ExtensionManagementErrorCode.Gallery));
-        e.stack = error.stack;
-        return e;
-    }
-    const e = ( new ExtensionManagementError(error.message, ExtensionManagementErrorCode.Internal));
-    e.stack = error.stack;
-    return e;
-}
-function reportTelemetry(telemetryService, eventName, { extensionData, verificationStatus, duration, error, durationSinceUpdate }) {
-    let errorcode;
-    let errorcodeDetail;
-    if (isDefined(verificationStatus)) {
-        if (verificationStatus === true) {
-            verificationStatus = 'Verified';
-        }
-        else if (verificationStatus === false) {
-            verificationStatus = 'Unverified';
-        }
-        else {
-            errorcode = ExtensionManagementErrorCode.Signature;
-            errorcodeDetail = verificationStatus;
-            verificationStatus = 'Unverified';
-        }
-    }
-    if (error) {
-        if (error instanceof ExtensionManagementError || error instanceof ExtensionGalleryError) {
-            errorcode = error.code;
-            if (error.code === ExtensionManagementErrorCode.Signature) {
-                errorcodeDetail = error.message;
-            }
-        }
-        else {
-            errorcode = ExtensionManagementErrorCode.Internal;
-        }
-    }
-    telemetryService.publicLog(eventName, { ...extensionData, verificationStatus, success: !error, duration, errorcode, errorcodeDetail, durationSinceUpdate });
-}
-class AbstractExtensionTask {
-    constructor() {
-        this.barrier = ( new Barrier());
-    }
-    async waitUntilTaskIsFinished() {
-        await this.barrier.wait();
-        return this.cancellablePromise;
-    }
-    async run() {
-        if (!this.cancellablePromise) {
-            this.cancellablePromise = createCancelablePromise(token => this.doRun(token));
-        }
-        this.barrier.open();
-        return this.cancellablePromise;
-    }
-    cancel() {
-        if (!this.cancellablePromise) {
-            this.cancellablePromise = createCancelablePromise(token => {
-                return ( new Promise((c, e) => {
-                    const disposable = token.onCancellationRequested(() => {
-                        disposable.dispose();
-                        e(( new CancellationError()));
-                    });
-                }));
-            });
-            this.barrier.open();
-        }
-        this.cancellablePromise.cancel();
-    }
-}
-export { AbstractExtensionManagementService, AbstractExtensionTask, joinErrors, toExtensionManagementError };