@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer.js

@@ -39,6 +39,7 @@ import { MarkupCell } from '../cellParts/markupCell.js';
 import { CellKind } from '../../../common/notebookCommon.js';
 import { INotebookExecutionStateService } from '../../../common/notebookExecutionStateService.service.js';
 var MarkupCellRenderer_1, CodeCellRenderer_1;
+const _moduleId = "vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer";
 const $ = $$1;
 let NotebookCellListDelegate = class NotebookCellListDelegate extends Disposable {
     constructor(targetWindow, configurationService) {
@@ -62,9 +63,9 @@ let NotebookCellListDelegate = class NotebookCellListDelegate extends Disposable
         }
     }
 };
-NotebookCellListDelegate = ( __decorate([
-    ( __param(1, IConfigurationService))
-], NotebookCellListDelegate));
+NotebookCellListDelegate = ( (__decorate([
+    ( (__param(1, IConfigurationService)))
+], NotebookCellListDelegate)));
 class AbstractCellRenderer {
     constructor(instantiationService, notebookEditor, contextMenuService, menuService, configurationService, keybindingService, notificationService, contextKeyServiceProvider, language, dndController) {
         this.instantiationService = instantiationService;
@@ -75,11 +76,11 @@ class AbstractCellRenderer {
         this.notificationService = notificationService;
         this.contextKeyServiceProvider = contextKeyServiceProvider;
         this.dndController = dndController;
-        this.editorOptions = ( new CellEditorOptions(
+        this.editorOptions = ( (new CellEditorOptions(
             this.notebookEditor.getBaseCellEditorOptions(language),
             this.notebookEditor.notebookOptions,
             configurationService
-        ));
+        )));
     }
     dispose() {
         this.editorOptions.dispose();
@@ -100,18 +101,18 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
     renderTemplate(rootContainer) {
         rootContainer.classList.add('markdown-cell-row');
         const container = append(rootContainer, $$1('.cell-inner-container'));
-        const templateDisposables = ( new DisposableStore());
+        const templateDisposables = ( (new DisposableStore()));
         const contextKeyService = templateDisposables.add(this.contextKeyServiceProvider(container));
         const decorationContainer = append(rootContainer, $('.cell-decoration'));
         const titleToolbarContainer = append(container, $('.cell-title-toolbar'));
-        const focusIndicatorTop = ( new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top'))));
-        const focusIndicatorLeft = ( new FastDomNode(
+        const focusIndicatorTop = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top')))));
+        const focusIndicatorLeft = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-left'))
-        ));
+        )));
         const foldingIndicator = append(focusIndicatorLeft.domNode, $$1('.notebook-folding-indicator'));
-        const focusIndicatorRight = ( new FastDomNode(
+        const focusIndicatorRight = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-right'))
-        ));
+        )));
         const codeInnerContent = append(container, $('.cell.code'));
         const editorPart = append(codeInnerContent, $('.cell-editor-part'));
         const cellChatPart = append(editorPart, $('.cell-chat-part'));
@@ -122,40 +123,38 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
         const cellCommentPartContainer = append(container, $('.cell-comment-container'));
         const innerContent = append(container, $('.cell.markdown'));
         const bottomCellContainer = append(container, $('.cell-bottom-toolbar-container'));
-        const scopedInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService])));
+        const scopedInstaService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, contextKeyService]))));
         const rootClassDelegate = {
             toggle: (className, force) => container.classList.toggle(className, force)
         };
         const titleToolbar = templateDisposables.add(scopedInstaService.createInstance(CellTitleToolbarPart, titleToolbarContainer, rootClassDelegate, this.notebookEditor.creationOptions.menuIds.cellTitleToolbar, this.notebookEditor.creationOptions.menuIds.cellDeleteToolbar, this.notebookEditor));
