@codingame/monaco-vscode-api 13.1.7 → 14.0.0

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

@@ -0,0 +1,143 @@
+
+import { NOTEBOOK_EDITOR_ID } from '../common/notebookCommon.js';
+import { isCompositeNotebookEditorInput } from '../common/notebookEditorInput.js';
+import { cellRangesToIndexes, reduceCellRanges } from '../common/notebookRange.js';
+
+const EXPAND_CELL_INPUT_COMMAND_ID = 'notebook.cell.expandCellInput';
+const EXECUTE_CELL_COMMAND_ID = 'notebook.cell.execute';
+const DETECT_CELL_LANGUAGE = 'notebook.cell.detectLanguage';
+const CHANGE_CELL_LANGUAGE = 'notebook.cell.changeLanguage';
+const QUIT_EDIT_CELL_COMMAND_ID = 'notebook.cell.quitEdit';
+const EXPAND_CELL_OUTPUT_COMMAND_ID = 'notebook.cell.expandCellOutput';
+const IPYNB_VIEW_TYPE = 'jupyter-notebook';
+const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
+const KERNEL_EXTENSIONS = ( new Map([
+    [IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID],
+]));
+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',
+});
+var RenderOutputType;
+(function (RenderOutputType) {
+    RenderOutputType[RenderOutputType["Html"] = 0] = "Html";
+    RenderOutputType[RenderOutputType["Extension"] = 1] = "Extension";
+})(RenderOutputType || (RenderOutputType = {}));
+var ScrollToRevealBehavior;
+(function (ScrollToRevealBehavior) {
+    ScrollToRevealBehavior[ScrollToRevealBehavior["fullCell"] = 0] = "fullCell";
+    ScrollToRevealBehavior[ScrollToRevealBehavior["firstLine"] = 1] = "firstLine";
+})(ScrollToRevealBehavior || (ScrollToRevealBehavior = {}));
+var CellLayoutState;
+(function (CellLayoutState) {
+    CellLayoutState[CellLayoutState["Uninitialized"] = 0] = "Uninitialized";
+    CellLayoutState[CellLayoutState["Estimated"] = 1] = "Estimated";
+    CellLayoutState[CellLayoutState["FromCache"] = 2] = "FromCache";
+    CellLayoutState[CellLayoutState["Measured"] = 3] = "Measured";
+})(CellLayoutState || (CellLayoutState = {}));
+var CellLayoutContext;
+(function (CellLayoutContext) {
+    CellLayoutContext[CellLayoutContext["Fold"] = 0] = "Fold";
+})(CellLayoutContext || (CellLayoutContext = {}));
+var NotebookOverviewRulerLane;
+(function (NotebookOverviewRulerLane) {
+    NotebookOverviewRulerLane[NotebookOverviewRulerLane["Left"] = 1] = "Left";
+    NotebookOverviewRulerLane[NotebookOverviewRulerLane["Center"] = 2] = "Center";
+    NotebookOverviewRulerLane[NotebookOverviewRulerLane["Right"] = 4] = "Right";
+    NotebookOverviewRulerLane[NotebookOverviewRulerLane["Full"] = 7] = "Full";
+})(NotebookOverviewRulerLane || (NotebookOverviewRulerLane = {}));
+var CellRevealType;
+(function (CellRevealType) {
+    CellRevealType[CellRevealType["Default"] = 1] = "Default";
+    CellRevealType[CellRevealType["Top"] = 2] = "Top";
+    CellRevealType[CellRevealType["Center"] = 3] = "Center";
+    CellRevealType[CellRevealType["CenterIfOutsideViewport"] = 4] = "CenterIfOutsideViewport";
+    CellRevealType[CellRevealType["NearTopIfOutsideViewport"] = 5] = "NearTopIfOutsideViewport";
+    CellRevealType[CellRevealType["FirstLineIfOutsideViewport"] = 6] = "FirstLineIfOutsideViewport";
+})(CellRevealType || (CellRevealType = {}));
+var CellRevealRangeType;
+(function (CellRevealRangeType) {
+    CellRevealRangeType[CellRevealRangeType["Default"] = 1] = "Default";
+    CellRevealRangeType[CellRevealRangeType["Center"] = 2] = "Center";
+    CellRevealRangeType[CellRevealRangeType["CenterIfOutsideViewport"] = 3] = "CenterIfOutsideViewport";
+})(CellRevealRangeType || (CellRevealRangeType = {}));
+var CellEditState;
+(function (CellEditState) {
+    CellEditState[CellEditState["Preview"] = 0] = "Preview";
+    CellEditState[CellEditState["Editing"] = 1] = "Editing";
+})(CellEditState || (CellEditState = {}));
+var CellFocusMode;
+(function (CellFocusMode) {
+    CellFocusMode[CellFocusMode["Container"] = 0] = "Container";
+    CellFocusMode[CellFocusMode["Editor"] = 1] = "Editor";
+    CellFocusMode[CellFocusMode["Output"] = 2] = "Output";
+    CellFocusMode[CellFocusMode["ChatInput"] = 3] = "ChatInput";
+})(CellFocusMode || (CellFocusMode = {}));
+var CursorAtBoundary;
+(function (CursorAtBoundary) {
+    CursorAtBoundary[CursorAtBoundary["None"] = 0] = "None";
+    CursorAtBoundary[CursorAtBoundary["Top"] = 1] = "Top";
+    CursorAtBoundary[CursorAtBoundary["Bottom"] = 2] = "Bottom";
+    CursorAtBoundary[CursorAtBoundary["Both"] = 3] = "Both";
+})(CursorAtBoundary || (CursorAtBoundary = {}));
+var CursorAtLineBoundary;
+(function (CursorAtLineBoundary) {
+    CursorAtLineBoundary[CursorAtLineBoundary["None"] = 0] = "None";
+    CursorAtLineBoundary[CursorAtLineBoundary["Start"] = 1] = "Start";
+    CursorAtLineBoundary[CursorAtLineBoundary["End"] = 2] = "End";
+    CursorAtLineBoundary[CursorAtLineBoundary["Both"] = 3] = "Both";
+})(CursorAtLineBoundary || (CursorAtLineBoundary = {}));
+function getNotebookEditorFromEditorPane(editorPane) {
+    if (!editorPane) {
+        return;
+    }
+    if (editorPane.getId() === NOTEBOOK_EDITOR_ID) {
+        return editorPane.getControl();
+    }
+    const input = editorPane.input;
+    const isCompositeNotebook = input && isCompositeNotebookEditorInput(input);
+    if (isCompositeNotebook) {
+        return editorPane.getControl()?.notebookEditor;
+    }
+    return undefined;
+}
+function expandCellRangesWithHiddenCells(editor, ranges) {
+    const indexes = cellRangesToIndexes(ranges);
+    const modelRanges = [];
+    indexes.forEach(index => {
+        const viewCell = editor.cellAt(index);
+        if (!viewCell) {
+            return;
+        }
+        const viewIndex = editor.getViewIndexByModelIndex(index);
+        if (viewIndex < 0) {
+            return;
+        }
+        const nextViewIndex = viewIndex + 1;
+        const range = editor.getCellRangeFromViewRange(viewIndex, nextViewIndex);
+        if (range) {
+            modelRanges.push(range);
+        }
+    });
+    return reduceCellRanges(modelRanges);
+}
+function cellRangeToViewCells(editor, ranges) {
+    const cells = [];
+    reduceCellRanges(ranges).forEach(range => {
+        cells.push(...editor.getCellsInRange(range));
+    });
+    return cells;
+}
+var CellFoldingState;
+(function (CellFoldingState) {
+    CellFoldingState[CellFoldingState["None"] = 0] = "None";
+    CellFoldingState[CellFoldingState["Expanded"] = 1] = "Expanded";
+    CellFoldingState[CellFoldingState["Collapsed"] = 2] = "Collapsed";
+})(CellFoldingState || (CellFoldingState = {}));
+
+export { CHANGE_CELL_LANGUAGE, CellEditState, CellFocusMode, CellFoldingState, CellLayoutContext, CellLayoutState, CellRevealRangeType, CellRevealType, CursorAtBoundary, CursorAtLineBoundary, DETECT_CELL_LANGUAGE, EXECUTE_CELL_COMMAND_ID, EXPAND_CELL_INPUT_COMMAND_ID, EXPAND_CELL_OUTPUT_COMMAND_ID, IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID, KERNEL_EXTENSIONS, KERNEL_RECOMMENDATIONS, NotebookOverviewRulerLane, QUIT_EDIT_CELL_COMMAND_ID, RenderOutputType, ScrollToRevealBehavior, cellRangeToViewCells, expandCellRangesWithHiddenCells, getNotebookEditorFromEditorPane };

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

