@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/api/common/extHostChatAgents2.js

@@ -3,23 +3,21 @@ import { raceCancellation } from '../../../base/common/async.js';
 import { toErrorMessage } from '../../../base/common/errorMessage.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
-import { DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
+import { Disposable, DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { assertType } from '../../../base/common/types.js';
 import { URI } from '../../../base/common/uri.js';
-import { localizeWithPath } from '../../../nls.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatAgentRequest, ChatAgentResult, ChatAgentResolvedVariable, ChatResponsePart, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, MarkdownString, ChatResponseMarkdownPart, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatResponseProgressPart, ChatResponseReferencePart, ChatResponseProgress } from './extHostTypeConverters.js';
-import { ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ChatResponseReferencePart as ChatResponseReferencePart$1, ThemeIcon, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart as ChatResponseProgressPart$1 } from './extHostTypes.js';
+import { ChatAgentRequest, ChatAgentResult, ChatAgentResolvedVariable, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, ChatLocation, ChatResponsePart, MarkdownString, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseMarkdownWithVulnerabilitiesPart as ChatResponseMarkdownWithVulnerabilitiesPart$1, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatResponseProgressPart, ChatResponseReferencePart, ChatResponseTextEditPart, ChatResponseDetectedParticipantPart } from './extHostTypeConverters.js';
+import { ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ChatResponseMarkdownPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseTextEditPart as ChatResponseTextEditPart$1, ChatResponseDetectedParticipantPart as ChatResponseDetectedParticipantPart$1, ChatResponseReferencePart as ChatResponseReferencePart$1, ThemeIcon, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart as ChatResponseProgressPart$1 } from './extHostTypes.js';
 import { InteractiveSessionVoteDirection } from '../../contrib/chat/common/chatService.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 class ChatAgentResponseStream {
-    constructor(_extension, _request, _proxy, _logService, _commandsConverter, _sessionDisposables) {
+    constructor(_extension, _request, _proxy, _commandsConverter, _sessionDisposables) {
         this._extension = _extension;
         this._request = _request;
         this._proxy = _proxy;
-        this._logService = _logService;
         this._commandsConverter = _commandsConverter;
         this._sessionDisposables = _sessionDisposables;
         this._stopWatch = StopWatch.create(false);
@@ -54,40 +52,50 @@ class ChatAgentResponseStream {
             this._apiObject = {
                 markdown(value) {
                     throwIfDone(this.markdown);
-                    const part = new ChatResponseMarkdownPart$1(value);
-                    const dto = ChatResponseMarkdownPart.to(part);
+                    const part = new ChatResponseMarkdownPart(value);
+                    const dto = ChatResponseMarkdownPart$1.from(part);
+                    _report(dto);
+                    return this;
+                },
+                markdownWithVulnerabilities(value, vulnerabilities) {
+                    throwIfDone(this.markdown);
+                    if (vulnerabilities) {
+                        checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    }
+                    const part = new ChatResponseMarkdownWithVulnerabilitiesPart(value, vulnerabilities);
+                    const dto = ChatResponseMarkdownWithVulnerabilitiesPart$1.from(part);
                     _report(dto);
                     return this;
                 },
                 filetree(value, baseUri) {
                     throwIfDone(this.filetree);
                     const part = new ChatResponseFileTreePart(value, baseUri);
-                    const dto = ChatResponseFilesPart.to(part);
+                    const dto = ChatResponseFilesPart.from(part);
                     _report(dto);
                     return this;
                 },
                 anchor(value, title) {
                     throwIfDone(this.anchor);
                     const part = new ChatResponseAnchorPart$1(value, title);
-                    const dto = ChatResponseAnchorPart.to(part);
+                    const dto = ChatResponseAnchorPart.from(part);
                     _report(dto);
                     return this;
                 },
                 button(value) {
                     throwIfDone(this.anchor);
                     const part = new ChatResponseCommandButtonPart$1(value);
-                    const dto = ChatResponseCommandButtonPart.to(part, that._commandsConverter, that._sessionDisposables);
+                    const dto = ChatResponseCommandButtonPart.from(part, that._commandsConverter, that._sessionDisposables);
                     _report(dto);
                     return this;
                 },
                 progress(value) {
                     throwIfDone(this.progress);
                     const part = new ChatResponseProgressPart$1(value);
-                    const dto = ChatResponseProgressPart.to(part);
+                    const dto = ChatResponseProgressPart.from(part);
                     _report(dto);
                     return this;
                 },
-                reference(value) {
+                reference(value, iconPath) {
                     throwIfDone(this.reference);
                     if ('variableName' in value && !value.value) {
                         const matchingVarData = that._request.variables.variables.find(v => v.name === value.variableName);
@@ -100,8 +108,8 @@ class ChatAgentResponseStream {
                                 })));
                             }
                             else {
-                                const part = new ChatResponseReferencePart$1(value);
-                                const dto = ChatResponseReferencePart.to(part);
+                                const part = new ChatResponseReferencePart$1(value, iconPath);
+                                const dto = ChatResponseReferencePart.from(part);
                                 references = [dto];
                             }
                             references.forEach(r => _report(r));
@@ -109,50 +117,61 @@ class ChatAgentResponseStream {
                         }
                     }
                     else {
-                        const part = new ChatResponseReferencePart$1(value);
-                        const dto = ChatResponseReferencePart.to(part);
+                        const part = new ChatResponseReferencePart$1(value, iconPath);
+                        const dto = ChatResponseReferencePart.from(part);
                         _report(dto);
                     }
                     return this;
                 },
+                textEdit(target, edits) {
+                    throwIfDone(this.textEdit);
+                    checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    const part = new ChatResponseTextEditPart$1(target, edits);
+                    const dto = ChatResponseTextEditPart.from(part);
+                    _report(dto);
+                    return this;
+                },
+                detectedParticipant(participant, command) {
+                    throwIfDone(this.detectedParticipant);
+                    checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    const part = new ChatResponseDetectedParticipantPart$1(participant, command);
+                    const dto = ChatResponseDetectedParticipantPart.from(part);
+                    _report(dto);
+                    return this;
+                },
                 push(part) {
                     throwIfDone(this.push);
+                    if (part instanceof ChatResponseTextEditPart$1 || part instanceof ChatResponseMarkdownWithVulnerabilitiesPart || part instanceof ChatResponseDetectedParticipantPart$1) {
+                        checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    }
                     if (part instanceof ChatResponseReferencePart$1) {
-                        this.reference(part.value);
+                        this.reference(part.value, part.iconPath);
                     }
                     else {
-                        const dto = ChatResponsePart.to(part, that._commandsConverter, that._sessionDisposables);
+                        const dto = ChatResponsePart.from(part, that._commandsConverter, that._sessionDisposables);
                         _report(dto);
                     }
                     return this;
                 },
-                report(progress) {
-                    throwIfDone(this.report);
-                    if ('placeholder' in progress && 'resolvedContent' in progress) {
-                        return;
-                    }
-                    const value = ChatResponseProgress.from(that._extension, progress);
-                    if (!value) {
-                        that._logService.error('Unknown progress type: ' + JSON.stringify(progress));
-                        return;
-                    }
-                    _report(value);
-                    return this;
-                }
             };
         }
         return this._apiObject;
     }
 }
