@codingame/monaco-vscode-notebook-service-override 11.1.2 → 12.0.0

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { toAction } from 'vscode/vscode/vs/base/common/actions';
 import { createErrorWithActions } from 'vscode/vscode/vs/base/common/errorMessage';
@@ -15,27 +16,29 @@ import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/c
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { Memento } from '@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/common/memento';
 import { notebooksExtensionPoint, notebookRendererExtensionPoint, notebookPreloadExtensionPoint } from '../notebookExtensionPoint.js';
-import { NotebookDiffEditorInput } from '@codingame/monaco-vscode-chat-notebook-common/vscode/vs/workbench/contrib/notebook/common/notebookDiffEditorInput';
+import { NotebookDiffEditorInput } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/common/notebookDiffEditorInput';
 import { NotebookTextModel } from '../../common/model/notebookTextModel.js';
-import { NotebookEditorPriority, NotebookSetting, CellUri, 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';
+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 '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
 import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
 import { NotebookOutputRendererInfo, NotebookStaticPreloadInfo } from '../../common/notebookOutputRenderer.js';
 import { NotebookProviderInfo } from '../../common/notebookProvider.js';
-import { SimpleNotebookProviderInfo } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { SimpleNotebookProviderInfo } from '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookService';
 import { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
 import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService.service';
 import { isProposedApiEnabled } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { InstallRecommendedExtensionAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+import { InstallRecommendedExtensionAction } from '@codingame/monaco-vscode-47923ab1-c4c8-58b5-89ac-fa1b998eb5dd-common/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
 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 '@codingame/monaco-vscode-chat-notebook-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditorInput';
+import { MergeEditorInput } from '@codingame/monaco-vscode-8ccb7637-50ea-5359-97bf-00015d7fe567-common/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
+import { streamToBuffer, VSBuffer, bufferToStream } from 'vscode/vscode/vs/base/common/buffer';
+import { NotebookMultiDiffEditorInput } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditorInput';
+import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
 
 var NotebookProviderInfoStore_1, NotebookService_1;
 let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposable {
@@ -52,13 +55,13 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
         this._notebookEditorModelResolverService = _notebookEditorModelResolverService;
         this.uriIdentService = uriIdentService;
         this._handled = false;
-        this._contributedEditors = ( (new Map()));
-        this._contributedEditorDisposables = this._register(( (new DisposableStore())));
-        this._memento = ( (new Memento(NotebookProviderInfoStore_1.CUSTOM_EDITORS_STORAGE_ID, storageService)));
-        const mementoObject = this._memento.getMemento(0 , 1 );
+        this._contributedEditors = ( new Map());
+        this._contributedEditorDisposables = this._register(( new DisposableStore()));
+        this._memento = ( new Memento(NotebookProviderInfoStore_1.CUSTOM_EDITORS_STORAGE_ID, storageService));
+        const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
         this._editorResolverService.bufferChangeEvents(() => {
             for (const info of (mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] || [])) {
-                this.add(( (new NotebookProviderInfo(info))), false);
+                this.add(( new NotebookProviderInfo(info)), false);
             }
         });
         this._register(extensionService.onDidRegisterExtensions(() => {
@@ -76,9 +79,9 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
     }
     _setupHandler(extensions) {
         this._handled = true;
-        const builtins = [...( (this._contributedEditors.values()))].filter(info => !info.extension);
+        const builtins = [...( this._contributedEditors.values())].filter(info => !info.extension);
         this._clear();
-        const builtinProvidersFromCache = ( (new Map()));
+        const builtinProvidersFromCache = ( new Map());
         builtins.forEach(builtin => {
             builtinProvidersFromCache.set(builtin.id, this.add(builtin));
         });
@@ -98,22 +101,22 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
                         continue;
                     }
                 }
-                this.add(( (new NotebookProviderInfo({
+                this.add(( new NotebookProviderInfo({
                     extension: extension.description.identifier,
                     id: notebookContribution.type,
                     displayName: notebookContribution.displayName,
                     selectors: notebookContribution.selector || [],
                     priority: this._convertPriority(notebookContribution.priority),
                     providerDisplayName: extension.description.displayName ?? extension.description.identifier.value,
-                }))));
+                })));
             }
         }
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._contributedEditors.values())));
+        const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
+        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
         this._memento.saveMemento();
     }
     clearEditorCache() {
-        const mementoObject = this._memento.getMemento(0 , 1 );
+        const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
         mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = [];
         this._memento.saveMemento();
     }
