@codingame/monaco-vscode-extensions-service-override 31.0.1 → 32.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.js

@@ -1,8 +1,8 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { multibyteAwareBtoa } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
-import { createCancelablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { DeferredPromise, createCancelablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { onUnexpectedError, isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
@@ -22,6 +22,7 @@ import { UndoRedoElementType } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { IUndoRedoService } from '@codingame/monaco-vscode-api/vscode/vs/platform/undoRedo/common/undoRedo.service';
 import { reviveWebviewExtension } from './mainThreadWebviews.js';
 import { ExtHostContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { CustomEditorDiffInput, CustomEditorSideBySideDiffInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/browser/customEditorDiffInput';
 import { CustomEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
 import { ICustomEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/common/customEditor.service';
 import { CustomTextEditorModel } from '../../contrib/customEditor/common/customTextEditorModel.js';
@@ -38,6 +39,7 @@ import { NO_TYPE_ID, WorkingCopyCapabilities } from '@codingame/monaco-vscode-ap
 import { IWorkingCopyFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IWorkingCopyService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IUntitledTextEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service';
 
 var MainThreadCustomEditorModel_1;
 var CustomEditorModelType;
@@ -59,7 +61,8 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         _editorService,
         _instantiationService,
         _webviewWorkbenchService,
-        _uriIdentityService
+        _uriIdentityService,
+        _untitledTextEditorService
     ) {
         super();
         this.mainThreadWebview = mainThreadWebview;
@@ -70,8 +73,10 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._instantiationService = _instantiationService;
         this._webviewWorkbenchService = _webviewWorkbenchService;
         this._uriIdentityService = _uriIdentityService;
+        this._untitledTextEditorService = _untitledTextEditorService;
         this._editorProviders = this._register(( new DisposableMap()));
         this._editorRenameBackups = ( new Map());
+        this._pendingSideBySideDiffResolutions = ( new Map());
         this._webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore("mainThreadCustomEditors.origins", storageService));
         this._proxyCustomEditors = ( context.getProxy(ExtHostContext.ExtHostCustomEditors));
         this._register(workingCopyFileService.registerWorkingCopyProvider(editorResource => {
@@ -87,7 +92,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         }));
         this._register(_webviewWorkbenchService.registerResolver({
             canResolve: webview => {
-                if (webview instanceof CustomEditorInput) {
+                if (webview instanceof CustomEditorInput || webview instanceof CustomEditorDiffInput || webview instanceof CustomEditorSideBySideDiffInput) {
                     extensionService.activateByEvent(`onCustomEditor:${webview.viewType}`);
                 }
                 return false;
@@ -121,6 +126,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         extensionData,
         viewType,
         options,
+        capabilities,
         supportsMultipleEditorsPerDocument,
         serializeBuffersForPostMessage
     ) {
@@ -129,7 +135,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
             reviveWebviewExtension(extensionData),
             viewType,
             options,
-            {},
+            capabilities,
             supportsMultipleEditorsPerDocument,
             serializeBuffersForPostMessage
         );
@@ -148,86 +154,201 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         }
         const disposables = ( new DisposableStore());
         disposables.add(this._customEditorService.registerCustomEditorCapabilities(viewType, {
-            supportsMultipleEditorsPerDocument
+            supportsMultipleEditorsPerDocument,
+            isTextEditor: modelType === CustomEditorModelType.Text,
+            supportsInlineDiff: capabilities.supportsInlineDiff,
+            supportsSideBySideDiff: capabilities.supportsSideBySideDiff
         }));
         disposables.add(this._webviewWorkbenchService.registerResolver({
             canResolve: webviewInput => {
-                return webviewInput instanceof CustomEditorInput && webviewInput.viewType === viewType;
+                return (webviewInput instanceof CustomEditorInput || webviewInput instanceof CustomEditorDiffInput || webviewInput instanceof CustomEditorSideBySideDiffInput) && webviewInput.viewType === viewType;
             },
             resolveWebview: async (webviewInput, cancellation) => {
+                if (!(webviewInput instanceof CustomEditorInput || webviewInput instanceof CustomEditorDiffInput || webviewInput instanceof CustomEditorSideBySideDiffInput)) {
+                    return;
+                }
                 const handle = generateUuid();
-                const resource = webviewInput.resource;
                 webviewInput.webview.origin = this._webviewOriginStore.getOrigin(viewType, extension.id);
                 this.mainThreadWebviewPanels.addWebviewInput(handle, webviewInput, {
                     serializeBuffersForPostMessage
                 });
                 webviewInput.webview.options = options;
                 webviewInput.webview.extension = extension;
-                let backupId = webviewInput.backupId;
-                if (webviewInput.oldResource && !webviewInput.backupId) {
-                    const backup = this._editorRenameBackups.get(( webviewInput.oldResource.toString()));
-                    backupId = backup?.backupId;
-                    this._editorRenameBackups.delete(( webviewInput.oldResource.toString()));
+                const resource = webviewInput instanceof CustomEditorDiffInput ? webviewInput.modifiedResource : webviewInput.resource;
+                let backupId;
+                if (webviewInput instanceof CustomEditorInput) {
+                    backupId = webviewInput.backupId;
+                    if (webviewInput.oldResource && !webviewInput.backupId) {
+                        const backup = this._editorRenameBackups.get(( webviewInput.oldResource.toString()));
+                        backupId = backup?.backupId;
+                        this._editorRenameBackups.delete(( webviewInput.oldResource.toString()));
+                    }
                 }
                 let modelRef;
+                const additionalModelRefs = ( new DisposableStore());
                 try {
                     modelRef = await this.getOrCreateCustomEditorModel(modelType, resource, viewType, {
                         backupId
                     }, cancellation);
+                    if (webviewInput instanceof CustomEditorDiffInput && !isEqual(webviewInput.originalResource, resource)) {
+                        additionalModelRefs.add(
+                            await this.getOrCreateCustomEditorModel(modelType, webviewInput.originalResource, viewType, {}, cancellation)
+                        );
+                    } else if (modelType === CustomEditorModelType.Text && webviewInput instanceof CustomEditorSideBySideDiffInput) {
+                        const otherResource = webviewInput.side === "original" ? webviewInput.modifiedResource : webviewInput.originalResource;
+                        if (!isEqual(otherResource, resource)) {
+                            additionalModelRefs.add(
+                                await this.getOrCreateCustomEditorModel(modelType, otherResource, viewType, {}, cancellation)
+                            );
+                        }
+                    }
                 } catch (error) {
                     onUnexpectedError(error);
                     webviewInput.webview.setHtml(this.mainThreadWebview.getWebviewResolvedFailedContent(viewType));
+                    additionalModelRefs.dispose();
+                    modelRef?.dispose();
                     return;
                 }
+                if (!modelRef) {
+                    additionalModelRefs.dispose();
+                    return;
+                }
+                let resolvedModelRef = modelRef;
                 if (cancellation.isCancellationRequested) {
-                    modelRef.dispose();
+                    additionalModelRefs.dispose();
+                    resolvedModelRef.dispose();
                     return;
                 }
-                const disposeSub = webviewInput.webview.onDidDispose(() => {
-                    disposeSub.dispose();
-                    inputDisposeSub.dispose();
-                    if (modelRef.object.isDirty()) {
-                        const sub = modelRef.object.onDidChangeDirty(() => {
-                            if (!modelRef.object.isDirty()) {
+                const disposeModelRefs = () => {
+                    additionalModelRefs.dispose();
+                    if (resolvedModelRef.object.isDirty()) {
+                        const sub = resolvedModelRef.object.onDidChangeDirty(() => {
+                            if (!resolvedModelRef.object.isDirty()) {
                                 sub.dispose();
-                                modelRef.dispose();
+                                resolvedModelRef.dispose();
                             }
                         });
                         return;
                     }
-                    modelRef.dispose();
+                    resolvedModelRef.dispose();
+                };
+                const disposeSub = webviewInput.webview.onDidDispose(() => {
+                    disposeSub.dispose();
+                    inputDisposeSub.dispose();
+                    disposeModelRefs();
                 });
                 const inputDisposeSub = webviewInput.onWillDispose(() => {
                     inputDisposeSub.dispose();
                     disposeSub.dispose();
-                    modelRef.dispose();
+                    disposeModelRefs();
                 });
-                if (capabilities.supportsMove) {
+                if (webviewInput instanceof CustomEditorInput && capabilities.supportsMove) {
                     webviewInput.onMove(async newResource => {
-                        const oldModel = modelRef;
-                        modelRef = await this.getOrCreateCustomEditorModel(modelType, newResource, viewType, {}, CancellationToken.None);
+                        const oldModel = resolvedModelRef;
+                        resolvedModelRef = await this.getOrCreateCustomEditorModel(modelType, newResource, viewType, {}, CancellationToken.None);
                         this._proxyCustomEditors.$onMoveCustomEditor(handle, newResource, viewType);
                         oldModel.dispose();
                     });
                 }
                 try {
-                    const actualResource = modelType === CustomEditorModelType.Text ? this._uriIdentityService.asCanonicalUri(resource) : resource;
-                    await this._proxyCustomEditors.$resolveCustomEditor(actualResource, handle, viewType, {
+                    const initData = {
                         title: webviewInput.getTitle(),
                         contentOptions: webviewInput.webview.contentOptions,
                         options: webviewInput.webview.options,
                         active: webviewInput === this._editorService.activeEditor
-                    }, editorGroupToColumn(this._editorGroupService, webviewInput.group || 0), cancellation);
+                    };
+                    const position = editorGroupToColumn(this._editorGroupService, webviewInput.group || 0);
+                    if (webviewInput instanceof CustomEditorDiffInput) {
+                        const originalResource = modelType === CustomEditorModelType.Text ? this._uriIdentityService.asCanonicalUri(webviewInput.originalResource) : webviewInput.originalResource;
+                        const modifiedResource = modelType === CustomEditorModelType.Text ? this._uriIdentityService.asCanonicalUri(webviewInput.modifiedResource) : webviewInput.modifiedResource;
+                        await this._proxyCustomEditors.$resolveCustomEditorInlineDiff(
+                            originalResource,
+                            modifiedResource,
+                            handle,
+                            viewType,
+                            initData,
+                            position,
+                            cancellation
+                        );
+                    } else if (webviewInput instanceof CustomEditorSideBySideDiffInput) {
+                        await this.resolveCustomEditorSideBySideDiff(
+                            modelType,
+                            webviewInput,
+                            handle,
+                            viewType,
+                            initData,
+                            position,
+                            cancellation
+                        );
+                    } else {
+                        const actualResource = modelType === CustomEditorModelType.Text ? this._uriIdentityService.asCanonicalUri(resource) : resource;
+                        await this._proxyCustomEditors.$resolveCustomEditor(actualResource, handle, viewType, initData, position, cancellation);
+                    }
                 } catch (error) {
                     onUnexpectedError(error);
                     webviewInput.webview.setHtml(this.mainThreadWebview.getWebviewResolvedFailedContent(viewType));
-                    modelRef.dispose();
+                    additionalModelRefs.dispose();
+                    resolvedModelRef.dispose();
                     return;
                 }
             }
         }));
         this._editorProviders.set(viewType, disposables);
     }
+    resolveCustomEditorSideBySideDiff(
+        modelType,
+        webviewInput,
+        handle,
+        viewType,
+        initData,
+        position,
+        cancellation
+    ) {
+        let pending = this._pendingSideBySideDiffResolutions.get(webviewInput.diffId);
+        if (!pending) {
+            pending = {
+                promise: ( new DeferredPromise()),
+                cancellation: ( new CancellationTokenSource()),
+                disposables: ( new DisposableStore())
+            };
+            this._pendingSideBySideDiffResolutions.set(webviewInput.diffId, pending);
+        }
+        const cleanup = () => {
+            this._pendingSideBySideDiffResolutions.delete(webviewInput.diffId);
+            pending.disposables.dispose();
+            pending.cancellation.dispose();
+        };
+        pending.disposables.add(cancellation.onCancellationRequested(() => {
+            pending.cancellation.cancel();
+            if (!pending.started) {
+                pending.promise.cancel();
+                cleanup();
+            }
+        }));
+        pending[webviewInput.side] = {
+            handle,
+            initData
+        };
+        if (pending.original && pending.modified && !pending.started) {
+            pending.started = true;
+            pending.promise.settleWith((async () => {
+                try {
+                    const originalResource = modelType === CustomEditorModelType.Text ? this._uriIdentityService.asCanonicalUri(webviewInput.originalResource) : webviewInput.originalResource;
+                    const modifiedResource = modelType === CustomEditorModelType.Text ? this._uriIdentityService.asCanonicalUri(webviewInput.modifiedResource) : webviewInput.modifiedResource;
+                    await this._proxyCustomEditors.$resolveCustomEditorSideBySideDiff(originalResource, modifiedResource, {
+                        original: pending.original.handle,
+                        modified: pending.modified.handle
+                    }, viewType, {
+                        original: pending.original.initData,
+                        modified: pending.modified.initData
+                    }, position, pending.cancellation.token);
+                } finally {
+                    cleanup();
+                }
+            })());
+        }
+        return pending.promise.p;
+    }
     $unregisterEditorProvider(viewType) {
         if (!( this._editorProviders.has(viewType))) {
             throw ( new Error(`No provider for ${viewType} registered`));
@@ -254,9 +375,10 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                     viewType,
                     resource,
                     options,
+                    this._untitledTextEditorService,
                     () => {
                         return Array.from(this.mainThreadWebviewPanels.webviewInputs).filter(
-                            editor => editor instanceof CustomEditorInput && isEqual(editor.resource, resource)
+                            editor => (editor instanceof CustomEditorInput && isEqual(editor.resource, resource)) || (editor instanceof CustomEditorDiffInput && (isEqual(editor.originalResource, resource) || isEqual(editor.modifiedResource, resource))) || (editor instanceof CustomEditorSideBySideDiffInput && isEqual(editor.resource, resource))
                         );
                     },
                     cancellation
@@ -303,7 +425,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         })());
     }
 };
-MainThreadCustomEditors = ( __decorate([( __param(3, IExtensionService)), ( __param(4, IStorageService)), ( __param(5, IWorkingCopyService)), ( __param(6, IWorkingCopyFileService)), ( __param(7, ICustomEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, IEditorService)), ( __param(10, IInstantiationService)), ( __param(11, IWebviewWorkbenchService)), ( __param(12, IUriIdentityService))], MainThreadCustomEditors));
+MainThreadCustomEditors = ( __decorate([( __param(3, IExtensionService)), ( __param(4, IStorageService)), ( __param(5, IWorkingCopyService)), ( __param(6, IWorkingCopyFileService)), ( __param(7, ICustomEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, IEditorService)), ( __param(10, IInstantiationService)), ( __param(11, IWebviewWorkbenchService)), ( __param(12, IUriIdentityService)), ( __param(13, IUntitledTextEditorService))], MainThreadCustomEditors));
 var HotExitState;
 (function(HotExitState) {
     let Type;
@@ -333,17 +455,22 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         viewType,
         resource,
         options,
+        untitledTextEditorService,
         getEditors,
         cancellation
     ) {
         const editors = getEditors();
         let untitledDocumentData;
-        if (editors.length !== 0) {
-            untitledDocumentData = editors[0].untitledDocumentData;
+        const primaryCustomEditorInput = editors.find(editor => editor instanceof CustomEditorInput);
+        if (primaryCustomEditorInput) {
+            untitledDocumentData = primaryCustomEditorInput.untitledDocumentData;
         }
         const {
             editable
         } = await proxy.$createCustomDocument(resource, viewType, options.backupId, untitledDocumentData, cancellation);
+        if (untitledDocumentData && resource.scheme === Schemas.untitled) {
+            untitledTextEditorService.get(resource)?.revert();
+        }
         return instantiationService.createInstance(
             MainThreadCustomEditorModel_1,
             proxy,
@@ -405,7 +532,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2552,
+                    2591,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -473,7 +600,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2553, "Edit")),
+            label: label ?? ( localize(2592, "Edit")),
             code: "undoredo.customEditorEdit",
             undo: () => this.undo(),
             redo: () => this.redo()

package/vscode/src/vs/workbench/api/browser/mainThreadDocumentDiff.d.ts

@@ -0,0 +1,10 @@
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { IDocumentDiffResultDto, MainThreadDocumentDiffShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadDocumentDiff implements MainThreadDocumentDiffShape {
+    private readonly _editorWorkerService;
+    constructor(_extHostContext: IExtHostContext, _editorWorkerService: IEditorWorkerService);
+    $computeDocumentDiff(originalUri: UriComponents, modifiedUri: UriComponents, ignoreTrimWhitespace: boolean, maxComputationTimeMs: number, computeMoves: boolean): Promise<IDocumentDiffResultDto | null>;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDocumentDiff.js

@@ -0,0 +1,58 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadDocumentDiff = class MainThreadDocumentDiff {
+    constructor(_extHostContext, _editorWorkerService) {
+        this._editorWorkerService = _editorWorkerService;
+    }
+    async $computeDocumentDiff(
+        originalUri,
+        modifiedUri,
+        ignoreTrimWhitespace,
+        maxComputationTimeMs,
+        computeMoves
+    ) {
+        const original = URI.revive(originalUri);
+        const modified = URI.revive(modifiedUri);
+        const result = await this._editorWorkerService.computeDiff(original, modified, {
+            ignoreTrimWhitespace,
+            maxComputationTimeMs,
+            computeMoves
+        }, "advanced");
+        if (!result) {
+            return null;
+        }
+        const toLineRange = r => ({
+            startLineNumber: r.startLineNumber,
+            startColumn: 1,
+            endLineNumber: r.endLineNumberExclusive,
+            endColumn: 1
+        });
+        const mapChange = c => ({
+            originalRange: toLineRange(c.original),
+            modifiedRange: toLineRange(c.modified),
+            innerChanges: c.innerChanges?.map(ic => ({
+                originalRange: ic.originalRange,
+                modifiedRange: ic.modifiedRange
+            }))
+        });
+        return {
+            identical: result.identical,
+            quitEarly: result.quitEarly,
+            changes: ( result.changes.map(mapChange)),
+            moves: ( result.moves.map(m => ({
+                originalRange: toLineRange(m.lineRangeMapping.original),
+                modifiedRange: toLineRange(m.lineRangeMapping.modified),
+                changes: ( m.changes.map(mapChange))
+            })))
+        };
+    }
+    dispose() {}
+};
+MainThreadDocumentDiff = __decorate([extHostNamedCustomer(MainContext.MainThreadDocumentDiff), ( __param(1, IEditorWorkerService))], MainThreadDocumentDiff);
+
+export { MainThreadDocumentDiff };

package/vscode/src/vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant.js

@@ -14,7 +14,7 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(2554, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2593, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         }));
         return raceCancellationError(p, token);

package/vscode/src/vs/workbench/api/browser/mainThreadExtensionService.js

@@ -111,7 +111,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2555,
+                    2594,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -119,7 +119,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "reload",
-                        label: ( localize(2556, "Reload Window")),
+                        label: ( localize(2595, "Reload Window")),
                         run: () => this._hostService.reload()
                     })]
                 }
@@ -130,7 +130,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2557,
+                        2596,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -140,7 +140,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2558,
+                        2597,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -148,7 +148,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "manageWorkspaceTrust",
-                            label: ( localize(2559, "Manage Workspace Trust")),
+                            label: ( localize(2598, "Manage Workspace Trust")),
                             run: () => this._commandService.executeCommand("workbench.trust.manage")
                         })]
                     }
@@ -157,7 +157,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2560,
+                        2599,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -165,7 +165,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "enable",
-                            label: ( localize(2561, "Enable and Reload")),
+                            label: ( localize(2600, "Enable and Reload")),
                             enabled: true,
                             run: () => this._extensionEnablementService.setEnablement(
                                 [missingInstalledDependency],
@@ -178,7 +178,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2562,
+                        2601,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -199,7 +199,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2563,
+                    2602,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
@@ -208,14 +208,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "install",
-                        label: ( localize(2564, "Install and Reload")),
+                        label: ( localize(2603, "Install and Reload")),
                         run: () => this._extensionsWorkbenchService.install(dependencyExtension).then(() => this._hostService.reload(), e => this._notificationService.error(e))
                     })]
                 }
             });
         } else {
             this._notificationService.error(( localize(
-                2565,
+                2604,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency