@codingame/monaco-vscode-extensions-service-override 25.1.1 → 26.0.0

package/index.js

@@ -49,6 +49,13 @@ import { WebExtensionsScannerService } from './vscode/src/vs/workbench/services/
 import { IBuiltinExtensionsScannerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions.service';
 import { ExtensionManifestTranslator } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionsScannerService';
 import { getBuiltInExtensionTranslationsUris } from '@codingame/monaco-vscode-api/l10n';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/jsonValidationExtensionPoint';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/themes/common/colorExtensionPoint';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/themes/common/iconExtensionPoint';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/themes/common/tokenClassificationExtensionPoint';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/common/languageConfigurationExtensionPoint';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/statusBarExtensionPoint';
+import './vscode/src/vs/workbench/services/themes/browser/cssExtensionPoint.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadLocalization.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadBulkEdits.js';
 import './vscode/src/vs/workbench/api/browser/mainThreadLanguageModels.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "25.1.1",
+  "version": "26.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - extensions service-override",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.1",
-    "@codingame/monaco-vscode-files-service-override": "25.1.1"
+    "@codingame/monaco-vscode-api": "26.0.0",
+    "@codingame/monaco-vscode-files-service-override": "26.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/base/common/console.js

@@ -15,46 +15,55 @@ function parse(entry) {
             stack = stackArgument.__$stack;
         }
         args.push(...parsedArguments);
+    } catch (error) {
+        args.push("Unable to log remote console arguments", entry.arguments);
     }
