@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/contrib/files/common/explorerFileNestingTrie.js

@@ -37,7 +37,7 @@ class ExplorerFileNestingTrie {
             }
         }
         const findAllRootAncestors = (file, seen = ( new Set())) => {
-            if (seen.has(file)) {
+            if (( seen.has(file))) {
                 return [];
             }
             seen.add(file);

package/dist/vscode/vs/workbench/contrib/files/common/files.js

@@ -1,12 +1,73 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ContextKeyExpr, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { InputFocusedContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 const VIEWLET_ID = 'workbench.view.explorer';
+const VIEW_ID = 'workbench.explorer.fileView';
+const ExplorerViewletVisibleContext = ( new RawContextKey(
+    'explorerViewletVisible',
+    true,
+    { type: 'boolean', description: ( localize('explorerViewletVisible', "True when the EXPLORER viewlet is visible.")) }
+));
 const FoldersViewVisibleContext = ( new RawContextKey('foldersViewVisible', true, { type: 'boolean', description: ( localize(
     'foldersViewVisible',
     "True when the FOLDERS view (the file tree within the explorer view container) is visible."
 )) }));
+const ExplorerFolderContext = ( new RawContextKey(
+    'explorerResourceIsFolder',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceIsFolder',
+        "True when the focused item in the EXPLORER is a folder."
+    )) }
+));
+const ExplorerResourceReadonlyContext = ( new RawContextKey(
+    'explorerResourceReadonly',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceReadonly',
+        "True when the focused item in the EXPLORER is readonly."
+    )) }
+));
+const ExplorerResourceNotReadonlyContext = ( ExplorerResourceReadonlyContext.toNegated());
+const ExplorerResourceAvailableEditorIdsContext = ( new RawContextKey('explorerResourceAvailableEditorIds', ''));
+const ExplorerRootContext = ( new RawContextKey(
+    'explorerResourceIsRoot',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceIsRoot',
+        "True when the focused item in the EXPLORER is a root folder."
+    )) }
+));
+const ExplorerResourceCut = ( new RawContextKey(
+    'explorerResourceCut',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceCut',
+        "True when an item in the EXPLORER has been cut for cut and paste."
+    )) }
+));
+const ExplorerResourceMoveableToTrash = ( new RawContextKey(
+    'explorerResourceMoveableToTrash',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceMoveableToTrash',
+        "True when the focused item in the EXPLORER can be moved to trash."
+    )) }
+));
 const FilesExplorerFocusedContext = ( new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localize('filesExplorerFocus', "True when the focus is inside the EXPLORER view.")) }));
+const OpenEditorsVisibleContext = ( new RawContextKey(
+    'openEditorsVisible',
+    false,
+    { type: 'boolean', description: ( localize('openEditorsVisible', "True when the OPEN EDITORS view is visible.")) }
+));
 const ExplorerFocusedContext = ( new RawContextKey(
     'explorerViewletFocus',
     true,
@@ -15,12 +76,44 @@ const ExplorerFocusedContext = ( new RawContextKey(
         "True when the focus is inside the EXPLORER viewlet."
     )) }
 ));
-( ContextKeyExpr.and(
+const ExplorerCompressedFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        'explorerViewletCompressedFocus',
+        "True when the focused item in the EXPLORER view is a compact item."
+    )) }
+));
+const ExplorerCompressedFirstFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedFirstFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        'explorerViewletCompressedFirstFocus',
+        "True when the focus is inside a compact item's first part in the EXPLORER view."
+    )) }
+));
+const ExplorerCompressedLastFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedLastFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        'explorerViewletCompressedLastFocus',
+        "True when the focus is inside a compact item's last part in the EXPLORER view."
+    )) }
+));
+const ViewHasSomeCollapsibleRootItemContext = ( new RawContextKey(
+    'viewHasSomeCollapsibleItem',
+    false,
+    { type: 'boolean', description: ( localize(
+        'viewHasSomeCollapsibleItem',
+        "True when a workspace in the EXPLORER view has some collapsible root child."
+    )) }
+));
+const FilesExplorerFocusCondition = ( ContextKeyExpr.and(
     FoldersViewVisibleContext,
     FilesExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
 ));
