@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -20,6 +20,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { isITextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
 import { equals as equals$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
@@ -27,9 +28,22 @@ import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/bas
 
 var MainThreadTextEditors_1;
 let MainThreadTextEditors = class MainThreadTextEditors {
-    static { MainThreadTextEditors_1 = this; }
-    static { this.INSTANCE_COUNT = 0; }
-    constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService, _configurationService, _quickDiffModelService, _uriIdentityService) {
+    static {
+        MainThreadTextEditors_1 = this;
+    }
+    static {
+        this.INSTANCE_COUNT = 0;
+    }
+    constructor(
+        _editorLocator,
+        extHostContext,
+        _codeEditorService,
+        _editorService,
+        _editorGroupService,
+        _configurationService,
+        _quickDiffModelService,
+        _uriIdentityService
+    ) {
         this._editorLocator = _editorLocator;
         this._codeEditorService = _codeEditorService;
         this._editorService = _editorService;
@@ -42,13 +56,19 @@ let MainThreadTextEditors = class MainThreadTextEditors {
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditors));
         this._textEditorsListenersMap = Object.create(null);
         this._editorPositionData = null;
-        this._toDispose.add(this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors()));
-        this._toDispose.add(this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors()));
-        this._toDispose.add(this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+        this._toDispose.add(
+            this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors())
+        );
+        this._toDispose.add(
+            this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors())
+        );
+        this._toDispose.add(
+            this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors())
+        );
         this._registeredDecorationTypes = Object.create(null);
     }
     dispose() {
-        ( Object.keys(this._textEditorsListenersMap)).forEach((editorId) => {
+        ( Object.keys(this._textEditorsListenersMap)).forEach(editorId => {
             dispose(this._textEditorsListenersMap[editorId]);
         });
         this._textEditorsListenersMap = Object.create(null);
@@ -61,7 +81,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
     handleTextEditorAdded(textEditor) {
         const id = textEditor.getId();
         const toDispose = [];
-        toDispose.push(textEditor.onPropertiesChanged((data) => {
+        toDispose.push(textEditor.onPropertiesChanged(data => {
             this._proxy.$acceptEditorPropertiesChanged(id, data);
         }));
         const diffInformationObs = this._getTextEditorDiffInformation(textEditor, toDispose);
@@ -97,54 +117,71 @@ let MainThreadTextEditors = class MainThreadTextEditors {
         if (!codeEditor) {
             return constObservable(undefined);
         }
-        const [diffEditor] = this._codeEditorService.listDiffEditors()
-            .filter(d => d.getOriginalEditor().getId() === codeEditor.getId() ||
-            d.getModifiedEditor().getId() === codeEditor.getId());
-        const editorModelObs = diffEditor
-            ? observableFromEvent(this, diffEditor.onDidChangeModel, () => diffEditor.getModel())
-            : observableFromEvent(this, codeEditor.onDidChangeModel, () => codeEditor.getModel());
+        const [diffEditor] = this._codeEditorService.listDiffEditors().filter(
+            d => d.getOriginalEditor().getId() === codeEditor.getId() || d.getModifiedEditor().getId() === codeEditor.getId()
+        );
+        const editorModelObs = diffEditor ? observableFromEvent(this, diffEditor.onDidChangeModel, () => diffEditor.getModel()) : observableFromEvent(this, codeEditor.onDidChangeModel, () => codeEditor.getModel());
         const editorChangesObs = derived(reader => {
             const editorModel = editorModelObs.read(reader);
-            const editorModelUri = codeEditor.getModel()?.uri;
-            if (!editorModel || !editorModelUri) {
+            if (!editorModel) {
                 return constObservable(undefined);
             }
-            let quickDiffModelRef;
             if (isITextModel(editorModel)) {
-                quickDiffModelRef = this._quickDiffModelService.createQuickDiffModelReference(editorModelUri);
-            }
-            else {
-                const diffAlgorithm = this._configurationService.getValue('diffEditor.diffAlgorithm');
-                quickDiffModelRef = this._quickDiffModelService.createQuickDiffModelReference(editorModelUri, { algorithm: diffAlgorithm });
+                const quickDiffModelRef = this._quickDiffModelService.createQuickDiffModelReference(editorModel.uri);
+                if (!quickDiffModelRef) {
+                    return constObservable(undefined);
+                }
+                toDispose.push(quickDiffModelRef);
+                return observableFromEvent(this, quickDiffModelRef.object.onDidChange, () => {
+                    return ( quickDiffModelRef.object.getQuickDiffResults().map(result => ({
+                        original: result.original,
+                        modified: result.modified,
+                        changes: result.changes2
+                    })));
+                });
             }
+            const diffAlgorithm = this._configurationService.getValue("diffEditor.diffAlgorithm");
+            const quickDiffModelRef = this._quickDiffModelService.createQuickDiffModelReference(editorModel.modified.uri, {
+                algorithm: diffAlgorithm
+            });
             if (!quickDiffModelRef) {
                 return constObservable(undefined);
             }
             toDispose.push(quickDiffModelRef);
-            return observableFromEvent(this, quickDiffModelRef.object.onDidChange, () => {
-                return ( quickDiffModelRef.object.getQuickDiffResults()
-                    .map(result => ({
-                    original: result.original,
-                    modified: result.modified,
-                    changes: result.changes2
-                })));
-            });
+            return observableFromEvent(
+                Event.any(quickDiffModelRef.object.onDidChange, diffEditor.onDidUpdateDiff),
+                () => {
+                    const diffChanges = diffEditor.getDiffComputationResult()?.changes2 ?? [];
+                    const diffInformation = [{
+                        original: editorModel.original.uri,
+                        modified: editorModel.modified.uri,
+                        changes: ( diffChanges.map(change => change))
+                    }];
+                    const quickDiffInformation = ( quickDiffModelRef.object.getQuickDiffResults().filter(result => result.providerKind !== "primary").map(result => ({
+                        original: result.original,
+                        modified: result.modified,
+                        changes: result.changes2
+                    })));
+                    return diffInformation.concat(quickDiffInformation);
+                }
+            );
         });
         return derivedOpts({
             owner: this,
-            equalsFn: (diff1, diff2) => equals$1(diff1, diff2, (a, b) => isTextEditorDiffInformationEqual(this._uriIdentityService, a, b))
+            equalsFn: (diff1, diff2) => equals$1(
+                diff1,
+                diff2,
+                (a, b) => isTextEditorDiffInformationEqual(this._uriIdentityService, a, b)
+            )
         }, reader => {
             const editorModel = editorModelObs.read(reader);
             const editorChanges = editorChangesObs.read(reader).read(reader);
             if (!editorModel || !editorChanges) {
                 return undefined;
             }
-            const documentVersion = isITextModel(editorModel)
-                ? editorModel.getVersionId()
-                : editorModel.modified.getVersionId();
+            const documentVersion = isITextModel(editorModel) ? editorModel.getVersionId() : editorModel.modified.getVersionId();
             return ( editorChanges.map(change => {
-                const changes = ( change.changes
-                    .map(change => [
+                const changes = ( change.changes.map(change => [
                     change.original.startLineNumber,
                     change.original.endLineNumberExclusive,
                     change.modified.startLineNumber,
@@ -172,7 +209,10 @@ let MainThreadTextEditors = class MainThreadTextEditors {
             resource: uri,
             options: editorOptions
         };
-        const editor = await this._editorService.openEditor(input, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
+        const editor = await this._editorService.openEditor(
+            input,
+            columnToEditorGroup(this._editorGroupService, this._configurationService, options.position)
+        );
         if (!editor) {
             return undefined;
         }
@@ -186,7 +226,9 @@ let MainThreadTextEditors = class MainThreadTextEditors {
             const model = mainThreadEditor.getModel();
             await this._editorService.openEditor({
                 resource: model.uri,
-                options: { preserveFocus: false }
+                options: {
+                    preserveFocus: false
+                }
             }, columnToEditorGroup(this._editorGroupService, this._configurationService, position));
             return;
         }
@@ -272,15 +314,17 @@ let MainThreadTextEditors = class MainThreadTextEditors {
     $getDiffInformation(id) {
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(( new Error('No such TextEditor')));
+            return Promise.reject(( new Error("No such TextEditor")));
         }
         const codeEditor = editor.getCodeEditor();
         if (!codeEditor) {
-            return Promise.reject(( new Error('No such CodeEditor')));
+            return Promise.reject(( new Error("No such CodeEditor")));
         }
         const codeEditorId = codeEditor.getId();
         const diffEditors = this._codeEditorService.listDiffEditors();
-        const [diffEditor] = diffEditors.filter(d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId);
+        const [diffEditor] = diffEditors.filter(
+            d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId
+        );
         if (diffEditor) {
             return Promise.resolve(diffEditor.getLineChanges() || []);
         }
@@ -292,31 +336,25 @@ let MainThreadTextEditors = class MainThreadTextEditors {
             return Promise.resolve([]);
         }
         try {
-            const primaryQuickDiff = quickDiffModelRef.object.quickDiffs.find(quickDiff => quickDiff.kind === 'primary');
+            const primaryQuickDiff = quickDiffModelRef.object.quickDiffs.find(quickDiff => quickDiff.kind === "primary");
             const primaryQuickDiffChanges = quickDiffModelRef.object.changes.filter(change => change.providerId === primaryQuickDiff?.id);
             return Promise.resolve(( primaryQuickDiffChanges.map(change => change.change)) ?? []);
-        }
-        finally {
+        } finally {
             quickDiffModelRef.dispose();
         }
     }
 };
-MainThreadTextEditors = MainThreadTextEditors_1 = ( __decorate([
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IEditorGroupsService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IQuickDiffModelService)),
-    ( __param(7, IUriIdentityService))
-], MainThreadTextEditors));
-CommandsRegistry.registerCommand('_workbench.revertAllDirty', async function (accessor) {
+MainThreadTextEditors = MainThreadTextEditors_1 = ( __decorate([( __param(2, ICodeEditorService)), ( __param(3, IEditorService)), ( __param(4, IEditorGroupsService)), ( __param(5, IConfigurationService)), ( __param(6, IQuickDiffModelService)), ( __param(7, IUriIdentityService))], MainThreadTextEditors));
+CommandsRegistry.registerCommand("_workbench.revertAllDirty", async function(accessor) {
     const environmentService = accessor.get(IEnvironmentService);
     if (!environmentService.extensionTestsLocationURI) {
-        throw ( new Error('Command is only available when running extension tests.'));
+        throw ( new Error("Command is only available when running extension tests."));
     }
     const workingCopyService = accessor.get(IWorkingCopyService);
     for (const workingCopy of workingCopyService.dirtyWorkingCopies) {
-        await workingCopy.revert({ soft: true });
+        await workingCopy.revert({
+            soft: true
+        });
     }
 });
 

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

@@ -7,7 +7,7 @@ import { createDecorator } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 
-const IEmbeddingsService = ( createDecorator('embeddingsService'));
+const IEmbeddingsService = ( createDecorator("embeddingsService"));
 class EmbeddingsService {
     constructor() {
         this._onDidChange = ( new Emitter());
@@ -31,8 +31,7 @@ class EmbeddingsService {
         const provider = this.providers.get(id);
         if (provider) {
             return provider.provideEmbeddings(input, token);
-        }
-        else {
+        } else {
             return Promise.reject(( new Error(`No embeddings provider registered with id: ${id}`)));
         }
     }
@@ -66,9 +65,6 @@ let MainThreadEmbeddings = class MainThreadEmbeddings {
         return this.embeddingsService.computeEmbeddings(embeddingsModel, input, token);
     }
 };
-MainThreadEmbeddings = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadEmbeddings),
-    ( __param(1, IEmbeddingsService))
-], MainThreadEmbeddings);
+MainThreadEmbeddings = __decorate([extHostNamedCustomer(MainContext.MainThreadEmbeddings), ( __param(1, IEmbeddingsService))], MainThreadEmbeddings);
 
 export { MainThreadEmbeddings };

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

@@ -23,7 +23,17 @@ import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/s
 import { ITimerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/timer/browser/timerService.service';
 
 let MainThreadExtensionService = class MainThreadExtensionService {
-    constructor(extHostContext, _extensionService, _notificationService, _extensionsWorkbenchService, _hostService, _extensionEnablementService, _timerService, _commandService, _environmentService) {
+    constructor(
+        extHostContext,
+        _extensionService,
+        _notificationService,
+        _extensionsWorkbenchService,
+        _hostService,
+        _extensionEnablementService,
+        _timerService,
+        _commandService,
+        _environmentService
+    ) {
         this._extensionService = _extensionService;
         this._notificationService = _notificationService;
         this._extensionsWorkbenchService = _extensionsWorkbenchService;
@@ -36,10 +46,9 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         const internalExtHostContext = extHostContext;
         this._internalExtensionService = internalExtHostContext.internalExtensionService;
         internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
-        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
-    }
-    dispose() {
+        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map(key => MainContext[key])));
     }
+    dispose() {}
     $getExtension(extensionId) {
         return this._extensionService.getExtension(extensionId);
     }
@@ -49,8 +58,20 @@ let MainThreadExtensionService = class MainThreadExtensionService {
     async $onWillActivateExtension(extensionId) {
         this._internalExtensionService._onWillActivateExtension(extensionId);
     }
-    $onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) {
-        this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
+    $onDidActivateExtension(
+        extensionId,
+        codeLoadingTime,
+        activateCallTime,
+        activateResolvedTime,
+        activationReason
+    ) {
+        this._internalExtensionService._onDidActivateExtension(
+            extensionId,
+            codeLoadingTime,
+            activateCallTime,
+            activateResolvedTime,
+            activationReason
+        );
     }
     $onExtensionRuntimeError(extensionId, data) {
         const error = transformErrorFromSerialization(data);
@@ -65,12 +86,13 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             const extension = await this._extensionService.getExtension(extensionId.value);
             if (extension) {
                 const local = await this._extensionsWorkbenchService.queryLocal();
-                const installedDependency = local.find(i => areSameExtensions(i.identifier, { id: missingExtensionDependency.dependency }));
+                const installedDependency = local.find(i => areSameExtensions(i.identifier, {
+                    id: missingExtensionDependency.dependency
+                }));
                 if (installedDependency?.local) {
                     await this._handleMissingInstalledDependency(extension, installedDependency.local);
                     return;
-                }
-                else {
+                } else {
                     await this._handleMissingNotInstalledDependency(extension, missingExtensionDependency.dependency);
                     return;
                 }
@@ -89,70 +111,78 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2504,
+                    2507,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                 )),
                 actions: {
-                    primary: [toAction({ id: 'reload', label: ( localize(2505, "Reload Window")), run: () => this._hostService.reload() })]
+                    primary: [toAction({
+                        id: "reload",
+                        label: ( localize(2508, "Reload Window")),
+                        run: () => this._hostService.reload()
+                    })]
                 }
             });
-        }
-        else {
+        } else {
             const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
             if (enablementState === EnablementState.DisabledByVirtualWorkspace) {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2506,
+                        2509,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
+                    ))
                 });
-            }
-            else if (enablementState === EnablementState.DisabledByTrustRequirement) {
+            } else if (enablementState === EnablementState.DisabledByTrustRequirement) {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2507,
+                        2510,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [toAction({ id: 'manageWorkspaceTrust', label: ( localize(2508, "Manage Workspace Trust")), run: () => this._commandService.executeCommand('workbench.trust.manage') })]
+                        primary: [toAction({
+                            id: "manageWorkspaceTrust",
+                            label: ( localize(2511, "Manage Workspace Trust")),
+                            run: () => this._commandService.executeCommand("workbench.trust.manage")
+                        })]
                     }
                 });
-            }
-            else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
+            } else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2509,
+                        2512,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
                         primary: [toAction({
-                                id: 'enable', label: ( localize(2510, "Enable and Reload")), enabled: true,
-                                run: () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace)
-                                    .then(() => this._hostService.reload(), e => this._notificationService.error(e))
-                            })]
+                            id: "enable",
+                            label: ( localize(2513, "Enable and Reload")),
+                            enabled: true,
+                            run: () => this._extensionEnablementService.setEnablement(
+                                [missingInstalledDependency],
+                                enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace
+                            ).then(() => this._hostService.reload(), e => this._notificationService.error(e))
+                        })]
                     }
                 });
-            }
-            else {
+            } else {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2511,
+                        2514,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
+                    ))
                 });
             }
         }
