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

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

@@ -38,28 +38,30 @@ let MainThreadNotebooks = class MainThreadNotebooks {
         const disposables = ( new DisposableStore());
         disposables.add(this._notebookService.registerNotebookSerializer(viewType, extension, {
             options,
-            dataToNotebook: async (data) => {
+            dataToNotebook: async data => {
                 const sw = ( new StopWatch());
                 let result;
-                if (data.byteLength === 0 && viewType === 'interactive') {
-                    result = NotebookDto.fromNotebookDataDto({ cells: [], metadata: {} });
-                }
-                else {
+                if (data.byteLength === 0 && viewType === "interactive") {
+                    result = NotebookDto.fromNotebookDataDto({
+                        cells: [],
+                        metadata: {}
+                    });
+                } else {
                     const dto = await this._proxy.$dataToNotebook(handle, data, CancellationToken.None);
                     result = NotebookDto.fromNotebookDataDto(dto.value);
                 }
                 this._logService.trace(`[NotebookSerializer] dataToNotebook DONE after ${sw.elapsed()}ms`, {
                     viewType,
-                    extensionId: extension.id.value,
+                    extensionId: extension.id.value
                 });
                 return result;
             },
-            notebookToData: (data) => {
+            notebookToData: data => {
                 const sw = ( new StopWatch());
                 const result = this._proxy.$notebookToData(handle, ( new SerializableObjectWithBuffers(NotebookDto.toNotebookDataDto(data))), CancellationToken.None);
                 this._logService.trace(`[NotebookSerializer] notebookToData DONE after ${sw.elapsed()}`, {
                     viewType,
-                    extensionId: extension.id.value,
+                    extensionId: extension.id.value
                 });
                 return result;
             },
@@ -77,21 +79,27 @@ let MainThreadNotebooks = class MainThreadNotebooks {
             searchInNotebooks: async (textQuery, token, allPriorityInfo) => {
                 const contributedType = this._notebookService.getContributedNotebookType(viewType);
                 if (!contributedType) {
-                    return { results: [], limitHit: false };
+                    return {
+                        results: [],
+                        limitHit: false
+                    };
                 }
                 const fileNames = contributedType.selectors;
-                const includes = ( fileNames.map((selector) => {
+                const includes = ( fileNames.map(selector => {
                     const globPattern = selector.include || selector;
                     return ( globPattern.toString());
                 }));
                 if (!includes.length) {
                     return {
-                        results: [], limitHit: false
+                        results: [],
+                        limitHit: false
                     };
                 }
-                const thisPriorityInfo = coalesce([{ isFromSettings: false, filenamePatterns: includes }, ...(allPriorityInfo.get(viewType) ?? [])]);
-                const otherEditorsPriorityInfo = Array.from(( allPriorityInfo.keys()))
-                    .flatMap(key => {
+                const thisPriorityInfo = coalesce([{
+                    isFromSettings: false,
+                    filenamePatterns: includes
+                }, ...(allPriorityInfo.get(viewType) ?? [])]);
+                const otherEditorsPriorityInfo = Array.from(( allPriorityInfo.keys())).flatMap(key => {
                     if (key !== viewType) {
                         return allPriorityInfo.get(key) ?? [];
                     }
@@ -105,16 +113,19 @@ let MainThreadNotebooks = class MainThreadNotebooks {
                         cellResults: ( result.cellResults.map(e => revive(e)))
                     };
                 }));
-                return { results: revivedResults, limitHit: searchComplete.limitHit };
+                return {
+                    results: revivedResults,
+                    limitHit: searchComplete.limitHit
+                };
             }
         }));
         if (data) {
             disposables.add(this._notebookService.registerContributedNotebookType(viewType, data));
         }
         this._notebookSerializer.set(handle, disposables);
-        this._logService.trace('[NotebookSerializer] registered notebook serializer', {
+        this._logService.trace("[NotebookSerializer] registered notebook serializer", {
             viewType,
-            extensionId: extension.id.value,
+            extensionId: extension.id.value
         });
     }
     $unregisterNotebookSerializer(handle) {
@@ -143,7 +154,7 @@ let MainThreadNotebooks = class MainThreadNotebooks {
             },
             viewType
         };
-        if (typeof eventHandle === 'number') {
+        if (typeof eventHandle === "number") {
             const emitter = ( new Emitter());
             this._notebookCellStatusBarRegistrations.set(eventHandle, emitter);
             provider.onDidChangeStatusBarItems = emitter.event;
@@ -152,7 +163,7 @@ let MainThreadNotebooks = class MainThreadNotebooks {
         this._notebookCellStatusBarRegistrations.set(handle, disposable);
     }
     async $unregisterNotebookCellStatusBarItemProvider(handle, eventHandle) {
-        const unregisterThing = (handle) => {
+        const unregisterThing = handle => {
             const entry = this._notebookCellStatusBarRegistrations.get(handle);
             if (entry) {
                 this._notebookCellStatusBarRegistrations.get(handle)?.dispose();
@@ -160,21 +171,16 @@ let MainThreadNotebooks = class MainThreadNotebooks {
             }
         };
         unregisterThing(handle);
-        if (typeof eventHandle === 'number') {
+        if (typeof eventHandle === "number") {
             unregisterThing(eventHandle);
         }
     }
 };
-MainThreadNotebooks = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadNotebook),
-    ( __param(1, INotebookService)),
-    ( __param(2, INotebookCellStatusBarService)),
-    ( __param(3, ILogService))
-], MainThreadNotebooks);
-CommandsRegistry.registerCommand('_executeDataToNotebook', async (accessor, ...args) => {
+MainThreadNotebooks = __decorate([extHostNamedCustomer(MainContext.MainThreadNotebook), ( __param(1, INotebookService)), ( __param(2, INotebookCellStatusBarService)), ( __param(3, ILogService))], MainThreadNotebooks);
+CommandsRegistry.registerCommand("_executeDataToNotebook", async (accessor, ...args) => {
     const [notebookType, bytes] = args;
-    assertType(typeof notebookType === 'string', 'string');
-    assertType(bytes instanceof VSBuffer, 'VSBuffer');
+    assertType(typeof notebookType === "string", "string");
+    assertType(bytes instanceof VSBuffer, "VSBuffer");
     const notebookService = accessor.get(INotebookService);
     const info = await notebookService.withNotebookDataProvider(notebookType);
     if (!(info instanceof SimpleNotebookProviderInfo)) {
@@ -183,8 +189,8 @@ CommandsRegistry.registerCommand('_executeDataToNotebook', async (accessor, ...a
     const dto = await info.serializer.dataToNotebook(bytes);
     return ( new SerializableObjectWithBuffers(NotebookDto.toNotebookDataDto(dto)));
 });
-CommandsRegistry.registerCommand('_executeNotebookToData', async (accessor, notebookType, dto) => {
-    assertType(typeof notebookType === 'string', 'string');
+CommandsRegistry.registerCommand("_executeNotebookToData", async (accessor, notebookType, dto) => {
+    assertType(typeof notebookType === "string", "string");
     const notebookService = accessor.get(INotebookService);
     const info = await notebookService.withNotebookDataProvider(notebookType);
     if (!(info instanceof SimpleNotebookProviderInfo)) {
@@ -196,7 +202,7 @@ CommandsRegistry.registerCommand('_executeNotebookToData', async (accessor, note
 });
 function isFileOperationError(error) {
     const candidate = error;
-    return typeof candidate?.fileOperationResult === 'number' && typeof candidate?.message === 'string';
+    return typeof candidate?.fileOperationResult === "number" && typeof candidate?.message === "string";
 }
 
 export { MainThreadNotebooks };

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

@@ -20,8 +20,12 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
         this._documentEventListenersMapping = ( new ResourceMap());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocuments));
         this._modelReferenceCollection = ( new BoundModelReferenceCollection(this._uriIdentityService.extUri));
-        this._disposables.add(this._notebookEditorModelResolverService.onDidChangeDirty(model => this._proxy.$acceptDirtyStateChanged(model.resource, model.isDirty())));
-        this._disposables.add(this._notebookEditorModelResolverService.onDidSaveNotebook(e => this._proxy.$acceptModelSaved(e)));
+        this._disposables.add(this._notebookEditorModelResolverService.onDidChangeDirty(
+            model => this._proxy.$acceptDirtyStateChanged(model.resource, model.isDirty())
+        ));
+        this._disposables.add(
+            this._notebookEditorModelResolverService.onDidSaveNotebook(e => this._proxy.$acceptModelSaved(e))
+        );
         this._disposables.add(_notebookEditorModelResolverService.onWillFailWithConflict(e => {
             this._modelReferenceCollection.remove(e.resource);
         }));
@@ -41,42 +45,42 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
                 };
                 for (const e of event.rawEvents) {
                     switch (e.kind) {
-                        case NotebookCellsChangeType.ModelChange:
-                            eventDto.rawEvents.push({
-                                kind: e.kind,
-                                changes: ( e.changes.map(diff => [diff[0], diff[1], ( diff[2].map(cell => NotebookDto.toNotebookCellDto(cell)))]))
-                            });
-                            break;
-                        case NotebookCellsChangeType.Move:
-                            eventDto.rawEvents.push({
-                                kind: e.kind,
-                                index: e.index,
-                                length: e.length,
-                                newIdx: e.newIdx,
-                            });
-                            break;
-                        case NotebookCellsChangeType.Output:
-                            eventDto.rawEvents.push({
-                                kind: e.kind,
-                                index: e.index,
-                                outputs: ( e.outputs.map(NotebookDto.toNotebookOutputDto))
-                            });
-                            break;
-                        case NotebookCellsChangeType.OutputItem:
-                            eventDto.rawEvents.push({
-                                kind: e.kind,
-                                index: e.index,
-                                outputId: e.outputId,
-                                outputItems: ( e.outputItems.map(NotebookDto.toNotebookOutputItemDto)),
-                                append: e.append
-                            });
-                            break;
-                        case NotebookCellsChangeType.ChangeCellLanguage:
-                        case NotebookCellsChangeType.ChangeCellContent:
-                        case NotebookCellsChangeType.ChangeCellMetadata:
-                        case NotebookCellsChangeType.ChangeCellInternalMetadata:
-                            eventDto.rawEvents.push(e);
-                            break;
+                    case NotebookCellsChangeType.ModelChange:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            changes: ( e.changes.map(diff => [diff[0], diff[1], ( diff[2].map(cell => NotebookDto.toNotebookCellDto(cell)))]))
+                        });
+                        break;
+                    case NotebookCellsChangeType.Move:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            index: e.index,
+                            length: e.length,
+                            newIdx: e.newIdx
+                        });
+                        break;
+                    case NotebookCellsChangeType.Output:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            index: e.index,
+                            outputs: ( e.outputs.map(NotebookDto.toNotebookOutputDto))
+                        });
+                        break;
+                    case NotebookCellsChangeType.OutputItem:
+                        eventDto.rawEvents.push({
+                            kind: e.kind,
+                            index: e.index,
+                            outputId: e.outputId,
+                            outputItems: ( e.outputItems.map(NotebookDto.toNotebookOutputItemDto)),
+                            append: e.append
+                        });
+                        break;
+                    case NotebookCellsChangeType.ChangeCellLanguage:
+                    case NotebookCellsChangeType.ChangeCellContent:
+                    case NotebookCellsChangeType.ChangeCellMetadata:
+                    case NotebookCellsChangeType.ChangeCellInternalMetadata:
+                        eventDto.rawEvents.push(e);
+                        break;
                     }
                 }
                 const hasDocumentMetadataChangeEvent = event.rawEvents.find(e => e.kind === NotebookCellsChangeType.ChangeDocumentMetadata);
@@ -93,7 +97,9 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
     }
     async $tryCreateNotebook(options) {
         if (options.content) {
-            const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: undefined }, options.viewType);
+            const ref = await this._notebookEditorModelResolverService.resolve({
+                untitledResource: undefined
+            }, options.viewType);
             Event.once(ref.object.notebook.onWillDispose)(() => {
                 ref.dispose();
             });
@@ -103,8 +109,7 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
                 ref.object.notebook.reset(data.cells, data.metadata, ref.object.notebook.transientOptions);
             }
             return ref.object.notebook.uri;
-        }
-        else {
+        } else {
             const notebook = await this._notebookEditorModelResolverService.createUntitledNotebookTextModel(options.viewType);
             return notebook.uri;
         }
@@ -112,7 +117,7 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
     async $tryOpenNotebook(uriComponents) {
         const uri = URI.revive(uriComponents);
         const ref = await this._notebookEditorModelResolverService.resolve(uri, undefined);
-        if (uriComponents.scheme === 'untitled') {
+        if (uriComponents.scheme === "untitled") {
             ref.object.notebook.onWillDispose(() => {
                 ref.dispose();
             });
@@ -128,9 +133,6 @@ let MainThreadNotebookDocuments = class MainThreadNotebookDocuments {
         return saveResult;
     }
 };
-MainThreadNotebookDocuments = ( __decorate([
-    ( __param(1, INotebookEditorModelResolverService)),
-    ( __param(2, IUriIdentityService))
-], MainThreadNotebookDocuments));
+MainThreadNotebookDocuments = ( __decorate([( __param(1, INotebookEditorModelResolverService)), ( __param(2, IUriIdentityService))], MainThreadNotebookDocuments));
 
 export { MainThreadNotebookDocuments };

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

@@ -39,9 +39,7 @@ class NotebookAndEditorState {
             addedEditors: editorDelta.added,
             removedEditors: ( editorDelta.removed.map(removed => removed.getId())),
             newActiveEditor: newActiveEditor,
-            visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0
-                ? undefined
-                : ( [...after.visibleEditors].map(editor => editor[0]))
+            visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0 ? undefined : ( [...after.visibleEditors].map(editor => editor[0]))
         };
     }
     constructor(documents, textEditors, activeEditor, visibleEditors) {
@@ -52,7 +50,15 @@ class NotebookAndEditorState {
     }
 }
 let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class MainThreadNotebooksAndEditors {
-    constructor(extHostContext, instantiationService, _notebookService, _notebookEditorService, _editorService, _editorGroupService, _logService) {
+    constructor(
+        extHostContext,
+        instantiationService,
+        _notebookService,
+        _notebookEditorService,
+        _editorService,
+        _editorGroupService,
+        _logService
+    ) {
         this._notebookService = _notebookService;
         this._notebookEditorService = _notebookEditorService;
         this._editorService = _editorService;
@@ -80,7 +86,10 @@ let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class Main
         this._editorListeners.dispose();
     }
     _handleEditorAdd(editor) {
-        this._editorListeners.set(editor.getId(), combinedDisposable(editor.onDidChangeModel(() => this._updateState()), editor.onDidFocusWidget(() => this._updateState(editor))));
+        this._editorListeners.set(editor.getId(), combinedDisposable(
+            editor.onDidChangeModel(() => this._updateState()),
+            editor.onDidFocusWidget(() => this._updateState(editor))
+        ));
         this._updateState();
     }
     _handleEditorRemove(editor) {
@@ -99,12 +108,15 @@ let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class Main
         let activeEditor = null;
         if (activeNotebookEditor) {
             activeEditor = activeNotebookEditor.getId();
-        }
-        else if (focusedEditor?.textModel) {
+        } else if (focusedEditor?.textModel) {
             activeEditor = focusedEditor.getId();
         }
         if (activeEditor && !( editors.has(activeEditor))) {
-            this._logService.trace('MainThreadNotebooksAndEditors#_updateState: active editor is not in editors list', activeEditor, ( editors.keys()));
+            this._logService.trace(
+                "MainThreadNotebooksAndEditors#_updateState: active editor is not in editors list",
+                activeEditor,
+                ( editors.keys())
+            );
             activeEditor = null;
         }
         for (const editorPane of this._editorService.visibleEditorPanes) {
@@ -127,7 +139,7 @@ let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class Main
             newActiveEditor: delta.newActiveEditor,
             visibleEditors: delta.visibleEditors,
             addedDocuments: ( delta.addedDocuments.map(MainThreadNotebooksAndEditors_1._asModelAddData)),
-            addedEditors: ( delta.addedEditors.map(this._asEditorAddData, this)),
+            addedEditors: ( delta.addedEditors.map(this._asEditorAddData, this))
         };
         this._proxy.$acceptDocumentAndEditorsDelta(( new SerializableObjectWithBuffers(dto)));
         this._mainThreadEditors.handleEditorsRemoved(delta.removedEditors);
@@ -177,14 +189,6 @@ let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class Main
         };
     }
 };
-MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = __decorate([
-    extHostCustomer,
-    ( __param(1, IInstantiationService)),
-    ( __param(2, INotebookService)),
-    ( __param(3, INotebookEditorService)),
-    ( __param(4, IEditorService)),
-    ( __param(5, IEditorGroupsService)),
-    ( __param(6, ILogService))
-], MainThreadNotebooksAndEditors);
+MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = __decorate([extHostCustomer, ( __param(1, IInstantiationService)), ( __param(2, INotebookService)), ( __param(3, INotebookEditorService)), ( __param(4, IEditorService)), ( __param(5, IEditorGroupsService)), ( __param(6, ILogService))], MainThreadNotebooksAndEditors);
 
 export { MainThreadNotebooksAndEditors };

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

@@ -3,7 +3,7 @@ import { CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { CellExecutionUpdateType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
 
 var NotebookDto;
-(function (NotebookDto) {
+(function(NotebookDto) {
     function toNotebookOutputItemDto(item) {
         return {
             mime: item.mime,
@@ -82,7 +82,7 @@ var NotebookDto;
             cellKind: cell.cellKind,
             outputs: ( cell.outputs.map(toNotebookOutputDto)),
             metadata: cell.metadata,
-            internalMetadata: cell.internalMetadata,
+            internalMetadata: cell.internalMetadata
         };
     }
     NotebookDto.toNotebookCellDto = toNotebookCellDto;
@@ -94,16 +94,14 @@ var NotebookDto;
                 append: data.append,
                 outputs: ( data.outputs.map(fromNotebookOutputDto))
             };
-        }
-        else if (data.editType === CellExecutionUpdateType.OutputItems) {
+        } else if (data.editType === CellExecutionUpdateType.OutputItems) {
             return {
                 editType: data.editType,
                 append: data.append,
                 outputId: data.outputId,
                 items: ( data.items.map(fromNotebookOutputItemDto))
             };
-        }
-        else {
+        } else {
             return data;
         }
     }
@@ -120,8 +118,7 @@ var NotebookDto;
                 count: edit.count,
                 cells: ( edit.cells.map(fromNotebookCellDataDto))
             };
-        }
-        else {
+        } else {
             return edit;
         }
     }

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

@@ -22,7 +22,13 @@ class MainThreadNotebook {
     }
 }
 let MainThreadNotebookEditors = class MainThreadNotebookEditors {
-    constructor(extHostContext, _editorService, _notebookEditorService, _editorGroupService, _configurationService) {
+    constructor(
+        extHostContext,
+        _editorService,
+        _notebookEditorService,
+        _editorGroupService,
+        _configurationService
+    ) {
         this._editorService = _editorService;
         this._notebookEditorService = _notebookEditorService;
         this._editorGroupService = _editorGroupService;
@@ -42,10 +48,18 @@ let MainThreadNotebookEditors = class MainThreadNotebookEditors {
         for (const editor of editors) {
             const editorDisposables = ( new DisposableStore());
             editorDisposables.add(editor.onDidChangeVisibleRanges(() => {
-                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges } });
+                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), {
+                    visibleRanges: {
+                        ranges: editor.visibleRanges
+                    }
+                });
             }));
             editorDisposables.add(editor.onDidChangeSelection(() => {
-                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { selections: { selections: editor.getSelections() } });
+                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), {
+                    selections: {
+                        selections: editor.getSelections()
+                    }
+                });
             }));
             const wrapper = ( new MainThreadNotebook(editor, editorDisposables));
             this._mainThreadEditors.set(editor.getId(), wrapper);
@@ -79,12 +93,14 @@ let MainThreadNotebookEditors = class MainThreadNotebookEditors {
             label: options.label,
             override: viewType
         };
-        const editorPane = await this._editorService.openEditor({ resource: URI.revive(resource), options: editorOptions }, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
+        const editorPane = await this._editorService.openEditor({
+            resource: URI.revive(resource),
+            options: editorOptions
+        }, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
         const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
         if (notebookEditor) {
             return notebookEditor.getId();
-        }
-        else {
+        } else {
             throw ( new Error(
                 `Notebook Editor creation failure for document ${JSON.stringify(resource)}`
             ));
@@ -104,14 +120,14 @@ let MainThreadNotebookEditors = class MainThreadNotebookEditors {
         }
         const cell = notebookEditor.cellAt(range.start);
         switch (revealType) {
-            case NotebookEditorRevealType.Default:
-                return notebookEditor.revealCellRangeInView(range);
-            case NotebookEditorRevealType.InCenter:
-                return notebookEditor.revealInCenter(cell);
-            case NotebookEditorRevealType.InCenterIfOutsideViewport:
-                return notebookEditor.revealInCenterIfOutsideViewport(cell);
-            case NotebookEditorRevealType.AtTop:
-                return notebookEditor.revealInViewAtTop(cell);
+        case NotebookEditorRevealType.Default:
+            return notebookEditor.revealCellRangeInView(range);
+        case NotebookEditorRevealType.InCenter:
+            return notebookEditor.revealInCenter(cell);
+        case NotebookEditorRevealType.InCenterIfOutsideViewport:
+            return notebookEditor.revealInCenterIfOutsideViewport(cell);
+        case NotebookEditorRevealType.AtTop:
+            return notebookEditor.revealInViewAtTop(cell);
         }
     }
     $trySetSelections(id, ranges) {
@@ -121,15 +137,13 @@ let MainThreadNotebookEditors = class MainThreadNotebookEditors {
         }
         editor.setSelections(ranges);
         if (ranges.length) {
-            editor.setFocus({ start: ranges[0].start, end: ranges[0].start + 1 });
+            editor.setFocus({
+                start: ranges[0].start,
+                end: ranges[0].start + 1
+            });
         }
     }
 };
-MainThreadNotebookEditors = ( __decorate([
-    ( __param(1, IEditorService)),
-    ( __param(2, INotebookEditorService)),
-    ( __param(3, IEditorGroupsService)),
-    ( __param(4, IConfigurationService))
-], MainThreadNotebookEditors));
+MainThreadNotebookEditors = ( __decorate([( __param(1, IEditorService)), ( __param(2, INotebookEditorService)), ( __param(3, IEditorGroupsService)), ( __param(4, IConfigurationService))], MainThreadNotebookEditors));
 
 export { MainThreadNotebookEditors };