@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

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

@@ -29,32 +29,28 @@ class MainThreadAuthenticationProvider extends Disposable {
     manageTrustedExtensions(accountName) {
         const allowedExtensions = readAllowedExtensions(this.storageService, this.id, accountName);
         if (!allowedExtensions.length) {
-            this.dialogService.info(( nls.localize('noTrustedExtensions', "This account has not been used by any extensions.")));
+            this.dialogService.info(nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'noTrustedExtensions', "This account has not been used by any extensions."));
             return;
         }
         const quickPick = this.quickInputService.createQuickPick();
         quickPick.canSelectMany = true;
         quickPick.customButton = true;
-        quickPick.customLabel = ( nls.localize('manageTrustedExtensions.cancel', 'Cancel'));
+        quickPick.customLabel = nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'manageTrustedExtensions.cancel', 'Cancel');
         const usages = readAccountUsages(this.storageService, this.id, accountName);
         const items = ( allowedExtensions.map(extension => {
             const usage = usages.find(usage => extension.id === usage.extensionId);
             return {
                 label: extension.name,
                 description: usage
-                    ? ( nls.localize(
-                    { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] },
-                    "Last used this account {0}",
-                    fromNow(usage.lastUsed, true)
-                ))
-                    : ( nls.localize('notUsed', "Has not used this account")),
+                    ? nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] }, "Last used this account {0}", fromNow(usage.lastUsed, true))
+                    : nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'notUsed', "Has not used this account"),
                 extension
             };
         }));
         quickPick.items = items;
         quickPick.selectedItems = items.filter(item => item.extension.allowed === undefined || item.extension.allowed);
-        quickPick.title = ( nls.localize('manageTrustedExtensions', "Manage Trusted Extensions"));
-        quickPick.placeholder = ( nls.localize('manageExtensions', "Choose which extensions can access this account"));
+        quickPick.title = nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'manageTrustedExtensions', "Manage Trusted Extensions");
+        quickPick.placeholder = nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'manageExtensions', "Choose which extensions can access this account");
         quickPick.onDidAccept(() => {
             const updatedAllowedList = ( quickPick.items
                 .map(i => i.extension));
@@ -82,14 +78,9 @@ class MainThreadAuthenticationProvider extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: Severity.Info,
             message: accountUsages.length
-                ? ( nls.localize(
-                'signOutMessage',
-                "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?",
-                accountName,
-                ( accountUsages.map(usage => usage.extensionName)).join('\n')
-            ))
-                : ( nls.localize('signOutMessageSimple', "Sign out of '{0}'?", accountName)),
-            primaryButton: ( nls.localize({ key: 'signOut', comment: ['&& denotes a mnemonic'] }, "&&Sign Out"))
+                ? nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'signOutMessage', "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?", accountName, ( accountUsages.map(usage => usage.extensionName)).join('\n'))
+                : nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'signOutMessageSimple', "Sign out of '{0}'?", accountName),
+            primaryButton: nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', { key: 'signOut', comment: ['&& denotes a mnemonic'] }, "&&Sign Out")
         });
         if (confirmed) {
             const removeSessionPromises = ( sessions.map(session => this.removeSession(session.id)));
@@ -106,7 +97,7 @@ class MainThreadAuthenticationProvider extends Disposable {
     }
     async removeSession(sessionId) {
         await this._proxy.$removeSession(this.id, sessionId);
-        this.notificationService.info(( nls.localize('signedOut', "Successfully signed out.")));
+        this.notificationService.info(nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'signedOut', "Successfully signed out."));
     }
 }
 let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
@@ -155,23 +146,13 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
     }
     async loginPrompt(providerName, extensionName, recreatingSession, detail) {
         const message = recreatingSession
-            ? ( nls.localize(
-            'confirmRelogin',
-            "The extension '{0}' wants you to sign in again using {1}.",
-            extensionName,
-            providerName
-        ))
-            : ( nls.localize(
-            'confirmLogin',
-            "The extension '{0}' wants to sign in using {1}.",
-            extensionName,
-            providerName
-        ));
+            ? nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'confirmRelogin', "The extension '{0}' wants you to sign in again using {1}.", extensionName, providerName)
+            : nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', 'confirmLogin', "The extension '{0}' wants to sign in using {1}.", extensionName, providerName);
         const { confirmed } = await this.dialogService.confirm({
             type: Severity.Info,
             message,
             detail,
-            primaryButton: ( nls.localize({ key: 'allow', comment: ['&& denotes a mnemonic'] }, "&&Allow"))
+            primaryButton: nls.localizeWithPath('vs/workbench/api/browser/mainThreadAuthentication', { key: 'allow', comment: ['&& denotes a mnemonic'] }, "&&Allow")
         });
         return confirmed;
     }

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

@@ -14,7 +14,7 @@ import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/comm
 import { ViewPaneContainer } from '../../browser/parts/views/viewPaneContainer.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 class MainThreadCommentThread {
     get input() {
@@ -369,7 +369,7 @@ class MainThreadCommentController {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize('commentsViewIcon', 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, localizeWithPath('vs/workbench/api/browser/mainThreadComments', 'commentsViewIcon', 'View icon of the comments view.'));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService) {
         super();

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

@@ -10,7 +10,7 @@ import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
 import { isEqualOrParent, isEqual, toLocalResource } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -46,10 +46,10 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._editorService = _editorService;
         this._instantiationService = _instantiationService;
         this._webviewWorkbenchService = _webviewWorkbenchService;
-        this._editorProviders = this._register(( (new DisposableMap())));
-        this._editorRenameBackups = ( (new Map()));
-        this._webviewOriginStore = ( (new ExtensionKeyedWebviewOriginStore('mainThreadCustomEditors.origins', storageService)));
-        this._proxyCustomEditors = ( (context.getProxy(ExtHostContext.ExtHostCustomEditors)));
+        this._editorProviders = this._register(( new DisposableMap()));
+        this._editorRenameBackups = ( new Map());
+        this._webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore('mainThreadCustomEditors.origins', storageService));
+        this._proxyCustomEditors = ( context.getProxy(ExtHostContext.ExtHostCustomEditors));
         this._register(workingCopyFileService.registerWorkingCopyProvider((editorResource) => {
             const matchedWorkingCopies = [];
             for (const workingCopy of workingCopyService.workingCopies) {
@@ -79,10 +79,10 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this.registerEditorProvider(0 , reviveWebviewExtension(extensionData), viewType, options, {}, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage);
     }
     registerEditorProvider(modelType, extension, viewType, options, capabilities, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage) {
-        if (( (this._editorProviders.has(viewType)))) {
+        if (( this._editorProviders.has(viewType))) {
             throw new Error(`Provider for ${viewType} already registered`);
         }
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         disposables.add(this._customEditorService.registerCustomEditorCapabilities(viewType, {
             supportsMultipleEditorsPerDocument
         }));
@@ -99,9 +99,9 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 webviewInput.webview.extension = extension;
                 let backupId = webviewInput.backupId;
                 if (webviewInput.oldResource && !webviewInput.backupId) {
-                    const backup = this._editorRenameBackups.get(( (webviewInput.oldResource.toString())));
+                    const backup = this._editorRenameBackups.get(( webviewInput.oldResource.toString()));
                     backupId = backup?.backupId;
-                    this._editorRenameBackups.delete(( (webviewInput.oldResource.toString())));
+                    this._editorRenameBackups.delete(( webviewInput.oldResource.toString()));
                 }
                 let modelRef;
                 try {
@@ -155,7 +155,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._editorProviders.set(viewType, disposables);
     }
     $unregisterEditorProvider(viewType) {
-        if (!( (this._editorProviders.has(viewType)))) {
+        if (!( this._editorProviders.has(viewType))) {
             throw new Error(`No provider for ${viewType} registered`);
         }
         this._editorProviders.deleteAndDispose(viewType);
@@ -213,33 +213,33 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 if (model instanceof MainThreadCustomEditorModel && model.isDirty()) {
                     const workingCopy = await model.backup(CancellationToken.None);
                     if (workingCopy.meta) {
-                        this._editorRenameBackups.set(( (model.editorResource.toString())), workingCopy.meta);
+                        this._editorRenameBackups.set(( model.editorResource.toString()), workingCopy.meta);
                     }
                 }
             }
         })());
     }
 };
-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)))
-], 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))
+], MainThreadCustomEditors));
 var HotExitState;