@@ -161,15 +191,15 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         const extName = extension.displayName || extension.name;
         let dependencyExtension = null;
         try {
-            dependencyExtension = (await this._extensionsWorkbenchService.getExtensions([{ id: missingDependency }], CancellationToken.None))[0];
-        }
-        catch (err) {
-        }
+            dependencyExtension = (await this._extensionsWorkbenchService.getExtensions([{
+                id: missingDependency
+            }], CancellationToken.None))[0];
+        } catch (err) {}
         if (dependencyExtension) {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2512,
+                    2515,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
@@ -177,17 +207,15 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 )),
                 actions: {
                     primary: [toAction({
-                            id: 'install',
-                            label: ( localize(2513, "Install and Reload")),
-                            run: () => this._extensionsWorkbenchService.install(dependencyExtension)
-                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))
-                        })]
+                        id: "install",
+                        label: ( localize(2516, "Install and Reload")),
+                        run: () => this._extensionsWorkbenchService.install(dependencyExtension).then(() => this._hostService.reload(), e => this._notificationService.error(e))
+                    })]
                 }
             });
-        }
-        else {
+        } else {
             this._notificationService.error(( localize(
-                2514,
+                2517,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency
@@ -196,23 +224,21 @@ let MainThreadExtensionService = class MainThreadExtensionService {
     }
     async $setPerformanceMarks(marks) {
         if (this._extensionHostKind === ExtensionHostKind.LocalProcess) {
-            this._timerService.setPerformanceMarks('localExtHost', marks);
-        }
-        else if (this._extensionHostKind === ExtensionHostKind.LocalWebWorker) {
-            this._timerService.setPerformanceMarks('workerExtHost', marks);
-        }
-        else {
-            this._timerService.setPerformanceMarks('remoteExtHost', marks);
+            this._timerService.setPerformanceMarks("localExtHost", marks);
+        } else if (this._extensionHostKind === ExtensionHostKind.LocalWebWorker) {
+            this._timerService.setPerformanceMarks("workerExtHost", marks);
+        } else {
+            this._timerService.setPerformanceMarks("remoteExtHost", marks);
         }
     }
     async $asBrowserUri(uri) {
         return FileAccess.uriToBrowserUri(URI.revive(uri));
     }
     async $getAllStaticBrowserUris() {
-        return Array.from(FileAccess.getRegisteredBrowserUris(), uri => [
-            uri,
-            FileAccess.uriToBrowserUri(uri)
-        ]);
+        return Array.from(
+            FileAccess.getRegisteredBrowserUris(),
+            uri => [uri, FileAccess.uriToBrowserUri(uri)]
+        );
     }
 };
 MainThreadExtensionService = __decorate([
@@ -270,23 +296,22 @@ class ExtensionHostProxy {
     }
 }
 function reviveResolveAuthorityResult(result) {
-    if (result.type === 'ok') {
+    if (result.type === "ok") {
         return {
-            type: 'ok',
+            type: "ok",
             value: {
                 ...result.value,
-                authority: reviveResolvedAuthority(result.value.authority),
+                authority: reviveResolvedAuthority(result.value.authority)
             }
         };
-    }
-    else {
+    } else {
         return result;
     }
 }
 function reviveResolvedAuthority(resolvedAuthority) {
     return {
         ...resolvedAuthority,
-        connectTo: reviveConnection(resolvedAuthority.connectTo),
+        connectTo: reviveConnection(resolvedAuthority.connectTo)
     };
 }
 function reviveConnection(connection) {