-    catch (error) {
-        args.push('Unable to log remote console arguments', entry.arguments);
-    }
-    return { args, stack };
+    return {
+        args,
+        stack
+    };
 }
 function findFirstFrame(stack) {
     if (!stack) {
         return stack;
     }
-    const newlineIndex = stack.indexOf('\n');
+    const newlineIndex = stack.indexOf("\n");
     if (newlineIndex === -1) {
         return stack;
     }
     return stack.substring(0, newlineIndex);
 }
 function log(entry, label) {
-    const { args, stack } = parse(entry);
-    const isOneStringArg = typeof args[0] === 'string' && args.length === 1;
+    const {
+        args,
+        stack
+    } = parse(entry);
+    const isOneStringArg = typeof args[0] === "string" && args.length === 1;
     let topFrame = findFirstFrame(stack);
     if (topFrame) {
         topFrame = `(${topFrame.trim()})`;
     }
     let consoleArgs = [];
-    if (typeof args[0] === 'string') {
+    if (typeof args[0] === "string") {
         if (topFrame && isOneStringArg) {
-            consoleArgs = [`%c[${label}] %c${args[0]} %c${topFrame}`, color('blue'), color(''), color('grey')];
-        }
-        else {
-            consoleArgs = [`%c[${label}] %c${args[0]}`, color('blue'), color(''), ...args.slice(1)];
+            consoleArgs = [
+                `%c[${label}] %c${args[0]} %c${topFrame}`,
+                color("blue"),
+                color(""),
+                color("grey")
+            ];
+        } else {
+            consoleArgs = [`%c[${label}] %c${args[0]}`, color("blue"), color(""), ...args.slice(1)];
         }
     }
     else {
-        consoleArgs = [`%c[${label}]%`, color('blue'), ...args];
+        consoleArgs = [`%c[${label}]%`, color("blue"), ...args];
     }
     if (topFrame && !isOneStringArg) {
         consoleArgs.push(topFrame);
     }
-    if (typeof console[entry.severity] !== 'function') {
-        throw ( new Error('Unknown console method'));
+    if (typeof console[entry.severity] !== "function") {
+        throw ( new Error("Unknown console method"));
     }
     console[entry.severity].apply(console, consoleArgs);
 }

package/vscode/src/vs/platform/extensionManagement/common/extensionManagementCLI.d.ts

@@ -4,11 +4,14 @@ import { IExtensionManagementService } from "@codingame/monaco-vscode-api/vscode
 import { IExtensionGalleryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
 import { IExtensionManifest } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
 import { ILogger } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
 export declare class ExtensionManagementCLI {
+    private readonly extensionsForceVersionByQuality;
     protected readonly logger: ILogger;
     private readonly extensionManagementService;
     private readonly extensionGalleryService;
-    constructor(logger: ILogger, extensionManagementService: IExtensionManagementService, extensionGalleryService: IExtensionGalleryService);
+    private readonly productService;
+    constructor(extensionsForceVersionByQuality: readonly string[], logger: ILogger, extensionManagementService: IExtensionManagementService, extensionGalleryService: IExtensionGalleryService, productService: IProductService);
     protected get location(): string | undefined;
     listExtensions(showVersions: boolean, category?: string, profileLocation?: URI): Promise<void>;
     installExtensions(extensions: (string | URI)[], builtinExtensions: (string | URI)[], installOptions: InstallOptions, force: boolean): Promise<void>;

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

@@ -11,18 +11,28 @@ import { InstallOperation, EXTENSION_IDENTIFIER_REGEX } from '@codingame/monaco-
 import { IExtensionManagementService, IExtensionGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
 import { getIdAndVersion, areSameExtensions, getGalleryExtensionId, getExtensionId } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
 import { ExtensionType, EXTENSION_CATEGORIES } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 
-const notFound = (id) => ( localize(1848, "Extension '{0}' not found.", id));
+const notFound = id => ( localize(1847, "Extension '{0}' not found.", id));
 const useId = ( localize(
-    1849,
+    1848,
     "Make sure you use the full extension ID, including the publisher, e.g.: {0}",
-    'ms-dotnettools.csharp'
+    "ms-dotnettools.csharp"
 ));
 let ExtensionManagementCLI = class ExtensionManagementCLI {
-    constructor(logger, extensionManagementService, extensionGalleryService) {
+    constructor(
+        extensionsForceVersionByQuality,
+        logger,
+        extensionManagementService,
+        extensionGalleryService,
+        productService
+    ) {
+        this.extensionsForceVersionByQuality = extensionsForceVersionByQuality;
         this.logger = logger;
         this.extensionManagementService = extensionManagementService;
         this.extensionGalleryService = extensionGalleryService;
+        this.productService = productService;
+        this.extensionsForceVersionByQuality = ( this.extensionsForceVersionByQuality.map(e => e.toLowerCase()));
     }
     get location() {
         return undefined;
@@ -30,9 +40,11 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
     async listExtensions(showVersions, category, profileLocation) {
         let extensions = await this.extensionManagementService.getInstalled(ExtensionType.User, profileLocation);
         const categories = ( EXTENSION_CATEGORIES.map(c => c.toLowerCase()));
-        if (category && category !== '') {
+        if (category && category !== "") {
             if (categories.indexOf(category.toLowerCase()) < 0) {
-                this.logger.info('Invalid category please enter a valid category. To list valid categories run --category without a category specified');
+                this.logger.info(
+                    "Invalid category please enter a valid category. To list valid categories run --category without a category specified"
+                );
                 return;
             }
             extensions = extensions.filter(e => {
@@ -42,16 +54,15 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
                 }
                 return false;
             });
-        }
-        else if (category === '') {
-            this.logger.info('Possible Categories: ');
+        } else if (category === "") {
+            this.logger.info("Possible Categories: ");
             categories.forEach(category => {
                 this.logger.info(category);
             });
             return;
         }
         if (this.location) {
-            this.logger.info(( localize(1850, "Extensions installed on {0}:", this.location)));
+            this.logger.info(( localize(1849, "Extensions installed on {0}:", this.location)));
         }
         extensions = extensions.sort((e1, e2) => e1.identifier.id.localeCompare(e2.identifier.id));
         let lastId = undefined;
@@ -66,38 +77,61 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         const failed = [];
         try {
             if (extensions.length) {
-                this.logger.info(this.location ? ( localize(1851, "Installing extensions on {0}...", this.location)) : ( localize(1852, "Installing extensions...")));
+                this.logger.info(this.location ? ( localize(1850, "Installing extensions on {0}...", this.location)) : ( localize(1851, "Installing extensions...")));
             }
             const installVSIXInfos = [];
             const installExtensionInfos = [];
             const addInstallExtensionInfo = (id, version, isBuiltin) => {
-                installExtensionInfos.push({ id, version: version !== 'prerelease' ? version : undefined, installOptions: { ...installOptions, isBuiltin, installPreReleaseVersion: version === 'prerelease' || installOptions.installPreReleaseVersion } });
+                if (this.extensionsForceVersionByQuality?.some(e => e === id.toLowerCase())) {
+                    version = this.productService.quality !== "stable" ? "prerelease" : undefined;
+                }
+                installExtensionInfos.push({
+                    id,
+                    version: version !== "prerelease" ? version : undefined,
+                    installOptions: {
+                        ...installOptions,
+                        isBuiltin,
+                        installPreReleaseVersion: version === "prerelease" || installOptions.installPreReleaseVersion
+                    }
+                });
             };
             for (const extension of extensions) {
                 if (extension instanceof URI) {
-                    installVSIXInfos.push({ vsix: extension, installOptions });
-                }
-                else {
+                    installVSIXInfos.push({
+                        vsix: extension,
+                        installOptions
+                    });
+                } else {
                     const [id, version] = getIdAndVersion(extension);
                     addInstallExtensionInfo(id, version, false);
                 }
             }
             for (const extension of builtinExtensions) {
                 if (extension instanceof URI) {
-                    installVSIXInfos.push({ vsix: extension, installOptions: { ...installOptions, isBuiltin: true, donotIncludePackAndDependencies: true } });
-                }
-                else {
+                    installVSIXInfos.push({
+                        vsix: extension,
+                        installOptions: {
+                            ...installOptions,
+                            isBuiltin: true,
+                            donotIncludePackAndDependencies: true
+                        }
+                    });
+                } else {
                     const [id, version] = getIdAndVersion(extension);
                     addInstallExtensionInfo(id, version, true);
                 }
             }
             const installed = await this.extensionManagementService.getInstalled(undefined, installOptions.profileLocation);
             if (installVSIXInfos.length) {
-                await Promise.all(( installVSIXInfos.map(async ({ vsix, installOptions }) => {
+                await Promise.all(( installVSIXInfos.map(async (
+                    {
+                        vsix,
+                        installOptions
+                    }
+                ) => {
                     try {
                         await this.installVSIX(vsix, installOptions, force, installed);
-                    }
-                    catch (err) {
+                    } catch (err) {
                         this.logger.error(err);
                         failed.push(( vsix.toString()));
                     }
@@ -107,13 +141,12 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
                 const failedGalleryExtensions = await this.installGalleryExtensions(installExtensionInfos, installed, force);
                 failed.push(...failedGalleryExtensions);
             }
-        }
-        catch (error) {
-            this.logger.error(( localize(1853, "Error while installing extensions: {0}", getErrorMessage(error))));
+        } catch (error) {
+            this.logger.error(( localize(1852, "Error while installing extensions: {0}", getErrorMessage(error))));
             throw error;
         }
         if (failed.length) {
-            throw ( new Error(( localize(1854, "Failed Installing Extensions: {0}", failed.join(', ')))));
+            throw ( new Error(( localize(1853, "Failed Installing Extensions: {0}", failed.join(", ")))));
         }
     }
     async updateExtensions(profileLocation) {
@@ -121,48 +154,57 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         const installedExtensionsQuery = [];
         for (const extension of installedExtensions) {
             if (!!extension.identifier.uuid) {
-                installedExtensionsQuery.push({ ...extension.identifier, preRelease: extension.preRelease });
+                installedExtensionsQuery.push({
+                    ...extension.identifier,
+                    preRelease: extension.preRelease
+                });
             }
         }
         this.logger.trace(( localize(
-            1855,
+            1854,
             "Fetching latest versions for {0} extensions",
             installedExtensionsQuery.length
         )));
-        const availableVersions = await this.extensionGalleryService.getExtensions(installedExtensionsQuery, { compatible: true }, CancellationToken.None);
+        const availableVersions = await this.extensionGalleryService.getExtensions(installedExtensionsQuery, {
+            compatible: true
+        }, CancellationToken.None);
         const extensionsToUpdate = [];
         for (const newVersion of availableVersions) {
             for (const oldVersion of installedExtensions) {
                 if (areSameExtensions(oldVersion.identifier, newVersion.identifier) && semverExports.gt(newVersion.version, oldVersion.manifest.version)) {
                     extensionsToUpdate.push({
                         extension: newVersion,
-                        options: { operation: InstallOperation.Update, installPreReleaseVersion: oldVersion.preRelease, profileLocation, isApplicationScoped: oldVersion.isApplicationScoped }
+                        options: {
+                            operation: InstallOperation.Update,
+                            installPreReleaseVersion: oldVersion.preRelease,
+                            profileLocation,
+                            isApplicationScoped: oldVersion.isApplicationScoped
+                        }
                     });
                 }
             }
         }
         if (!extensionsToUpdate.length) {
-            this.logger.info(( localize(1856, "No extension to update")));
+            this.logger.info(( localize(1855, "No extension to update")));
             return;
         }
         this.logger.info(( localize(
-            1857,
+            1856,
             "Updating extensions: {0}",
-            ( extensionsToUpdate.map(ext => ext.extension.identifier.id)).join(', ')
+            ( extensionsToUpdate.map(ext => ext.extension.identifier.id)).join(", ")
         )));
         const installationResult = await this.extensionManagementService.installGalleryExtensions(extensionsToUpdate);
         for (const extensionResult of installationResult) {
             if (extensionResult.error) {
                 this.logger.error(( localize(
-                    1858,
+                    1857,
                     "Error while updating extension {0}: {1}",
                     extensionResult.identifier.id,
                     getErrorMessage(extensionResult.error)
                 )));
-            }
-            else {
+            } else {
                 this.logger.info(( localize(
-                    1859,
+                    1858,
                     "Extension '{0}' v{1} was successfully updated.",
                     extensionResult.identifier.id,
                     extensionResult.local?.manifest.version
@@ -172,12 +214,18 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
     }
     async installGalleryExtensions(installExtensionInfos, installed, force) {
         installExtensionInfos = installExtensionInfos.filter(installExtensionInfo => {
-            const { id, version, installOptions } = installExtensionInfo;
-            const installedExtension = installed.find(i => areSameExtensions(i.identifier, { id }));
+            const {
+                id,
+                version,
+                installOptions
+            } = installExtensionInfo;
+            const installedExtension = installed.find(i => areSameExtensions(i.identifier, {
+                id
+            }));
             if (installedExtension) {
-                if (!force && (!version || (version === 'prerelease' && installedExtension.preRelease))) {
+                if (!force && (!version || (version === "prerelease" && installedExtension.preRelease))) {
                     this.logger.info(( localize(
-                        1860,
+                        1859,
                         "Extension '{0}' v{1} is already installed. Use '--force' option to update to latest version or provide '@<version>' to install a specific version, for example: '{2}@1.2.3'.",
                         id,
                         installedExtension.manifest.version,
@@ -186,10 +234,10 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
                     return false;
                 }
                 if (version && installedExtension.manifest.version === version) {
-                    this.logger.info(( localize(1861, "Extension '{0}' is already installed.", `${id}@${version}`)));
+                    this.logger.info(( localize(1860, "Extension '{0}' is already installed.", `${id}@${version}`)));
                     return false;
                 }
-                if (installedExtension.preRelease && version !== 'prerelease') {
+                if (installedExtension.preRelease && version !== "prerelease") {
                     installOptions.preRelease = false;
                 }
             }
@@ -201,7 +249,13 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         const failed = [];
         const extensionsToInstall = [];
         const galleryExtensions = await this.getGalleryExtensions(installExtensionInfos);
-        await Promise.all(( installExtensionInfos.map(async ({ id, version, installOptions }) => {
+        await Promise.all(( installExtensionInfos.map(async (
+            {
+                id,
+                version,
+                installOptions
+            }
+        ) => {
             const gallery = galleryExtensions.get(id.toLowerCase());
             if (!gallery) {
                 this.logger.error(`${notFound(version ? `${id}@${version}` : id)}\n${useId}`);
@@ -213,8 +267,7 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
                 if (manifest && !this.validateExtensionKind(manifest)) {
                     return;
                 }
-            }
-            catch (err) {
+            } catch (err) {
                 this.logger.error(err.message || err.stack || err);
                 failed.push(id);
                 return;
@@ -223,28 +276,31 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
             if (installedExtension) {
                 if (gallery.version === installedExtension.manifest.version) {
                     this.logger.info(( localize(
-                        1861,
+                        1860,
                         "Extension '{0}' is already installed.",
                         version ? `${id}@${version}` : id
                     )));
                     return;
                 }
                 this.logger.info(( localize(
-                    1862,
+                    1861,
                     "Updating the extension '{0}' to the version {1}",
                     id,
                     gallery.version
                 )));
             }
             if (installOptions.isBuiltin) {
-                this.logger.info(version ? ( localize(1863, "Installing builtin extension '{0}' v{1}...", id, version)) : ( localize(1864, "Installing builtin extension '{0}'...", id)));
-            }
-            else {
-                this.logger.info(version ? ( localize(1865, "Installing extension '{0}' v{1}...", id, version)) : ( localize(1866, "Installing extension '{0}'...", id)));
+                this.logger.info(version ? ( localize(1862, "Installing builtin extension '{0}' v{1}...", id, version)) : ( localize(1863, "Installing builtin extension '{0}'...", id)));
+            } else {
+                this.logger.info(version ? ( localize(1864, "Installing extension '{0}' v{1}...", id, version)) : ( localize(1865, "Installing extension '{0}'...", id)));
             }
             extensionsToInstall.push({
                 extension: gallery,
-                options: { ...installOptions, installGivenVersion: !!version, isApplicationScoped: installOptions.isApplicationScoped || installedExtension?.isApplicationScoped },
+                options: {
+                    ...installOptions,
+                    installGivenVersion: !!version,
+                    isApplicationScoped: installOptions.isApplicationScoped || installedExtension?.isApplicationScoped
+                }
             });
         })));
         if (extensionsToInstall.length) {
@@ -252,16 +308,15 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
             for (const extensionResult of installationResult) {
                 if (extensionResult.error) {
                     this.logger.error(( localize(
-                        1867,
+                        1866,
                         "Error while installing extension {0}: {1}",
                         extensionResult.identifier.id,
                         getErrorMessage(extensionResult.error)
                     )));
                     failed.push(extensionResult.identifier.id);
-                }
-                else {
+                } else {
                     this.logger.info(( localize(
-                        1868,
+                        1867,
                         "Extension '{0}' v{1} was successfully installed.",
                         extensionResult.identifier.id,
                         extensionResult.local?.manifest.version
@@ -274,19 +329,20 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
     async installVSIX(vsix, installOptions, force, installedExtensions) {
         const manifest = await this.extensionManagementService.getManifest(vsix);
         if (!manifest) {
-            throw ( new Error('Invalid vsix'));
+            throw ( new Error("Invalid vsix"));
         }
         const valid = await this.validateVSIX(manifest, force, installOptions.profileLocation, installedExtensions);
         if (valid) {
             try {
-                await this.extensionManagementService.install(vsix, { ...installOptions, installGivenVersion: true });
-                this.logger.info(( localize(1869, "Extension '{0}' was successfully installed.", basename(vsix))));
-            }
-            catch (error) {
+                await this.extensionManagementService.install(vsix, {
+                    ...installOptions,
+                    installGivenVersion: true
+                });
+                this.logger.info(( localize(1868, "Extension '{0}' was successfully installed.", basename(vsix))));
+            } catch (error) {
                 if (isCancellationError(error)) {
-                    this.logger.info(( localize(1870, "Cancelled installing extension '{0}'.", basename(vsix))));
-                }
-                else {
+                    this.logger.info(( localize(1869, "Cancelled installing extension '{0}'.", basename(vsix))));
+                } else {
                     throw error;
                 }
             }
@@ -299,11 +355,16 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         const extensionInfos = [];
         for (const extension of extensions) {
             if (EXTENSION_IDENTIFIER_REGEX.test(extension.id)) {
-                extensionInfos.push({ ...extension, preRelease });
+                extensionInfos.push({
+                    ...extension,
+                    preRelease
+                });
             }
         }
         if (extensionInfos.length) {
-            const result = await this.extensionGalleryService.getExtensions(extensionInfos, { targetPlatform }, CancellationToken.None);
+            const result = await this.extensionGalleryService.getExtensions(extensionInfos, {
+                targetPlatform
+            }, CancellationToken.None);
             for (const extension of result) {
                 galleryExtensions.set(extension.identifier.id.toLowerCase(), extension);
             }
@@ -315,11 +376,15 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
     }
     async validateVSIX(manifest, force, profileLocation, installedExtensions) {
         if (!force) {
-            const extensionIdentifier = { id: getGalleryExtensionId(manifest.publisher, manifest.name) };
-            const newer = installedExtensions.find(local => areSameExtensions(extensionIdentifier, local.identifier) && semverExports.gt(local.manifest.version, manifest.version));
+            const extensionIdentifier = {
+                id: getGalleryExtensionId(manifest.publisher, manifest.name)
+            };
+            const newer = installedExtensions.find(
+                local => areSameExtensions(extensionIdentifier, local.identifier) && semverExports.gt(local.manifest.version, manifest.version)
+            );
             if (newer) {
                 this.logger.info(( localize(
-                    1871,
+                    1870,
                     "A newer version of extension '{0}' v{1} is already installed. Use '--force' option to downgrade to older version.",
                     newer.identifier.id,
                     newer.manifest.version,
@@ -331,7 +396,7 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         return this.validateExtensionKind(manifest);
     }
     async uninstallExtensions(extensions, force, profileLocation) {
-        const getId = async (extensionDescription) => {
+        const getId = async extensionDescription => {
             if (extensionDescription instanceof URI) {
                 const manifest = await this.extensionManagementService.getManifest(extensionDescription);
                 return getExtensionId(manifest.publisher, manifest.name);
@@ -341,13 +406,15 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         for (const extension of extensions) {
             const id = await getId(extension);
             const installed = await this.extensionManagementService.getInstalled(undefined, profileLocation);
-            const extensionsToUninstall = installed.filter(e => areSameExtensions(e.identifier, { id }));
+            const extensionsToUninstall = installed.filter(e => areSameExtensions(e.identifier, {
+                id
+            }));
             if (!extensionsToUninstall.length) {
                 throw ( new Error(`${this.notInstalled(id)}\n${useId}`));
             }
             if (( extensionsToUninstall.some(e => e.type === ExtensionType.System))) {
                 this.logger.info(( localize(
-                    1872,
+                    1871,
                     "Extension '{0}' is a Built-in extension and cannot be uninstalled",
                     id
                 )));
@@ -355,26 +422,27 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
             }
             if (!force && ( extensionsToUninstall.some(e => e.isBuiltin))) {
                 this.logger.info(( localize(
-                    1873,
+                    1872,
                     "Extension '{0}' is marked as a Built-in extension by user. Please use '--force' option to uninstall it.",
                     id
                 )));
                 return;
             }
-            this.logger.info(( localize(1874, "Uninstalling {0}...", id)));
+            this.logger.info(( localize(1873, "Uninstalling {0}...", id)));
             for (const extensionToUninstall of extensionsToUninstall) {
-                await this.extensionManagementService.uninstall(extensionToUninstall, { profileLocation });
+                await this.extensionManagementService.uninstall(extensionToUninstall, {
+                    profileLocation
+                });
             }
             if (this.location) {
                 this.logger.info(( localize(
-                    1875,
+                    1874,
                     "Extension '{0}' was successfully uninstalled from {1}!",
                     id,
                     this.location
                 )));
-            }
-            else {
-                this.logger.info(( localize(1876, "Extension '{0}' was successfully uninstalled!", id)));
+            } else {
+                this.logger.info(( localize(1875, "Extension '{0}' was successfully uninstalled!", id)));
             }
         }
     }
@@ -392,12 +460,9 @@ let ExtensionManagementCLI = class ExtensionManagementCLI {
         });
     }
     notInstalled(id) {
-        return this.location ? ( localize(1877, "Extension '{0}' is not installed on {1}.", id, this.location)) : ( localize(1878, "Extension '{0}' is not installed.", id));
+        return this.location ? ( localize(1876, "Extension '{0}' is not installed on {1}.", id, this.location)) : ( localize(1877, "Extension '{0}' is not installed.", id));
     }
 };
-ExtensionManagementCLI = ( __decorate([
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IExtensionGalleryService))
-], ExtensionManagementCLI));
+ExtensionManagementCLI = ( __decorate([( __param(2, IExtensionManagementService)), ( __param(3, IExtensionGalleryService)), ( __param(4, IProductService))], ExtensionManagementCLI));
 
 export { ExtensionManagementCLI };