@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor.d.ts

@@ -0,0 +1,57 @@
+import * as DOM from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { INotebookEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { NotebookOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookOptions";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { NotebookMultiDiffEditorInput } from "./notebookMultiDiffEditorInput.js";
+import type { IMultiDiffEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidgetImpl";
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type IDiffElementViewModelBase } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/diffElementViewModel";
+export declare class NotebookMultiTextDiffEditor extends EditorPane {
+    private readonly instantiationService;
+    private readonly _parentContextKeyService;
+    private readonly notebookEditorWorkerService;
+    private readonly configurationService;
+    private readonly notebookService;
+    private _multiDiffEditorWidget?;
+    static readonly ID: string;
+    private _fontInfo;
+    protected _scopeContextKeyService: IContextKeyService;
+    private readonly modelSpecificResources;
+    private _model?;
+    private viewModel?;
+    private widgetViewModel?;
+    get textModel(): import("../../common/model/notebookTextModel.js").NotebookTextModel | undefined;
+    private _notebookOptions;
+    get notebookOptions(): NotebookOptions;
+    private readonly ctxAllCollapsed;
+    private readonly ctxHasUnchangedCells;
+    private readonly ctxHiddenUnchangedCells;
+    constructor(group: IEditorGroup, instantiationService: IInstantiationService, themeService: IThemeService, _parentContextKeyService: IContextKeyService, notebookEditorWorkerService: INotebookEditorWorkerService, configurationService: IConfigurationService, telemetryService: ITelemetryService, storageService: IStorageService, notebookService: INotebookService);
+    private get fontInfo();
+    layout(dimension: DOM.Dimension, position?: DOM.IDomPosition): void;
+    private createFontInfo;
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: NotebookMultiDiffEditorInput, options: IMultiDiffEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    private _detachModel;
+    _generateFontFamily(): string;
+    setOptions(options: IMultiDiffEditorOptions | undefined): void;
+    getControl(): import("@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/diffEditorWidget").DiffEditorWidget | undefined;
+    focus(): void;
+    hasFocus(): boolean;
+    clearInput(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    hideUnchanged(): void;
+    showUnchanged(): void;
+    getDiffElementViewModel(uri: URI): IDiffElementViewModelBase | undefined;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor.js

@@ -0,0 +1,286 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { createBareFontInfoFromRawSettings } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/fontInfoFromSettings';
+import { PixelRatio } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/pixelRatio';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { EditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { NOTEBOOK_MULTI_DIFF_EDITOR_ID, CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { FontMeasurements } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/config/fontMeasurements';
+import { NotebookOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookOptions';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { NotebookMultiDiffEditorWidgetInput } from './notebookMultiDiffEditorInput.js';
+import { MultiDiffEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget';
+import { ResourceLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { INotebookDocumentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { getIconClassesForLanguageId } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/getIconClasses';
+import { NotebookDiffViewModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel';
+import { NotebookDiffEditorEventDispatcher } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/eventDispatcher';
+import { NOTEBOOK_DIFF_CELLS_COLLAPSED, NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS, NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditorBrowser';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { DiffEditorHeightCalculatorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/editorHeightCalculator';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var NotebookMultiTextDiffEditor_1;
+let NotebookMultiTextDiffEditor = class NotebookMultiTextDiffEditor extends EditorPane {
+    static {
+        NotebookMultiTextDiffEditor_1 = this;
+    }
+    static {
+        this.ID = NOTEBOOK_MULTI_DIFF_EDITOR_ID;
+    }
+    get textModel() {
+        return this._model?.modified.notebook;
+    }
+    get notebookOptions() {
+        return this._notebookOptions;
+    }
+    constructor(
+        group,
+        instantiationService,
+        themeService,
+        _parentContextKeyService,
+        notebookEditorWorkerService,
+        configurationService,
+        telemetryService,
+        storageService,
+        notebookService
+    ) {
+        super(
+            NotebookMultiTextDiffEditor_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
+        this.instantiationService = instantiationService;
+        this._parentContextKeyService = _parentContextKeyService;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.configurationService = configurationService;
+        this.notebookService = notebookService;
+        this.modelSpecificResources = this._register(( new DisposableStore()));
+        this.ctxAllCollapsed = this._parentContextKeyService.createKey(NOTEBOOK_DIFF_CELLS_COLLAPSED.key, false);
+        this.ctxHasUnchangedCells = this._parentContextKeyService.createKey(NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS.key, false);
+        this.ctxHiddenUnchangedCells = this._parentContextKeyService.createKey(NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN.key, true);
+        this._notebookOptions = instantiationService.createInstance(NotebookOptions, this.window, false, undefined);
+        this._register(this._notebookOptions);
+    }
+    get fontInfo() {
+        if (!this._fontInfo) {
+            this._fontInfo = this.createFontInfo();
+        }
+        return this._fontInfo;
+    }
+    layout(dimension, position) {
+        this._multiDiffEditorWidget.layout(dimension);
+    }
+    createFontInfo() {
+        const editorOptions = this.configurationService.getValue("editor");
+        return FontMeasurements.readFontInfo(
+            this.window,
+            createBareFontInfoFromRawSettings(editorOptions, PixelRatio.getInstance(this.window).value)
+        );
+    }
+    createEditor(parent) {
+        this._multiDiffEditorWidget = this._register(this.instantiationService.createInstance(
+            MultiDiffEditorWidget,
+            parent,
+            this.instantiationService.createInstance(WorkbenchUIElementFactory)
+        ));
+        this._register(this._multiDiffEditorWidget.onDidChangeActiveControl(() => {
+            this._onDidChangeControl.fire();
+        }));
+    }
+    async setInput(input, options, context, token) {
+        super.setInput(input, options, context, token);
+        const model = await input.resolve();
+        if (this._model !== model) {
+            this._detachModel();
+            this._model = model;
+        }
+        const eventDispatcher = this.modelSpecificResources.add(( new NotebookDiffEditorEventDispatcher()));
+        const diffEditorHeightCalculator = this.instantiationService.createInstance(DiffEditorHeightCalculatorService, this.fontInfo.lineHeight);
+        this.viewModel = this.modelSpecificResources.add(( new NotebookDiffViewModel(
+            model,
+            this.notebookEditorWorkerService,
+            this.configurationService,
+            eventDispatcher,
+            this.notebookService,
+            diffEditorHeightCalculator,
+            undefined,
+            true
+        )));
+        await this.viewModel.computeDiff(this.modelSpecificResources.add(( new CancellationTokenSource())).token);
+        this.ctxHasUnchangedCells.set(this.viewModel.hasUnchangedCells);
+        this.ctxHasUnchangedCells.set(this.viewModel.hasUnchangedCells);
+        const widgetInput = this.modelSpecificResources.add(
+            NotebookMultiDiffEditorWidgetInput.createInput(this.viewModel, this.instantiationService)
+        );
+        this.widgetViewModel = this.modelSpecificResources.add(await widgetInput.getViewModel());
+        const itemsWeHaveSeen = ( new WeakSet());
+        this.modelSpecificResources.add(autorun(reader => {
+            if (!this.widgetViewModel || !this.viewModel) {
+                return;
+            }
+            const items = this.widgetViewModel.items.read(reader);
+            const diffItems = this.viewModel.value;
+            if (items.length !== diffItems.length) {
+                return;
+            }
+            transaction(tx => {
+                items.forEach(item => {
+                    if (( itemsWeHaveSeen.has(item))) {
+                        return;
+                    }
+                    itemsWeHaveSeen.add(item);
+                    const diffItem = diffItems.find(
+                        d => d.modifiedUri?.toString() === item.modifiedUri?.toString() && d.originalUri?.toString() === item.originalUri?.toString()
+                    );
+                    if (diffItem && diffItem.type === "unchanged") {
+                        item.collapsed.set(true, tx);
+                    }
+                });
+            });
+        }));
+        this._multiDiffEditorWidget.setViewModel(this.widgetViewModel);
+    }
+    _detachModel() {
+        this.viewModel = undefined;
+        this.modelSpecificResources.clear();
+    }
+    _generateFontFamily() {
+        return this.fontInfo.fontFamily ?? `"SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace`;
+    }
+    setOptions(options) {
+        super.setOptions(options);
+    }
+    getControl() {
+        return this._multiDiffEditorWidget.getActiveControl();
+    }
+    focus() {
+        super.focus();
+        this._multiDiffEditorWidget?.getActiveControl()?.focus();
+    }
+    hasFocus() {
+        return this._multiDiffEditorWidget?.getActiveControl()?.hasTextFocus() || super.hasFocus();
+    }
+    clearInput() {
+        super.clearInput();
+        this._multiDiffEditorWidget.setViewModel(undefined);
+        this.modelSpecificResources.clear();
+        this.viewModel = undefined;
+        this.widgetViewModel = undefined;
+    }
+    expandAll() {
+        if (this.widgetViewModel) {
+            this.widgetViewModel.expandAll();
+            this.ctxAllCollapsed.set(false);
+        }
+    }
+    collapseAll() {
+        if (this.widgetViewModel) {
+            this.widgetViewModel.collapseAll();
+            this.ctxAllCollapsed.set(true);
+        }
+    }
+    hideUnchanged() {
+        if (this.viewModel) {
+            this.viewModel.includeUnchanged = false;
+            this.ctxHiddenUnchangedCells.set(true);
+        }
+    }
+    showUnchanged() {
+        if (this.viewModel) {
+            this.viewModel.includeUnchanged = true;
+            this.ctxHiddenUnchangedCells.set(false);
+        }
+    }
+    getDiffElementViewModel(uri) {
+        if (uri.scheme === Schemas.vscodeNotebookCellOutput || uri.scheme === Schemas.vscodeNotebookCellOutputDiff || uri.scheme === Schemas.vscodeNotebookCellMetadata || uri.scheme === Schemas.vscodeNotebookCellMetadataDiff) {
+            const data = CellUri.parseCellPropertyUri(uri, uri.scheme);
+            if (data) {
+                uri = CellUri.generate(data.notebook, data.handle);
+            }
+        }
+        if (uri.scheme === Schemas.vscodeNotebookMetadata) {
+            return this.viewModel?.items.find(
+                item => item.type === "modifiedMetadata" || item.type === "unchangedMetadata"
+            );
+        }
+        return this.viewModel?.items.find(c => {
+            switch (c.type) {
+            case "delete":
+                return c.original?.uri.toString() === ( uri.toString());
+            case "insert":
+                return c.modified?.uri.toString() === ( uri.toString());
+            case "modified":
+            case "unchanged":
+                return c.modified?.uri.toString() === ( uri.toString()) || c.original?.uri.toString() === ( uri.toString());
+            default:
+                return;
+            }
+        });
+    }
+};
+NotebookMultiTextDiffEditor = NotebookMultiTextDiffEditor_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IThemeService)), ( __param(3, IContextKeyService)), ( __param(4, INotebookEditorWorkerService)), ( __param(5, IConfigurationService)), ( __param(6, ITelemetryService)), ( __param(7, IStorageService)), ( __param(8, INotebookService))], NotebookMultiTextDiffEditor));
+let WorkbenchUIElementFactory = class WorkbenchUIElementFactory {
+    constructor(_instantiationService, notebookDocumentService, notebookService) {
+        this._instantiationService = _instantiationService;
+        this.notebookDocumentService = notebookDocumentService;
+        this.notebookService = notebookService;
+    }
+    createResourceLabel(element) {
+        const label = this._instantiationService.createInstance(ResourceLabel, element, {});
+        const that = this;
+        return {
+            setUri(uri, options = {}) {
+                if (!uri) {
+                    label.element.clear();
+                } else {
+                    let name = "";
+                    let description = "";
+                    let extraClasses = undefined;
+                    if (uri.scheme === Schemas.vscodeNotebookCell) {
+                        const notebookDocument = uri.scheme === Schemas.vscodeNotebookCell ? that.notebookDocumentService.getNotebook(uri) : undefined;
+                        const cellIndex = Schemas.vscodeNotebookCell ? that.notebookDocumentService.getNotebook(uri)?.getCellIndex(uri) : undefined;
+                        if (notebookDocument && cellIndex !== undefined) {
+                            name = ( localize(9824, "Cell {0}", `${cellIndex + 1}`));
+                            const nb = notebookDocument ? that.notebookService.getNotebookTextModel(notebookDocument?.uri) : undefined;
+                            const cellLanguage = nb && cellIndex !== undefined ? nb.cells[cellIndex].language : undefined;
+                            extraClasses = cellLanguage ? getIconClassesForLanguageId(cellLanguage) : undefined;
+                        }
+                    } else if (uri.scheme === Schemas.vscodeNotebookCellMetadata || uri.scheme === Schemas.vscodeNotebookCellMetadataDiff) {
+                        description = ( localize(9825, "Metadata"));
+                    } else if (uri.scheme === Schemas.vscodeNotebookCellOutput || uri.scheme === Schemas.vscodeNotebookCellOutputDiff) {
+                        description = ( localize(9826, "Output"));
+                    }
+                    label.element.setResource({
+                        name,
+                        description
+                    }, {
+                        strikethrough: options.strikethrough,
+                        forceLabel: true,
+                        hideIcon: !extraClasses,
+                        extraClasses
+                    });
+                }
+            },
+            dispose() {
+                label.dispose();
+            }
+        };
+    }
+};
+WorkbenchUIElementFactory = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, INotebookDocumentService)), ( __param(2, INotebookService))], WorkbenchUIElementFactory));
+
+export { NotebookMultiTextDiffEditor };

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditorInput.d.ts

@@ -0,0 +1,22 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { ITextResourceConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { MultiDiffEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput";
+import { IResolvedMultiDiffSource, type IMultiDiffSourceResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService";
+import { IMultiDiffSourceResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service";
+import { NotebookDiffViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel";
+import { NotebookDiffEditorInput } from "../../common/notebookDiffEditorInput.js";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+export declare const NotebookMultiDiffEditorScheme = "multi-cell-notebook-diff-editor";
+export declare class NotebookMultiDiffEditorInput extends NotebookDiffEditorInput {
+    static readonly ID: string;
+    static create(instantiationService: IInstantiationService, resource: URI, name: string | undefined, description: string | undefined, originalResource: URI, viewType: string): NotebookMultiDiffEditorInput;
+}
+export declare class NotebookMultiDiffEditorWidgetInput extends MultiDiffEditorInput implements IMultiDiffSourceResolver {
+    private readonly notebookDiffViewModel;
+    static createInput(notebookDiffViewModel: NotebookDiffViewModel, instantiationService: IInstantiationService): NotebookMultiDiffEditorWidgetInput;
+    constructor(multiDiffSource: URI, notebookDiffViewModel: NotebookDiffViewModel, _textModelService: ITextModelService, _textResourceConfigurationService: ITextResourceConfigurationService, _instantiationService: IInstantiationService, _multiDiffSourceResolverService: IMultiDiffSourceResolverService, _textFileService: ITextFileService);
+    canHandleUri(uri: URI): boolean;
+    resolveDiffSource(_: URI): Promise<IResolvedMultiDiffSource>;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditorInput.js

@@ -0,0 +1,82 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { ITextResourceConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { IMultiDiffSourceResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service';
+import { NotebookDiffEditorInput } from '../../common/notebookDiffEditorInput.js';
+import { NotebookEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+
+var NotebookMultiDiffEditorWidgetInput_1;
+const NotebookMultiDiffEditorScheme = "multi-cell-notebook-diff-editor";
+class NotebookMultiDiffEditorInput extends NotebookDiffEditorInput {
+    static {
+        this.ID = "workbench.input.multiDiffNotebookInput";
+    }
+    static create(
+        instantiationService,
+        resource,
+        name,
+        description,
+        originalResource,
+        viewType
+    ) {
+        const original = NotebookEditorInput.getOrCreate(instantiationService, originalResource, undefined, viewType);
+        const modified = NotebookEditorInput.getOrCreate(instantiationService, resource, undefined, viewType);
+        return instantiationService.createInstance(
+            NotebookMultiDiffEditorInput,
+            name,
+            description,
+            original,
+            modified,
+            viewType
+        );
+    }
+}
+let NotebookMultiDiffEditorWidgetInput = NotebookMultiDiffEditorWidgetInput_1 = class NotebookMultiDiffEditorWidgetInput extends MultiDiffEditorInput {
+    static createInput(notebookDiffViewModel, instantiationService) {
+        const multiDiffSource = ( URI.parse(`${NotebookMultiDiffEditorScheme}:${( ( new Date()).getMilliseconds().toString()) + ( Math.random().toString())}`));
+        return instantiationService.createInstance(
+            NotebookMultiDiffEditorWidgetInput_1,
+            multiDiffSource,
+            notebookDiffViewModel
+        );
+    }
+    constructor(
+        multiDiffSource,
+        notebookDiffViewModel,
+        _textModelService,
+        _textResourceConfigurationService,
+        _instantiationService,
+        _multiDiffSourceResolverService,
+        _textFileService
+    ) {
+        super(
+            multiDiffSource,
+            undefined,
+            undefined,
+            true,
+            _textModelService,
+            _textResourceConfigurationService,
+            _instantiationService,
+            _multiDiffSourceResolverService,
+            _textFileService
+        );
+        this.notebookDiffViewModel = notebookDiffViewModel;
+        this._register(_multiDiffSourceResolverService.registerResolver(this));
+    }
+    canHandleUri(uri) {
+        return ( uri.toString()) === ( this.multiDiffSource.toString());
+    }
+    async resolveDiffSource(_) {
+        return {
+            resources: this.notebookDiffViewModel
+        };
+    }
+};
+NotebookMultiDiffEditorWidgetInput = NotebookMultiDiffEditorWidgetInput_1 = ( __decorate([( __param(2, ITextModelService)), ( __param(3, ITextResourceConfigurationService)), ( __param(4, IInstantiationService)), ( __param(5, IMultiDiffSourceResolverService)), ( __param(6, ITextFileService))], NotebookMultiDiffEditorWidgetInput));
+
+export { NotebookMultiDiffEditorInput, NotebookMultiDiffEditorScheme, NotebookMultiDiffEditorWidgetInput };