-        const focusIndicatorBottom = ( new FastDomNode(
-            append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom'))
-        ));
-        const cellParts = ( new CellPartsCollection(getWindow(rootContainer), [
+        const focusIndicatorBottom = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom')))));
+        const cellParts = ( (new CellPartsCollection(getWindow(rootContainer), [
             templateDisposables.add(scopedInstaService.createInstance(CellChatPart, this.notebookEditor, cellChatPart)),
             templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, undefined)),
-            templateDisposables.add(( new CellFocusIndicator(
+            templateDisposables.add(( (new CellFocusIndicator(
                 this.notebookEditor,
                 titleToolbar,
                 focusIndicatorTop,
                 focusIndicatorLeft,
                 focusIndicatorRight,
                 focusIndicatorBottom
-            ))),
-            templateDisposables.add(( new FoldedCellHint(
+            )))),
+            templateDisposables.add(( (new FoldedCellHint(
                 this.notebookEditor,
                 append(container, $('.notebook-folded-hint')),
                 this._notebookExecutionStateService
-            ))),
-            templateDisposables.add(( new CellDecorations(rootContainer, decorationContainer))),
+            )))),
+            templateDisposables.add(( (new CellDecorations(rootContainer, decorationContainer)))),
             templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)),
-            templateDisposables.add(( new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer))),
-            templateDisposables.add(( new CellFocusPart(container, undefined, this.notebookEditor))),
-            templateDisposables.add(( new CellDragAndDropPart(container))),
+            templateDisposables.add(( (new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer)))),
+            templateDisposables.add(( (new CellFocusPart(container, undefined, this.notebookEditor)))),
+            templateDisposables.add(( (new CellDragAndDropPart(container)))),
             templateDisposables.add(scopedInstaService.createInstance(CellContextKeyPart, this.notebookEditor)),
         ], [
             titleToolbar,
             templateDisposables.add(scopedInstaService.createInstance(BetweenCellToolbar, this.notebookEditor, titleToolbarContainer, bottomCellContainer))
-        ]));
+        ])));
         templateDisposables.add(cellParts);
         const templateData = {
             rootContainer,
@@ -167,7 +166,7 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
             editorContainer,
             foldingIndicator,
             templateDisposables,
-            elementDisposables: ( new DisposableStore()),
+            elementDisposables: ( (new DisposableStore())),
             cellParts,
             toJSON: () => { return {}; }
         };
@@ -175,7 +174,7 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
     }
     renderElement(element, index, templateData, height) {
         if (!this.notebookEditor.hasModel()) {
-            throw new Error('The notebook editor is not attached with view model yet.');
+            throw ( (new Error('The notebook editor is not attached with view model yet.')));
         }
         templateData.currentRenderedCell = element;
         templateData.currentEditor = undefined;
@@ -194,15 +193,15 @@ let MarkupCellRenderer = class MarkupCellRenderer extends AbstractCellRenderer {
         templateData.elementDisposables.clear();
     }
 };
-MarkupCellRenderer = MarkupCellRenderer_1 = ( __decorate([
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, INotificationService)),
-    ( __param(10, INotebookExecutionStateService))
-], MarkupCellRenderer));
+MarkupCellRenderer = MarkupCellRenderer_1 = ( (__decorate([
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IMenuService))),
+    ( (__param(8, IKeybindingService))),
+    ( (__param(9, INotificationService))),
+    ( (__param(10, INotebookExecutionStateService)))
+], MarkupCellRenderer)));
 let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
     static { CodeCellRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'code_cell'; }
@@ -216,30 +215,26 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
     renderTemplate(rootContainer) {
         rootContainer.classList.add('code-cell-row');
         const container = append(rootContainer, $$1('.cell-inner-container'));
-        const templateDisposables = ( new DisposableStore());
+        const templateDisposables = ( (new DisposableStore()));
         const contextKeyService = templateDisposables.add(this.contextKeyServiceProvider(container));
         const decorationContainer = append(rootContainer, $('.cell-decoration'));
-        const focusIndicatorTop = ( new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top'))));
+        const focusIndicatorTop = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-top')))));
         const titleToolbarContainer = append(container, $('.cell-title-toolbar'));
-        const focusIndicatorLeft = ( new FastDomNode(
+        const focusIndicatorLeft = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-left'))
-        ));
+        )));
         const cellChatPart = append(container, $('.cell-chat-part'));
         const cellContainer = append(container, $('.cell.code'));
         const runButtonContainer = append(cellContainer, $('.run-button-container'));
         const cellInputCollapsedContainer = append(cellContainer, $('.input-collapse-container'));
         cellInputCollapsedContainer.style.display = 'none';
         const executionOrderLabel = append(focusIndicatorLeft.domNode, $('div.execution-count-label'));
-        executionOrderLabel.title = ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer',
-            'cellExecutionOrderCountLabel',
-            'Execution Order'
-        ));
+        executionOrderLabel.title = ( localizeWithPath(_moduleId, 0, 'Execution Order'));
         const editorPart = append(cellContainer, $('.cell-editor-part'));
         const editorContainer = append(editorPart, $('.cell-editor-container'));
         const cellCommentPartContainer = append(container, $('.cell-comment-container'));
         const editorContextKeyService = templateDisposables.add(this.contextKeyServiceProvider(editorPart));
-        const editorInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, editorContextKeyService])));
+        const editorInstaService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, editorContextKeyService]))));
         EditorContextKeys.inCompositeEditor.bindTo(editorContextKeyService).set(true);
         const editor = editorInstaService.createInstance(CodeEditorWidget, editorContainer, {
             ...this.editorOptions.getDefaultValue(),
@@ -251,49 +246,47 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
             contributions: this.notebookEditor.creationOptions.cellEditorContributions
         });
         templateDisposables.add(editor);
-        const outputContainer = ( new FastDomNode(append(container, $('.output'))));
+        const outputContainer = ( (new FastDomNode(append(container, $('.output')))));
         const cellOutputCollapsedContainer = append(outputContainer.domNode, $('.output-collapse-container'));
-        const outputShowMoreContainer = ( new FastDomNode(append(container, $('.output-show-more-container'))));
-        const focusIndicatorRight = ( new FastDomNode(
+        const outputShowMoreContainer = ( (new FastDomNode(append(container, $('.output-show-more-container')))));
+        const focusIndicatorRight = ( (new FastDomNode(
             append(container, $$1('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-right'))
-        ));
+        )));
         const focusSinkElement = append(container, $('.cell-editor-focus-sink'));
         focusSinkElement.setAttribute('tabindex', '0');
         const bottomCellToolbarContainer = append(container, $('.cell-bottom-toolbar-container'));
-        const focusIndicatorBottom = ( new FastDomNode(
-            append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom'))
-        ));
-        const scopedInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService])));
+        const focusIndicatorBottom = ( (new FastDomNode(append(container, $('.cell-focus-indicator.cell-focus-indicator-bottom')))));
+        const scopedInstaService = this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, contextKeyService]))));
         const rootClassDelegate = {
             toggle: (className, force) => container.classList.toggle(className, force)
         };
         const titleToolbar = templateDisposables.add(scopedInstaService.createInstance(CellTitleToolbarPart, titleToolbarContainer, rootClassDelegate, this.notebookEditor.creationOptions.menuIds.cellTitleToolbar, this.notebookEditor.creationOptions.menuIds.cellDeleteToolbar, this.notebookEditor));
-        const focusIndicatorPart = templateDisposables.add(( new CellFocusIndicator(
+        const focusIndicatorPart = templateDisposables.add(( (new CellFocusIndicator(
             this.notebookEditor,
             titleToolbar,
             focusIndicatorTop,
             focusIndicatorLeft,
             focusIndicatorRight,
             focusIndicatorBottom
-        )));
-        const cellParts = ( new CellPartsCollection(getWindow(rootContainer), [
+        ))));
+        const cellParts = ( (new CellPartsCollection(getWindow(rootContainer), [
             focusIndicatorPart,
             templateDisposables.add(scopedInstaService.createInstance(CellChatPart, this.notebookEditor, cellChatPart)),
             templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, editor)),
             templateDisposables.add(scopedInstaService.createInstance(CellProgressBar, editorPart, cellInputCollapsedContainer)),
             templateDisposables.add(scopedInstaService.createInstance(RunToolbar, this.notebookEditor, contextKeyService, container, runButtonContainer)),
-            templateDisposables.add(( new CellDecorations(rootContainer, decorationContainer))),
+            templateDisposables.add(( (new CellDecorations(rootContainer, decorationContainer)))),
             templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)),
             templateDisposables.add(scopedInstaService.createInstance(CellExecutionPart, this.notebookEditor, executionOrderLabel)),
             templateDisposables.add(scopedInstaService.createInstance(CollapsedCellOutput, this.notebookEditor, cellOutputCollapsedContainer)),
-            templateDisposables.add(( new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer))),
-            templateDisposables.add(( new CellFocusPart(container, focusSinkElement, this.notebookEditor))),
-            templateDisposables.add(( new CellDragAndDropPart(container))),
+            templateDisposables.add(( (new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer)))),
+            templateDisposables.add(( (new CellFocusPart(container, focusSinkElement, this.notebookEditor)))),
+            templateDisposables.add(( (new CellDragAndDropPart(container)))),
             templateDisposables.add(scopedInstaService.createInstance(CellContextKeyPart, this.notebookEditor)),
         ], [
             titleToolbar,
             templateDisposables.add(scopedInstaService.createInstance(BetweenCellToolbar, this.notebookEditor, titleToolbarContainer, bottomCellToolbarContainer))
-        ]));
+        ])));
         templateDisposables.add(cellParts);
         const templateData = {
             rootContainer,
@@ -308,17 +301,17 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
             outputShowMoreContainer,
             editor,
             templateDisposables,
-            elementDisposables: ( new DisposableStore()),
+            elementDisposables: ( (new DisposableStore())),
             cellParts,
             toJSON: () => { return {}; }
         };
         const dragHandles = [focusIndicatorLeft.domNode, focusIndicatorPart.codeFocusIndicator.domNode, focusIndicatorPart.outputFocusIndicator.domNode];
