@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/outputEditor/notebookOutputEditor.js

@@ -33,25 +33,29 @@ import { ViewContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/co
 
 var NotebookOutputEditor_1;
 class NoopCellEditorOptions extends Disposable {
-    static { this.fixedEditorOptions = {
-        scrollBeyondLastLine: false,
-        scrollbar: {
-            verticalScrollbarSize: 14,
-            horizontal: 'auto',
-            useShadows: true,
-            verticalHasArrows: false,
-            horizontalHasArrows: false,
-            alwaysConsumeMouseWheel: false
-        },
-        renderLineHighlightOnlyWhenFocus: true,
-        overviewRulerLanes: 0,
-        lineDecorationsWidth: 0,
-        folding: true,
-        fixedOverflowWidgets: true,
-        minimap: { enabled: false },
-        renderValidationDecorations: 'on',
-        lineNumbersMinChars: 3
-    }; }
+    static {
+        this.fixedEditorOptions = {
+            scrollBeyondLastLine: false,
+            scrollbar: {
+                verticalScrollbarSize: 14,
+                horizontal: "auto",
+                useShadows: true,
+                verticalHasArrows: false,
+                horizontalHasArrows: false,
+                alwaysConsumeMouseWheel: false
+            },
+            renderLineHighlightOnlyWhenFocus: true,
+            overviewRulerLanes: 0,
+            lineDecorationsWidth: 0,
+            folding: true,
+            fixedOverflowWidgets: true,
+            minimap: {
+                enabled: false
+            },
+            renderValidationDecorations: "on",
+            lineNumbersMinChars: 3
+        };
+    }
     get value() {
         return this._value;
     }
@@ -61,19 +65,40 @@ class NoopCellEditorOptions extends Disposable {
         this.onDidChange = this._onDidChange.event;
         this._value = ( Object.freeze({
             ...NoopCellEditorOptions.fixedEditorOptions,
-            padding: { top: 12, bottom: 12 },
+            padding: {
+                top: 12,
+                bottom: 12
+            },
             readOnly: true
         }));
     }
 }
 let NotebookOutputEditor = class NotebookOutputEditor extends EditorPane {
-    static { NotebookOutputEditor_1 = this; }
-    static { this.ID = NOTEBOOK_OUTPUT_EDITOR_ID; }
+    static {
+        NotebookOutputEditor_1 = this;
+    }
+    static {
+        this.ID = NOTEBOOK_OUTPUT_EDITOR_ID;
+    }
     get isDisposed() {
         return this._isDisposed;
     }
-    constructor(group, instantiationService, themeService, telemetryService, storageService, configurationService, notebookService) {
-        super(NotebookOutputEditor_1.ID, group, telemetryService, themeService, storageService);
+    constructor(
+        group,
+        instantiationService,
+        themeService,
+        telemetryService,
+        storageService,
+        configurationService,
+        notebookService
+    ) {
+        super(
+            NotebookOutputEditor_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
         this.instantiationService = instantiationService;
         this.configurationService = configurationService;
         this.notebookService = notebookService;
@@ -84,7 +109,7 @@ let NotebookOutputEditor = class NotebookOutputEditor extends EditorPane {
         this._register(this._notebookOptions);
     }
     createEditor(parent) {
-        this._rootElement = append(parent, $('.notebook-output-editor'));
+        this._rootElement = append(parent, $(".notebook-output-editor"));
     }
     get fontInfo() {
         if (!this._fontInfo) {
@@ -93,8 +118,11 @@ let NotebookOutputEditor = class NotebookOutputEditor extends EditorPane {
         return this._fontInfo;
     }
     createFontInfo() {
-        const editorOptions = this.configurationService.getValue('editor');
-        return FontMeasurements.readFontInfo(this.window, createBareFontInfoFromRawSettings(editorOptions, PixelRatio.getInstance(this.window).value));
+        const editorOptions = this.configurationService.getValue("editor");
+        return FontMeasurements.readFontInfo(
+            this.window,
+            createBareFontInfoFromRawSettings(editorOptions, PixelRatio.getInstance(this.window).value)
+        );
     }
     async _createOriginalWebview(id, viewType, resource) {
         this._outputWebview?.dispose();
@@ -114,59 +142,73 @@ let NotebookOutputEditor = class NotebookOutputEditor extends EditorPane {
         if (this.input) {
             return this.input.getName();
         }
-        return localize(9681, "Notebook Output Editor");
+        return localize(10001, "Notebook Output Editor");
     }
     async setInput(input, options, context, token) {
         await super.setInput(input, options, context, token);
         const model = await input.resolve();
         if (!model) {
-            throw ( new Error('Invalid notebook output editor input'));
+            throw ( new Error("Invalid notebook output editor input"));
         }
         const resolvedNotebookEditorModel = model.resolvedNotebookEditorModel;
-        await this._createOriginalWebview(generateUuid(), resolvedNotebookEditorModel.viewType, ( URI.from(
-            { scheme: Schemas.vscodeNotebookCellOutput, path: '', query: 'openIn=notebookOutputEditor' }
-        )));
+        await this._createOriginalWebview(generateUuid(), resolvedNotebookEditorModel.viewType, ( URI.from({
+            scheme: Schemas.vscodeNotebookCellOutput,
+            path: "",
+            query: "openIn=notebookOutputEditor"
+        })));
         const notebookTextModel = resolvedNotebookEditorModel.notebook;
         const eventDispatcher = this._register(( new NotebookEventDispatcher()));
         const editorOptions = this._register(( new NoopCellEditorOptions()));
         const viewContext = ( new ViewContext(this._notebookOptions, eventDispatcher, _language => editorOptions));
-        this._notebookViewModel = this.instantiationService.createInstance(NotebookViewModel, notebookTextModel.viewType, notebookTextModel, viewContext, null, { isReadOnly: true });
+        this._notebookViewModel = this.instantiationService.createInstance(
+            NotebookViewModel,
+            notebookTextModel.viewType,
+            notebookTextModel,
+            viewContext,
+            null,
+            {
+                isReadOnly: true
+            }
+        );
         const cellViewModel = this._notebookViewModel.getCellByHandle(model.cell.handle);
         if (!cellViewModel) {
-            throw ( new Error('Invalid NotebookOutputEditorInput, no matching cell view model'));
+            throw ( new Error("Invalid NotebookOutputEditorInput, no matching cell view model"));
         }
         const cellOutputViewModel = cellViewModel.outputsViewModels.find(outputViewModel => outputViewModel.model.outputId === model.outputId);
         if (!cellOutputViewModel) {
-            throw ( new Error('Invalid NotebookOutputEditorInput, no matching cell output view model'));
+            throw ( new Error("Invalid NotebookOutputEditorInput, no matching cell output view model"));
         }
         let result = undefined;
         const [mimeTypes, pick] = cellOutputViewModel.resolveMimeTypes(notebookTextModel, undefined);
         const pickedMimeTypeRenderer = cellOutputViewModel.pickedMimeType || mimeTypes[pick];
         if (mimeTypes.length !== 0) {
             const renderer = this.notebookService.getRendererInfo(pickedMimeTypeRenderer.rendererId);
-            result = renderer
-                ? { type: RenderOutputType.Extension, renderer, source: cellOutputViewModel, mimeType: pickedMimeTypeRenderer.mimeType }
-                : this._renderMissingRenderer(cellOutputViewModel, pickedMimeTypeRenderer.mimeType);
+            result = renderer ? {
+                type: RenderOutputType.Extension,
+                renderer,
+                source: cellOutputViewModel,
+                mimeType: pickedMimeTypeRenderer.mimeType
+            } : this._renderMissingRenderer(cellOutputViewModel, pickedMimeTypeRenderer.mimeType);
         }
         if (!result) {
-            throw ( new Error('No InsetRenderInfo for output'));
+            throw ( new Error("No InsetRenderInfo for output"));
         }
         const cellInfo = {
             cellId: cellViewModel.id,
             cellHandle: model.cell.handle,
-            cellUri: model.cell.uri,
+            cellUri: model.cell.uri
         };
         this._outputWebview?.createOutput(cellInfo, result, 0, 0);
     }
     _renderMissingRenderer(viewModel, preferredMimeType) {
         if (!viewModel.model.outputs.length) {
-            return this._renderMessage(viewModel, ( localize(9682, "Cell has no output")));
+            return this._renderMessage(viewModel, ( localize(10002, "Cell has no output")));
         }
         if (!preferredMimeType) {
             const mimeTypes = ( viewModel.model.outputs.map(op => op.mime));
-            const mimeTypesMessage = mimeTypes.join(', ');
+            const mimeTypesMessage = mimeTypes.join(", ");
             return this._renderMessage(viewModel, ( localize(
-                9683,
+                10003,
                 "No renderer could be found for output. It has the following mimetypes: {0}",
                 mimeTypesMessage
             )));
@@ -174,100 +216,102 @@ let NotebookOutputEditor = class NotebookOutputEditor extends EditorPane {
         return this._renderSearchForMimetype(viewModel, preferredMimeType);
     }
     _renderMessage(viewModel, message) {
-        const el = $('p', undefined, message);
-        return { type: RenderOutputType.Html, source: viewModel, htmlContent: el.outerHTML };
+        const el = $("p", undefined, message);
+        return {
+            type: RenderOutputType.Html,
+            source: viewModel,
+            htmlContent: el.outerHTML
+        };
     }
     _renderSearchForMimetype(viewModel, mimeType) {
         const query = `@tag:notebookRenderer ${mimeType}`;
-        const p = $('p', undefined, `No renderer could be found for mimetype "${mimeType}", but one might be available on the Marketplace.`);
-        const a = $('a', { href: `command:workbench.extensions.search?%22${query}%22`, class: 'monaco-button monaco-text-button', tabindex: 0, role: 'button', style: 'padding: 8px; text-decoration: none; color: rgb(255, 255, 255); background-color: rgb(14, 99, 156); max-width: 200px;' }, `Search Marketplace`);
+        const p = $(
+            "p",
+            undefined,
+            `No renderer could be found for mimetype "${mimeType}", but one might be available on the Marketplace.`
+        );
+        const a = $("a", {
+            href: `command:workbench.extensions.search?%22${query}%22`,
+            class: "monaco-button monaco-text-button",
+            tabindex: 0,
+            role: "button",
+            style: "padding: 8px; text-decoration: none; color: rgb(255, 255, 255); background-color: rgb(14, 99, 156); max-width: 200px;"
+        }, `Search Marketplace`);
         return {
             type: RenderOutputType.Html,
             source: viewModel,
-            htmlContent: p.outerHTML + a.outerHTML,
+            htmlContent: p.outerHTML + a.outerHTML
         };
     }
     scheduleOutputHeightAck(cellInfo, outputId, height) {
         scheduleAtNextAnimationFrame(this.window, () => {
-            this._outputWebview?.ackHeight([{ cellId: cellInfo.cellId, outputId, height }]);
+            this._outputWebview?.ackHeight([{
+                cellId: cellInfo.cellId,
+                outputId,
+                height
+            }]);
         }, 10);
     }
-    async focusNotebookCell(cell, focus) {
-    }
-    async focusNextNotebookCell(cell, focus) {
-    }
+    async focusNotebookCell(cell, focus) {}
+    async focusNextNotebookCell(cell, focus) {}
     toggleNotebookCellSelection(cell) {
-        throw ( new Error('Not implemented.'));
+        throw ( new Error("Not implemented."));
     }
     getCellById(cellId) {
-        throw ( new Error('Not implemented'));
+        throw ( new Error("Not implemented"));
     }
     getCellByInfo(cellInfo) {
         return this._notebookViewModel?.getCellByHandle(cellInfo.cellHandle);
     }
-    layout(dimension, position) {
-    }
-    setScrollTop(scrollTop) {
-    }
-    triggerScroll(event) {
-    }
-    getOutputRenderer() {
-    }
-    updateOutputHeight(cellInfo, output, height, isInit, source) {
-    }
-    updateMarkupCellHeight(cellId, height, isInit) {
-    }
-    setMarkupCellEditState(cellId, editState) {
-    }
-    didResizeOutput(cellId) {
-    }
-    didStartDragMarkupCell(cellId, event) {
-    }
-    didDragMarkupCell(cellId, event) {
-    }
-    didDropMarkupCell(cellId, event) {
-    }
-    didEndDragMarkupCell(cellId) {
-    }
-    updatePerformanceMetadata(cellId, executionId, duration, rendererId) {
-    }
-    didFocusOutputInputChange(inputFocused) {
-    }
+    layout(dimension, position) {}
+    setScrollTop(scrollTop) {}
+    triggerScroll(event) {}
+    getOutputRenderer() {}
+    updateOutputHeight(cellInfo, output, height, isInit, source) {}
+    updateMarkupCellHeight(cellId, height, isInit) {}
+    setMarkupCellEditState(cellId, editState) {}
+    didResizeOutput(cellId) {}
+    didStartDragMarkupCell(cellId, event) {}
+    didDragMarkupCell(cellId, event) {}
+    didDropMarkupCell(cellId, event) {}
+    didEndDragMarkupCell(cellId) {}
+    updatePerformanceMetadata(cellId, executionId, duration, rendererId) {}
+    didFocusOutputInputChange(inputFocused) {}
     dispose() {
         this._isDisposed = true;
         super.dispose();
     }
 };
-NotebookOutputEditor = NotebookOutputEditor_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IThemeService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, INotebookService))
-], NotebookOutputEditor));
+NotebookOutputEditor = NotebookOutputEditor_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IThemeService)), ( __param(3, ITelemetryService)), ( __param(4, IStorageService)), ( __param(5, IConfigurationService)), ( __param(6, INotebookService))], NotebookOutputEditor));
 let NotebookOutputEditorContribution = class NotebookOutputEditorContribution {
-    static { this.ID = 'workbench.contribution.notebookOutputEditorContribution'; }
+    static {
+        this.ID = "workbench.contribution.notebookOutputEditorContribution";
+    }
     constructor(editorResolverService, instantiationService, uriIdentityService) {
         this.instantiationService = instantiationService;
         this.uriIdentityService = uriIdentityService;
         editorResolverService.registerEditor(`${Schemas.vscodeNotebookCellOutput}:/**`, {
-            id: 'notebookOutputEditor',
-            label: 'Notebook Output Editor',
+            id: "notebookOutputEditor",
+            label: "Notebook Output Editor",
             priority: RegisteredEditorPriority.default
         }, {
-            canSupportResource: (resource) => {
+            canSupportResource: resource => {
                 if (resource.scheme === Schemas.vscodeNotebookCellOutput) {
                     const params = ( new URLSearchParams(resource.query));
-                    return params.get('openIn') === 'notebookOutputEditor';
+                    return params.get("openIn") === "notebookOutputEditor";
                 }
                 return false;
             }
         }, {
-            createEditorInput: async ({ resource, options }) => {
+            createEditorInput: async (
+                {
+                    resource,
+                    options
+                }
+            ) => {
                 const outputUriData = CellUri.parseCellOutputUri(resource);
                 if (!outputUriData || !outputUriData.notebook || outputUriData.cellIndex === undefined || outputUriData.outputIndex === undefined || !outputUriData.outputId) {
-                    throw ( new Error('Invalid output uri for notebook output editor'));
+                    throw ( new Error("Invalid output uri for notebook output editor"));
                 }
                 const notebookUri = this.uriIdentityService.asCanonicalUri(outputUriData.notebook);
                 const cellIndex = outputUriData.cellIndex;
@@ -282,11 +326,11 @@ let NotebookOutputEditorContribution = class NotebookOutputEditorContribution {
         });
     }
 };
-NotebookOutputEditorContribution = ( __decorate([
-    ( __param(0, IEditorResolverService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IUriIdentityService))
-], NotebookOutputEditorContribution));
-registerWorkbenchContribution2(NotebookOutputEditorContribution.ID, NotebookOutputEditorContribution, WorkbenchPhase.BlockRestore);
+NotebookOutputEditorContribution = ( __decorate([( __param(0, IEditorResolverService)), ( __param(1, IInstantiationService)), ( __param(2, IUriIdentityService))], NotebookOutputEditorContribution));
+registerWorkbenchContribution2(
+    NotebookOutputEditorContribution.ID,
+    NotebookOutputEditorContribution,
+    WorkbenchPhase.BlockRestore
+);
 
 export { NoopCellEditorOptions, NotebookOutputEditor, NotebookOutputEditorContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/outputEditor/notebookOutputEditorInput.js

@@ -19,9 +19,19 @@ class ResolvedNotebookOutputEditorInputModel {
     }
 }
 let NotebookOutputEditorInput = class NotebookOutputEditorInput extends EditorInput {
-    static { NotebookOutputEditorInput_1 = this; }
-    static { this.ID = 'workbench.input.notebookOutputEditorInput'; }
-    constructor(notebookUri, cellIndex, outputId, outputIndex, notebookEditorModelResolverService) {
+    static {
+        NotebookOutputEditorInput_1 = this;
+    }
+    static {
+        this.ID = "workbench.input.notebookOutputEditorInput";
+    }
+    constructor(
+        notebookUri,
+        cellIndex,
+        outputId,
+        outputIndex,
+        notebookEditorModelResolverService
+    ) {
         super();
         this.notebookEditorModelResolverService = notebookEditorModelResolverService;
         this._notebookUri = notebookUri;
@@ -39,12 +49,12 @@ let NotebookOutputEditorInput = class NotebookOutputEditorInput extends EditorIn
         }
         const cell = this._notebookRef.object.notebook.cells[this.cellIndex];
         if (!cell) {
-            throw ( new Error('Cell not found'));
+            throw ( new Error("Cell not found"));
         }
         this.cellUri = cell.uri;
         const resolvedOutputId = cell.outputs[this.outputIndex]?.outputId;
         if (!resolvedOutputId) {
-            throw ( new Error('Output not found'));
+            throw ( new Error("Output not found"));
         }
         if (!this.outputId) {
             this.outputId = resolvedOutputId;
@@ -67,14 +77,14 @@ let NotebookOutputEditorInput = class NotebookOutputEditorInput extends EditorIn
         return {
             notebookUri: this._notebookUri,
             cellIndex: cellIndex,
-            outputIndex: outputIndex,
+            outputIndex: outputIndex
         };
     }
     getName() {
-        return localize(9684, "Notebook Output Preview");
+        return localize(10004, "Notebook Output Preview");
     }
     get editorId() {
-        return 'notebookOutputEditor';
+        return "notebookOutputEditor";
     }
     get resource() {
         return;
@@ -86,8 +96,6 @@ let NotebookOutputEditorInput = class NotebookOutputEditorInput extends EditorIn
         super.dispose();
     }
 };
-NotebookOutputEditorInput = NotebookOutputEditorInput_1 = ( __decorate([
-    ( __param(4, INotebookEditorModelResolverService))
-], NotebookOutputEditorInput));
+NotebookOutputEditorInput = NotebookOutputEditorInput_1 = ( __decorate([( __param(4, INotebookEditorModelResolverService))], NotebookOutputEditorInput));
 
 export { NotebookOutputEditorInput };

package/vscode/src/vs/workbench/contrib/notebook/browser/replEditorAccessibleView.js

@@ -3,14 +3,14 @@ import { AccessibleViewType, AccessibleContentProvider, AccessibleViewProviderId
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
-import { isReplEditorControl } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
+import { isReplEditorControl } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
 import { IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
 import { getAllOutputsText } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/viewModel/cellOutputTextHelper';
 
 class ReplEditorAccessibleView {
     constructor() {
         this.priority = 100;
-        this.name = 'replEditorInput';
+        this.name = "replEditorInput";
         this.type = AccessibleViewType.View;
         this.when = ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( NOTEBOOK_CELL_LIST_FOCUSED.negate())));
     }
@@ -30,15 +30,13 @@ function getAccessibleOutputProvider(editorService) {
                 const cell = viewModel.viewCells[lastCellIndex];
                 const outputContent = getAllOutputsText(viewModel.notebookDocument, cell);
                 if (outputContent) {
-                    return ( new AccessibleContentProvider(
-                        AccessibleViewProviderId.Notebook,
-                        { type: AccessibleViewType.View },
-                        () => { return outputContent; },
-                        () => {
-                            editorControl.activeCodeEditor?.focus();
-                        },
-                        AccessibilityVerbositySettingId.ReplEditor
-                    ));
+                    return ( new AccessibleContentProvider(AccessibleViewProviderId.Notebook, {
+                        type: AccessibleViewType.View
+                    }, () => {
+                        return outputContent;
+                    }, () => {
+                        editorControl.activeCodeEditor?.focus();
+                    }, AccessibilityVerbositySettingId.ReplEditor));
                 }
             }
         }

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookCellStatusBarServiceImpl.js

@@ -26,14 +26,17 @@ class NotebookCellStatusBarService extends Disposable {
         });
     }
     async getStatusBarItemsForCell(docUri, cellIndex, viewType, token) {
-        const providers = this._providers.filter(p => p.viewType === viewType || p.viewType === '*');
-        return await Promise.all(( providers.map(async (p) => {
+        const providers = this._providers.filter(p => p.viewType === viewType || p.viewType === "*");
+        return await Promise.all(( providers.map(async p => {
             try {
-                return (await p.provideCellStatusBarItems(docUri, cellIndex, token)) ?? { items: [] };
-            }
-            catch (e) {
+                return (await p.provideCellStatusBarItems(docUri, cellIndex, token)) ?? {
+                    items: []
+                };
+            } catch (e) {
                 onUnexpectedExternalError(e);
-                return { items: [] };
+                return {
+                    items: []
+                };
             }
         })));
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookEditorServiceImpl.js

@@ -13,7 +13,7 @@ import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { MOST_RECENT_REPL_EDITOR, InteractiveWindowOpen } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
 import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
 import { IEditorProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
-import { NotebookDiffEditorInput } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/common/notebookDiffEditorInput';
+import { NotebookDiffEditorInput } from '../../common/notebookDiffEditorInput.js';
 
 let NotebookEditorWidgetService = class NotebookEditorWidgetService {
     constructor(editorGroupService, editorService, contextKeyService, instantiationService) {
@@ -28,17 +28,17 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         this.onDidAddNotebookEditor = this._onNotebookEditorAdd.event;
         this.onDidRemoveNotebookEditor = this._onNotebookEditorsRemove.event;
         this._borrowableEditors = ( new Map());
-        const onNewGroup = (group) => {
-            const { id } = group;
+        const onNewGroup = group => {
+            const {
+                id
+            } = group;
             const listeners = [];
             listeners.push(group.onDidCloseEditor(e => {
                 const widgetMap = this._borrowableEditors.get(group.id);
                 if (!widgetMap) {
                     return;
                 }
-                const inputs = e.editor instanceof NotebookEditorInput || e.editor instanceof NotebookDiffEditorInput
-                    ? [e.editor]
-                    : (isCompositeNotebookEditorInput(e.editor) ? e.editor.editorInputs : []);
+                const inputs = e.editor instanceof NotebookEditorInput || e.editor instanceof NotebookDiffEditorInput ? [e.editor] : (isCompositeNotebookEditorInput(e.editor) ? e.editor.editorInputs : []);
                 inputs.forEach(input => {
                     const widgets = widgetMap.get(input.resource);
                     const index = widgets?.findIndex(widget => widget.editorType === input.typeId);
@@ -91,8 +91,7 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
                 if (editorService.editors.find(editor => isCompositeNotebookEditorInput(editor))) {
                     interactiveWindowOpen.set(true);
                 }
-            }
-            else if (e.event.kind === GroupModelChangeKind.EDITOR_CLOSE && interactiveWindowOpen.get()) {
+            } else if (e.event.kind === GroupModelChangeKind.EDITOR_CLOSE && interactiveWindowOpen.get()) {
                 if (!editorService.editors.find(editor => isCompositeNotebookEditorInput(editor))) {
                     interactiveWindowOpen.set(false);
                 }
@@ -103,7 +102,7 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         this._disposables.dispose();
         this._onNotebookEditorAdd.dispose();
         this._onNotebookEditorsRemove.dispose();
-        this.groupListener.forEach((listeners) => {
+        this.groupListener.forEach(listeners => {
             listeners.forEach(listener => listener.dispose());
         });
         this.groupListener.clear();
@@ -131,7 +130,7 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         }
         const widget = this._borrowableEditors.get(sourceID)?.get(input.resource)?.find(widget => widget.editorType === input.typeId);
         if (!widget) {
-            throw ( new Error('no widget at source group'));
+            throw ( new Error("no widget at source group"));
         }
         const sourceWidgets = this._borrowableEditors.get(sourceID)?.get(input.resource);
         if (sourceWidgets) {
@@ -175,9 +174,21 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
             const editorGroupContextKeyService = accessor.get(IContextKeyService);
             const editorGroupEditorProgressService = accessor.get(IEditorProgressService);
             const widgetDisposeStore = ( new DisposableStore());
-            const widget = this.createWidget(editorGroupContextKeyService, widgetDisposeStore, editorGroupEditorProgressService, creationOptions, codeWindow, initialDimension);
+            const widget = this.createWidget(
+                editorGroupContextKeyService,
+                widgetDisposeStore,
+                editorGroupEditorProgressService,
+                creationOptions,
+                codeWindow,
+                initialDimension
+            );
             const token = this._tokenPool++;
-            value = { widget, editorType: input.typeId, token, disposableStore: widgetDisposeStore };
+            value = {
+                widget,
+                editorType: input.typeId,
+                token,
+                disposableStore: widgetDisposeStore
+            };
             let map = this._borrowableEditors.get(groupId);
             if (!map) {
                 map = ( new ResourceMap());
@@ -186,13 +197,19 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
             const values = map.get(input.resource) ?? [];
             values.push(value);
             map.set(input.resource, values);
-        }
-        else {
+        } else {
             value.token = this._tokenPool++;
         }
         return this._createBorrowValue(value.token, value);
     }
-    createWidget(editorGroupContextKeyService, widgetDisposeStore, editorGroupEditorProgressService, creationOptions, codeWindow, initialDimension) {
+    createWidget(
+        editorGroupContextKeyService,
+        widgetDisposeStore,
+        editorGroupEditorProgressService,
+        creationOptions,
+        codeWindow,
+        initialDimension
+    ) {
         const notebookInstantiationService = widgetDisposeStore.add(this.instantiationService.createChild(( new ServiceCollection(
             [IContextKeyService, editorGroupContextKeyService],
             [IEditorProgressService, editorGroupEditorProgressService]
@@ -200,7 +217,7 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         const ctorOptions = creationOptions ?? getDefaultNotebookCreationOptions();
         const widget = notebookInstantiationService.createInstance(NotebookEditorWidget, {
             ...ctorOptions,
-            codeWindow: codeWindow ?? ctorOptions.codeWindow,
+            codeWindow: codeWindow ?? ctorOptions.codeWindow
         }, initialDimension);
         return widget;
     }
@@ -244,11 +261,6 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         this._mostRecentRepl.set(uri);
     }
 };
-NotebookEditorWidgetService = ( __decorate([
-    ( __param(0, IEditorGroupsService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IInstantiationService))
-], NotebookEditorWidgetService));
+NotebookEditorWidgetService = ( __decorate([( __param(0, IEditorGroupsService)), ( __param(1, IEditorService)), ( __param(2, IContextKeyService)), ( __param(3, IInstantiationService))], NotebookEditorWidgetService));
 
 export { NotebookEditorWidgetService };