-( ((function(HotExitState) {
-    ( ((function(Type) {
+( (function(HotExitState) {
+    ( (function(Type) {
         Type[Type["Allowed"] = 0] = "Allowed";
         Type[Type["NotAllowed"] = 1] = "NotAllowed";
         Type[Type["Pending"] = 2] = "Pending";
-    })(HotExitState.Type || (HotExitState.Type = {}))));
-    HotExitState.Allowed = ( (Object.freeze({ type: 0  })));
-    HotExitState.NotAllowed = ( (Object.freeze({ type: 1  })));
+    })(HotExitState.Type || (HotExitState.Type = {})));
+    HotExitState.Allowed = ( Object.freeze({ type: 0  }));
+    HotExitState.NotAllowed = ( Object.freeze({ type: 1  }));
     class Pending {
         constructor(operation) {
             this.operation = operation;
@@ -247,7 +247,7 @@ var HotExitState;
         }
     }
     HotExitState.Pending = Pending;
-})(HotExitState || (HotExitState = {}))));
+})(HotExitState || (HotExitState = {})));
 let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThreadCustomEditorModel extends ResourceWorkingCopy {
     static async create(instantiationService, proxy, viewType, resource, options, getEditors, cancellation) {
         const editors = getEditors();
@@ -277,11 +277,11 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._edits = [];
         this._isDirtyFromContentChange = false;
         this.typeId = NO_TYPE_ID;
-        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this._onDidChangeDirty = this._register(( new Emitter()));
         this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeContent = this._register(( (new Emitter())));
+        this._onDidChangeContent = this._register(( new Emitter()));
         this.onDidChangeContent = this._onDidChangeContent.event;
-        this._onDidSave = this._register(( (new Emitter())));
+        this._onDidSave = this._register(( new Emitter()));
         this.onDidSave = this._onDidSave.event;
         this.onDidChangeReadonly = Event.None;
         this._fromBackup = fromBackup;
@@ -297,7 +297,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
                         return true;
                     }
                     return false;
-                })(), ( (localize('vetoExtHostRestart', "Custom editor '{0}' could not be saved.", this.name))));
+                })(), localizeWithPath('vs/workbench/api/browser/mainThreadCustomEditors', 'vetoExtHostRestart', "Custom editor '{0}' could not be saved.", this.name));
             }));
         }
         if (startDirty) {
@@ -316,15 +316,13 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     static toWorkingCopyResource(viewType, resource) {
         const authority = viewType.replace(/[^a-z0-9\-_]/gi, '-');
-        const path = `/${multibyteAwareBtoa(( ( resource.with({ query: null, fragment: null }).toString(true))))}`;
-        return (
-             (URI.from({
-                scheme: Schemas.vscodeCustomEditor,
-                authority: authority,
-                path: path,
-                query: JSON.stringify(resource.toJSON()),
-            }))
-        );
+        const path = `/${multibyteAwareBtoa(( resource.with({ query: null, fragment: null }).toString(true)))}`;
+        return ( URI.from({
+            scheme: Schemas.vscodeCustomEditor,
+            authority: authority,
+            path: path,
+            query: JSON.stringify(resource.toJSON()),
+        }));
     }
     get name() {
         return basename(this._labelService.getUriLabel(this._editorResource));
@@ -364,7 +362,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: 0 ,
             resource: this._editorResource,
-            label: label ?? ( (localize('defaultEditLabel', "Edit"))),
+            label: label ?? localizeWithPath('vs/workbench/api/browser/mainThreadCustomEditors', 'defaultEditLabel', "Edit"),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),
@@ -556,14 +554,14 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         throw new Error(`Cannot back up in this state: ${errorMessage}`);
     }
 };
-MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( (__decorate([
-    ( (__param(7, IFileDialogService))),
-    ( (__param(8, IFileService))),
-    ( (__param(9, ILabelService))),
-    ( (__param(10, IUndoRedoService))),
-    ( (__param(11, IWorkbenchEnvironmentService))),
-    ( (__param(12, IWorkingCopyService))),
-    ( (__param(13, IPathService))),
-    ( (__param(14, IExtensionService)))
-], MainThreadCustomEditorModel)));
+MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( __decorate([
+    ( __param(7, IFileDialogService)),
+    ( __param(8, IFileService)),
+    ( __param(9, ILabelService)),
+    ( __param(10, IUndoRedoService)),
+    ( __param(11, IWorkbenchEnvironmentService)),
+    ( __param(12, IWorkingCopyService)),
+    ( __param(13, IPathService)),
+    ( __param(14, IExtensionService))
+], MainThreadCustomEditorModel));
 export { MainThreadCustomEditors };

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