@@ -127,7 +130,7 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
         return RegisteredEditorPriority.option;
     }
     _registerContributionPoint(notebookProviderInfo) {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         for (const selector of notebookProviderInfo.selectors) {
             const globPattern = selector.include || selector;
             const notebookEditorInfo = {
@@ -236,8 +239,8 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
         return this._contributedEditors.get(viewType);
     }
     add(info, saveMemento = true) {
-        if (( (this._contributedEditors.has(info.id)))) {
-            throw ( (new Error(`notebook type '${info.id}' ALREADY EXISTS`)));
+        if (( this._contributedEditors.has(info.id))) {
+            throw ( new Error(`notebook type '${info.id}' ALREADY EXISTS`));
         }
         this._contributedEditors.set(info.id, info);
         let editorRegistration;
@@ -246,13 +249,13 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
             this._contributedEditorDisposables.add(editorRegistration);
         }
         if (saveMemento) {
-            const mementoObject = this._memento.getMemento(0 , 1 );
-            mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._contributedEditors.values())));
+            const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
+            mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
             this._memento.saveMemento();
         }
         return this._register(toDisposable(() => {
-            const mementoObject = this._memento.getMemento(0 , 1 );
-            mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._contributedEditors.values())));
+            const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
+            mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
             this._memento.saveMemento();
             editorRegistration?.dispose();
             this._contributedEditors.delete(info.id);
@@ -260,40 +263,38 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
     }
     getContributedNotebook(resource) {
         const result = [];
-        for (const info of ( (this._contributedEditors.values()))) {
+        for (const info of ( this._contributedEditors.values())) {
             if (info.matches(resource)) {
                 result.push(info);
             }
         }
         if (result.length === 0 && resource.scheme === Schemas.untitled) {
-            return Array.from(( (this._contributedEditors.values())));
+            return Array.from(( this._contributedEditors.values()));
         }
         return result;
     }
     [Symbol.iterator]() {
-        return (
-             (this._contributedEditors.values())
-        );
+        return ( this._contributedEditors.values());
     }
 };