@@ -3,8 +3,8 @@ import { CodeWindow } from "../../../../../base/browser/window.js";
 import { Event } from "../../../../../base/common/event.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { type ServicesAccessor } from "../../../../../platform/instantiation/common/instantiation.js";
-import { NotebookEditorInput } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput";
-import { INotebookEditorCreationOptions, INotebookEditor } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { NotebookEditorInput } from "../../common/notebookEditorInput.js";
+import { INotebookEditorCreationOptions, INotebookEditor } from "../notebookBrowser.js";
 import { NotebookEditorWidget } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget";
 import { IBorrowValue } from "./notebookEditorService.js";
 export declare const INotebookEditorService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<INotebookEditorService>;

package/vscode/src/vs/workbench/contrib/notebook/common/notebookCommon.d.ts

@@ -20,12 +20,12 @@ import { IFileReadLimits } from "../../../../platform/files/common/files.js";
 import { UndoRedoGroup } from "../../../../platform/undoRedo/common/undoRedo.js";
 import { IRevertOptions, ISaveOptions, IUntypedEditorInput } from "../../../common/editor.js";
 import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
-import { ICellExecutionError } from "@codingame/monaco-vscode-972e8507-3a64-566d-8bc0-b78993998562-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
+import { ICellExecutionError } from "@codingame/monaco-vscode-af5ccfda-af82-504b-b365-92b4e654e5c5-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
 import { INotebookTextModelLike } from "./notebookKernelService.js";