@@ -47,10 +47,10 @@ class DocumentAndEditorStateDelta {
     }
     toString() {
         let ret = 'DocumentAndEditorStateDelta\n';
-        ret += `\tRemoved Documents: [${( ( this.removedDocuments.map(d => ( ( d.uri.toString(true)))))).join(', ')}]\n`;
-        ret += `\tAdded Documents: [${( ( this.addedDocuments.map(d => ( ( d.uri.toString(true)))))).join(', ')}]\n`;
-        ret += `\tRemoved Editors: [${( ( this.removedEditors.map(e => e.id))).join(', ')}]\n`;
-        ret += `\tAdded Editors: [${( ( this.addedEditors.map(e => e.id))).join(', ')}]\n`;
+        ret += `\tRemoved Documents: [${( this.removedDocuments.map(d => ( d.uri.toString(true)))).join(', ')}]\n`;
+        ret += `\tAdded Documents: [${( this.addedDocuments.map(d => ( d.uri.toString(true)))).join(', ')}]\n`;
+        ret += `\tRemoved Editors: [${( this.removedEditors.map(e => e.id)).join(', ')}]\n`;
+        ret += `\tAdded Editors: [${( this.addedEditors.map(e => e.id)).join(', ')}]\n`;
         ret += `\tNew Active Editor: ${this.newActiveEditor}\n`;
         return ret;
     }