-class ExtHostChatAgents2 {
+class ExtHostChatAgents2 extends Disposable {
     static { this._idPool = 0; }
     constructor(mainContext, _logService, commands) {
+        super();
         this._logService = _logService;
         this.commands = commands;
         this._agents = ( new Map());
-        this._sessionDisposables = ( new DisposableMap());
+        this._sessionDisposables = this._register(( new DisposableMap()));
+        this._completionDisposables = this._register(( new DisposableStore()));
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatAgents2));
     }
+    transferActiveChat(newWorkspace) {
+        this._proxy.$transferActiveChatSession(newWorkspace);
+    }
     createChatAgent(extension, id, handler) {
         const handle = ExtHostChatAgents2._idPool++;
         const agent = ( new ExtHostChatAgent(extension, id, this._proxy, handle, handler));
@@ -164,13 +183,15 @@ class ExtHostChatAgents2 {
         const handle = ExtHostChatAgents2._idPool++;
         const agent = ( new ExtHostChatAgent(extension, id, this._proxy, handle, handler));
         this._agents.set(handle, agent);
-        this._proxy.$registerAgent(handle, extension.identifier, id, {}, { name, description });
+        this._proxy.$registerAgent(handle, extension.identifier, id, { isSticky: true }, { name, description });
         return agent.apiAgent;
     }
     async $invokeAgent(handle, request, context, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
-            throw new Error(`[CHAT](${handle}) CANNOT invoke agent because the agent is not registered`);
+            throw ( new Error(
+                `[CHAT](${handle}) CANNOT invoke agent because the agent is not registered`
+            ));
         }
         let sessionDisposables = this._sessionDisposables.get(request.sessionId);
         if (!sessionDisposables) {
@@ -181,7 +202,6 @@ class ExtHostChatAgents2 {
             agent.extension,
             request,
             this._proxy,
-            this._logService,
             this.commands.converter,
             sessionDisposables
         ));
@@ -204,12 +224,7 @@ class ExtHostChatAgents2 {
         }
         catch (e) {
             this._logService.error(e, agent.extension);
-            return { errorDetails: { message: ( localizeWithPath(
-                'vs/workbench/api/common/extHostChatAgents2',
-                'errorResponse',
-                "Error from participant: {0}",
-                toErrorMessage(e)
-            )), responseIsIncomplete: true } };
+            return { errorDetails: { message: toErrorMessage(e), responseIsIncomplete: true } };
         }
         finally {
             stream.close();
@@ -223,7 +238,7 @@ class ExtHostChatAgents2 {
                 ehResult :
                 { ...ehResult, metadata: undefined };
             res.push(new ChatRequestTurn(h.request.message, h.request.command, ( h.request.variables.variables.map(ChatAgentResolvedVariable.to)), h.request.agentId));
-            const parts = coalesce(( h.response.map(r => ChatResponsePart.fromContent(r, this.commands.converter))));
+            const parts = coalesce(( h.response.map(r => ChatResponsePart.toContent(r, this.commands.converter))));
             res.push(new ChatResponseTurn(parts, result, h.request.agentId, h.request.command));
         }
         return res;
@@ -286,21 +301,23 @@ class ExtHostChatAgents2 {
             return [];
         }
         const items = await agent.invokeCompletionProvider(query, token);
-        return ( items.map(ChatAgentCompletionItem.from));
+        return ( items.map(
+            (i) => ChatAgentCompletionItem.from(i, this.commands.converter, this._completionDisposables)
+        ));
     }
-    async $provideWelcomeMessage(handle, token) {
+    async $provideWelcomeMessage(handle, location, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
-        return await agent.provideWelcomeMessage(token);
+        return await agent.provideWelcomeMessage(ChatLocation.to(location), token);
     }
-    async $provideSampleQuestions(handle, token) {
+    async $provideSampleQuestions(handle, location, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
-        return ( (await agent.provideSampleQuestions(token))
+        return ( (await agent.provideSampleQuestions(ChatLocation.to(location), token))
             .map(f => ChatFollowup.from(f, undefined)));
     }
 }
@@ -338,11 +355,11 @@ class ExtHostChatAgent {
             .filter(f => !(f && 'commandId' in f))
             .filter(f => !(f && 'message' in f));
     }
-    async provideWelcomeMessage(token) {
+    async provideWelcomeMessage(location, token) {
         if (!this._welcomeMessageProvider) {
             return [];
         }
-        const content = await this._welcomeMessageProvider.provideWelcomeMessage(token);
+        const content = await this._welcomeMessageProvider.provideWelcomeMessage(location, token);
         if (!content) {
             return [];
         }
@@ -355,11 +372,11 @@ class ExtHostChatAgent {
             }
         }));
     }
-    async provideSampleQuestions(token) {
+    async provideSampleQuestions(location, token) {
         if (!this._welcomeMessageProvider || !this._welcomeMessageProvider.provideSampleQuestions) {
             return [];
         }
-        const content = await this._welcomeMessageProvider.provideSampleQuestions(token);
+        const content = await this._welcomeMessageProvider.provideSampleQuestions(location, token);
         if (!content) {
             return [];
         }
@@ -503,7 +520,7 @@ class ExtHostChatAgent {
                 that._agentVariableProvider = v;
                 if (v) {
                     if (!v.triggerCharacters.length) {
-                        throw new Error('triggerCharacters are required');
+                        throw ( new Error('triggerCharacters are required'));
                     }
                     that._proxy.$registerAgentCompletionsProvider(that._handle, v.triggerCharacters);
                 }

package/vscode/src/vs/workbench/api/common/extHostChatVariables.js

@@ -72,24 +72,24 @@ class ChatVariableResolverResponseStream {
                 progress(value) {
                     throwIfDone(this.progress);
                     const part = new ChatResponseProgressPart$1(value);
-                    const dto = ChatResponseProgressPart.to(part);
+                    const dto = ChatResponseProgressPart.from(part);
                     _report(dto);
                     return this;
                 },
                 reference(value) {
                     throwIfDone(this.reference);
                     const part = new ChatResponseReferencePart$1(value);
-                    const dto = ChatResponseReferencePart.to(part);
+                    const dto = ChatResponseReferencePart.from(part);
                     _report(dto);
                     return this;
                 },
                 push(part) {
                     throwIfDone(this.push);
                     if (part instanceof ChatResponseReferencePart$1) {
-                        _report(ChatResponseReferencePart.to(part));
+                        _report(ChatResponseReferencePart.from(part));
                     }
                     else if (part instanceof ChatResponseProgressPart$1) {
-                        _report(ChatResponseProgressPart.to(part));
+                        _report(ChatResponseProgressPart.from(part));
                     }
                     return this;
                 }

package/vscode/src/vs/workbench/api/common/extHostCodeInsets.js

@@ -31,7 +31,7 @@ class ExtHostEditorInsets {
             }
         }
         if (!apiEditor) {
-            throw new Error('not a visible editor');
+            throw ( new Error('not a visible editor'));
         }
         const that = this;
         const handle = this._handlePool++;

package/vscode/src/vs/workbench/api/common/extHostCommands.js

@@ -73,7 +73,9 @@ let ExtHostCommands = class ExtHostCommands {
         const registration = this.registerCommand(false, apiCommand.id, async (...apiArgs) => {
             const internalArgs = ( apiCommand.args.map((arg, i) => {
                 if (!arg.validate(apiArgs[i])) {
-                    throw new Error(`Invalid argument '${arg.name}' when running '${apiCommand.id}', received: ${typeof apiArgs[i] === 'object' ? JSON.stringify(apiArgs[i], null, '\t') : apiArgs[i]} `);
+                    throw ( new Error(
+                        `Invalid argument '${arg.name}' when running '${apiCommand.id}', received: ${typeof apiArgs[i] === 'object' ? JSON.stringify(apiArgs[i], null, '\t') : apiArgs[i]} `
+                    ));
                 }
                 return arg.convert(apiArgs[i]);
             }));
@@ -93,10 +95,10 @@ let ExtHostCommands = class ExtHostCommands {
     registerCommand(global, id, callback, thisArg, metadata, extension) {
         this._logService.trace('ExtHostCommands#registerCommand', id);
         if (!id.trim().length) {
-            throw new Error('invalid id');
+            throw ( new Error('invalid id'));
         }
         if (( this._commands.has(id))) {
-            throw new Error(`command '${id}' already exists`);
+            throw ( new Error(`command '${id}' already exists`));
         }
         this._commands.set(id, { callback, thisArg, metadata, extension });
         if (global) {
@@ -167,7 +169,7 @@ let ExtHostCommands = class ExtHostCommands {
     async _executeContributedCommand(id, args, annotateError) {
         const command = this._commands.get(id);
         if (!command) {
-            throw new Error('Unknown command');
+            throw ( new Error('Unknown command'));
         }
         const { callback, thisArg, metadata } = command;
         if (metadata?.args) {
@@ -176,7 +178,9 @@ let ExtHostCommands = class ExtHostCommands {
                     validateConstraint(args[i], metadata.args[i].constraint);
                 }
                 catch (err) {
-                    throw new Error(`Running the contributed command: '${id}' failed. Illegal argument '${metadata.args[i].name}' - ${metadata.args[i].description}`);
+                    throw ( new Error(
+                        `Running the contributed command: '${id}' failed. Illegal argument '${metadata.args[i].name}' - ${metadata.args[i].description}`
+                    ));
                 }
             }
         }

package/vscode/src/vs/workbench/api/common/extHostConfiguration.js

@@ -89,7 +89,7 @@ class ExtHostConfigProvider {
         this._proxy = proxy;
         this._logService = logService;
         this._extHostWorkspace = extHostWorkspace;
-        this._configuration = Configuration$1.parse(data);
+        this._configuration = Configuration$1.parse(data, logService);
         this._configurationScopes = this._toMap(data.configurationScopes);
     }
     get onDidChangeConfiguration() {
@@ -97,7 +97,7 @@ class ExtHostConfigProvider {
     }
     $acceptConfigurationChanged(data, change) {
         const previous = { data: this._configuration.toData(), workspace: this._extHostWorkspace.workspace };
-        this._configuration = Configuration$1.parse(data);
+        this._configuration = Configuration$1.parse(data, this._logService);
         this._configurationScopes = this._toMap(data.configurationScopes);
         this._onDidChangeConfiguration.fire(this._toConfigurationChangeEvent(change, previous));
     }
@@ -229,10 +229,16 @@ class ExtHostConfigProvider {
             return isObject(target) ?
                 ( new Proxy(target, {
                     get: (target, property) => readonlyProxy(target[property]),
-                    set: (_target, property, _value) => { throw new Error(`TypeError: Cannot assign to read only property '${String(property)}' of object`); },
-                    deleteProperty: (_target, property) => { throw new Error(`TypeError: Cannot delete read only property '${String(property)}' of object`); },
-                    defineProperty: (_target, property) => { throw new Error(`TypeError: Cannot define property '${String(property)}' for a readonly object`); },
-                    setPrototypeOf: (_target) => { throw new Error(`TypeError: Cannot set prototype for a readonly object`); },
+                    set: (_target, property, _value) => { throw ( new Error(
+                        `TypeError: Cannot assign to read only property '${String(property)}' of object`
+                    )); },
+                    deleteProperty: (_target, property) => { throw ( new Error(
+                        `TypeError: Cannot delete read only property '${String(property)}' of object`
+                    )); },
+                    defineProperty: (_target, property) => { throw ( new Error(
+                        `TypeError: Cannot define property '${String(property)}' for a readonly object`
+                    )); },
+                    setPrototypeOf: (_target) => { throw ( new Error(`TypeError: Cannot set prototype for a readonly object`)); },
                     isExtensible: () => false,
                     preventExtensions: () => true
                 })) : target;
@@ -256,7 +262,13 @@ class ExtHostConfigProvider {
         }
     }
     _toConfigurationChangeEvent(change, previous) {
-        const event = ( new ConfigurationChangeEvent(change, previous, this._configuration, this._extHostWorkspace.workspace));
+        const event = ( new ConfigurationChangeEvent(
+            change,
+            previous,
+            this._configuration,
+            this._extHostWorkspace.workspace,
+            this._logService
+        ));
         return ( Object.freeze({
             affectsConfiguration: (section, scope) => event.affectsConfiguration(section, scopeToOverrides(scope))
         }));

package/vscode/src/vs/workbench/api/common/extHostCustomEditors.js

@@ -38,7 +38,7 @@ class CustomDocumentStoreEntry {
     }
     getNewBackupUri() {
         if (!this._storagePath) {
-            throw new Error('Backup requires a valid storage path');
+            throw ( new Error('Backup requires a valid storage path'));
         }
         const fileName = hashPath(this.document.uri) + (this._backupCounter++);
         return joinPath(this._storagePath, fileName);
@@ -54,7 +54,7 @@ class CustomDocumentStoreEntry {
     getEdit(editId) {
         const edit = this._edits.get(editId, 0);
         if (!edit) {
-            throw new Error('No edit found');
+            throw ( new Error('No edit found'));
         }
         return edit;
     }
@@ -69,7 +69,9 @@ class CustomDocumentStore {
     add(viewType, document, storagePath) {
         const key = this.key(viewType, document.uri);
         if (( this._documents.has(key))) {
-            throw new Error(`Document already exists for viewType:${viewType} resource:${document.uri}`);
+            throw ( new Error(
+                `Document already exists for viewType:${viewType} resource:${document.uri}`
+            ));
         }
         const entry = ( new CustomDocumentStoreEntry(document, storagePath));
         this._documents.set(key, entry);
@@ -98,7 +100,7 @@ class EditorProviderStore {
     }
     add(type, viewType, extension, provider) {
         if (( this._providers.has(viewType))) {
-            throw new Error(`Provider for viewType:${viewType} already registered`);
+            throw ( new Error(`Provider for viewType:${viewType} already registered`));
         }
         this._providers.set(viewType, { type, extension, provider });
         return new Disposable(() => this._providers.delete(viewType));
@@ -145,10 +147,10 @@ class ExtHostCustomEditors {
     async $createCustomDocument(resource, viewType, backupId, untitledDocumentData, cancellation) {
         const entry = this._editorProviders.get(viewType);
         if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
+            throw ( new Error(`No provider found for '${viewType}'`));
         }
         if (entry.type !== 1 ) {
-            throw new Error(`Invalid provide type for '${viewType}'`);
+            throw ( new Error(`Invalid provide type for '${viewType}'`));
         }
         const revivedResource = URI.revive(resource);
         const document = await entry.provider.openCustomDocument(revivedResource, { backupId, untitledDocumentData: untitledDocumentData?.buffer }, cancellation);
@@ -162,10 +164,10 @@ class ExtHostCustomEditors {
     async $disposeCustomDocument(resource, viewType) {
         const entry = this._editorProviders.get(viewType);
         if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
+            throw ( new Error(`No provider found for '${viewType}'`));
         }
         if (entry.type !== 1 ) {
-            throw new Error(`Invalid provider type for '${viewType}'`);
+            throw ( new Error(`Invalid provider type for '${viewType}'`));
         }
         const revivedResource = URI.revive(resource);
         const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
@@ -175,7 +177,7 @@ class ExtHostCustomEditors {
     async $resolveCustomEditor(resource, handle, viewType, initData, position, cancellation) {
         const entry = this._editorProviders.get(viewType);
         if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
+            throw ( new Error(`No provider found for '${viewType}'`));
         }
         const viewColumn = ViewColumn.to(position);
         const webview = this._extHostWebview.createNewWebview(handle, initData.contentOptions, entry.extension);
@@ -191,7 +193,7 @@ class ExtHostCustomEditors {
                 return entry.provider.resolveCustomTextEditor(document, panel, cancellation);
             }
             default: {
-                throw new Error('Unknown webview provider type');
+                throw ( new Error('Unknown webview provider type'));
             }
         }
     }
@@ -202,14 +204,14 @@ class ExtHostCustomEditors {
     async $onMoveCustomEditor(handle, newResourceComponents, viewType) {
         const entry = this._editorProviders.get(viewType);
         if (!entry) {
-            throw new Error(`No provider found for '${viewType}'`);
+            throw ( new Error(`No provider found for '${viewType}'`));
         }
         if (!entry.provider.moveCustomTextEditor) {
-            throw new Error(`Provider does not implement move '${viewType}'`);
+            throw ( new Error(`Provider does not implement move '${viewType}'`));
         }
         const webview = this._extHostWebviewPanels.getWebviewPanel(handle);
         if (!webview) {
-            throw new Error(`No webview found`);
+            throw ( new Error(`No webview found`));
         }
         const resource = URI.revive(newResourceComponents);
         const document = this._extHostDocuments.getDocument(resource);
@@ -252,7 +254,7 @@ class ExtHostCustomEditors {
     getCustomDocumentEntry(viewType, resource) {
         const entry = this._documents.get(viewType, URI.revive(resource));
         if (!entry) {
-            throw new Error('No custom document found');
+            throw ( new Error('No custom document found'));
         }
         return entry;
     }
@@ -260,7 +262,7 @@ class ExtHostCustomEditors {
         const entry = this._editorProviders.get(viewType);
         const provider = entry?.provider;
         if (!provider || !isCustomEditorProviderWithEditingCapability(provider)) {
-            throw new Error('Custom document is not editable');
+            throw ( new Error('Custom document is not editable'));
         }
         return provider;
     }