@codingame/monaco-vscode-extensions-service-override 4.5.1 → 4.5.2

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

@@ -18,6 +18,7 @@ import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/service
 import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadCLICommands";
 CommandsRegistry.registerCommand('_remoteCLI.openExternal', function (accessor, uri) {
     const openerService = accessor.get(IOpenerService);
     return openerService.open(isString(uri) ? uri : URI.revive(uri), { openExternal: true, allowTunneling: true });
@@ -46,12 +47,12 @@ CommandsRegistry.registerCommand('_remoteCLI.manageExtensions', async function (
             lines.push(message);
         }
     })();
-    const cliService = instantiationService.createChild(( new ServiceCollection([IExtensionManagementService, remoteExtensionManagementService]))).createInstance(RemoteExtensionManagementCLI, logger);
+    const cliService = instantiationService.createChild(( (new ServiceCollection([IExtensionManagementService, remoteExtensionManagementService])))).createInstance(RemoteExtensionManagementCLI, logger);
     if (args.list) {
         await cliService.listExtensions(!!args.list.showVersions, args.list.category, undefined);
     }
     else {
-        const revive = (inputs) => ( inputs.map(input => isString(input) ? input : URI.revive(input)));
+        const revive = (inputs) => ( (inputs.map(input => isString(input) ? input : URI.revive(input))));
         if (Array.isArray(args.install) && args.install.length) {
             try {
                 await cliService.installExtensions(revive(args.install), [], { isMachineScoped: true }, !!args.force);
@@ -85,8 +86,8 @@ let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends Ex
         if (!this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)
             && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
             this.logger.info(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadCLICommands',
-                'cannot be installed',
+                _moduleId,
+                0,
                 "Cannot install the '{0}' extension because it is declared to not run in this setup.",
                 getExtensionId(manifest.publisher, manifest.name)
             )));
@@ -95,10 +96,10 @@ let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends Ex
         return true;
     }
 };
-RemoteExtensionManagementCLI = ( __decorate([
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IExtensionGalleryService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, IExtensionManifestPropertiesService))
-], RemoteExtensionManagementCLI));
+RemoteExtensionManagementCLI = ( (__decorate([
+    ( (__param(1, IExtensionManagementService))),
+    ( (__param(2, IExtensionGalleryService))),
+    ( (__param(3, ILabelService))),
+    ( (__param(4, IWorkbenchEnvironmentService))),
+    ( (__param(5, IExtensionManifestPropertiesService)))
+], RemoteExtensionManagementCLI)));

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