@@ -58,31 +58,20 @@ class DocumentAndEditorStateDelta {
 class DocumentAndEditorState {
     static compute(before, after) {
         if (!before) {
-            return (
-                 (new DocumentAndEditorStateDelta(
-                    [],
-                    [...( (after.documents.values()))],
-                    [],
-                    [...( (after.textEditors.values()))],
-                    undefined,
-                    after.activeEditor
-                ))
-            );
+            return ( new DocumentAndEditorStateDelta([], [...( after.documents.values())], [], [...( after.textEditors.values())], undefined, after.activeEditor));
         }
         const documentDelta = diffSets(before.documents, after.documents);
         const editorDelta = diffMaps(before.textEditors, after.textEditors);
         const oldActiveEditor = before.activeEditor !== after.activeEditor ? before.activeEditor : undefined;
         const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
-        return (
-             (new DocumentAndEditorStateDelta(
-                documentDelta.removed,
-                documentDelta.added,
-                editorDelta.removed,
-                editorDelta.added,
-                oldActiveEditor,
-                newActiveEditor
-            ))
-        );
+        return ( new DocumentAndEditorStateDelta(
+            documentDelta.removed,
+            documentDelta.added,
+            editorDelta.removed,
+            editorDelta.added,
+            oldActiveEditor,
+            newActiveEditor
+        ));
     }
     constructor(documents, textEditors, activeEditor) {
         this.documents = documents;
@@ -97,8 +86,8 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
         this._codeEditorService = _codeEditorService;
         this._editorService = _editorService;
         this._paneCompositeService = _paneCompositeService;
-        this._toDispose = ( (new DisposableStore()));
-        this._toDisposeOnEditorRemove = ( (new DisposableMap()));
+        this._toDispose = ( new DisposableStore());
+        this._toDisposeOnEditorRemove = ( new DisposableMap());
         this._activeEditorOrder = 0 ;
         this._modelService.onModelAdded(this._updateStateOnModelAdd, this, this._toDispose);
         this._modelService.onModelRemoved(_ => this._updateState(), this, this._toDispose);
@@ -121,7 +110,7 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
     }
     _onDidRemoveEditor(e) {
         const id = e.getId();
-        if (( (this._toDisposeOnEditorRemove.has(id)))) {
+        if (( this._toDisposeOnEditorRemove.has(id))) {
             this._toDisposeOnEditorRemove.deleteAndDispose(id);
             this._updateState();
         }
@@ -134,21 +123,21 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
             this._updateState();
             return;
         }
-        this._currentState = ( (new DocumentAndEditorState(
+        this._currentState = ( new DocumentAndEditorState(
             this._currentState.documents.add(model),
             this._currentState.textEditors,
             this._currentState.activeEditor
-        )));
-        this._onDidChangeState(( (new DocumentAndEditorStateDelta([], [model], [], [], undefined, undefined))));
+        ));
+        this._onDidChangeState(( new DocumentAndEditorStateDelta([], [model], [], [], undefined, undefined)));
     }
     _updateState(widgetFocusCandidate) {
-        const models = ( (new Set()));
+        const models = ( new Set());
         for (const model of this._modelService.getModels()) {
             if (shouldSynchronizeModel(model)) {
                 models.add(model);
             }
         }
-        const editors = ( (new Map()));
+        const editors = ( new Map());
         let activeEditor = null;
         for (const editor of this._codeEditorService.listCodeEditors()) {
             if (editor.isSimpleWidget) {
@@ -159,7 +148,7 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
                 && !model.isDisposed()
                 && Boolean(this._modelService.getModel(model.uri))
             ) {
-                const apiEditor = ( (new TextEditorSnapshot(editor)));
+                const apiEditor = ( new TextEditorSnapshot(editor));
                 editors.set(apiEditor.id, apiEditor);
                 if (editor.hasTextFocus() || (widgetFocusCandidate === editor && editor.hasWidgetFocus())) {
                     activeEditor = apiEditor.id;
@@ -175,14 +164,14 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
                 candidate = this._getActiveEditorFromPanel() || this._getActiveEditorFromEditorPart();
             }
             if (candidate) {
-                for (const snapshot of ( (editors.values()))) {
+                for (const snapshot of ( editors.values())) {
                     if (candidate === snapshot.editor) {
                         activeEditor = snapshot.id;
                     }
                 }
             }
         }
-        const newState = ( (new DocumentAndEditorState(models, editors, activeEditor)));
+        const newState = ( new DocumentAndEditorState(models, editors, activeEditor));
         const delta = DocumentAndEditorState.compute(this._currentState, newState);
         if (!delta.isEmpty) {
             this._currentState = newState;
@@ -207,12 +196,12 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
         return activeTextEditorControl;
     }
 };
-MainThreadDocumentAndEditorStateComputer = ( (__decorate([
-    ( (__param(1, IModelService))),
-    ( (__param(2, ICodeEditorService))),
-    ( (__param(3, IEditorService))),
-    ( (__param(4, IPaneCompositePartService)))
-], MainThreadDocumentAndEditorStateComputer)));
+MainThreadDocumentAndEditorStateComputer = ( __decorate([
+    ( __param(1, IModelService)),
+    ( __param(2, ICodeEditorService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IPaneCompositePartService))
+], MainThreadDocumentAndEditorStateComputer));
 let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
     constructor(extHostContext, _modelService, _textFileService, _editorService, codeEditorService, fileService, textModelResolverService, _editorGroupService, paneCompositeService, environmentService, workingCopyFileService, uriIdentityService, _clipboardService, pathService, configurationService) {
         this._modelService = _modelService;
@@ -220,10 +209,10 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
         this._editorService = _editorService;
         this._editorGroupService = _editorGroupService;
         this._clipboardService = _clipboardService;
-        this._toDispose = ( (new DisposableStore()));
-        this._textEditors = ( (new Map()));
-        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostDocumentsAndEditors)));
-        this._mainThreadDocuments = this._toDispose.add(( (new MainThreadDocuments(
+        this._toDispose = ( new DisposableStore());
+        this._textEditors = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentsAndEditors));
+        this._mainThreadDocuments = this._toDispose.add(( new MainThreadDocuments(
             extHostContext,
             this._modelService,
             this._textFileService,
@@ -233,24 +222,24 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
             uriIdentityService,
             workingCopyFileService,
             pathService
-        ))));
+        )));
         extHostContext.set(MainContext.MainThreadDocuments, this._mainThreadDocuments);