-        this.dndController?.registerDragHandle(templateData, rootContainer, dragHandles, () => ( new CodeCellDragImageRenderer()).getDragImage(templateData, templateData.editor, 'code'));
+        this.dndController?.registerDragHandle(templateData, rootContainer, dragHandles, () => ( (new CodeCellDragImageRenderer())).getDragImage(templateData, templateData.editor, 'code'));
         return templateData;
     }
     renderElement(element, index, templateData, height) {
         if (!this.notebookEditor.hasModel()) {
-            throw new Error('The notebook editor is not attached with view model yet.');
+            throw ( (new Error('The notebook editor is not attached with view model yet.')));
         }
         templateData.currentRenderedCell = element;
         if (height === undefined) {
@@ -337,12 +330,12 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
         this.renderedEditors.delete(element);
     }
 };
-CodeCellRenderer = CodeCellRenderer_1 = ( __decorate([
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IMenuService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, INotificationService))
-], CodeCellRenderer));
+CodeCellRenderer = CodeCellRenderer_1 = ( (__decorate([
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IMenuService))),
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, IKeybindingService))),
+    ( (__param(9, INotificationService)))
+], CodeCellRenderer)));
 export { CodeCellRenderer, MarkupCellRenderer, NotebookCellListDelegate };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/renderers/webviewPreloads.js