-( ContextKeyExpr.and(
+const ExplorerFocusCondition = ( ContextKeyExpr.and(
     FoldersViewVisibleContext,
     ExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
@@ -29,4 +122,102 @@ const TEXT_FILE_EDITOR_ID = 'workbench.editors.files.textFileEditor';
 const FILE_EDITOR_INPUT_ID = 'workbench.editors.files.fileEditorInput';
 const BINARY_FILE_EDITOR_ID = 'workbench.editors.files.binaryFileEditor';
 const BINARY_TEXT_FILE_MODE = 'code-text-binary';
-export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerFocusedContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusedContext, FoldersViewVisibleContext, TEXT_FILE_EDITOR_ID, VIEWLET_ID };
+let TextFileContentProvider = class TextFileContentProvider extends Disposable {
+    constructor(textFileService, fileService, languageService, modelService) {
+        super();
+        this.textFileService = textFileService;
+        this.fileService = fileService;
+        this.languageService = languageService;
+        this.modelService = modelService;
+        this.fileWatcherDisposable = this._register(( new MutableDisposable()));
+    }
+    static async open(resource, scheme, label, editorService, options) {
+        await editorService.openEditor({
+            original: { resource: TextFileContentProvider.resourceToTextFile(scheme, resource) },
+            modified: { resource },
+            label,
+            options
+        });
+    }
+    static resourceToTextFile(scheme, resource) {
+        return resource.with({ scheme, query: JSON.stringify({ scheme: resource.scheme, query: resource.query }) });
+    }
+    static textFileToResource(resource) {
+        const { scheme, query } = JSON.parse(resource.query);
+        return resource.with({ scheme, query });
+    }
+    async provideTextContent(resource) {
+        if (!resource.query) {
+            return null;
+        }
+        const savedFileResource = TextFileContentProvider.textFileToResource(resource);
+        const codeEditorModel = await this.resolveEditorModel(resource);
+        if (!this.fileWatcherDisposable.value) {
+            this.fileWatcherDisposable.value = this.fileService.onDidFilesChange(changes => {
+                if (changes.contains(savedFileResource, 0 )) {
+                    this.resolveEditorModel(resource, false );
+                }
+            });
+            if (codeEditorModel) {
+                once(codeEditorModel.onWillDispose)(() => this.fileWatcherDisposable.clear());
+            }
+        }
+        return codeEditorModel;
+    }
+    async resolveEditorModel(resource, createAsNeeded = true) {
+        const savedFileResource = TextFileContentProvider.textFileToResource(resource);
+        const content = await this.textFileService.readStream(savedFileResource);
+        let codeEditorModel = this.modelService.getModel(resource);
+        if (codeEditorModel) {
+            this.modelService.updateModel(codeEditorModel, content.value);
+        }
+        else if (createAsNeeded) {
+            const textFileModel = this.modelService.getModel(savedFileResource);
+            let languageSelector;
+            if (textFileModel) {
+                languageSelector = this.languageService.createById(textFileModel.getLanguageId());
+            }
+            else {
+                languageSelector = this.languageService.createByFilepathOrFirstLine(savedFileResource);
+            }
+            codeEditorModel = this.modelService.createModel(content.value, languageSelector, resource);
+        }
+        return codeEditorModel;
+    }
+};
+TextFileContentProvider = ( __decorate([
+    ( __param(0, ITextFileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService))
+], TextFileContentProvider));
+class OpenEditor {
+    constructor(_editor, _group) {
+        this._editor = _editor;
+        this._group = _group;
+        this.id = OpenEditor.COUNTER++;
+    }
+    get editor() {
+        return this._editor;
+    }
+    get group() {
+        return this._group;
+    }
+    get groupId() {
+        return this._group.id;
+    }
+    getId() {
+        return `openeditor:${this.groupId}:${this.id}`;
+    }
+    isPreview() {
+        return !this._group.isPinned(this.editor);
+    }
+    isSticky() {
+        return this._group.isSticky(this.editor);
+    }
+    getResource() {
+        return EditorResourceAccessor.getOriginalUri(this.editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+    }
+}
+OpenEditor.COUNTER = 0;
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsVisibleContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };

package/dist/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser.js

@@ -0,0 +1,27 @@
+import { NOTEBOOK_EDITOR_ID } from '../common/notebookCommon.js';
+import { isCompositeNotebookEditorInput } from '../common/notebookEditorInput.js';
+const IPYNB_VIEW_TYPE = 'jupyter-notebook';
+const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
+const KERNEL_RECOMMENDATIONS = ( new Map());
+KERNEL_RECOMMENDATIONS.set(IPYNB_VIEW_TYPE, ( new Map()));
+KERNEL_RECOMMENDATIONS.get(IPYNB_VIEW_TYPE)?.set('python', {
+    extensionIds: [
+        'ms-python.python',
+        JUPYTER_EXTENSION_ID
+    ],
+    displayName: 'Python + Jupyter',
+});
+function getNotebookEditorFromEditorPane(editorPane) {
+    if (!editorPane) {
+        return;
+    }
+    if (editorPane.getId() === NOTEBOOK_EDITOR_ID) {
+        return editorPane.getControl();
+    }
+    const input = editorPane.input;
+    if (input && isCompositeNotebookEditorInput(input)) {
+        return editorPane.getControl().notebookEditor;
+    }
+    return undefined;
+}
+export { IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID, KERNEL_RECOMMENDATIONS, getNotebookEditorFromEditorPane };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookCommon.js

@@ -1,9 +1,87 @@
+import { encodeBase64, VSBuffer, decodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+const NOTEBOOK_EDITOR_ID = 'workbench.editor.notebook';
 var CellKind;
 ( (function(CellKind) {
     CellKind[CellKind["Markup"] = 1] = "Markup";
     CellKind[CellKind["Code"] = 2] = "Code";
 })(CellKind || (CellKind = {})));
+var SelectionStateType;
+( (function(SelectionStateType) {
+    SelectionStateType[SelectionStateType["Handle"] = 0] = "Handle";
+    SelectionStateType[SelectionStateType["Index"] = 1] = "Index";
+})(SelectionStateType || (SelectionStateType = {})));
+var CellUri;
+( (function(CellUri) {
+    CellUri.scheme = Schemas.vscodeNotebookCell;
+    const _lengths = ['W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f'];
+    const _padRegexp = ( new RegExp(`^[${_lengths.join('')}]+`));
+    const _radix = 7;
+    function generate(notebook, handle) {
+        const s = ( handle.toString(_radix));
+        const p = s.length < _lengths.length ? _lengths[s.length - 1] : 'z';
+        const fragment = `${p}${s}s${encodeBase64(VSBuffer.fromString(notebook.scheme), true, true)}`;
+        return notebook.with({ scheme: CellUri.scheme, fragment });
+    }
+    CellUri.generate = generate;
+    function parse(cell) {
+        if (cell.scheme !== CellUri.scheme) {
+            return undefined;
+        }
+        const idx = cell.fragment.indexOf('s');
+        if (idx < 0) {
+            return undefined;
+        }
+        const handle = parseInt(cell.fragment.substring(0, idx).replace(_padRegexp, ''), _radix);
+        const _scheme = ( decodeBase64(cell.fragment.substring(idx + 1)).toString());
+        if (isNaN(handle)) {
+            return undefined;
+        }
+        return {
+            handle,
+            notebook: cell.with({ scheme: _scheme, fragment: null })
+        };
+    }
+    CellUri.parse = parse;
+    function generateCellOutputUri(notebook, outputId) {
+        return notebook.with({
+            scheme: Schemas.vscodeNotebookCellOutput,
+            fragment: `op${outputId ?? ''},${notebook.scheme !== Schemas.file ? notebook.scheme : ''}`
+        });
+    }
+    CellUri.generateCellOutputUri = generateCellOutputUri;
+    function parseCellOutputUri(uri) {
+        if (uri.scheme !== Schemas.vscodeNotebookCellOutput) {
+            return;
+        }
+        const match = /^op([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})?\,(.*)$/i.exec(uri.fragment);
+        if (!match) {
+            return undefined;
+        }
+        const outputId = (match[1] && match[1] !== '') ? match[1] : undefined;
+        const scheme = match[2];
+        return {
+            outputId,
+            notebook: uri.with({
+                scheme: scheme || Schemas.file,
+                fragment: null
+            })
+        };
+    }
+    CellUri.parseCellOutputUri = parseCellOutputUri;
+    function generateCellPropertyUri(notebook, handle, scheme) {
+        return CellUri.generate(notebook, handle).with({ scheme: scheme });
+    }
+    CellUri.generateCellPropertyUri = generateCellPropertyUri;
+    function parseCellPropertyUri(uri, propertyScheme) {
+        if (uri.scheme !== propertyScheme) {
+            return undefined;
+        }
+        return CellUri.parse(uri.with({ scheme: CellUri.scheme }));
+    }
+    CellUri.parseCellPropertyUri = parseCellPropertyUri;
+})(CellUri || (CellUri = {})));
 function isTextStreamMime(mimeType) {
     return ['application/vnd.code.notebook.stdout', 'application/vnd.code.notebook.stderr'].includes(mimeType);
 }
-export { CellKind, isTextStreamMime };
+export { CellKind, CellUri, NOTEBOOK_EDITOR_ID, SelectionStateType, isTextStreamMime };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput.js

@@ -0,0 +1,249 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { SimpleNotebookProviderInfo, INotebookService } from './notebookService.js';
+import { joinPath, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { INotebookEditorModelResolverService } from './notebookEditorModelResolverService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { AbstractResourceEditorInput } from '../../../common/editor/resourceEditorInput.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+let NotebookEditorInput = class NotebookEditorInput extends AbstractResourceEditorInput {
+    static create(instantiationService, resource, viewType, options = {}) {
+        return instantiationService.createInstance(NotebookEditorInput, resource, viewType, options);
+    }
+    constructor(resource, viewType, options, _notebookService, _notebookModelResolverService, _fileDialogService, _instantiationService, labelService, fileService) {
+        super(resource, undefined, labelService, fileService);
+        this.viewType = viewType;
+        this.options = options;
+        this._notebookService = _notebookService;
+        this._notebookModelResolverService = _notebookModelResolverService;
+        this._fileDialogService = _fileDialogService;
+        this._instantiationService = _instantiationService;
+        this._editorModelReference = null;
+        this._defaultDirtyState = false;
+        this._defaultDirtyState = !!options.startDirty;
+        this._sideLoadedListener = _notebookService.onDidAddNotebookDocument(e => {
+            if (e.viewType === this.viewType && ( e.uri.toString()) === ( this.resource.toString())) {
+                this.resolve().catch(onUnexpectedError);
+            }
+        });
+    }
+    dispose() {
+        this._sideLoadedListener.dispose();
+        this._editorModelReference?.dispose();
+        this._editorModelReference = null;
+        super.dispose();
+    }
+    get typeId() {
+        return NotebookEditorInput.ID;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = 0 ;
+        if (this.resource.scheme === Schemas.untitled) {
+            capabilities |= 4 ;
+        }
+        if (this._editorModelReference) {
+            if (this._editorModelReference.object.isReadonly()) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            if (this.fileService.hasCapability(this.resource, 2048 )) {
+                capabilities |= 2 ;
+            }
+        }
+        if (!((capabilities & 2) )) {
+            capabilities |= 128 ;
+        }
+        return capabilities;
+    }
+    getDescription(verbosity = 1 ) {
+        if (!this.hasCapability(4 ) || this._editorModelReference?.object.hasAssociatedFilePath()) {
+            return super.getDescription(verbosity);
+        }
+        return undefined;
+    }
+    isDirty() {
+        if (!this._editorModelReference) {
+            return this._defaultDirtyState;
+        }
+        return this._editorModelReference.object.isDirty();
+    }
+    async save(group, options) {
+        if (this._editorModelReference) {
+            if (this.hasCapability(4 )) {
+                return this.saveAs(group, options);
+            }
+            else {
+                await this._editorModelReference.object.save(options);
+            }
+            return this;
+        }
+        return undefined;
+    }
+    async saveAs(group, options) {
+        if (!this._editorModelReference) {
+            return undefined;
+        }
+        const provider = this._notebookService.getContributedNotebookType(this.viewType);
+        if (!provider) {
+            return undefined;
+        }
+        const pathCandidate = this.hasCapability(4 ) ? await this._suggestName(provider, this.labelService.getUriBasenameLabel(this.resource)) : this._editorModelReference.object.resource;
+        let target;
+        if (this._editorModelReference.object.hasAssociatedFilePath()) {
+            target = pathCandidate;
+        }
+        else {
+            target = await this._fileDialogService.pickFileToSave(pathCandidate, options?.availableFileSystems);
+            if (!target) {
+                return undefined;
+            }
+        }
+        if (!provider.matches(target)) {
+            const patterns = ( provider.selectors.map(pattern => {
+                if (typeof pattern === 'string') {
+                    return pattern;
+                }
+                if (glob.isRelativePattern(pattern)) {
+                    return `${pattern} (base ${pattern.base})`;
+                }
+                if (pattern.exclude) {
+                    return `${pattern.include} (exclude: ${pattern.exclude})`;
+                }
+                else {
+                    return `${pattern.include}`;
+                }
+            })).join(', ');
+            throw new Error(`File name ${target} is not supported by ${provider.providerDisplayName}.\n\nPlease make sure the file name matches following patterns:\n${patterns}`);
+        }
+        return await this._editorModelReference.object.saveAs(target);
+    }
+    async _suggestName(provider, suggestedFilename) {
+        const firstSelector = provider.selectors[0];
+        let selectorStr = firstSelector && typeof firstSelector === 'string' ? firstSelector : undefined;
+        if (!selectorStr && firstSelector) {
+            const include = firstSelector.include;
+            if (typeof include === 'string') {
+                selectorStr = include;
+            }
+        }
+        if (selectorStr) {
+            const matches = /^\*\.([A-Za-z_-]*)$/.exec(selectorStr);
+            if (matches && matches.length > 1) {
+                const fileExt = matches[1];
+                if (!suggestedFilename.endsWith(fileExt)) {
+                    return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename + '.' + fileExt);
+                }
+            }
+        }
+        return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename);
+    }
+    async rename(group, target) {
+        if (this._editorModelReference) {
+            const contributedNotebookProviders = this._notebookService.getContributedNotebookTypes(target);
+            if (contributedNotebookProviders.find(provider => provider.id === this._editorModelReference.object.viewType)) {
+                return this._move(group, target);
+            }
+        }
+        return undefined;
+    }
+    _move(_group, newResource) {
+        const editorInput = NotebookEditorInput.create(this._instantiationService, newResource, this.viewType);
+        return { editor: editorInput };
+    }
+    async revert(_group, options) {
+        if (this._editorModelReference && this._editorModelReference.object.isDirty()) {
+            await this._editorModelReference.object.revert(options);
+        }
+    }
+    async resolve(_options, perf) {
+        if (!(await this._notebookService.canResolve(this.viewType))) {
+            return null;
+        }
+        perf?.mark('extensionActivated');
+        this._sideLoadedListener.dispose();
+        if (!this._editorModelReference) {
+            const ref = await this._notebookModelResolverService.resolve(this.resource, this.viewType);
+            if (this._editorModelReference) {
+                ref.dispose();
+                return this._editorModelReference.object;
+            }
+            this._editorModelReference = ref;
+            if (this.isDisposed()) {
+                this._editorModelReference.dispose();
+                this._editorModelReference = null;
+                return null;
+            }
+            this._register(this._editorModelReference.object.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+            this._register(this._editorModelReference.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+            if (this._editorModelReference.object.isDirty()) {
+                this._onDidChangeDirty.fire();
+            }
+        }
+        else {
+            this._editorModelReference.object.load();
+        }
+        if (this.options._backupId) {
+            const info = await this._notebookService.withNotebookDataProvider(this._editorModelReference.object.notebook.viewType);
+            if (!(info instanceof SimpleNotebookProviderInfo)) {
+                throw new Error('CANNOT open file notebook with this provider');
+            }
+            const data = await info.serializer.dataToNotebook(VSBuffer.fromString(JSON.stringify({ __webview_backup: this.options._backupId })));
+            this._editorModelReference.object.notebook.applyEdits([
+                {
+                    editType: 1 ,
+                    index: 0,
+                    count: this._editorModelReference.object.notebook.length,
+                    cells: data.cells
+                }
+            ], true, undefined, () => undefined, undefined, false);
+            if (this.options._workingCopy) {
+                this.options._backupId = undefined;
+                this.options._workingCopy = undefined;
+                this.options.startDirty = undefined;
+            }
+        }
+        return this._editorModelReference.object;
+    }
+    toUntyped() {
+        return {
+            resource: this.preferredResource,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof NotebookEditorInput) {
+            return this.viewType === otherInput.viewType && isEqual(this.resource, otherInput.resource);
+        }
+        return false;
+    }
+};
+NotebookEditorInput.ID = 'workbench.input.notebook';
+NotebookEditorInput = ( __decorate([
+    ( __param(3, INotebookService)),
+    ( __param(4, INotebookEditorModelResolverService)),
+    ( __param(5, IFileDialogService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IFileService))
+], NotebookEditorInput));
+function isCompositeNotebookEditorInput(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && Array.isArray(thing.editorInputs)
+        && (thing.editorInputs.every(input => input instanceof NotebookEditorInput));
+}
+export { NotebookEditorInput, isCompositeNotebookEditorInput };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const INotebookEditorModelResolverService = ( createDecorator('INotebookModelResolverService'));
+export { INotebookEditorModelResolverService };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookService.js

@@ -0,0 +1,10 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const INotebookService = ( createDecorator('notebookService'));
+class SimpleNotebookProviderInfo {
+    constructor(viewType, serializer, extensionData) {
+        this.viewType = viewType;
+        this.serializer = serializer;
+        this.extensionData = extensionData;
+    }
+}
+export { INotebookService, SimpleNotebookProviderInfo };