-import { ICellRange } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { ICellRange } from "./notebookRange.js";
 import { RegisteredEditorPriority } from "../../../services/editor/common/editorResolverService.js";
-import { IWorkingCopyBackupMeta, IWorkingCopySaveEvent } from "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
-import { SnapshotContext } from "@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { IWorkingCopyBackupMeta, IWorkingCopySaveEvent } from "@codingame/monaco-vscode-ce8c4b18-4e75-55dd-9656-517347af9de7-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { SnapshotContext } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
 export declare const NOTEBOOK_EDITOR_ID = "workbench.editor.notebook";
 export declare const NOTEBOOK_DIFF_EDITOR_ID = "workbench.editor.notebookTextDiffEditor";
 export declare const NOTEBOOK_MULTI_DIFF_EDITOR_ID = "workbench.editor.notebookMultiTextDiffEditor";
@@ -668,10 +668,12 @@ export declare const NotebookSetting: {
     readonly cellChat: "notebook.experimental.cellChat";
     readonly cellGenerate: "notebook.experimental.generate";
     readonly notebookVariablesView: "notebook.variablesView";
+    readonly notebookInlineValues: "notebook.inlineValues";
     readonly InteractiveWindowPromptToSave: "interactiveWindow.promptToSaveOnClose";
     readonly cellFailureDiagnostics: "notebook.cellFailureDiagnostics";
     readonly outputBackupSizeLimit: "notebook.backup.sizeLimit";
     readonly multiCursor: "notebook.multiCursor.enabled";
+    readonly markupFontFamily: "notebook.markup.fontFamily";
 };
 export declare enum CellStatusbarAlignment {
     Left = 1,

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

@@ -341,10 +341,12 @@ const NotebookSetting = {
     cellChat: 'notebook.experimental.cellChat',
     cellGenerate: 'notebook.experimental.generate',
     notebookVariablesView: 'notebook.variablesView',
+    notebookInlineValues: 'notebook.inlineValues',
     InteractiveWindowPromptToSave: 'interactiveWindow.promptToSaveOnClose',
     cellFailureDiagnostics: 'notebook.cellFailureDiagnostics',
     outputBackupSizeLimit: 'notebook.backup.sizeLimit',
     multiCursor: 'notebook.multiCursor.enabled',
+    markupFontFamily: 'notebook.markup.fontFamily',
 };
 var CellStatusbarAlignment;
 (function (CellStatusbarAlignment) {

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorInput.d.ts

@@ -0,0 +1,60 @@
+import { GroupIdentifier, ISaveOptions, IMoveResult, IRevertOptions, EditorInputCapabilities, Verbosity, IUntypedEditorInput, IFileLimitedEditorInputOptions } from "../../../common/editor.js";
+import { EditorInput } from "../../../common/editor/editorInput.js";
+import { INotebookService } from "./notebookService.service.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { IFileDialogService } from "../../../../platform/dialogs/common/dialogs.service.js";
+import { INotebookEditorModelResolverService } from "./notebookEditorModelResolverService.service.js";
+import { IReference } from "../../../../base/common/lifecycle.js";
+import { IResolvedNotebookEditorModel } from "./notebookCommon.js";
+import { ILabelService } from "../../../../platform/label/common/label.service.js";
+import { IFileService } from "../../../../platform/files/common/files.service.js";
+import { AbstractResourceEditorInput } from "../../../common/editor/resourceEditorInput.js";
+import { IResourceEditorInput } from "../../../../platform/editor/common/editor.js";
+import { IWorkingCopyIdentifier } from "@codingame/monaco-vscode-ce8c4b18-4e75-55dd-9656-517347af9de7-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { NotebookPerfMarks } from "@codingame/monaco-vscode-6f9bc782-77e0-5716-93bd-b05210c768c5-common/vscode/vs/workbench/contrib/notebook/common/notebookPerformance";
+import { IFilesConfigurationService } from "../../../services/filesConfiguration/common/filesConfigurationService.service.js";
+import { IExtensionService } from "../../../services/extensions/common/extensions.service.js";
+import { IEditorService } from "../../../services/editor/common/editorService.service.js";
+import { IMarkdownString } from "../../../../base/common/htmlContent.js";
+import { ITextResourceConfigurationService } from "../../../../editor/common/services/textResourceConfiguration.js";
+import { ICustomEditorLabelService } from "../../../services/editor/common/customEditorLabelService.service.js";
+export interface NotebookEditorInputOptions {
+    startDirty?: boolean;
+    _backupId?: string;
+    _workingCopy?: IWorkingCopyIdentifier;
+}
+export declare class NotebookEditorInput extends AbstractResourceEditorInput {
+    readonly viewType: string;
+    readonly options: NotebookEditorInputOptions;
+    private readonly _notebookService;
+    private readonly _notebookModelResolverService;
+    private readonly _fileDialogService;
+    static getOrCreate(instantiationService: IInstantiationService, resource: URI, preferredResource: URI | undefined, viewType: string, options?: NotebookEditorInputOptions): NotebookEditorInput;
+    static readonly ID: string;
+    protected editorModelReference: IReference<IResolvedNotebookEditorModel> | null;
+    private _sideLoadedListener;
+    private _defaultDirtyState;
+    constructor(resource: URI, preferredResource: URI | undefined, viewType: string, options: NotebookEditorInputOptions, _notebookService: INotebookService, _notebookModelResolverService: INotebookEditorModelResolverService, _fileDialogService: IFileDialogService, labelService: ILabelService, fileService: IFileService, filesConfigurationService: IFilesConfigurationService, extensionService: IExtensionService, editorService: IEditorService, textResourceConfigurationService: ITextResourceConfigurationService, customEditorLabelService: ICustomEditorLabelService);
+    dispose(): void;
+    get typeId(): string;
+    get editorId(): string | undefined;
+    get capabilities(): EditorInputCapabilities;
+    getDescription(verbosity?: Verbosity): string | undefined;
+    isReadonly(): boolean | IMarkdownString;
+    isDirty(): boolean;
+    isSaving(): boolean;
+    save(group: GroupIdentifier, options?: ISaveOptions): Promise<EditorInput | IUntypedEditorInput | undefined>;
+    saveAs(group: GroupIdentifier, options?: ISaveOptions): Promise<IUntypedEditorInput | undefined>;
+    private _suggestName;
+    rename(group: GroupIdentifier, target: URI): Promise<IMoveResult | undefined>;
+    revert(_group: GroupIdentifier, options?: IRevertOptions): Promise<void>;
+    resolve(_options?: IFileLimitedEditorInputOptions, perf?: NotebookPerfMarks): Promise<IResolvedNotebookEditorModel | null>;
+    toUntyped(): IResourceEditorInput;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+}
+export interface ICompositeNotebookEditorInput {
+    readonly editorInputs: NotebookEditorInput[];
+}
+export declare function isCompositeNotebookEditorInput(thing: unknown): thing is ICompositeNotebookEditorInput;
+export declare function isNotebookEditorInput(thing: EditorInput | undefined): thing is NotebookEditorInput;

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

@@ -0,0 +1,316 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isRelativePattern } from '../../../../base/common/glob.js';
+import { EditorInputCapabilities, Verbosity, isResourceEditorInput } from '../../../common/editor.js';
+import { SimpleNotebookProviderInfo } from './notebookService.js';
+import { INotebookService } from './notebookService.service.js';
+import { joinPath, isEqual } from '../../../../base/common/resources.js';
+import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { INotebookEditorModelResolverService } from './notebookEditorModelResolverService.service.js';
+import { CellEditType, CellUri } from './notebookCommon.js';
+import { ILabelService } from '../../../../platform/label/common/label.service.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { AbstractResourceEditorInput } from '../../../common/editor/resourceEditorInput.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.service.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { localize } from '../../../../nls.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
+import { ICustomEditorLabelService } from '../../../services/editor/common/customEditorLabelService.service.js';
+
+var NotebookEditorInput_1;
+let NotebookEditorInput = class NotebookEditorInput extends AbstractResourceEditorInput {
+    static { NotebookEditorInput_1 = this; }
+    static getOrCreate(instantiationService, resource, preferredResource, viewType, options = {}) {
+        const editor = instantiationService.createInstance(NotebookEditorInput_1, resource, preferredResource, viewType, options);
+        if (preferredResource) {
+            editor.setPreferredResource(preferredResource);
+        }
+        return editor;
+    }
+    static { this.ID = 'workbench.input.notebook'; }
+    constructor(resource, preferredResource, viewType, options, _notebookService, _notebookModelResolverService, _fileDialogService, labelService, fileService, filesConfigurationService, extensionService, editorService, textResourceConfigurationService, customEditorLabelService) {
+        super(resource, preferredResource, labelService, fileService, filesConfigurationService, textResourceConfigurationService, customEditorLabelService);
+        this.viewType = viewType;
+        this.options = options;
+        this._notebookService = _notebookService;
+        this._notebookModelResolverService = _notebookModelResolverService;
+        this._fileDialogService = _fileDialogService;
+        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);
+            }
+        });
+        this._register(extensionService.onWillStop(e => {
+            if (!e.auto && !this.isDirty()) {
+                return;
+            }
+            const reason = e.auto
+                ? ( localize(
+                7960,
+                "An extension provided notebook for '{0}' is still open that would close otherwise.",
+                this.getName()
+            ))
+                : ( localize(
+                7961,
+                "An extension provided notebook for '{0}' could not be saved.",
+                this.getName()
+            ));
+            e.veto((async () => {
+                const editors = editorService.findEditors(this);
+                if (e.auto) {
+                    return true;
+                }
+                if (editors.length > 0) {
+                    const result = await editorService.save(editors[0]);
+                    if (result.success) {
+                        return false;
+                    }
+                }
+                return true;
+            })(), reason);
+        }));
+    }
+    dispose() {
+        this._sideLoadedListener.dispose();
+        this.editorModelReference?.dispose();
+        this.editorModelReference = null;
+        super.dispose();
+    }
+    get typeId() {
+        return NotebookEditorInput_1.ID;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = EditorInputCapabilities.None;
+        if (this.resource.scheme === Schemas.untitled) {
+            capabilities |= EditorInputCapabilities.Untitled;
+        }
+        if (this.editorModelReference) {
+            if (this.editorModelReference.object.isReadonly()) {
+                capabilities |= EditorInputCapabilities.Readonly;
+            }
+        }
+        else {
+            if (this.filesConfigurationService.isReadonly(this.resource)) {
+                capabilities |= EditorInputCapabilities.Readonly;
+            }
+        }
+        if (!(capabilities & EditorInputCapabilities.Readonly)) {
+            capabilities |= EditorInputCapabilities.CanDropIntoEditor;
+        }
+        return capabilities;
+    }
+    getDescription(verbosity = Verbosity.MEDIUM) {
+        if (!this.hasCapability(EditorInputCapabilities.Untitled) || this.editorModelReference?.object.hasAssociatedFilePath()) {
+            return super.getDescription(verbosity);
+        }
+        return undefined;
+    }
+    isReadonly() {
+        if (!this.editorModelReference) {
+            return this.filesConfigurationService.isReadonly(this.resource);
+        }
+        return this.editorModelReference.object.isReadonly();
+    }
+    isDirty() {
+        if (!this.editorModelReference) {
+            return this._defaultDirtyState;
+        }
+        return this.editorModelReference.object.isDirty();
+    }
+    isSaving() {
+        const model = this.editorModelReference?.object;
+        if (!model || !model.isDirty() || model.hasErrorState || this.hasCapability(EditorInputCapabilities.Untitled)) {
+            return false;
+        }
+        return this.filesConfigurationService.hasShortAutoSaveDelay(this);
+    }
+    async save(group, options) {
+        if (this.editorModelReference) {
+            if (this.hasCapability(EditorInputCapabilities.Untitled)) {
+                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(EditorInputCapabilities.Untitled) ? 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 (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) {
+            return { editor: { resource: target }, options: { override: this.viewType } };
+        }
+        return undefined;
+    }
+    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 scratchpad = this.capabilities & EditorInputCapabilities.Scratchpad ? true : false;
+            const ref = await this._notebookModelResolverService.resolve(this.resource, this.viewType, { limits: this.ensureLimits(_options), scratchpad, viewType: this.editorId });
+            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()));
+            this._register(this.editorModelReference.object.onDidRevertUntitled(() => this.dispose()));
+            if (this.editorModelReference.object.isDirty()) {
+                this._onDidChangeDirty.fire();
+            }
+        }
+        else {
+            this.editorModelReference.object.load({ limits: this.ensureLimits(_options) });
+        }
+        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: CellEditType.Replace,
+                    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.resource,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof NotebookEditorInput_1) {
+            return this.viewType === otherInput.viewType && isEqual(this.resource, otherInput.resource);
+        }
+        if (isResourceEditorInput(otherInput) && otherInput.resource.scheme === CellUri.scheme) {
+            return isEqual(this.resource, CellUri.parse(otherInput.resource)?.notebook);
+        }
+        return false;
+    }
+};
+NotebookEditorInput = NotebookEditorInput_1 = ( __decorate([
+    ( __param(4, INotebookService)),
+    ( __param(5, INotebookEditorModelResolverService)),
+    ( __param(6, IFileDialogService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IFileService)),
+    ( __param(9, IFilesConfigurationService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, IEditorService)),
+    ( __param(12, ITextResourceConfigurationService)),
+    ( __param(13, ICustomEditorLabelService))
+], NotebookEditorInput));
+function isCompositeNotebookEditorInput(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && Array.isArray(thing.editorInputs)
+        && (thing.editorInputs.every(input => input instanceof NotebookEditorInput));
+}
+function isNotebookEditorInput(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && thing.typeId === NotebookEditorInput.ID;
+}
+
+export { NotebookEditorInput, isCompositeNotebookEditorInput, isNotebookEditorInput };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookExecutionService.d.ts