-        this._mainThreadEditors = this._toDispose.add(( (new MainThreadTextEditors(
+        this._mainThreadEditors = this._toDispose.add(( new MainThreadTextEditors(
             this,
             extHostContext,
             codeEditorService,
             this._editorService,
             this._editorGroupService,
             configurationService
-        ))));
+        )));
         extHostContext.set(MainContext.MainThreadTextEditors, this._mainThreadEditors);
-        this._toDispose.add(( (new MainThreadDocumentAndEditorStateComputer(
+        this._toDispose.add(( new MainThreadDocumentAndEditorStateComputer(
             delta => this._onDelta(delta),
             _modelService,
             codeEditorService,
             this._editorService,
             paneCompositeService
-        ))));
+        )));
     }
     dispose() {
         this._toDispose.dispose();
@@ -258,9 +247,9 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
     _onDelta(delta) {
         const removedEditors = [];
         const addedEditors = [];
-        const removedDocuments = ( (delta.removedDocuments.map(m => m.uri)));
+        const removedDocuments = ( delta.removedDocuments.map(m => m.uri));
         for (const apiEditor of delta.addedEditors) {
-            const mainThreadEditor = ( (new MainThreadTextEditor(
+            const mainThreadEditor = ( new MainThreadTextEditor(
                 apiEditor.id,
                 apiEditor.editor.getModel(),
                 apiEditor.editor,
@@ -268,7 +257,7 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
                 this._mainThreadDocuments,
                 this._modelService,
                 this._clipboardService
-            )));
+            ));
             this._textEditors.set(apiEditor.id, mainThreadEditor);
             addedEditors.push(mainThreadEditor);
         }
@@ -296,11 +285,11 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
         }
         if (delta.addedDocuments.length > 0) {
             empty = false;
-            extHostDelta.addedDocuments = ( (delta.addedDocuments.map(m => this._toModelAddData(m))));
+            extHostDelta.addedDocuments = ( delta.addedDocuments.map(m => this._toModelAddData(m)));
         }
         if (delta.addedEditors.length > 0) {
             empty = false;
-            extHostDelta.addedEditors = ( (addedEditors.map(e => this._toTextEditorAddData(e))));
+            extHostDelta.addedEditors = ( addedEditors.map(e => this._toTextEditorAddData(e)));
         }
         if (!empty) {
             this._proxy.$acceptDocumentsAndEditorsDelta(extHostDelta);
@@ -361,19 +350,19 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
 };
 MainThreadDocumentsAndEditors = __decorate([
     extHostCustomer,
-    ( (__param(1, IModelService))),
-    ( (__param(2, ITextFileService))),
-    ( (__param(3, IEditorService))),
-    ( (__param(4, ICodeEditorService))),
-    ( (__param(5, IFileService))),
-    ( (__param(6, ITextModelService))),
-    ( (__param(7, IEditorGroupsService))),
-    ( (__param(8, IPaneCompositePartService))),
-    ( (__param(9, IWorkbenchEnvironmentService))),
-    ( (__param(10, IWorkingCopyFileService))),
-    ( (__param(11, IUriIdentityService))),
-    ( (__param(12, IClipboardService))),
-    ( (__param(13, IPathService))),
-    ( (__param(14, IConfigurationService)))
+    ( __param(1, IModelService)),
+    ( __param(2, ITextFileService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IPaneCompositePartService)),
+    ( __param(9, IWorkbenchEnvironmentService)),
+    ( __param(10, IWorkingCopyFileService)),
+    ( __param(11, IUriIdentityService)),
+    ( __param(12, IClipboardService)),
+    ( __param(13, IPathService)),
+    ( __param(14, IConfigurationService))
 ], MainThreadDocumentsAndEditors);
 export { MainThreadDocumentsAndEditors };

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { raceCancellationError } from 'monaco-editor/esm/vs/base/common/async.js';
@@ -12,10 +12,9 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(
-                'timeout.onWillCreateEditSessionIdentity',
-                "Aborted onWillCreateEditSessionIdentity-event after 10000ms"
-            ))))), this.timeout);
+            setTimeout(() => reject(( new Error(
+                localizeWithPath('vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant', 'timeout.onWillCreateEditSessionIdentity', "Aborted onWillCreateEditSessionIdentity-event after 10000ms")
+            ))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         }));
         return raceCancellationError(p, token);