@codingame/monaco-vscode-notebook-service-override 4.0.0 → 4.1.0

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

@@ -1,641 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { toAction } from 'vscode/vscode/vs/base/common/actions';
-import { createErrorWithActions } from 'vscode/vscode/vs/base/common/errorMessage';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
-import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { isDefined } from 'vscode/vscode/vs/base/common/types';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
-import { notebooksExtensionPoint, notebookRendererExtensionPoint, notebookPreloadExtensionPoint } from '../notebookExtensionPoint.js';
-import { NotebookDiffEditorInput } from '../../common/notebookDiffEditorInput.js';
-import { NotebookTextModel } from '../../common/model/notebookTextModel.js';
-import { NotebookEditorPriority, NotebookSetting, RENDERER_NOT_AVAILABLE, RENDERER_EQUIVALENT_EXTENSIONS, MimeTypeDisplayOrder, ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, NOTEBOOK_DISPLAY_ORDER, CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
-import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
-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 { RegisteredEditorPriority, IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
-import { isProposedApiEnabled, IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { InstallRecommendedExtensionAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { INotebookDocumentService } from 'vscode/vscode/vs/workbench/services/notebook/common/notebookDocumentService';
-
-var NotebookProviderInfoStore_1, NotebookService_1;
-let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposable {
-    static { NotebookProviderInfoStore_1 = this; }
-    static { this.CUSTOM_EDITORS_STORAGE_ID = 'notebookEditors'; }
-    static { this.CUSTOM_EDITORS_ENTRY_ID = 'editors'; }
-    constructor(storageService, extensionService, _editorResolverService, _configurationService, _accessibilityService, _instantiationService, _fileService, _notebookEditorModelResolverService, uriIdentService) {
-        super();
-        this._editorResolverService = _editorResolverService;
-        this._configurationService = _configurationService;
-        this._accessibilityService = _accessibilityService;
-        this._instantiationService = _instantiationService;
-        this._fileService = _fileService;
-        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._editorResolverService.bufferChangeEvents(() => {
-            for (const info of (mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] || [])) {
-                this.add(( new NotebookProviderInfo(info)));
-            }
-        });
-        this._register(extensionService.onDidRegisterExtensions(() => {
-            if (!this._handled) {
-                this._clear();
-                mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = [];
-                this._memento.saveMemento();
-            }
-        }));
-        notebooksExtensionPoint.setHandler(extensions => this._setupHandler(extensions));
-    }
-    dispose() {
-        this._clear();
-        super.dispose();
-    }
-    _setupHandler(extensions) {
-        this._handled = true;
-        const builtins = [...( this._contributedEditors.values())].filter(info => !info.extension);
-        this._clear();
-        const builtinProvidersFromCache = ( new Map());
-        builtins.forEach(builtin => {
-            builtinProvidersFromCache.set(builtin.id, this.add(builtin));
-        });
-        for (const extension of extensions) {
-            for (const notebookContribution of extension.value) {
-                if (!notebookContribution.type) {
-                    extension.collector.error(`Notebook does not specify type-property`);
-                    continue;
-                }
-                const existing = this.get(notebookContribution.type);
-                if (existing) {
-                    if (!existing.extension && extension.description.isBuiltin && builtins.find(builtin => builtin.id === notebookContribution.type)) {
-                        builtinProvidersFromCache.get(notebookContribution.type)?.dispose();
-                    }
-                    else {
-                        extension.collector.error(`Notebook type '${notebookContribution.type}' already used`);
-                        continue;
-                    }
-                }
-                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,
-                    exclusive: false
-                })));
-            }
-        }
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
-        this._memento.saveMemento();
-    }
-    clearEditorCache() {
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = [];
-        this._memento.saveMemento();
-    }
-    _convertPriority(priority) {
-        if (!priority) {
-            return RegisteredEditorPriority.default;
-        }
-        if (priority === NotebookEditorPriority.default) {
-            return RegisteredEditorPriority.default;
-        }
-        return RegisteredEditorPriority.option;
-    }
-    _registerContributionPoint(notebookProviderInfo) {
-        const disposables = ( new DisposableStore());
-        for (const selector of notebookProviderInfo.selectors) {
-            const globPattern = selector.include || selector;
-            const notebookEditorInfo = {
-                id: notebookProviderInfo.id,
-                label: notebookProviderInfo.displayName,
-                detail: notebookProviderInfo.providerDisplayName,
-                priority: notebookProviderInfo.exclusive ? RegisteredEditorPriority.exclusive : notebookProviderInfo.priority,
-            };
-            const notebookEditorOptions = {
-                canHandleDiff: () => !!this._configurationService.getValue(NotebookSetting.textDiffEditorPreview) && !this._accessibilityService.isScreenReaderOptimized(),
-                canSupportResource: (resource) => resource.scheme === Schemas.untitled || resource.scheme === Schemas.vscodeNotebookCell || this._fileService.hasProvider(resource)
-            };
-            const notebookEditorInputFactory = ({ resource, options }) => {
-                const data = CellUri.parse(resource);
-                let notebookUri;
-                let cellOptions;
-                let preferredResource = resource;
-                if (data) {
-                    notebookUri = this.uriIdentService.asCanonicalUri(data.notebook);
-                    preferredResource = data.notebook;
-                    cellOptions = { resource, options };
-                }
-                else {
-                    notebookUri = this.uriIdentService.asCanonicalUri(resource);
-                }
-                if (!cellOptions) {
-                    cellOptions = options?.cellOptions;
-                }
-                const notebookOptions = { ...options, cellOptions };
-                const editor = NotebookEditorInput.getOrCreate(this._instantiationService, notebookUri, preferredResource, notebookProviderInfo.id);
-                return { editor, options: notebookOptions };
-            };
-            const notebookUntitledEditorFactory = async ({ resource, options }) => {
-                const ref = await this._notebookEditorModelResolverService.resolve({ untitledResource: resource }, notebookProviderInfo.id);
-                ref.object.notebook.onWillDispose(() => {
-                    ref.dispose();
-                });
-                return { editor: NotebookEditorInput.getOrCreate(this._instantiationService, ref.object.resource, undefined, notebookProviderInfo.id), options };
-            };
-            const notebookDiffEditorInputFactory = ({ modified, original, label, description }) => {
-                return { editor: NotebookDiffEditorInput.create(this._instantiationService, modified.resource, label, description, original.resource, notebookProviderInfo.id) };
-            };
-            const notebookFactoryObject = {
-                createEditorInput: notebookEditorInputFactory,
-                createDiffEditorInput: notebookDiffEditorInputFactory,
-                createUntitledEditorInput: notebookUntitledEditorFactory,
-            };
-            const notebookCellFactoryObject = {
-                createEditorInput: notebookEditorInputFactory,
-                createDiffEditorInput: notebookDiffEditorInputFactory,
-            };
-            disposables.add(this._configurationService.onDidChangeConfiguration(e => {
-                if (e.affectsConfiguration(NotebookSetting.textDiffEditorPreview)) {
-                    const canHandleDiff = !!this._configurationService.getValue(NotebookSetting.textDiffEditorPreview) && !this._accessibilityService.isScreenReaderOptimized();
-                    if (canHandleDiff) {
-                        notebookFactoryObject.createDiffEditorInput = notebookDiffEditorInputFactory;
-                        notebookCellFactoryObject.createDiffEditorInput = notebookDiffEditorInputFactory;
-                    }
-                    else {
-                        notebookFactoryObject.createDiffEditorInput = undefined;
-                        notebookCellFactoryObject.createDiffEditorInput = undefined;
-                    }
-                }
-            }));
-            disposables.add(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
-                const canHandleDiff = !!this._configurationService.getValue(NotebookSetting.textDiffEditorPreview) && !this._accessibilityService.isScreenReaderOptimized();
-                if (canHandleDiff) {
-                    notebookFactoryObject.createDiffEditorInput = notebookDiffEditorInputFactory;
-                    notebookCellFactoryObject.createDiffEditorInput = notebookDiffEditorInputFactory;
-                }
-                else {
-                    notebookFactoryObject.createDiffEditorInput = undefined;
-                    notebookCellFactoryObject.createDiffEditorInput = undefined;
-                }
-            }));
-            disposables.add(this._editorResolverService.registerEditor(globPattern, notebookEditorInfo, notebookEditorOptions, notebookFactoryObject));
-            disposables.add(this._editorResolverService.registerEditor(`${Schemas.vscodeNotebookCell}:/**/${globPattern}`, { ...notebookEditorInfo, priority: RegisteredEditorPriority.exclusive }, notebookEditorOptions, notebookCellFactoryObject));
-        }
-        return disposables;
-    }
-    _clear() {
-        this._contributedEditors.clear();
-        this._contributedEditorDisposables.clear();
-    }
-    get(viewType) {
-        return this._contributedEditors.get(viewType);
-    }
-    add(info) {
-        if (( this._contributedEditors.has(info.id))) {
-            throw new Error(`notebook type '${info.id}' ALREADY EXISTS`);
-        }
-        this._contributedEditors.set(info.id, info);
-        let editorRegistration;
-        if (info.extension) {
-            editorRegistration = this._registerContributionPoint(info);
-            this._contributedEditorDisposables.add(editorRegistration);
-        }
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        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()));
-            this._memento.saveMemento();
-            editorRegistration?.dispose();
-            this._contributedEditors.delete(info.id);
-        }));
-    }
-    getContributedNotebook(resource) {
-        const result = [];
-        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 result;
-    }
-    [Symbol.iterator]() {
-        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));
-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));
-    }
-    clear() {
-        this.contributedRenderers.clear();
-    }
-    get(rendererId) {
-        return this.contributedRenderers.get(rendererId);
-    }
-    getAll() {
-        return Array.from(( this.contributedRenderers.values()));
-    }
-    add(info) {
-        if (( this.contributedRenderers.has(info.id))) {
-            return;
-        }
-        this.contributedRenderers.set(info.id, info);
-    }
-    setPreferred(notebookProviderInfo, mimeType, rendererId) {
-        const mementoObj = this.preferredMimetype.value;
-        const forNotebook = mementoObj[notebookProviderInfo.id];
-        if (forNotebook) {
-            forNotebook[mimeType] = rendererId;
-        }
-        else {
-            mementoObj[notebookProviderInfo.id] = { [mimeType]: rendererId };
-        }
-        this.preferredMimetypeMemento.saveMemento();
-    }
-    findBestRenderers(notebookProviderInfo, mimeType, kernelProvides) {
-        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()))
-            .map(renderer => {
-            const ownScore = kernelProvides === undefined
-                ? renderer.matchesWithoutKernel(mimeType)
-                : renderer.matches(mimeType, kernelProvides);
-            if (ownScore === 3 ) {
-                return undefined;
-            }
-            const rendererExtId = renderer.extensionId.value;
-            const reuseScore = preferred === renderer.id
-                ? 256
-                : rendererExtId === notebookExtId || RENDERER_EQUIVALENT_EXTENSIONS.get(rendererExtId)?.has(notebookId)
-                    ? 512
-                    : renderer.isBuiltin ? 1024  : 768 ;
-            return {
-                ordered: { mimeType, rendererId: renderer.id, isTrusted: true },
-                score: reuseScore | ownScore,
-            };
-        })).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));
-    }
-};
-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.add(model.onWillDispose(() => onWillDispose(model)));
-    }
-    getCellIndex(cellUri) {
-        return this.model.cells.findIndex(cell => isEqual(cell.uri, cellUri));
-    }
-    dispose() {
-        this._modelEventListeners.dispose();
-    }
-}
-let NotebookService = class NotebookService extends Disposable {
-    static { NotebookService_1 = this; }
-    static { this._storageNotebookViewTypeProvider = 'notebook.viewTypeProvider'; }
-    get notebookProviderInfoStore() {
-        if (!this._notebookProviderInfoStore) {
-            this._notebookProviderInfoStore = this._register(this._instantiationService.createInstance(NotebookProviderInfoStore));
-        }
-        return this._notebookProviderInfoStore;
-    }
-    constructor(_extensionService, _configurationService, _accessibilityService, _instantiationService, _storageService, _notebookDocumentService) {
-        super();
-        this._extensionService = _extensionService;
-        this._configurationService = _configurationService;
-        this._accessibilityService = _accessibilityService;
-        this._instantiationService = _instantiationService;
-        this._storageService = _storageService;
-        this._notebookDocumentService = _notebookDocumentService;
-        this._notebookProviders = ( new Map());
-        this._notebookProviderInfoStore = undefined;
-        this._notebookRenderersInfoStore = this._instantiationService.createInstance(NotebookOutputRendererInfoStore);
-        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.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._onAddViewType.event;
-        this._onWillRemoveViewType = this._register(( new Emitter()));
-        this.onWillRemoveViewType = this._onWillRemoveViewType.event;
-        this._onDidChangeEditorTypes = this._register(( new Emitter()));
-        this.onDidChangeEditorTypes = this._onDidChangeEditorTypes.event;
-        this._lastClipboardIsCopy = true;
-        notebookRendererExtensionPoint.setHandler((renderers) => {
-            this._notebookRenderersInfoStore.clear();
-            for (const extension of renderers) {
-                for (const notebookContribution of extension.value) {
-                    if (!notebookContribution.entrypoint) {
-                        extension.collector.error(`Notebook renderer does not specify entry point`);
-                        continue;
-                    }
-                    const id = notebookContribution.id;
-                    if (!id) {
-                        extension.collector.error(`Notebook renderer does not specify id-property`);
-                        continue;
-                    }
-                    this._notebookRenderersInfoStore.add(( new NotebookOutputRendererInfo({
-                        id,
-                        extension: extension.description,
-                        entrypoint: notebookContribution.entrypoint,
-                        displayName: notebookContribution.displayName,
-                        mimeTypes: notebookContribution.mimeTypes || [],
-                        dependencies: notebookContribution.dependencies,
-                        optionalDependencies: notebookContribution.optionalDependencies,
-                        requiresMessaging: notebookContribution.requiresMessaging,
-                    })));
-                }
-            }
-            this._onDidChangeOutputRenderers.fire();
-        });
-        notebookPreloadExtensionPoint.setHandler(extensions => {
-            this._notebookStaticPreloadInfoStore.clear();
-            for (const extension of extensions) {
-                if (!isProposedApiEnabled(extension.description, 'contribNotebookStaticPreloads')) {
-                    continue;
-                }
-                for (const notebookContribution of extension.value) {
-                    if (!notebookContribution.entrypoint) {
-                        extension.collector.error(`Notebook preload does not specify entry point`);
-                        continue;
-                    }
-                    const type = notebookContribution.type;
-                    if (!type) {
-                        extension.collector.error(`Notebook preload does not specify type-property`);
-                        continue;
-                    }
-                    this._notebookStaticPreloadInfoStore.add(( new NotebookStaticPreloadInfo({
-                        type,
-                        extension: extension.description,
-                        entrypoint: notebookContribution.entrypoint,
-                        localResourceRoots: notebookContribution.localResourceRoots ?? [],
-                    })));
-                }
-            }
-        });
-        const updateOrder = () => {
-            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 => {
-            if (e.affectsConfiguration(NotebookSetting.displayOrder)) {
-                updateOrder();
-            }
-        }));
-        this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
-            updateOrder();
-        }));
-        this._memento = ( new Memento(NotebookService_1._storageNotebookViewTypeProvider, this._storageService));
-        this._viewTypeCache = this._memento.getMemento(1 , 1 );
-    }
-    getEditorTypes() {
-        return ( [...this.notebookProviderInfoStore].map(info => ({
-            id: info.id,
-            displayName: info.displayName,
-            providerDisplayName: info.providerDisplayName
-        })));
-    }
-    clearEditorCache() {
-        this.notebookProviderInfoStore.clearEditorCache();
-    }
-    _postDocumentOpenActivation(viewType) {
-        this._extensionService.activateByEvent(`onNotebook:${viewType}`);
-        this._extensionService.activateByEvent(`onNotebook:*`);
-    }
-    async canResolve(viewType) {
-        if (( this._notebookProviders.has(viewType))) {
-            return true;
-        }
-        await this._extensionService.whenInstalledExtensionsRegistered();
-        await this._extensionService.activateByEvent(`onNotebookSerializer:${viewType}`);
-        return ( this._notebookProviders.has(viewType));
-    }
-    registerContributedNotebookType(viewType, data) {
-        const info = ( new NotebookProviderInfo({
-            extension: data.extension,
-            id: viewType,
-            displayName: data.displayName,
-            providerDisplayName: data.providerDisplayName,
-            exclusive: data.exclusive,
-            priority: RegisteredEditorPriority.default,
-            selectors: []
-        }));
-        info.update({ selectors: data.filenamePattern });
-        const reg = this.notebookProviderInfoStore.add(info);
-        this._onDidChangeEditorTypes.fire();
-        return toDisposable(() => {
-            reg.dispose();
-            this._onDidChangeEditorTypes.fire();
-        });
-    }
-    _registerProviderData(viewType, data) {
-        if (( this._notebookProviders.has(viewType))) {
-            throw new Error(`notebook provider for viewtype '${viewType}' already exists`);
-        }
-        this._notebookProviders.set(viewType, data);
-        this._onAddViewType.fire(viewType);
-        return toDisposable(() => {
-            this._onWillRemoveViewType.fire(viewType);
-            this._notebookProviders.delete(viewType);
-        });
-    }
-    registerNotebookSerializer(viewType, extensionData, serializer) {
-        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)));
-    }
-    async withNotebookDataProvider(viewType) {
-        const selected = this.notebookProviderInfoStore.get(viewType);
-        if (!selected) {
-            const knownProvider = this.getViewTypeProvider(viewType);
-            const actions = knownProvider ? [
-                toAction({
-                    id: 'workbench.notebook.action.installMissingViewType', label: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/services/notebookServiceImpl',
-                    'notebookOpenInstallMissingViewType',
-                    "Install extension for '{0}'",
-                    viewType
-                )), run: async () => {
-                        await this._instantiationService.createInstance(InstallRecommendedExtensionAction, knownProvider).run();
-                    }
-                })
-            ] : [];
-            throw createErrorWithActions(`UNKNOWN notebook type '${viewType}'`, actions);
-        }
-        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}'`);
-        }
-        return result;
-    }
-    _persistMementos() {
-        this._memento.saveMemento();
-    }
-    getViewTypeProvider(viewType) {
-        return this._viewTypeCache[viewType];
-    }
-    getRendererInfo(rendererId) {
-        return this._notebookRenderersInfoStore.get(rendererId);
-    }
-    updateMimePreferredRenderer(viewType, mimeType, rendererId, otherMimetypes) {
-        const info = this.notebookProviderInfoStore.get(viewType);
-        if (info) {
-            this._notebookRenderersInfoStore.setPreferred(info, mimeType, rendererId);
-        }
-        this._displayOrder.prioritize(mimeType, otherMimetypes);
-    }
-    saveMimeDisplayOrder(target) {
-        this._configurationService.updateValue(NotebookSetting.displayOrder, this._displayOrder.toArray(), target);
-    }
-    getRenderers() {
-        return this._notebookRenderersInfoStore.getAll();
-    }
-    *getStaticPreloads(viewType) {
-        for (const preload of this._notebookStaticPreloadInfoStore) {
-            if (preload.type === viewType) {
-                yield preload;
-            }
-        }
-    }
-    createNotebookTextModel(viewType, uri, data, transientOptions) {
-        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 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);
-        return notebookModel;
-    }
-    getNotebookTextModel(uri) {
-        return this._models.get(uri)?.model;
-    }
-    getNotebookTextModels() {
-        return ( Iterable.map(( this._models.values()), data => data.model));
-    }
-    listNotebookDocuments() {
-        return ( [...this._models].map(e => e[1].model));
-    }
-    _onWillDisposeDocument(model) {
-        const modelData = this._models.get(model.uri);
-        if (modelData) {
-            this._onWillRemoveNotebookDocument.fire(modelData.model);
-            this._models.delete(model.uri);
-            this._notebookDocumentService.removeNotebookDocument(modelData);
-            modelData.dispose();
-            this._onDidRemoveNotebookDocument.fire(modelData.model);
-        }
-    }
-    getOutputMimeTypeInfo(textModel, kernelProvides, output) {
-        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))
-            .sort((a, b) => (a.rendererId === RENDERER_NOT_AVAILABLE ? 1 : 0) - (b.rendererId === RENDERER_NOT_AVAILABLE ? 1 : 0));
-    }
-    getContributedNotebookTypes(resource) {
-        if (resource) {
-            return this.notebookProviderInfoStore.getContributedNotebook(resource);
-        }
-        return [...this.notebookProviderInfoStore];
-    }
-    getContributedNotebookType(viewType) {
-        return this.notebookProviderInfoStore.get(viewType);
-    }
-    getNotebookProviderResourceRoots() {
-        const ret = [];
-        this._notebookProviders.forEach(val => {
-            if (val.extensionData.location) {
-                ret.push(URI.revive(val.extensionData.location));
-            }
-        });
-        return ret;
-    }
-    setToCopy(items, isCopy) {
-        this._cutItems = items;
-        this._lastClipboardIsCopy = isCopy;
-    }
-    getToCopy() {
-        if (this._cutItems) {
-            return { items: this._cutItems, isCopy: this._lastClipboardIsCopy };
-        }
-        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));
-
-export { NotebookOutputRendererInfoStore, NotebookProviderInfoStore, NotebookService };