@@ -1,5 +1,5 @@
 import { IOutputDto, IOutputItemDto } from "./notebookCommon.js";
-import { INotebookCellExecution } from "@codingame/monaco-vscode-972e8507-3a64-566d-8bc0-b78993998562-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
+import { INotebookCellExecution } from "@codingame/monaco-vscode-af5ccfda-af82-504b-b365-92b4e654e5c5-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
 export declare enum CellExecutionUpdateType {
     Output = 1,
     OutputItems = 2,

package/vscode/src/vs/workbench/contrib/notebook/common/notebookExecutionService.service.d.ts

@@ -1,6 +1,6 @@
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
-import { NotebookCellTextModel } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
+import { NotebookCellTextModel } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
 import { INotebookTextModel } from "./notebookCommon.js";
 import { ICellExecutionParticipant } from "./notebookExecutionService.js";
 export declare const INotebookExecutionService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<INotebookExecutionService>;

package/vscode/src/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service.d.ts

@@ -1,6 +1,6 @@
 import { Event } from "../../../../base/common/event.js";
 import { URI } from "../../../../base/common/uri.js";
-import { ICellExecutionStateChangedEvent, IExecutionStateChangedEvent, INotebookFailStateChangedEvent, INotebookCellExecution, INotebookExecution } from "@codingame/monaco-vscode-972e8507-3a64-566d-8bc0-b78993998562-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
+import { ICellExecutionStateChangedEvent, IExecutionStateChangedEvent, INotebookFailStateChangedEvent, INotebookCellExecution, INotebookExecution } from "@codingame/monaco-vscode-af5ccfda-af82-504b-b365-92b4e654e5c5-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService";
 export declare const INotebookExecutionStateService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<INotebookExecutionStateService>;
 export interface INotebookExecutionStateService {
     _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/notebook/common/notebookRange.d.ts

@@ -0,0 +1,13 @@
+export interface ICellRange {
+    start: number;
+    end: number;
+}
+export declare function isICellRange(candidate: any): candidate is ICellRange;
+export declare function cellIndexesToRanges(indexes: number[]): {
+    start: number;
+    end: number;
+}[];
+export declare function cellRangesToIndexes(ranges: ICellRange[]): number[];
+export declare function reduceCellRanges(ranges: ICellRange[]): ICellRange[];
+export declare function cellRangesEqual(a: ICellRange[], b: ICellRange[]): boolean;
+export declare function cellRangeContains(range: ICellRange, other: ICellRange): boolean;