@codingame/monaco-vscode-notebook-service-override 8.0.4 → 9.0.2

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

@@ -27,7 +27,7 @@ const NotebookPreloadContribution = ( (Object.freeze({
     localResourceRoots: 'localResourceRoots',
 })));
 const notebookProviderContribution = {
-    description: ( localize(7841, 'Contributes notebook document provider.')),
+    description: ( localize(7632, 'Contributes notebook document provider.')),
     type: 'array',
     defaultSnippets: [{ body: [{ type: '', displayName: '', 'selector': [{ 'filenamePattern': '' }] }] }],
     items: {
@@ -40,25 +40,25 @@ const notebookProviderContribution = {
         properties: {
             [NotebookEditorContribution.type]: {
                 type: 'string',
-                description: ( localize(7842, 'Type of the notebook.')),
+                description: ( localize(7633, 'Type of the notebook.')),
             },
             [NotebookEditorContribution.displayName]: {
                 type: 'string',
-                description: ( localize(7843, 'Human readable name of the notebook.')),
+                description: ( localize(7634, 'Human readable name of the notebook.')),
             },
             [NotebookEditorContribution.selector]: {
                 type: 'array',
-                description: ( localize(7844, 'Set of globs that the notebook is for.')),
+                description: ( localize(7635, 'Set of globs that the notebook is for.')),
                 items: {
                     type: 'object',
                     properties: {
                         filenamePattern: {
                             type: 'string',
-                            description: ( localize(7845, 'Glob that the notebook is enabled for.')),
+                            description: ( localize(7636, 'Glob that the notebook is enabled for.')),
                         },
                         excludeFileNamePattern: {
                             type: 'string',
-                            description: ( localize(7846, 'Glob that the notebook is disabled for.'))
+                            description: ( localize(7637, 'Glob that the notebook is disabled for.'))
                         }
                     }
                 }
@@ -66,7 +66,7 @@ const notebookProviderContribution = {
             [NotebookEditorContribution.priority]: {
                 type: 'string',
                 markdownDeprecationMessage: ( localize(
-                    7847,
+                    7638,
                     'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
                 )),
                 enum: [
@@ -75,11 +75,11 @@ const notebookProviderContribution = {
                 ],
                 markdownEnumDescriptions: [
                     ( localize(
-                        7848,
+                        7639,
                         'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
                     )),
                     ( localize(
-                        7849,
+                        7640,
                         'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
                     )),
                 ],
@@ -90,7 +90,7 @@ const notebookProviderContribution = {
 };
 const defaultRendererSnippet = ( (Object.freeze({ id: '', displayName: '', mimeTypes: [''], entrypoint: '' })));
 const notebookRendererContribution = {
-    description: ( localize(7850, 'Contributes notebook output renderer provider.')),
+    description: ( localize(7641, 'Contributes notebook output renderer provider.')),
     type: 'array',
     defaultSnippets: [{ body: [defaultRendererSnippet] }],
     items: {
@@ -105,18 +105,18 @@ const notebookRendererContribution = {
                 properties: {
                     [NotebookRendererContribution.id]: {
                         type: 'string',
-                        description: ( localize(7851, 'Unique identifier of the notebook output renderer.')),
+                        description: ( localize(7642, 'Unique identifier of the notebook output renderer.')),
                     },
                     [NotebookRendererContribution.displayName]: {
                         type: 'string',
-                        description: ( localize(7852, 'Human readable name of the notebook output renderer.')),
+                        description: ( localize(7643, 'Human readable name of the notebook output renderer.')),
                     },
                     [NotebookRendererContribution.hardDependencies]: {
                         type: 'array',
                         uniqueItems: true,
                         items: { type: 'string' },
                         markdownDescription: ( localize(
-                            7853,
+                            7644,
                             'List of kernel dependencies the renderer requires. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer can be used.'
                         )),
                     },
@@ -125,7 +125,7 @@ const notebookRendererContribution = {
                         uniqueItems: true,
                         items: { type: 'string' },
                         markdownDescription: ( localize(
-                            7854,
+                            7645,
                             'List of soft kernel dependencies the renderer can make use of. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer will be preferred over renderers that don\'t interact with the kernel.'
                         )),
                     },
@@ -138,17 +138,17 @@ const notebookRendererContribution = {
                         ],
                         enumDescriptions: [
                             ( localize(
-                                7855,
+                                7646,
                                 'Messaging is required. The renderer will only be used when it\'s part of an extension that can be run in an extension host.'
                             )),
                             ( localize(
-                                7856,
+                                7647,
                                 'The renderer is better with messaging available, but it\'s not requried.'
                             )),
-                            ( localize(7857, 'The renderer does not require messaging.')),
+                            ( localize(7648, 'The renderer does not require messaging.')),
                         ],
                         description: ( localize(
-                            7858,
+                            7649,
                             'Defines how and if the renderer needs to communicate with an extension host, via `createRendererMessaging`. Renderers with stronger messaging requirements may not work in all environments.'
                         )),
                     },
@@ -164,13 +164,13 @@ const notebookRendererContribution = {
                         properties: {
                             [NotebookRendererContribution.mimeTypes]: {
                                 type: 'array',
-                                description: ( localize(7859, 'Set of globs that the notebook is for.')),
+                                description: ( localize(7650, 'Set of globs that the notebook is for.')),
                                 items: {
                                     type: 'string'
                                 }
                             },
                             [NotebookRendererContribution.entrypoint]: {
-                                description: ( localize(7860, 'File to load in the webview to render the extension.')),
+                                description: ( localize(7651, 'File to load in the webview to render the extension.')),
                                 type: 'string',
                             },
                         }
@@ -181,17 +181,17 @@ const notebookRendererContribution = {
                         ],
                         properties: {
                             [NotebookRendererContribution.entrypoint]: {
-                                description: ( localize(7860, 'File to load in the webview to render the extension.')),
+                                description: ( localize(7651, 'File to load in the webview to render the extension.')),
                                 type: 'object',
                                 required: ['extends', 'path'],
                                 properties: {
                                     extends: {
                                         type: 'string',
-                                        description: ( localize(7861, 'Existing renderer that this one extends.')),
+                                        description: ( localize(7652, 'Existing renderer that this one extends.')),
                                     },
                                     path: {
                                         type: 'string',
-                                        description: ( localize(7860, 'File to load in the webview to render the extension.')),
+                                        description: ( localize(7651, 'File to load in the webview to render the extension.')),
                                     },
                                 }
                             },
@@ -203,7 +203,7 @@ const notebookRendererContribution = {
     }
 };
 const notebookPreloadContribution = {
-    description: ( localize(7862, 'Contributes notebook preloads.')),
+    description: ( localize(7653, 'Contributes notebook preloads.')),
     type: 'array',
     defaultSnippets: [{ body: [{ type: '', entrypoint: '' }] }],
     items: {
@@ -215,17 +215,17 @@ const notebookPreloadContribution = {
         properties: {
             [NotebookPreloadContribution.type]: {
                 type: 'string',
-                description: ( localize(7863, 'Type of the notebook.')),
+                description: ( localize(7654, 'Type of the notebook.')),
             },
             [NotebookPreloadContribution.entrypoint]: {
                 type: 'string',
-                description: ( localize(7864, 'Path to file loaded in the webview.')),
+                description: ( localize(7655, 'Path to file loaded in the webview.')),
             },
             [NotebookPreloadContribution.localResourceRoots]: {
                 type: 'array',
                 items: { type: 'string' },
                 description: ( localize(
-                    7865,
+                    7656,
                     'Paths to additional resources that should be allowed in the webview.'
                 )),
             },
@@ -272,8 +272,8 @@ class NotebooksDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localize(7866, "ID")),
-            ( localize(7867, "Name")),
+            ( localize(7657, "ID")),
+            ( localize(7658, "Name")),
         ];
         const rows = ( (contrib
             .sort((a, b) => a.type.localeCompare(b.type))
@@ -306,8 +306,8 @@ class NotebookRenderersDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localize(7868, "Name")),
-            ( localize(7869, "Mimetypes")),
+            ( localize(7659, "Name")),
+            ( localize(7660, "Mimetypes")),
         ];
         const rows = ( (contrib
             .sort((a, b) => a.displayName.localeCompare(b.displayName))
@@ -328,7 +328,7 @@ class NotebookRenderersDataRenderer extends Disposable {
 }
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'notebooks',
-    label: ( localize(7870, "Notebooks")),
+    label: ( localize(7661, "Notebooks")),
     access: {
         canToggle: false
     },
@@ -336,7 +336,7 @@ class NotebookRenderersDataRenderer extends Disposable {
 });
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'notebookRenderer',
-    label: ( localize(7871, "Notebook Renderers")),
+    label: ( localize(7662, "Notebook Renderers")),
     access: {
         canToggle: false
     },

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

@@ -4,7 +4,7 @@ import { getDefaultNotebookCreationOptions, NotebookEditorWidget } from 'vscode/
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { NotebookEditorInput, isCompositeNotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { NotebookEditorInput, isCompositeNotebookEditorInput, isNotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { GroupModelChangeKind } from 'vscode/vscode/vs/workbench/common/editor';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -20,34 +20,35 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         this._tokenPool = 1;
         this._disposables = ( new DisposableStore());
         this._notebookEditors = ( new Map());
+        this.groupListener = ( new Map());
         this._onNotebookEditorAdd = ( new Emitter());
         this._onNotebookEditorsRemove = ( new Emitter());
         this.onDidAddNotebookEditor = this._onNotebookEditorAdd.event;
         this.onDidRemoveNotebookEditor = this._onNotebookEditorsRemove.event;
         this._borrowableEditors = ( new Map());
-        const groupListener = ( new Map());
         const onNewGroup = (group) => {
             const { id } = group;
             const listeners = [];
             listeners.push(group.onDidCloseEditor(e => {
-                const widgets = this._borrowableEditors.get(group.id);
-                if (!widgets) {
+                const widgetMap = this._borrowableEditors.get(group.id);
+                if (!widgetMap) {
                     return;
                 }
                 const inputs = e.editor instanceof NotebookEditorInput ? [e.editor] : (isCompositeNotebookEditorInput(e.editor) ? e.editor.editorInputs : []);
                 inputs.forEach(input => {
-                    const value = widgets.get(input.resource);
-                    if (!value) {
+                    const widgets = widgetMap.get(input.resource);
+                    const index = widgets?.findIndex(widget => widget.editorType === input.typeId);
+                    if (!widgets || index === undefined || index === -1) {
                         return;
                     }
+                    const value = widgets.splice(index, 1)[0];
                     value.token = undefined;
                     this._disposeWidget(value.widget);
-                    widgets.delete(input.resource);
                     value.widget = undefined;
                 });
             }));
             listeners.push(group.onWillMoveEditor(e => {
-                if (e.editor instanceof NotebookEditorInput) {
+                if (isNotebookEditorInput(e.editor)) {
                     this._allowWidgetMove(e.editor, e.groupId, e.target);
                 }
                 if (isCompositeNotebookEditorInput(e.editor)) {
@@ -56,22 +57,24 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
                     });
                 }
             }));
-            groupListener.set(id, listeners);
+            this.groupListener.set(id, listeners);
         };
         this._disposables.add(editorGroupService.onDidAddGroup(onNewGroup));
         editorGroupService.whenReady.then(() => editorGroupService.groups.forEach(onNewGroup));
         this._disposables.add(editorGroupService.onDidRemoveGroup(group => {
-            const listeners = groupListener.get(group.id);
+            const listeners = this.groupListener.get(group.id);
             if (listeners) {
                 listeners.forEach(listener => listener.dispose());
-                groupListener.delete(group.id);
+                this.groupListener.delete(group.id);
             }
             const widgets = this._borrowableEditors.get(group.id);
             this._borrowableEditors.delete(group.id);
             if (widgets) {
-                for (const value of ( widgets.values())) {
-                    value.token = undefined;
-                    this._disposeWidget(value.widget);
+                for (const values of ( widgets.values())) {
+                    for (const value of values) {
+                        value.token = undefined;
+                        this._disposeWidget(value.widget);
+                    }
                 }
             }
         }));
@@ -93,6 +96,10 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         this._disposables.dispose();
         this._onNotebookEditorAdd.dispose();
         this._onNotebookEditorsRemove.dispose();
+        this.groupListener.forEach((listeners) => {
+            listeners.forEach(listener => listener.dispose());
+        });
+        this.groupListener.clear();
     }
     _disposeWidget(widget) {
         widget.onWillHide();
@@ -106,27 +113,35 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         if (sourcePart.windowId !== targetPart.windowId) {
             return;
         }
-        const targetWidget = this._borrowableEditors.get(targetID)?.get(input.resource);
-        if (targetWidget) {
+        const target = this._borrowableEditors.get(targetID)?.get(input.resource)?.findIndex(widget => widget.editorType === input.typeId);
+        if (target !== undefined && target !== -1) {
             return;
         }
-        const widget = this._borrowableEditors.get(sourceID)?.get(input.resource);
+        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'));
         }
-        this._borrowableEditors.get(sourceID)?.delete(input.resource);
+        const sourceWidgets = this._borrowableEditors.get(sourceID)?.get(input.resource);
+        if (sourceWidgets) {
+            const indexToRemove = sourceWidgets.findIndex(widget => widget.editorType === input.typeId);
+            if (indexToRemove !== -1) {
+                sourceWidgets.splice(indexToRemove, 1);
+            }
+        }
         let targetMap = this._borrowableEditors.get(targetID);
         if (!targetMap) {
             targetMap = ( new ResourceMap());
             this._borrowableEditors.set(targetID, targetMap);
         }
-        targetMap.set(input.resource, widget);
+        const widgetsAtTarget = targetMap.get(input.resource) ?? [];
+        widgetsAtTarget?.push(widget);
+        targetMap.set(input.resource, widgetsAtTarget);
     }
     retrieveExistingWidgetFromURI(resource) {
         for (const widgetInfo of ( this._borrowableEditors.values())) {
-            const widget = widgetInfo.get(resource);
-            if (widget) {
-                return this._createBorrowValue(widget.token, widget);
+            const widgets = widgetInfo.get(resource);
+            if (widgets && widgets.length > 0) {
+                return this._createBorrowValue(widgets[0].token, widgets[0]);
             }
         }
         return undefined;
@@ -134,40 +149,48 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
     retrieveAllExistingWidgets() {
         const ret = [];
         for (const widgetInfo of ( this._borrowableEditors.values())) {
-            for (const widget of ( widgetInfo.values())) {
-                ret.push(this._createBorrowValue(widget.token, widget));
+            for (const widgets of ( widgetInfo.values())) {
+                for (const widget of widgets) {
+                    ret.push(this._createBorrowValue(widget.token, widget));
+                }
             }
         }
         return ret;
     }
-    retrieveWidget(accessor, group, input, creationOptions, initialDimension, codeWindow) {
-        let value = this._borrowableEditors.get(group.id)?.get(input.resource);
+    retrieveWidget(accessor, groupId, input, creationOptions, initialDimension, codeWindow) {
+        let value = this._borrowableEditors.get(groupId)?.get(input.resource)?.find(widget => widget.editorType === input.typeId);
         if (!value) {
             const editorGroupContextKeyService = accessor.get(IContextKeyService);
             const editorGroupEditorProgressService = accessor.get(IEditorProgressService);
-            const notebookInstantiationService = this.instantiationService.createChild(( new ServiceCollection(
-                [IContextKeyService, editorGroupContextKeyService],
-                [IEditorProgressService, editorGroupEditorProgressService]
-            )));
-            const ctorOptions = creationOptions ?? getDefaultNotebookCreationOptions();
-            const widget = notebookInstantiationService.createInstance(NotebookEditorWidget, {
-                ...ctorOptions,
-                codeWindow: codeWindow ?? ctorOptions.codeWindow,
-            }, initialDimension);
+            const widget = this.createWidget(editorGroupContextKeyService, editorGroupEditorProgressService, creationOptions, codeWindow, initialDimension);
             const token = this._tokenPool++;
-            value = { widget, token };
-            let map = this._borrowableEditors.get(group.id);
+            value = { widget, editorType: input.typeId, token };
+            let map = this._borrowableEditors.get(groupId);
             if (!map) {
                 map = ( new ResourceMap());
-                this._borrowableEditors.set(group.id, map);
+                this._borrowableEditors.set(groupId, map);
             }
-            map.set(input.resource, value);
+            const values = map.get(input.resource) ?? [];
+            values.push(value);
+            map.set(input.resource, values);
         }
         else {
             value.token = this._tokenPool++;
         }
         return this._createBorrowValue(value.token, value);
     }
+    createWidget(editorGroupContextKeyService, editorGroupEditorProgressService, creationOptions, codeWindow, initialDimension) {
+        const notebookInstantiationService = this.instantiationService.createChild(( new ServiceCollection(
+            [IContextKeyService, editorGroupContextKeyService],
+            [IEditorProgressService, editorGroupEditorProgressService]
+        )));
+        const ctorOptions = creationOptions ?? getDefaultNotebookCreationOptions();
+        const widget = notebookInstantiationService.createInstance(NotebookEditorWidget, {
+            ...ctorOptions,
+            codeWindow: codeWindow ?? ctorOptions.codeWindow,
+        }, initialDimension);
+        return widget;
+    }
     _createBorrowValue(myToken, widget) {
         return {
             get value() {

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

@@ -2,12 +2,12 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localize } from 'vscode/vscode/vs/nls';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { KernelPickerMRUStrategy } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewParts/notebookKernelQuickPickStrategy';
 import { CellKind, NotebookCellExecutionState } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
 import { INotebookKernelService, INotebookKernelHistoryService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
+import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
 
 let NotebookExecutionService = class NotebookExecutionService {
     constructor(_commandService, _notebookKernelService, _notebookKernelHistoryService, _workspaceTrustRequestService, _logService, _notebookExecutionStateService) {
@@ -25,8 +25,8 @@ let NotebookExecutionService = class NotebookExecutionService {
         if (!cellsArr.length) {
             return;
         }
-        this._logService.debug(`NotebookExecutionService#executeNotebookCells ${JSON.stringify(( (cellsArr.map(c => c.handle))))}`);
-        const message = ( localize(3301, "Executing a notebook cell will run code from this workspace."));
+        this._logService.debug(`Execution`, `${JSON.stringify(( (cellsArr.map(c => c.handle))))}`);
+        const message = ( localize(3259, "Executing a notebook cell will run code from this workspace."));
         const trust = await this._workspaceTrustRequestService.requestWorkspaceTrust({ message });
         if (!trust) {
             return;
@@ -60,14 +60,15 @@ let NotebookExecutionService = class NotebookExecutionService {
             await kernel.executeNotebookCellsRequest(notebook.uri, ( (validCellExecutions.map(c => c.cellHandle))));
             const unconfirmed = validCellExecutions.filter(exe => exe.state === NotebookCellExecutionState.Unconfirmed);
             if (unconfirmed.length) {
-                this._logService.debug(`NotebookExecutionService#executeNotebookCells completing unconfirmed executions ${JSON.stringify(( (unconfirmed.map(exe => exe.cellHandle))))}`);
+                this._logService.debug(`Execution`, `Completing unconfirmed executions ${JSON.stringify(( (unconfirmed.map(exe => exe.cellHandle))))}`);
                 unconfirmed.forEach(exe => exe.complete({}));
             }
+            this._logService.debug(`Execution`, `Completed executions ${JSON.stringify(( (validCellExecutions.map(exe => exe.cellHandle))))}`);
         }
     }
     async cancelNotebookCellHandles(notebook, cells) {
         const cellsArr = Array.from(cells);
-        this._logService.debug(`NotebookExecutionService#cancelNotebookCellHandles ${JSON.stringify(cellsArr)}`);
+        this._logService.debug(`Execution`, `CancelNotebookCellHandles ${JSON.stringify(cellsArr)}`);
         const kernel = this._notebookKernelService.getSelectedOrSuggestedKernel(notebook);
         if (kernel) {
             await kernel.cancelNotebookCellExecution(notebook.uri, cellsArr);
@@ -95,7 +96,7 @@ NotebookExecutionService = ( (__decorate([
     ( (__param(1, INotebookKernelService))),
     ( (__param(2, INotebookKernelHistoryService))),
     ( (__param(3, IWorkspaceTrustRequestService))),
-    ( (__param(4, ILogService))),
+    ( (__param(4, INotebookLoggingService))),
     ( (__param(5, INotebookExecutionStateService)))
 ], NotebookExecutionService)));
 

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

@@ -113,7 +113,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.clearNotebookKernelsMRUCache',
-            title: ( localize2(3305, "Clear Notebook Kernels MRU Cache")),
+            title: ( localize2(3263, "Clear Notebook Kernels MRU Cache")),
             category: Categories.Developer,
             f1: true
         });

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

@@ -74,14 +74,14 @@ let NotebookKeymapService = class NotebookKeymapService extends Disposable {
             }
         };
         this.notificationService.prompt(Severity$1.Info, ( localize(
-            3302,
+            3260,
             "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
             ( (distinct(( (oldKeymaps.map(k => k.local.manifest.displayName)))).map(name => `'${name}'`))).join(', ')
         )), [{
-                label: ( localize(3303, "Yes")),
+                label: ( localize(3261, "Yes")),
                 run: () => onPrompt(true)
             }, {
-                label: ( localize(3304, "No")),
+                label: ( localize(3262, "No")),
                 run: () => onPrompt(false)
             }]);
     }

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

@@ -8,7 +8,7 @@ let NotebookLoggingService = class NotebookLoggingService extends Disposable {
     static { this.ID = 'notebook'; }
     constructor(loggerService) {
         super();
-        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localize(3306, "Notebook rendering")) }));
+        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localize(3264, "Notebook")) }));
     }
     debug(category, output) {
         this._logger.debug(`[${category}] ${output}`);
@@ -16,6 +16,12 @@ let NotebookLoggingService = class NotebookLoggingService extends Disposable {
     info(category, output) {
         this._logger.info(`[${category}] ${output}`);
     }
+    warn(category, output) {
+        this._logger.warn(`[${category}] ${output}`);
+    }
+    error(category, output) {
+        this._logger.error(`[${category}] ${output}`);
+    }
 };
 NotebookLoggingService = ( (__decorate([
     ( (__param(0, ILoggerService)))

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

@@ -19,7 +19,7 @@ import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/c
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
 import { notebooksExtensionPoint, notebookRendererExtensionPoint, notebookPreloadExtensionPoint } from '../notebookExtensionPoint.js';
-import { NotebookDiffEditorInput } from '../../common/notebookDiffEditorInput.js';
+import { NotebookDiffEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookDiffEditorInput';
 import { NotebookTextModel } from '../../common/model/notebookTextModel.js';
 import { NotebookEditorPriority, NotebookSetting, CellUri, NotebookRendererMatch, RENDERER_EQUIVALENT_EXTENSIONS, RENDERER_NOT_AVAILABLE, MimeTypeDisplayOrder, ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, NOTEBOOK_DISPLAY_ORDER } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
@@ -35,6 +35,8 @@ import { InstallRecommendedExtensionAction } from 'vscode/vscode/vs/workbench/co
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { INotebookDocumentService } from 'vscode/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service';
 import { MergeEditorInput } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
+import { streamToBuffer, VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { NotebookMultiDiffEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditorInput';
 
 var NotebookProviderInfoStore_1, NotebookService_1;
 let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposable {
@@ -166,7 +168,11 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
                 });
                 return { editor: NotebookEditorInput.getOrCreate(this._instantiationService, ref.object.resource, undefined, notebookProviderInfo.id), options };
             };
-            const notebookDiffEditorInputFactory = ({ modified, original, label, description }) => {
+            const notebookDiffEditorInputFactory = (diffEditorInput, group) => {
+                const { modified, original, label, description } = diffEditorInput;
+                if (this._configurationService.getValue('notebook.experimental.enableNewDiffEditor')) {
+                    return { editor: NotebookMultiDiffEditorInput.create(this._instantiationService, modified.resource, label, description, original.resource, notebookProviderInfo.id) };
+                }
                 return { editor: NotebookDiffEditorInput.create(this._instantiationService, modified.resource, label, description, original.resource, notebookProviderInfo.id) };
             };
             const mergeEditorInputFactory = (mergeEditor) => {
@@ -548,7 +554,7 @@ let NotebookService = class NotebookService extends Disposable {
             const knownProvider = this.getViewTypeProvider(viewType);
             const actions = knownProvider ? [
                 toAction({
-                    id: 'workbench.notebook.action.installMissingViewType', label: ( localize(3300, "Install extension for '{0}'", viewType)), run: async () => {
+                    id: 'workbench.notebook.action.installMissingViewType', label: ( localize(3258, "Install extension for '{0}'", viewType)), run: async () => {
                         await this._instantiationService.createInstance(InstallRecommendedExtensionAction, knownProvider).run();
                     }
                 })
@@ -598,17 +604,23 @@ let NotebookService = class NotebookService extends Disposable {
             }
         }
     }
-    createNotebookTextModel(viewType, uri, data, transientOptions) {
+    async createNotebookTextModel(viewType, uri, stream) {
         if (( (this._models.has(uri)))) {
             throw ( (new Error(`notebook for ${uri} already exists`)));
         }
-        const notebookModel = this._instantiationService.createInstance(NotebookTextModel, viewType, uri, data.cells, data.metadata, transientOptions);
+        const info = await this.withNotebookDataProvider(viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            throw ( (new Error('CANNOT open file notebook with this provider')));
+        }
+        const bytes = stream ? await streamToBuffer(stream) : VSBuffer.fromByteArray([]);
+        const data = await info.serializer.dataToNotebook(bytes);
+        const notebookModel = this._instantiationService.createInstance(NotebookTextModel, info.viewType, uri, data.cells, data.metadata, info.serializer.options);
         const modelData = ( (new ModelData(notebookModel, this._onWillDisposeDocument.bind(this))));
         this._models.set(uri, modelData);
         this._notebookDocumentService.addNotebookDocument(modelData);
         this._onWillAddNotebookDocument.fire(notebookModel);
         this._onDidAddNotebookDocument.fire(notebookModel);
-        this._postDocumentOpenActivation(viewType);
+        this._postDocumentOpenActivation(info.viewType);
         return notebookModel;
     }
     getNotebookTextModel(uri) {