-NotebookProviderInfoStore = NotebookProviderInfoStore_1 = ( (__decorate([
-    ( (__param(0, IStorageService))),
-    ( (__param(1, IExtensionService))),
-    ( (__param(2, IEditorResolverService))),
-    ( (__param(3, IConfigurationService))),
-    ( (__param(4, IAccessibilityService))),
-    ( (__param(5, IInstantiationService))),
-    ( (__param(6, IFileService))),
-    ( (__param(7, INotebookEditorModelResolverService))),
-    ( (__param(8, IUriIdentityService)))
-], NotebookProviderInfoStore)));
+NotebookProviderInfoStore = NotebookProviderInfoStore_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IEditorResolverService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IAccessibilityService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IFileService)),
+    ( __param(7, INotebookEditorModelResolverService)),
+    ( __param(8, IUriIdentityService))
+], NotebookProviderInfoStore));
 let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
     constructor(storageService) {
-        this.contributedRenderers = ( (new Map()));
-        this.preferredMimetype = ( (new Lazy(
-            () => this.preferredMimetypeMemento.getMemento(1 , 1 )
-        )));
-        this.preferredMimetypeMemento = ( (new Memento('workbench.editor.notebook.preferredRenderer2', storageService)));
+        this.contributedRenderers = ( new Map());
+        this.preferredMimetype = ( new Lazy(
+            () => this.preferredMimetypeMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE)
+        ));
+        this.preferredMimetypeMemento = ( new Memento('workbench.editor.notebook.preferredRenderer2', storageService));
     }
     clear() {
         this.contributedRenderers.clear();
@@ -302,10 +303,10 @@ let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
         return this.contributedRenderers.get(rendererId);
     }
     getAll() {
-        return Array.from(( (this.contributedRenderers.values())));
+        return Array.from(( this.contributedRenderers.values()));
     }
     add(info) {
-        if (( (this.contributedRenderers.has(info.id)))) {
+        if (( this.contributedRenderers.has(info.id))) {
             return;
         }
         this.contributedRenderers.set(info.id, info);
@@ -322,44 +323,49 @@ let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
         this.preferredMimetypeMemento.saveMemento();
     }
     findBestRenderers(notebookProviderInfo, mimeType, kernelProvides) {
+        let ReuseOrder;
+        (function (ReuseOrder) {
+            ReuseOrder[ReuseOrder["PreviouslySelected"] = 256] = "PreviouslySelected";
+            ReuseOrder[ReuseOrder["SameExtensionAsNotebook"] = 512] = "SameExtensionAsNotebook";
+            ReuseOrder[ReuseOrder["OtherRenderer"] = 768] = "OtherRenderer";
+            ReuseOrder[ReuseOrder["BuiltIn"] = 1024] = "BuiltIn";
+        })(ReuseOrder || (ReuseOrder = {}));
         const preferred = notebookProviderInfo && this.preferredMimetype.value[notebookProviderInfo.id]?.[mimeType];
         const notebookExtId = notebookProviderInfo?.extension?.value;
         const notebookId = notebookProviderInfo?.id;
-        const renderers = ( (Array.from(( (this.contributedRenderers.values())))
+        const renderers = ( Array.from(( this.contributedRenderers.values()))
             .map(renderer => {
             const ownScore = kernelProvides === undefined
                 ? renderer.matchesWithoutKernel(mimeType)
                 : renderer.matches(mimeType, kernelProvides);
-            if (ownScore === 3 ) {
+            if (ownScore === NotebookRendererMatch.Never) {
                 return undefined;
             }
             const rendererExtId = renderer.extensionId.value;
             const reuseScore = preferred === renderer.id
-                ? 256
+                ? ReuseOrder.PreviouslySelected
                 : rendererExtId === notebookExtId || RENDERER_EQUIVALENT_EXTENSIONS.get(rendererExtId)?.has(notebookId)
-                    ? 512
-                    : renderer.isBuiltin ? 1024  : 768 ;
+                    ? ReuseOrder.SameExtensionAsNotebook
+                    : renderer.isBuiltin ? ReuseOrder.BuiltIn : ReuseOrder.OtherRenderer;
             return {
                 ordered: { mimeType, rendererId: renderer.id, isTrusted: true },
                 score: reuseScore | ownScore,
             };
-        }))).filter(isDefined);
+        })).filter(isDefined);
         if (renderers.length === 0) {
             return [{ mimeType, rendererId: RENDERER_NOT_AVAILABLE, isTrusted: true }];
         }
-        return (
-             (renderers.sort((a, b) => a.score - b.score).map(r => r.ordered))
-        );
+        return ( renderers.sort((a, b) => a.score - b.score).map(r => r.ordered));
     }
 };