@@ -1443,7 +1443,7 @@ async function webviewPreloads(ctx) {
                 await Promise.all(( dependantRenderers.map(async (d) => {
                     const renderer = renderers.getRenderer(d.id);
                     if (!renderer) {
-                        throw new Error(`Could not find extending renderer: ${d.id}`);
+                        throw ( new Error(`Could not find extending renderer: ${d.id}`));
                     }
                     try {
                         return await renderer.load();

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/baseCellViewModel.js

@@ -149,7 +149,7 @@ class BaseCellViewModel extends Disposable {
     }
     attachTextEditor(editor, estimatedHasHorizontalScrolling) {
         if (!editor.hasModel()) {
-            throw new Error('Invalid editor: model is missing');
+            throw ( new Error('Invalid editor: model is missing'));
         }
         if (this._textEditor === editor) {
             if (this._editorListeners.length === 0) {
@@ -462,7 +462,7 @@ class BaseCellViewModel extends Disposable {
                 return this.textModel;
             }
             if (!this._textModelRef) {
-                throw new Error(`Cannot resolve text model for ${this.uri}`);
+                throw ( new Error(`Cannot resolve text model for ${this.uri}`));
             }
             this._textModelRefChangeDisposable.value = this.textModel.onDidChangeContent(() => this.onDidChangeTextModelContent());
         }

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel.js

@@ -27,7 +27,7 @@ let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
         this.layoutChange({ editorHeight: true }, 'CodeCellViewModel#editorHeight');
     }
     get editorHeight() {
-        throw new Error('editorHeight is write-only');
+        throw ( new Error('editorHeight is write-only'));
     }
     set chatHeight(height) {
         if (this._chatHeight === height) {
@@ -384,7 +384,7 @@ let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
     }
     updateOutputHeight(index, height, source) {
         if (index >= this._outputCollection.length) {
-            throw new Error('Output index out of range!');
+            throw ( new Error('Output index out of range!'));
         }
         this._ensureOutputsTop();
         if (height < 28 && this._outputViewModels[index].hasMultiMimeType()) {
@@ -398,7 +398,7 @@ let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
     getOutputOffsetInContainer(index) {
         this._ensureOutputsTop();
         if (index >= this._outputCollection.length) {
-            throw new Error('Output index out of range!');
+            throw ( new Error('Output index out of range!'));
         }
         return this._outputsTop.getPrefixSum(index - 1);
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/markupCellViewModel.js

@@ -37,7 +37,7 @@ let MarkupCellViewModel = class MarkupCellViewModel extends BaseCellViewModel {
         this._updateTotalHeight(this._computeTotalHeight());
     }
     get editorHeight() {
-        throw new Error('MarkdownCellViewModel.editorHeight is write only');
+        throw ( new Error('MarkdownCellViewModel.editorHeight is write only'));
     }
     get foldingState() {
         return this.foldingDelegate.getFoldingState(this.foldingDelegate.getCellIndex(this));

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.js

@@ -3,6 +3,7 @@ import { localizeWithPath } from '../../../../../nls.js';
 import { getMarkdownHeadersInCell } from './foldingModel.js';
 import { OutlineEntry } from './OutlineEntry.js';
 import { CellKind } from '../../common/notebookCommon.js';
+const _moduleId = "vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory";
 class NotebookOutlineEntryFactory {
     constructor(executionStateService) {
         this.executionStateService = executionStateService;
@@ -17,7 +18,7 @@ class NotebookOutlineEntryFactory {
             const fullContent = cell.getText().substring(0, 10000);
             for (const { depth, text } of getMarkdownHeadersInCell(fullContent)) {
                 hasHeader = true;
-                entries.push(( new OutlineEntry(index++, depth, cell, text, false, false)));
+                entries.push(( (new OutlineEntry(index++, depth, cell, text, false, false))));
             }
             if (!hasHeader) {
                 const match = fullContent.match(/<h([1-6]).*>(.*)<\/h\1>/i);
@@ -25,7 +26,7 @@ class NotebookOutlineEntryFactory {
                     hasHeader = true;
                     const level = parseInt(match[1]);
                     const text = match[2].trim();
-                    entries.push(( new OutlineEntry(index++, level, cell, text, false, false)));
+                    entries.push(( (new OutlineEntry(index++, level, cell, text, false, false))));
                 }
             }
             if (!hasHeader) {
@@ -39,17 +40,17 @@ class NotebookOutlineEntryFactory {
                 const cachedEntries = this.cellOutlineEntryCache[cell.model.textModel.id];
                 if (cachedEntries) {
                     if (target === 1 ) {
-                        entries.push(( new OutlineEntry(
+                        entries.push(( (new OutlineEntry(
                             index++,
                             7,
                             cell,
                             preview,
                             !!exeState,
                             exeState ? exeState.isPaused : false
-                        )));
+                        ))));
                     }
                     cachedEntries.forEach((cached) => {
-                        entries.push(( new OutlineEntry(
+                        entries.push(( (new OutlineEntry(
                             index++,
                             cached.level,
                             cell,
@@ -58,26 +59,22 @@ class NotebookOutlineEntryFactory {
                             false,
                             cached.range,
                             cached.kind
-                        )));
+                        ))));
                     });
                 }
             }
             if (entries.length === 0) {
                 if (preview.length === 0) {
-                    preview = ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory',
-                        'empty',
-                        "empty cell"
-                    ));
+                    preview = ( localizeWithPath(_moduleId, 0, "empty cell"));
                 }
-                entries.push(( new OutlineEntry(
+                entries.push(( (new OutlineEntry(
                     index++,
                     7,
                     cell,
                     preview,
                     !!exeState,
                     exeState ? exeState.isPaused : false
-                )));
+                ))));
             }
         }
         return entries;

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookViewModelImpl.js

@@ -23,7 +23,7 @@ import { NotebookMetadataChangedEvent } from '../notebookViewEvents.js';
 import { CellFindMatchModel } from '../contrib/find/findModel.js';
 import { NotebookExecutionType } from '../../common/notebookExecutionStateService.js';
 import { INotebookExecutionStateService } from '../../common/notebookExecutionStateService.service.js';
-const invalidFunc = () => { throw new Error(`Invalid change accessor`); };
+const invalidFunc = () => { throw ( new Error(`Invalid change accessor`)); };
 class DecorationsTree {
     constructor() {
         this._decorationsTree = ( new IntervalTree());
@@ -76,7 +76,7 @@ let NotebookViewModel = class NotebookViewModel extends Disposable {
         return this._viewCells;
     }
     set viewCells(_) {
-        throw new Error('NotebookViewModel.viewCells is readonly');
+        throw ( new Error('NotebookViewModel.viewCells is readonly'));
     }
     get length() {
         return this._viewCells.length;