@@ -21,7 +21,7 @@ let MainThreadChat = class MainThreadChat extends Disposable {
     $transferChatSession(sessionId, toWorkspace) {
         const sessionIdStr = this._chatService.getSessionId(sessionId);
         if (!sessionIdStr) {
-            throw new Error(`Failed to transfer session. Unknown session provider ID: ${sessionId}`);
+            throw ( new Error(`Failed to transfer session. Unknown session provider ID: ${sessionId}`));
         }
         const widget = this._chatWidgetService.getWidgetBySessionId(sessionIdStr);
         const inputValue = widget?.inputEditor.getValue() ?? '';
@@ -30,7 +30,7 @@ let MainThreadChat = class MainThreadChat extends Disposable {
     async $registerChatProvider(handle, id) {
         const registration = this.chatContribService.registeredProviders.find(staticProvider => staticProvider.id === id);
         if (!registration) {
-            throw new Error(`Provider ${id} must be declared in the package.json.`);
+            throw ( new Error(`Provider ${id} must be declared in the package.json.`));
         }
         const unreg = this._chatService.registerProvider({
             id,

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

@@ -55,9 +55,11 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         const staticAgentRegistration = this._chatAgentService.getAgent(id);
         if (!staticAgentRegistration && !dynamicProps) {
             if (this._chatAgentService.getAgentsByName(id).length) {
-                throw new Error(`chatParticipant must be declared with an ID in package.json. The "id" property may be missing! "${id}"`);
+                throw ( new Error(
+                    `chatParticipant must be declared with an ID in package.json. The "id" property may be missing! "${id}"`
+                ));
             }
-            throw new Error(`chatParticipant must be declared in package.json: ${id}`);
+            throw ( new Error(`chatParticipant must be declared in package.json: ${id}`));
         }
         const impl = {
             invoke: async (request, progress, history, token) => {
@@ -107,7 +109,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $updateAgent(handle, metadataUpdate) {
         const data = this._agents.get(handle);
         if (!data) {
-            throw new Error(`No agent with handle ${handle} registered`);
+            throw ( new Error(`No agent with handle ${handle} registered`));
         }
         data.hasFollowups = metadataUpdate.hasFollowups;
         this._chatAgentService.updateAgent(data.id, revive(metadataUpdate));

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

@@ -94,7 +94,7 @@ let MainThreadEditorInsets = class MainThreadEditorInsets {
     getInset(handle) {
         const inset = this._insets.get(handle);
         if (!inset) {
-            throw new Error('Unknown inset');
+            throw ( new Error('Unknown inset'));
         }
         return inset;
     }

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

@@ -60,7 +60,7 @@ let MainThreadCommands = class MainThreadCommands {
         }
         if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
             await this._extensionService.activateByEvent(`onCommand:${id}`);
-            throw new Error('$executeCommand:retry');
+            throw ( new Error('$executeCommand:retry'));
         }
         return this._commandService.executeCommand(id, ...args);
     }

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

@@ -19,6 +19,7 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadComments";
 class MainThreadCommentThread {
     get input() {
         return this._input;
@@ -113,20 +114,20 @@ class MainThreadCommentThread {
         this._range = _range;
         this._canReply = _canReply;
         this._isTemplate = _isTemplate;
-        this._onDidChangeInput = ( new Emitter());
-        this._onDidChangeLabel = ( new Emitter());
+        this._onDidChangeInput = ( (new Emitter()));
+        this._onDidChangeLabel = ( (new Emitter()));
         this.onDidChangeLabel = this._onDidChangeLabel.event;
-        this._onDidChangeComments = ( new Emitter());
-        this._onDidChangeCanReply = ( new Emitter());
-        this._onDidChangeRange = ( new Emitter());
+        this._onDidChangeComments = ( (new Emitter()));
+        this._onDidChangeCanReply = ( (new Emitter()));
+        this._onDidChangeRange = ( (new Emitter()));
         this.onDidChangeRange = this._onDidChangeRange.event;
-        this._onDidChangeCollapsibleState = ( new Emitter());
+        this._onDidChangeCollapsibleState = ( (new Emitter()));
         this.onDidChangeCollapsibleState = this._onDidChangeCollapsibleState.event;
-        this._onDidChangeInitialCollapsibleState = ( new Emitter());
+        this._onDidChangeInitialCollapsibleState = ( (new Emitter()));
         this.onDidChangeInitialCollapsibleState = this._onDidChangeInitialCollapsibleState.event;
-        this._onDidChangeApplicability = ( new Emitter());
+        this._onDidChangeApplicability = ( (new Emitter()));
         this.onDidChangeApplicability = this._onDidChangeApplicability.event;
-        this._onDidChangeState = ( new Emitter());
+        this._onDidChangeState = ( (new Emitter()));
         this.onDidChangeState = this._onDidChangeState.event;
         this._isDisposed = false;
         if (_isTemplate) {
@@ -219,7 +220,7 @@ class MainThreadCommentController {
         this._id = _id;
         this._label = _label;
         this._features = _features;
-        this._threads = ( new Map());
+        this._threads = ( (new Map()));
     }
     async setActiveCommentAndThread(commentInfo) {
         return this._proxy.$setActiveComment(this._handle, commentInfo ? { commentThreadHandle: commentInfo.thread.commentThreadHandle, uniqueIdInThread: commentInfo.comment?.uniqueIdInThread } : undefined);
@@ -228,7 +229,16 @@ class MainThreadCommentController {
         this._features = features;
     }
     createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, isTemplate) {
-        const thread = ( new MainThreadCommentThread(commentThreadHandle, this.handle, extensionId, threadId, ( URI.revive(resource).toString()), range, true, isTemplate));
+        const thread = ( (new MainThreadCommentThread(
+            commentThreadHandle,
+            this.handle,
+            extensionId,
+            threadId,
+             (URI.revive(resource).toString()),
+            range,
+            true,
+            isTemplate
+        )));
         this._threads.set(commentThreadHandle, thread);
         if (thread.isDocumentCommentThread()) {
             this._commentService.updateComments(this._uniqueId, {
@@ -310,7 +320,7 @@ class MainThreadCommentController {
     getKnownThread(commentThreadHandle) {
         const thread = this._threads.get(commentThreadHandle);
         if (!thread) {
-            throw new Error('unknown thread');
+            throw ( (new Error('unknown thread')));
         }
         return thread;
     }
@@ -328,9 +338,9 @@ class MainThreadCommentController {
             };
         }
         const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
+        for (const thread of [...( (this._threads.keys()))]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.resource === ( resource.toString())) {
+            if (commentThread.resource === ( (resource.toString()))) {
                 ret.push(commentThread);
             }
         }
@@ -355,9 +365,9 @@ class MainThreadCommentController {
             };
         }
         const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
+        for (const thread of [...( (this._threads.keys()))]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.resource === ( resource.toString())) {
+            if (commentThread.resource === ( (resource.toString()))) {
                 ret.push(commentThread);
             }
         }
@@ -372,7 +382,7 @@ class MainThreadCommentController {
     }
     getAllComments() {
         const ret = [];
-        for (const thread of [...( this._threads.keys())]) {
+        for (const thread of [...( (this._threads.keys()))]) {
             ret.push(this._threads.get(thread));
         }
         return ret;
@@ -390,22 +400,18 @@ class MainThreadCommentController {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localizeWithPath(
-    'vs/workbench/api/browser/mainThreadComments',
-    'commentsViewIcon',
-    'View icon of the comments view.'
-)));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localizeWithPath(_moduleId, 0, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService) {
         super();
         this._commentService = _commentService;
         this._viewsService = _viewsService;
         this._viewDescriptorService = _viewDescriptorService;
-        this._handlers = ( new Map());
-        this._commentControllers = ( new Map());
-        this._activeEditingCommentThreadDisposables = this._register(( new DisposableStore()));
+        this._handlers = ( (new Map()));
+        this._commentControllers = ( (new Map()));
+        this._activeEditingCommentThreadDisposables = this._register(( (new DisposableStore())));
         this._openViewListener = null;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostComments));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostComments)));
         this._commentService.unregisterCommentController();
         this._register(this._commentService.onDidChangeActiveEditingCommentThread(async (thread) => {
             const handle = thread.controllerHandle;
@@ -421,7 +427,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     $registerCommentController(handle, id, label, extensionId) {
         const providerId = `${id}-${extensionId}`;
         this._handlers.set(handle, providerId);
-        const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
+        const provider = ( (new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {})));
         this._commentService.registerCommentController(providerId, provider);
         this._commentControllers.set(handle, provider);
         const commentsPanelAlreadyConstructed = !!this._viewDescriptorService.getViewDescriptorById(COMMENTS_VIEW_ID);
@@ -479,23 +485,23 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     }
     registerView(commentsViewAlreadyRegistered) {
         if (!commentsViewAlreadyRegistered) {
-            const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+            const VIEW_CONTAINER = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
                 id: COMMENTS_VIEW_ID,
                 title: COMMENTS_VIEW_TITLE,
-                ctorDescriptor: ( new SyncDescriptor(
+                ctorDescriptor: ( (new SyncDescriptor(
                     ViewPaneContainer,
                     [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
-                )),
+                ))),
                 storageId: COMMENTS_VIEW_STORAGE_ID,
                 hideIfEmpty: true,
                 icon: commentsViewIcon,
                 order: 10,
             }, 1 );
-            ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
+            ( (Registry.as(Extensions.ViewsRegistry))).registerViews([{
                     id: COMMENTS_VIEW_ID,
                     name: COMMENTS_VIEW_TITLE,
                     canToggleVisibility: false,
-                    ctorDescriptor: ( new SyncDescriptor(CommentsPanel)),
+                    ctorDescriptor: ( (new SyncDescriptor(CommentsPanel))),
                     canMoveView: true,
                     containerIcon: commentsViewIcon,
                     focusCommand: {
@@ -505,7 +511,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }
     }
     setComments() {
-        [...( this._commentControllers.keys())].forEach(handle => {
+        [...( (this._commentControllers.keys()))].forEach(handle => {
             const threads = this._commentControllers.get(handle).getAllComments();
             if (threads.length) {
                 const providerId = this.getHandler(handle);
@@ -545,17 +551,17 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }));
     }
     getHandler(handle) {
-        if (!( this._handlers.has(handle))) {
-            throw new Error('Unknown handler');
+        if (!( (this._handlers.has(handle)))) {
+            throw ( (new Error('Unknown handler')));
         }
         return this._handlers.get(handle);
     }
 };
 MainThreadComments = __decorate([
     extHostNamedCustomer(MainContext.MainThreadComments),
-    ( __param(1, ICommentService)),
-    ( __param(2, IViewsService)),
-    ( __param(3, IViewDescriptorService))
+    ( (__param(1, ICommentService))),
+    ( (__param(2, IViewsService))),
+    ( (__param(3, IViewDescriptorService)))
 ], MainThreadComments);
 
 export { MainThreadCommentController, MainThreadCommentThread, MainThreadComments };

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

@@ -36,6 +36,7 @@ import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/wor
 import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
 
 var MainThreadCustomEditorModel_1;
+const _moduleId = "vs/workbench/api/browser/mainThreadCustomEditors";
 let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
     constructor(context, mainThreadWebview, mainThreadWebviewPanels, extensionService, storageService, workingCopyService, workingCopyFileService, _customEditorService, _editorGroupService, _editorService, _instantiationService, _webviewWorkbenchService) {
         super();
@@ -46,10 +47,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) {
@@ -68,7 +69,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 }
                 return false;
             },
-            resolveWebview: () => { throw new Error('not implemented'); }
+            resolveWebview: () => { throw ( (new Error('not implemented'))); }
         }));
         this._register(workingCopyFileService.onWillRunWorkingCopyFileOperation(async (e) => this.onWillRunWorkingCopyFileOperation(e)));
     }
@@ -79,10 +80,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))) {
-            throw new Error(`Provider for ${viewType} already registered`);
+        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 +100,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,8 +156,8 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._editorProviders.set(viewType, disposables);
     }
     $unregisterEditorProvider(viewType) {
-        if (!( this._editorProviders.has(viewType))) {
-            throw new Error(`No provider for ${viewType} registered`);
+        if (!( (this._editorProviders.has(viewType)))) {
+            throw ( (new Error(`No provider for ${viewType} registered`)));
         }
         this._editorProviders.deleteAndDispose(viewType);
         this._customEditorService.models.disposeAllModelsForView(viewType);
@@ -194,7 +195,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         const resource = URI.revive(resourceComponents);
         const model = await this._customEditorService.models.get(resource, viewType);
         if (!model || !(model instanceof MainThreadCustomEditorModel)) {
-            throw new Error('Could not find model for webview editor');
+            throw ( (new Error('Could not find model for webview editor')));
         }
         return model;
     }
@@ -213,33 +214,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 +248,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 +278,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,12 +298,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
                         return true;
                     }
                     return false;
-                })(), ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadCustomEditors',
-                    'vetoExtHostRestart',
-                    "Custom editor '{0}' could not be saved.",
-                    this.name
-                )));
+                })(), ( localizeWithPath(_moduleId, 0, "Custom editor '{0}' could not be saved.", this.name)));
             }));
         }
         if (startDirty) {
@@ -321,13 +317,15 @@ 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));
@@ -358,7 +356,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     pushEdit(editId, label) {
         if (!this._editable) {
-            throw new Error('Document is not editable');
+            throw ( (new Error('Document is not editable')));
         }
         this.change(() => {
             this.spliceEdits(editId);
@@ -367,11 +365,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: 0 ,
             resource: this._editorResource,
-            label: label ?? ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadCustomEditors',
-                'defaultEditLabel',
-                "Edit"
-            )),
+            label: label ?? ( localizeWithPath(_moduleId, 1, "Edit")),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),
@@ -484,7 +478,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     suggestUntitledSavePath(options) {
         if (!this.isUntitled()) {
-            throw new Error('Resource is not untitled');
+            throw ( (new Error('Resource is not untitled')));
         }
         const remoteAuthority = this._environmentService.remoteAuthority;
         const localResource = toLocalResource(this._editorResource, remoteAuthority, this._pathService.defaultUriScheme);
@@ -507,7 +501,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     async backup(token) {
         const editors = this._getEditors();
         if (!editors.length) {
-            throw new Error('No editors found for resource, cannot back up');
+            throw ( (new Error('No editors found for resource, cannot back up')));
         }
         const primaryEditor = editors[0];
         const backupMeta = {
@@ -561,18 +555,18 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         if (this._hotExitState === HotExitState.Allowed) {
             return backupData;
         }
-        throw new Error(`Cannot backup in this state: ${errorMessage}`);
+        throw ( (new Error(`Cannot backup 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/mainThreadDebugService.js

@@ -274,7 +274,7 @@ let MainThreadDebugService = class MainThreadDebugService {
             return this.debugService.startDebugging(launch, nameOrConfig, debugOptions, saveBeforeStart);
         }
         catch (err) {
-            throw new ErrorNoTelemetry(err && err.message ? err.message : 'cannot start debugging');
+            throw ( new ErrorNoTelemetry(err && err.message ? err.message : 'cannot start debugging'));
         }
     }
     $setDebugSessionName(sessionId, name) {
@@ -330,7 +330,7 @@ let MainThreadDebugService = class MainThreadDebugService {
     getDebugAdapter(handle) {
         const adapter = this._debugAdapters.get(handle);
         if (!adapter) {
-            throw new Error('Invalid debug adapter');
+            throw ( new Error('Invalid debug adapter'));
         }
         return adapter;
     }

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

@@ -172,7 +172,7 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
     async $tryOpenDocument(uriData) {
         const inputUri = URI.revive(uriData);
         if (!inputUri.scheme || !(inputUri.fsPath || inputUri.authority)) {
-            throw new ErrorNoTelemetry(`Invalid uri. Scheme and authority or path must be set.`);
+            throw ( new ErrorNoTelemetry(`Invalid uri. Scheme and authority or path must be set.`));
         }
         const canonicalUri = this._uriIdentityService.asCanonicalUri(inputUri);
         let promise;
@@ -190,16 +190,16 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
             documentUri = await promise;
         }
         catch (err) {
-            throw new ErrorNoTelemetry(`cannot open ${canonicalUri.toString()}. Detail: ${toErrorMessage(err)}`);
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}. Detail: ${toErrorMessage(err)}`));
         }
         if (!documentUri) {
-            throw new ErrorNoTelemetry(`cannot open ${canonicalUri.toString()}`);
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}`));
         }
         else if (!extUri.isEqual(documentUri, canonicalUri)) {
-            throw new ErrorNoTelemetry(`cannot open ${canonicalUri.toString()}. Detail: Actual document opened as ${documentUri.toString()}`);
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}. Detail: Actual document opened as ${( documentUri.toString())}`));
         }
         else if (!( this._modelTrackers.has(canonicalUri))) {
-            throw new ErrorNoTelemetry(`cannot open ${canonicalUri.toString()}. Detail: Files above 50MB cannot be synchronized with extensions.`);
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}. Detail: Files above 50MB cannot be synchronized with extensions.`));
         }
         else {
             return canonicalUri;
@@ -231,7 +231,7 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
         const ref = await this._textModelResolverService.createModelReference(resource);
         if (!( this._modelTrackers.has(resource))) {
             ref.dispose();
-            throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);
+            throw ( new Error(`expected URI ${( resource.toString())} to have come to LIFE`));
         }
         this._modelReferenceCollection.add(resource, ref, ref.object.textEditorModel.getValueLength());
         Event.once(model.onDidRevert)(() => this._modelReferenceCollection.remove(resource));