-NotebookOutputRendererInfoStore = ( (__decorate([
-    ( (__param(0, IStorageService)))
-], NotebookOutputRendererInfoStore)));
+NotebookOutputRendererInfoStore = ( __decorate([
+    ( __param(0, IStorageService))
+], NotebookOutputRendererInfoStore));
 class ModelData {
     get uri() { return this.model.uri; }
     constructor(model, onWillDispose) {
         this.model = model;
-        this._modelEventListeners = ( (new DisposableStore()));
+        this._modelEventListeners = ( new DisposableStore());
         this._modelEventListeners.add(model.onWillDispose(() => onWillDispose(model)));
     }
     getCellIndex(cellUri) {
@@ -386,26 +392,26 @@ let NotebookService = class NotebookService extends Disposable {
         this._instantiationService = _instantiationService;
         this._storageService = _storageService;
         this._notebookDocumentService = _notebookDocumentService;
-        this._notebookProviders = ( (new Map()));
+        this._notebookProviders = ( new Map());
         this._notebookProviderInfoStore = undefined;
         this._notebookRenderersInfoStore = this._instantiationService.createInstance(NotebookOutputRendererInfoStore);
-        this._onDidChangeOutputRenderers = this._register(( (new Emitter())));
+        this._onDidChangeOutputRenderers = this._register(( new Emitter()));
         this.onDidChangeOutputRenderers = this._onDidChangeOutputRenderers.event;
-        this._notebookStaticPreloadInfoStore = ( (new Set()));
-        this._models = ( (new ResourceMap()));
-        this._onWillAddNotebookDocument = this._register(( (new Emitter())));
-        this._onDidAddNotebookDocument = this._register(( (new Emitter())));
-        this._onWillRemoveNotebookDocument = this._register(( (new Emitter())));
-        this._onDidRemoveNotebookDocument = this._register(( (new Emitter())));
+        this._notebookStaticPreloadInfoStore = ( new Set());
+        this._models = ( new ResourceMap());
+        this._onWillAddNotebookDocument = this._register(( new Emitter()));
+        this._onDidAddNotebookDocument = this._register(( new Emitter()));
+        this._onWillRemoveNotebookDocument = this._register(( new Emitter()));
+        this._onDidRemoveNotebookDocument = this._register(( new Emitter()));
         this.onWillAddNotebookDocument = this._onWillAddNotebookDocument.event;
         this.onDidAddNotebookDocument = this._onDidAddNotebookDocument.event;
         this.onDidRemoveNotebookDocument = this._onDidRemoveNotebookDocument.event;
         this.onWillRemoveNotebookDocument = this._onWillRemoveNotebookDocument.event;
-        this._onAddViewType = this._register(( (new Emitter())));
+        this._onAddViewType = this._register(( new Emitter()));
         this.onAddViewType = this._onAddViewType.event;
-        this._onWillRemoveViewType = this._register(( (new Emitter())));
+        this._onWillRemoveViewType = this._register(( new Emitter()));
         this.onWillRemoveViewType = this._onWillRemoveViewType.event;
-        this._onDidChangeEditorTypes = this._register(( (new Emitter())));
+        this._onDidChangeEditorTypes = this._register(( new Emitter()));
         this.onDidChangeEditorTypes = this._onDidChangeEditorTypes.event;
         this._lastClipboardIsCopy = true;
         notebookRendererExtensionPoint.setHandler((renderers) => {
@@ -421,7 +427,7 @@ let NotebookService = class NotebookService extends Disposable {
                         extension.collector.error(`Notebook renderer does not specify id-property`);
                         continue;
                     }
-                    this._notebookRenderersInfoStore.add(( (new NotebookOutputRendererInfo({
+                    this._notebookRenderersInfoStore.add(( new NotebookOutputRendererInfo({
                         id,
                         extension: extension.description,
                         entrypoint: notebookContribution.entrypoint,
@@ -430,7 +436,7 @@ let NotebookService = class NotebookService extends Disposable {
                         dependencies: notebookContribution.dependencies,
                         optionalDependencies: notebookContribution.optionalDependencies,
                         requiresMessaging: notebookContribution.requiresMessaging,
-                    }))));
+                    })));
                 }
             }
             this._onDidChangeOutputRenderers.fire();
@@ -451,22 +457,22 @@ let NotebookService = class NotebookService extends Disposable {
                         extension.collector.error(`Notebook preload does not specify type-property`);
                         continue;
                     }
-                    this._notebookStaticPreloadInfoStore.add(( (new NotebookStaticPreloadInfo({
+                    this._notebookStaticPreloadInfoStore.add(( new NotebookStaticPreloadInfo({
                         type,
                         extension: extension.description,
                         entrypoint: notebookContribution.entrypoint,
                         localResourceRoots: notebookContribution.localResourceRoots ?? [],
-                    }))));
+                    })));
                 }
             }
         });
         const updateOrder = () => {
-            this._displayOrder = ( (new MimeTypeDisplayOrder(
+            this._displayOrder = ( new MimeTypeDisplayOrder(
                 this._configurationService.getValue(NotebookSetting.displayOrder) || [],
                 this._accessibilityService.isScreenReaderOptimized()
                     ? ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER
                     : NOTEBOOK_DISPLAY_ORDER
-            )));
+            ));
         };
         updateOrder();
         this._register(this._configurationService.onDidChangeConfiguration(e => {
@@ -477,17 +483,15 @@ let NotebookService = class NotebookService extends Disposable {
         this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
             updateOrder();
         }));
-        this._memento = ( (new Memento(NotebookService_1._storageNotebookViewTypeProvider, this._storageService)));
-        this._viewTypeCache = this._memento.getMemento(1 , 1 );
+        this._memento = ( new Memento(NotebookService_1._storageNotebookViewTypeProvider, this._storageService));
+        this._viewTypeCache = this._memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
     }
     getEditorTypes() {
-        return (
-             ([...this.notebookProviderInfoStore].map(info => ({
-                id: info.id,
-                displayName: info.displayName,
-                providerDisplayName: info.providerDisplayName
-            })))
-        );
+        return ( [...this.notebookProviderInfoStore].map(info => ({
+            id: info.id,
+            displayName: info.displayName,
+            providerDisplayName: info.providerDisplayName
+        })));
     }
     clearEditorCache() {
         this.notebookProviderInfoStore.clearEditorCache();
@@ -497,24 +501,22 @@ let NotebookService = class NotebookService extends Disposable {
         this._extensionService.activateByEvent(`onNotebook:*`);
     }
     async canResolve(viewType) {
-        if (( (this._notebookProviders.has(viewType)))) {
+        if (( this._notebookProviders.has(viewType))) {
             return true;
         }
         await this._extensionService.whenInstalledExtensionsRegistered();
         await this._extensionService.activateByEvent(`onNotebookSerializer:${viewType}`);
-        return (
-             (this._notebookProviders.has(viewType))
-        );
+        return ( this._notebookProviders.has(viewType));
     }
     registerContributedNotebookType(viewType, data) {
-        const info = ( (new NotebookProviderInfo({
+        const info = ( new NotebookProviderInfo({
             extension: data.extension,
             id: viewType,
             displayName: data.displayName,
             providerDisplayName: data.providerDisplayName,
             priority: data.priority || RegisteredEditorPriority.default,
             selectors: []
-        })));
+        }));
         info.update({ selectors: data.filenamePattern });
         const reg = this.notebookProviderInfoStore.add(info);
         this._onDidChangeEditorTypes.fire();
@@ -524,8 +526,8 @@ let NotebookService = class NotebookService extends Disposable {
         });
     }
     _registerProviderData(viewType, data) {
-        if (( (this._notebookProviders.has(viewType)))) {
-            throw ( (new Error(`notebook provider for viewtype '${viewType}' already exists`)));
+        if (( this._notebookProviders.has(viewType))) {
+            throw ( new Error(`notebook provider for viewtype '${viewType}' already exists`));
         }
         this._notebookProviders.set(viewType, data);
         this._onAddViewType.fire(viewType);
@@ -538,7 +540,7 @@ let NotebookService = class NotebookService extends Disposable {
         this.notebookProviderInfoStore.get(viewType)?.update({ options: serializer.options });
         this._viewTypeCache[viewType] = extensionData.id.value;
         this._persistMementos();
-        return this._registerProviderData(viewType, ( (new SimpleNotebookProviderInfo(viewType, serializer, extensionData))));
+        return this._registerProviderData(viewType, ( new SimpleNotebookProviderInfo(viewType, serializer, extensionData)));
     }
     async withNotebookDataProvider(viewType) {
         const selected = this.notebookProviderInfoStore.get(viewType);
@@ -546,7 +548,7 @@ let NotebookService = class NotebookService extends Disposable {
             const knownProvider = this.getViewTypeProvider(viewType);
             const actions = knownProvider ? [
                 toAction({
-                    id: 'workbench.notebook.action.installMissingViewType', label: ( localize(3292, "Install extension for '{0}'", viewType)), run: async () => {
+                    id: 'workbench.notebook.action.installMissingViewType', label: ( localize(7748, "Install extension for '{0}'", viewType)), run: async () => {
                         await this._instantiationService.createInstance(InstallRecommendedExtensionAction, knownProvider).run();
                     }
                 })
@@ -556,7 +558,7 @@ let NotebookService = class NotebookService extends Disposable {
         await this.canResolve(selected.id);
         const result = this._notebookProviders.get(selected.id);
         if (!result) {
-            throw ( (new Error(`NO provider registered for view type: '${selected.id}'`)));
+            throw ( new Error(`NO provider registered for view type: '${selected.id}'`));
         }
         return result;
     }
@@ -597,17 +599,17 @@ let NotebookService = class NotebookService extends Disposable {
         }
     }
     async createNotebookTextModel(viewType, uri, stream) {
-        if (( (this._models.has(uri)))) {
-            throw ( (new Error(`notebook for ${uri} already exists`)));
+        if (( this._models.has(uri))) {
+            throw ( new Error(`notebook for ${uri} already exists`));
         }
         const info = await this.withNotebookDataProvider(viewType);
         if (!(info instanceof SimpleNotebookProviderInfo)) {
-            throw ( (new Error('CANNOT open file notebook with this provider')));
+            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))));
+        const modelData = ( new ModelData(notebookModel, this._onWillDisposeDocument.bind(this)));
         this._models.set(uri, modelData);
         this._notebookDocumentService.addNotebookDocument(modelData);
         this._onWillAddNotebookDocument.fire(notebookModel);
@@ -615,18 +617,51 @@ let NotebookService = class NotebookService extends Disposable {
         this._postDocumentOpenActivation(info.viewType);
         return notebookModel;
     }
+    async createNotebookTextDocumentSnapshot(uri, context, token) {
+        const model = this.getNotebookTextModel(uri);
+        if (!model) {
+            throw ( new Error(`notebook for ${uri} doesn't exist`));
+        }
+        const info = await this.withNotebookDataProvider(model.viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            throw ( new Error('CANNOT open file notebook with this provider'));
+        }
+        const serializer = info.serializer;
+        const outputSizeLimit = this._configurationService.getValue(NotebookSetting.outputBackupSizeLimit) * 1024;
+        const data = model.createSnapshot({ context: context, outputSizeLimit: outputSizeLimit, transientOptions: serializer.options });
+        const indentAmount = model.metadata.indentAmount;
+        if (typeof indentAmount === 'string' && indentAmount) {
+            data.metadata.indentAmount = indentAmount;
+        }
+        const bytes = await serializer.notebookToData(data);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        return bufferToStream(bytes);
+    }
+    async restoreNotebookTextModelFromSnapshot(uri, viewType, snapshot) {
+        const model = this.getNotebookTextModel(uri);
+        if (!model) {
+            throw ( new Error(`notebook for ${uri} doesn't exist`));
+        }
+        const info = await this.withNotebookDataProvider(model.viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            throw ( new Error('CANNOT open file notebook with this provider'));
+        }
+        const serializer = info.serializer;
+        const bytes = await streamToBuffer(snapshot);
+        const data = await info.serializer.dataToNotebook(bytes);
+        model.restoreSnapshot(data, serializer.options);
+        return model;
+    }
     getNotebookTextModel(uri) {
         return this._models.get(uri)?.model;
     }
     getNotebookTextModels() {
-        return (
-             (Iterable.map( (this._models.values()), data => data.model))
-        );
+        return ( Iterable.map(( this._models.values()), data => data.model));
     }
     listNotebookDocuments() {
-        return (
-             ([...this._models].map(e => e[1].model))
-        );
+        return ( [...this._models].map(e => e[1].model));
     }
     _onWillDisposeDocument(model) {
         const modelData = this._models.get(model.uri);
@@ -639,7 +674,7 @@ let NotebookService = class NotebookService extends Disposable {
         }
     }
     getOutputMimeTypeInfo(textModel, kernelProvides, output) {
-        const sorted = this._displayOrder.sort(( (new Set( (output.outputs.map(op => op.mime))))));
+        const sorted = this._displayOrder.sort(( new Set(( output.outputs.map(op => op.mime)))));
         const notebookProviderInfo = this.notebookProviderInfoStore.get(textModel.viewType);
         return sorted
             .flatMap(mimeType => this._notebookRenderersInfoStore.findBestRenderers(notebookProviderInfo, mimeType, kernelProvides))
@@ -651,6 +686,14 @@ let NotebookService = class NotebookService extends Disposable {
         }
         return [...this.notebookProviderInfoStore];
     }
+    hasSupportedNotebooks(resource) {
+        const contribution = this.notebookProviderInfoStore.getContributedNotebook(resource);
+        if (!contribution.length) {
+            return false;
+        }
+        return ( contribution.some(info => info.matches(resource) &&
+            (info.priority === RegisteredEditorPriority.default || info.priority === RegisteredEditorPriority.exclusive)));
+    }
     getContributedNotebookType(viewType) {
         return this.notebookProviderInfoStore.get(viewType);
     }
@@ -674,13 +717,13 @@ let NotebookService = class NotebookService extends Disposable {
         return undefined;
     }
 };
-NotebookService = NotebookService_1 = ( (__decorate([
-    ( (__param(0, IExtensionService))),
-    ( (__param(1, IConfigurationService))),
-    ( (__param(2, IAccessibilityService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IStorageService))),
-    ( (__param(5, INotebookDocumentService)))
-], NotebookService)));
+NotebookService = NotebookService_1 = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IAccessibilityService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, INotebookDocumentService))
+], NotebookService));
 
 export { NotebookOutputRendererInfoStore, NotebookProviderInfoStore, NotebookService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.d.ts

@@ -0,0 +1,14 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { INotebookDiffResult } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { INotebookService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { INotebookEditorWorkerService } from "vscode/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+export declare class NotebookEditorWorkerServiceImpl extends Disposable implements INotebookEditorWorkerService {
+    readonly _serviceBrand: undefined;
+    private readonly _workerManager;
+    constructor(notebookService: INotebookService, modelService: IModelService);
+    canComputeDiff(original: URI, modified: URI): boolean;
+    computeDiff(original: URI, modified: URI): Promise<INotebookDiffResult>;
+    canPromptRecommendation(model: URI): Promise<boolean>;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable, DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { createWebWorker } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
 import { CellUri, NotebookCellsChangeType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';

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

@@ -0,0 +1,21 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IOutlineModelService } from "vscode/vscode/vs/editor/contrib/documentSymbols/browser/outlineModel";
+import { ICellViewModel } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { OutlineEntry } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/viewModel/OutlineEntry";
+import { INotebookExecutionStateService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service";
+import { ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { INotebookOutlineEntryFactory } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.service";
+export declare enum NotebookOutlineConstants {
+    NonHeaderOutlineLevel = 7
+}
+export declare class NotebookOutlineEntryFactory implements INotebookOutlineEntryFactory {
+    private readonly executionStateService;
+    private readonly outlineModelService;
+    private readonly textModelService;
+    readonly _serviceBrand: undefined;
+    private cellOutlineEntryCache;
+    private readonly cachedMarkdownOutlineEntries;
+    constructor(executionStateService: INotebookExecutionStateService, outlineModelService: IOutlineModelService, textModelService: ITextModelService);
+    getOutlineEntries(cell: ICellViewModel, index: number): OutlineEntry[];
+    cacheSymbols(cell: ICellViewModel, cancelToken: CancellationToken): Promise<void>;
+}