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

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

@@ -1,911 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { append, $ as $$1, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, scheduleAtNextAnimationFrame } from 'vscode/vscode/vs/base/browser/dom';
-import { findLastIdx } from 'vscode/vscode/vs/base/common/arraysFind';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { registerThemingParticipant, IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { getDefaultNotebookCreationOptions } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { SideBySideDiffElementViewModel, SingleSideDiffElementViewModel } from './diffElementViewModel.js';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { CellDiffSingleSideRenderer, CellDiffSideBySideRenderer, NotebookTextDiffList, NotebookCellTextDiffListDelegate } from './notebookDiffList.js';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import 'vscode/vscode/vs/platform/theme/common/colorUtils';
-import { foreground, focusBorder } from 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
-import { editorBackground, diffDiagonalFill } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
-import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
-import { INotebookEditorWorkerService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { BareFontInfo } from 'vscode/vscode/vs/editor/common/config/fontInfo';
-import { PixelRatio } from 'vscode/vscode/vs/base/browser/pixelRatio';
-import { DiffSide, DIFF_CELL_MARGIN } from './notebookDiffEditorBrowser.js';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
-import { NOTEBOOK_DIFF_EDITOR_ID, NotebookSetting, CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { SequencerByKey } from 'vscode/vscode/vs/base/common/async';
-import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { DiffNestedCellViewModel } from './diffNestedCellViewModel.js';
-import { BackLayerWebView } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/view/renderers/backLayerWebView';
-import { NotebookDiffEditorEventDispatcher, NotebookDiffLayoutChangedEvent } from './eventDispatcher.js';
-import { FontMeasurements } from 'vscode/vscode/vs/editor/browser/config/fontMeasurements';
-import { NotebookOptions } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookOptions';
-import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { cellRangesToIndexes, cellIndexesToRanges } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookRange';
-import { NotebookDiffOverviewRuler } from './notebookDiffOverviewRuler.js';
-import { registerZIndex, ZIndex } from 'vscode/vscode/vs/platform/layout/browser/zIndexRegistry';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-
-var NotebookTextDiffEditor_1;
-const $ = $$1;
-class NotebookDiffEditorSelection {
-    constructor(selections) {
-        this.selections = selections;
-    }
-    compare(other) {
-        if (!(other instanceof NotebookDiffEditorSelection)) {
-            return 3 ;
-        }
-        if (this.selections.length !== other.selections.length) {
-            return 3 ;
-        }
-        for (let i = 0; i < this.selections.length; i++) {
-            if (this.selections[i] !== other.selections[i]) {
-                return 3 ;
-            }
-        }
-        return 1 ;
-    }
-    restore(options) {
-        const notebookOptions = {
-            cellSelections: cellIndexesToRanges(this.selections)
-        };
-        Object.assign(notebookOptions, options);
-        return notebookOptions;
-    }
-}
-let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
-    static { NotebookTextDiffEditor_1 = this; }
-    static { this.ENTIRE_DIFF_OVERVIEW_WIDTH = 30; }
-    static { this.ID = NOTEBOOK_DIFF_EDITOR_ID; }
-    get textModel() {
-        return this._model?.modified.notebook;
-    }
-    get notebookOptions() {
-        return this._notebookOptions;
-    }
-    get isDisposed() {
-        return this._isDisposed;
-    }
-    constructor(group, instantiationService, themeService, contextKeyService, notebookEditorWorkerService, configurationService, telemetryService, storageService, notebookExecutionStateService, codeEditorService) {
-        super(NotebookTextDiffEditor_1.ID, group, telemetryService, themeService, storageService);
-        this.instantiationService = instantiationService;
-        this.contextKeyService = contextKeyService;
-        this.notebookEditorWorkerService = notebookEditorWorkerService;
-        this.configurationService = configurationService;
-        this.creationOptions = getDefaultNotebookCreationOptions();
-        this._dimension = null;
-        this._diffElementViewModels = [];
-        this._modifiedWebview = null;
-        this._originalWebview = null;
-        this._webviewTransparentCover = null;
-        this._onMouseUp = this._register(( new Emitter()));
-        this.onMouseUp = this._onMouseUp.event;
-        this._onDidScroll = this._register(( new Emitter()));
-        this.onDidScroll = this._onDidScroll.event;
-        this.onDidChangeScroll = this._onDidScroll.event;
-        this._model = null;
-        this._modifiedResourceDisposableStore = this._register(( new DisposableStore()));
-        this._insetModifyQueueByOutputId = ( new SequencerByKey());
-        this._onDidDynamicOutputRendered = this._register(( new Emitter()));
-        this.onDidDynamicOutputRendered = this._onDidDynamicOutputRendered.event;
-        this._localStore = this._register(( new DisposableStore()));
-        this._onDidChangeSelection = this._register(( new Emitter()));
-        this.onDidChangeSelection = this._onDidChangeSelection.event;
-        this._isDisposed = false;
-        this.pendingLayouts = ( new WeakMap());
-        this._notebookOptions = ( new NotebookOptions(
-            this.window,
-            this.configurationService,
-            notebookExecutionStateService,
-            codeEditorService,
-            false
-        ));
-        this._register(this._notebookOptions);
-        this._revealFirst = true;
-    }
-    get fontInfo() {
-        if (!this._fontInfo) {
-            this._fontInfo = this.createFontInfo();
-        }
-        return this._fontInfo;
-    }
-    createFontInfo() {
-        const editorOptions = this.configurationService.getValue('editor');
-        return FontMeasurements.readFontInfo(this.window, BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.getInstance(this.window).value));
-    }
-    isOverviewRulerEnabled() {
-        return this.configurationService.getValue(NotebookSetting.diffOverviewRuler) ?? false;
-    }
-    getSelection() {
-        const selections = this._list.getFocus();
-        return ( new NotebookDiffEditorSelection(selections));
-    }
-    toggleNotebookCellSelection(cell) {
-    }
-    updatePerformanceMetadata(cellId, executionId, duration, rendererId) {
-    }
-    async focusNotebookCell(cell, focus) {
-    }
-    async focusNextNotebookCell(cell, focus) {
-    }
-    didFocusOutputInputChange(inputFocused) {
-    }
-    getScrollTop() {
-        return this._list?.scrollTop ?? 0;
-    }
-    getScrollHeight() {
-        return this._list?.scrollHeight ?? 0;
-    }
-    getScrollPosition() {
-        return {
-            scrollTop: this.getScrollTop(),
-            scrollLeft: this._list?.scrollLeft ?? 0
-        };
-    }
-    setScrollPosition(scrollPosition) {
-        if (!this._list) {
-            return;
-        }
-        this._list.scrollTop = scrollPosition.scrollTop;
-        if (scrollPosition.scrollLeft !== undefined) {
-            this._list.scrollLeft = scrollPosition.scrollLeft;
-        }
-    }
-    delegateVerticalScrollbarPointerDown(browserEvent) {
-        this._list?.delegateVerticalScrollbarPointerDown(browserEvent);
-    }
-    updateOutputHeight(cellInfo, output, outputHeight, isInit) {
-        const diffElement = cellInfo.diffElement;
-        const cell = this.getCellByInfo(cellInfo);
-        const outputIndex = cell.outputsViewModels.indexOf(output);
-        if (diffElement instanceof SideBySideDiffElementViewModel) {
-            const info = CellUri.parse(cellInfo.cellUri);
-            if (!info) {
-                return;
-            }
-            diffElement.updateOutputHeight(( info.notebook.toString()) === this._model?.original.resource.toString() ? DiffSide.Original : DiffSide.Modified, outputIndex, outputHeight);
-        }
-        else {
-            diffElement.updateOutputHeight(diffElement.type === 'insert' ? DiffSide.Modified : DiffSide.Original, outputIndex, outputHeight);
-        }
-        if (isInit) {
-            this._onDidDynamicOutputRendered.fire({ cell, output });
-        }
-    }
-    setMarkupCellEditState(cellId, editState) {
-    }
-    didStartDragMarkupCell(cellId, event) {
-    }
-    didDragMarkupCell(cellId, event) {
-    }
-    didEndDragMarkupCell(cellId) {
-    }
-    didDropMarkupCell(cellId) {
-    }
-    didResizeOutput(cellId) {
-    }
-    createEditor(parent) {
-        this._rootElement = append(parent, $$1('.notebook-text-diff-editor'));
-        this._overflowContainer = document.createElement('div');
-        this._overflowContainer.classList.add('notebook-overflow-widget-container', 'monaco-editor');
-        append(parent, this._overflowContainer);
-        const renderers = [
-            this.instantiationService.createInstance(CellDiffSingleSideRenderer, this),
-            this.instantiationService.createInstance(CellDiffSideBySideRenderer, this),
-        ];
-        this._listViewContainer = append(this._rootElement, $$1('.notebook-diff-list-view'));
-        this._list = this.instantiationService.createInstance(NotebookTextDiffList, 'NotebookTextDiff', this._listViewContainer, this.instantiationService.createInstance(NotebookCellTextDiffListDelegate, this.window), renderers, this.contextKeyService, {
-            setRowLineHeight: false,
-            setRowHeight: false,
-            supportDynamicHeights: true,
-            horizontalScrolling: false,
-            keyboardSupport: false,
-            mouseSupport: true,
-            multipleSelectionSupport: false,
-            typeNavigationEnabled: true,
-            paddingBottom: 0,
-            styleController: (_suffix) => { return this._list; },
-            overrideStyles: {
-                listBackground: editorBackground,
-                listActiveSelectionBackground: editorBackground,
-                listActiveSelectionForeground: foreground,
-                listFocusAndSelectionBackground: editorBackground,
-                listFocusAndSelectionForeground: foreground,
-                listFocusBackground: editorBackground,
-                listFocusForeground: foreground,
-                listHoverForeground: foreground,
-                listHoverBackground: editorBackground,
-                listHoverOutline: focusBorder,
-                listFocusOutline: focusBorder,
-                listInactiveSelectionBackground: editorBackground,
-                listInactiveSelectionForeground: foreground,
-                listInactiveFocusBackground: editorBackground,
-                listInactiveFocusOutline: editorBackground,
-            },
-            accessibilityProvider: {
-                getAriaLabel() { return null; },
-                getWidgetAriaLabel() {
-                    return ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor',
-                        'notebookTreeAriaLabel',
-                        "Notebook Text Diff"
-                    ));
-                }
-            },
-        });
-        this._register(this._list);
-        this._register(this._list.onMouseUp(e => {
-            if (e.element) {
-                this._onMouseUp.fire({ event: e.browserEvent, target: e.element });
-            }
-        }));
-        this._register(this._list.onDidScroll(() => {
-            this._onDidScroll.fire();
-        }));
-        this._register(this._list.onDidChangeFocus(() => this._onDidChangeSelection.fire({ reason: 2  })));
-        this._overviewRulerContainer = document.createElement('div');
-        this._overviewRulerContainer.classList.add('notebook-overview-ruler-container');
-        this._rootElement.appendChild(this._overviewRulerContainer);
-        this._registerOverviewRuler();
-        this._webviewTransparentCover = append(this._list.rowsContainer, $('.webview-cover'));
-        this._webviewTransparentCover.style.display = 'none';
-        this._register(addStandardDisposableGenericMouseDownListener(this._overflowContainer, (e) => {
-            if (e.target.classList.contains('slider') && this._webviewTransparentCover) {
-                this._webviewTransparentCover.style.display = 'block';
-            }
-        }));
-        this._register(addStandardDisposableGenericMouseUpListener(this._overflowContainer, () => {
-            if (this._webviewTransparentCover) {
-                this._webviewTransparentCover.style.display = 'none';
-            }
-        }));
-        this._register(this._list.onDidScroll(e => {
-            this._webviewTransparentCover.style.top = `${e.scrollTop}px`;
-        }));
-    }
-    _registerOverviewRuler() {
-        this._overviewRuler = this._register(this.instantiationService.createInstance(NotebookDiffOverviewRuler, this, NotebookTextDiffEditor_1.ENTIRE_DIFF_OVERVIEW_WIDTH, this._overviewRulerContainer));
-    }
-    _updateOutputsOffsetsInWebview(scrollTop, scrollHeight, activeWebview, getActiveNestedCell, diffSide) {
-        activeWebview.element.style.height = `${scrollHeight}px`;
-        if (activeWebview.insetMapping) {
-            const updateItems = [];
-            const removedItems = [];
-            activeWebview.insetMapping.forEach((value, key) => {
-                const cell = getActiveNestedCell(value.cellInfo.diffElement);
-                if (!cell) {
-                    return;
-                }
-                const viewIndex = this._list.indexOf(value.cellInfo.diffElement);
-                if (viewIndex === undefined) {
-                    return;
-                }
-                if (cell.outputsViewModels.indexOf(key) < 0) {
-                    removedItems.push(key);
-                }
-                else {
-                    const cellTop = this._list.getCellViewScrollTop(value.cellInfo.diffElement);
-                    const outputIndex = cell.outputsViewModels.indexOf(key);
-                    const outputOffset = value.cellInfo.diffElement.getOutputOffsetInCell(diffSide, outputIndex);
-                    updateItems.push({
-                        cell,
-                        output: key,
-                        cellTop: cellTop,
-                        outputOffset: outputOffset,
-                        forceDisplay: false
-                    });
-                }
-            });
-            activeWebview.removeInsets(removedItems);
-            if (updateItems.length) {
-                activeWebview.updateScrollTops(updateItems, []);
-            }
-        }
-    }
-    async setInput(input, options, context, token) {
-        await super.setInput(input, options, context, token);
-        const model = await input.resolve();
-        if (this._model !== model) {
-            this._detachModel();
-            this._model = model;
-            this._attachModel();
-        }
-        this._model = model;
-        if (this._model === null) {
-            return;
-        }
-        this._revealFirst = true;
-        this._modifiedResourceDisposableStore.clear();
-        this._layoutCancellationTokenSource = ( new CancellationTokenSource());
-        this._modifiedResourceDisposableStore.add(Event.any(this._model.original.notebook.onDidChangeContent, this._model.modified.notebook.onDidChangeContent)(e => {
-            if (this._model !== null) {
-                this._layoutCancellationTokenSource?.dispose();
-                this._layoutCancellationTokenSource = ( new CancellationTokenSource());
-                this.updateLayout(this._layoutCancellationTokenSource.token);
-            }
-        }));
-        await this._createOriginalWebview(generateUuid(), this._model.original.viewType, this._model.original.resource);
-        if (this._originalWebview) {
-            this._modifiedResourceDisposableStore.add(this._originalWebview);
-        }
-        await this._createModifiedWebview(generateUuid(), this._model.modified.viewType, this._model.modified.resource);
-        if (this._modifiedWebview) {
-            this._modifiedResourceDisposableStore.add(this._modifiedWebview);
-        }
-        await this.updateLayout(this._layoutCancellationTokenSource.token, options?.cellSelections ? cellRangesToIndexes(options.cellSelections) : undefined);
-    }
-    _detachModel() {
-        this._localStore.clear();
-        this._originalWebview?.dispose();
-        this._originalWebview?.element.remove();
-        this._originalWebview = null;
-        this._modifiedWebview?.dispose();
-        this._modifiedWebview?.element.remove();
-        this._modifiedWebview = null;
-        this._modifiedResourceDisposableStore.clear();
-        this._list.clear();
-    }
-    _attachModel() {
-        this._eventDispatcher = ( new NotebookDiffEditorEventDispatcher());
-        const updateInsets = () => {
-            scheduleAtNextAnimationFrame(this.window, () => {
-                if (this._isDisposed) {
-                    return;
-                }
-                if (this._modifiedWebview) {
-                    this._updateOutputsOffsetsInWebview(this._list.scrollTop, this._list.scrollHeight, this._modifiedWebview, (diffElement) => {
-                        return diffElement.modified;
-                    }, DiffSide.Modified);
-                }
-                if (this._originalWebview) {
-                    this._updateOutputsOffsetsInWebview(this._list.scrollTop, this._list.scrollHeight, this._originalWebview, (diffElement) => {
-                        return diffElement.original;
-                    }, DiffSide.Original);
-                }
-            });
-        };
-        this._localStore.add(this._list.onDidChangeContentHeight(() => {
-            updateInsets();
-        }));
-        this._localStore.add(this._eventDispatcher.onDidChangeCellLayout(() => {
-            updateInsets();
-        }));
-    }
-    async _createModifiedWebview(id, viewType, resource) {
-        this._modifiedWebview?.dispose();
-        this._modifiedWebview = this.instantiationService.createInstance(BackLayerWebView, this, id, viewType, resource, {
-            ...this._notebookOptions.computeDiffWebviewOptions(),
-            fontFamily: this._generateFontFamily()
-        }, undefined);
-        this._list.rowsContainer.insertAdjacentElement('afterbegin', this._modifiedWebview.element);
-        this._modifiedWebview.createWebview(this.window);
-        this._modifiedWebview.element.style.width = `calc(50% - 16px)`;
-        this._modifiedWebview.element.style.left = `calc(50%)`;
-    }
-    _generateFontFamily() {
-        return this.fontInfo.fontFamily ?? `"SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace`;
-    }
-    async _createOriginalWebview(id, viewType, resource) {
-        this._originalWebview?.dispose();
-        this._originalWebview = this.instantiationService.createInstance(BackLayerWebView, this, id, viewType, resource, {
-            ...this._notebookOptions.computeDiffWebviewOptions(),
-            fontFamily: this._generateFontFamily()
-        }, undefined);
-        this._list.rowsContainer.insertAdjacentElement('afterbegin', this._originalWebview.element);
-        this._originalWebview.createWebview(this.window);
-        this._originalWebview.element.style.width = `calc(50% - 16px)`;
-        this._originalWebview.element.style.left = `16px`;
-    }
-    setOptions(options) {
-        const selections = options?.cellSelections ? cellRangesToIndexes(options.cellSelections) : undefined;
-        if (selections) {
-            this._list.setFocus(selections);
-        }
-    }
-    async updateLayout(token, selections) {
-        if (!this._model) {
-            return;
-        }
-        const diffResult = await this.notebookEditorWorkerService.computeDiff(this._model.original.resource, this._model.modified.resource);
-        if (token.isCancellationRequested) {
-            return;
-        }
-        NotebookTextDiffEditor_1.prettyChanges(this._model, diffResult.cellsDiff);
-        const { viewModels, firstChangeIndex } = NotebookTextDiffEditor_1.computeDiff(this.instantiationService, this.configurationService, this._model, this._eventDispatcher, diffResult, this.fontInfo);
-        const isSame = this._isViewModelTheSame(viewModels);
-        if (!isSame) {
-            this._originalWebview?.removeInsets([...this._originalWebview?.insetMapping.keys()]);
-            this._modifiedWebview?.removeInsets([...this._modifiedWebview?.insetMapping.keys()]);
-            this._setViewModel(viewModels);
-        }
-        if (this._revealFirst && firstChangeIndex !== -1 && firstChangeIndex < this._list.length) {
-            this._revealFirst = false;
-            this._list.setFocus([firstChangeIndex]);
-            this._list.reveal(firstChangeIndex, 0.3);
-        }
-        if (selections) {
-            this._list.setFocus(selections);
-        }
-    }
-    _isViewModelTheSame(viewModels) {
-        let isSame = true;
-        if (this._diffElementViewModels.length === viewModels.length) {
-            for (let i = 0; i < viewModels.length; i++) {
-                const a = this._diffElementViewModels[i];
-                const b = viewModels[i];
-                if (a.original?.textModel.getHashValue() !== b.original?.textModel.getHashValue()
-                    || a.modified?.textModel.getHashValue() !== b.modified?.textModel.getHashValue()) {
-                    isSame = false;
-                    break;
-                }
-            }
-        }
-        else {
-            isSame = false;
-        }
-        return isSame;
-    }
-    _setViewModel(viewModels) {
-        this._diffElementViewModels = viewModels;
-        this._list.splice(0, this._list.length, this._diffElementViewModels);
-        if (this.isOverviewRulerEnabled()) {
-            this._overviewRuler.updateViewModels(this._diffElementViewModels, this._eventDispatcher);
-        }
-    }
-    static prettyChanges(model, diffResult) {
-        const changes = diffResult.changes;
-        for (let i = 0; i < diffResult.changes.length - 1; i++) {
-            const curr = changes[i];
-            const next = changes[i + 1];
-            const x = curr.originalStart;
-            const y = curr.modifiedStart;
-            if (curr.originalLength === 1
-                && curr.modifiedLength === 0
-                && next.originalStart === x + 2
-                && next.originalLength === 0
-                && next.modifiedStart === y + 1
-                && next.modifiedLength === 1
-                && model.original.notebook.cells[x].getHashValue() === model.modified.notebook.cells[y + 1].getHashValue()
-                && model.original.notebook.cells[x + 1].getHashValue() === model.modified.notebook.cells[y].getHashValue()) {
-                curr.originalStart = x;
-                curr.originalLength = 0;
-                curr.modifiedStart = y;
-                curr.modifiedLength = 1;
-                next.originalStart = x + 1;
-                next.originalLength = 1;
-                next.modifiedStart = y + 2;
-                next.modifiedLength = 0;
-                i++;
-            }
-        }
-    }
-    static computeDiff(instantiationService, configurationService, model, eventDispatcher, diffResult, fontInfo) {
-        const cellChanges = diffResult.cellsDiff.changes;
-        const diffElementViewModels = [];
-        const originalModel = model.original.notebook;
-        const modifiedModel = model.modified.notebook;
-        let originalCellIndex = 0;
-        let modifiedCellIndex = 0;
-        let firstChangeIndex = -1;
-        const initData = {
-            metadataStatusHeight: configurationService.getValue('notebook.diff.ignoreMetadata') ? 0 : 25,
-            outputStatusHeight: configurationService.getValue('notebook.diff.ignoreOutputs') || !!(modifiedModel.transientOptions.transientOutputs) ? 0 : 25,
-            fontInfo
-        };
-        for (let i = 0; i < cellChanges.length; i++) {
-            const change = cellChanges[i];
-            for (let j = 0; j < change.originalStart - originalCellIndex; j++) {
-                const originalCell = originalModel.cells[originalCellIndex + j];
-                const modifiedCell = modifiedModel.cells[modifiedCellIndex + j];
-                if (originalCell.getHashValue() === modifiedCell.getHashValue()) {
-                    diffElementViewModels.push(( new SideBySideDiffElementViewModel(
-                        model.modified.notebook,
-                        model.original.notebook,
-                        instantiationService.createInstance(DiffNestedCellViewModel, originalCell),
-                        instantiationService.createInstance(DiffNestedCellViewModel, modifiedCell),
-                        'unchanged',
-                        eventDispatcher,
-                        initData
-                    )));
-                }
-                else {
-                    if (firstChangeIndex === -1) {
-                        firstChangeIndex = diffElementViewModels.length;
-                    }
-                    diffElementViewModels.push(( new SideBySideDiffElementViewModel(
-                        model.modified.notebook,
-                        model.original.notebook,
-                        instantiationService.createInstance(DiffNestedCellViewModel, originalCell),
-                        instantiationService.createInstance(DiffNestedCellViewModel, modifiedCell),
-                        'modified',
-                        eventDispatcher,
-                        initData
-                    )));
-                }
-            }
-            const modifiedLCS = NotebookTextDiffEditor_1.computeModifiedLCS(instantiationService, change, originalModel, modifiedModel, eventDispatcher, initData);
-            if (modifiedLCS.length && firstChangeIndex === -1) {
-                firstChangeIndex = diffElementViewModels.length;
-            }
-            diffElementViewModels.push(...modifiedLCS);
-            originalCellIndex = change.originalStart + change.originalLength;
-            modifiedCellIndex = change.modifiedStart + change.modifiedLength;
-        }
-        for (let i = originalCellIndex; i < originalModel.cells.length; i++) {
-            diffElementViewModels.push(( new SideBySideDiffElementViewModel(
-                model.modified.notebook,
-                model.original.notebook,
-                instantiationService.createInstance(DiffNestedCellViewModel, originalModel.cells[i]),
-                instantiationService.createInstance(DiffNestedCellViewModel, modifiedModel.cells[i - originalCellIndex + modifiedCellIndex]),
-                'unchanged',
-                eventDispatcher,
-                initData
-            )));
-        }
-        return {
-            viewModels: diffElementViewModels,
-            firstChangeIndex
-        };
-    }
-    static computeModifiedLCS(instantiationService, change, originalModel, modifiedModel, eventDispatcher, initData) {
-        const result = [];
-        const modifiedLen = Math.min(change.originalLength, change.modifiedLength);
-        for (let j = 0; j < modifiedLen; j++) {
-            const isTheSame = originalModel.cells[change.originalStart + j].equal(modifiedModel.cells[change.modifiedStart + j]);
-            result.push(( new SideBySideDiffElementViewModel(
-                modifiedModel,
-                originalModel,
-                instantiationService.createInstance(DiffNestedCellViewModel, originalModel.cells[change.originalStart + j]),
-                instantiationService.createInstance(DiffNestedCellViewModel, modifiedModel.cells[change.modifiedStart + j]),
-                isTheSame ? 'unchanged' : 'modified',
-                eventDispatcher,
-                initData
-            )));
-        }
-        for (let j = modifiedLen; j < change.originalLength; j++) {
-            result.push(( new SingleSideDiffElementViewModel(
-                originalModel,
-                modifiedModel,
-                instantiationService.createInstance(DiffNestedCellViewModel, originalModel.cells[change.originalStart + j]),
-                undefined,
-                'delete',
-                eventDispatcher,
-                initData
-            )));
-        }
-        for (let j = modifiedLen; j < change.modifiedLength; j++) {
-            result.push(( new SingleSideDiffElementViewModel(
-                modifiedModel,
-                originalModel,
-                undefined,
-                instantiationService.createInstance(DiffNestedCellViewModel, modifiedModel.cells[change.modifiedStart + j]),
-                'insert',
-                eventDispatcher,
-                initData
-            )));
-        }
-        return result;
-    }
-    scheduleOutputHeightAck(cellInfo, outputId, height) {
-        const diffElement = cellInfo.diffElement;
-        let diffSide = DiffSide.Original;
-        if (diffElement instanceof SideBySideDiffElementViewModel) {
-            const info = CellUri.parse(cellInfo.cellUri);
-            if (!info) {
-                return;
-            }
-            diffSide = ( info.notebook.toString()) === this._model?.original.resource.toString() ? DiffSide.Original : DiffSide.Modified;
-        }
-        else {
-            diffSide = diffElement.type === 'insert' ? DiffSide.Modified : DiffSide.Original;
-        }
-        const webview = diffSide === DiffSide.Modified ? this._modifiedWebview : this._originalWebview;
-        scheduleAtNextAnimationFrame(this.window, () => {
-            webview?.ackHeight([{ cellId: cellInfo.cellId, outputId, height }]);
-        }, 10);
-    }
-    layoutNotebookCell(cell, height) {
-        const relayout = (cell, height) => {
-            this._list.updateElementHeight2(cell, height);
-        };
-        if (( this.pendingLayouts.has(cell))) {
-            this.pendingLayouts.get(cell).dispose();
-        }
-        let r;
-        const layoutDisposable = scheduleAtNextAnimationFrame(this.window, () => {
-            this.pendingLayouts.delete(cell);
-            relayout(cell, height);
-            r();
-        });
-        this.pendingLayouts.set(cell, toDisposable(() => {
-            layoutDisposable.dispose();
-            r();
-        }));
-        return ( new Promise(resolve => { r = resolve; }));
-    }
-    setScrollTop(scrollTop) {
-        this._list.scrollTop = scrollTop;
-    }
-    triggerScroll(event) {
-        this._list.triggerScrollFromMouseWheelEvent(event);
-    }
-    previousChange() {
-        let currFocus = this._list.getFocus()[0];
-        if (isNaN(currFocus) || currFocus < 0) {
-            currFocus = 0;
-        }
-        let prevChangeIndex = currFocus - 1;
-        while (prevChangeIndex >= 0) {
-            const vm = this._diffElementViewModels[prevChangeIndex];
-            if (vm.type !== 'unchanged') {
-                break;
-            }
-            prevChangeIndex--;
-        }
-        if (prevChangeIndex >= 0) {
-            this._list.setFocus([prevChangeIndex]);
-            this._list.reveal(prevChangeIndex);
-        }
-        else {
-            const index = findLastIdx(this._diffElementViewModels, vm => vm.type !== 'unchanged');
-            if (index >= 0) {
-                this._list.setFocus([index]);
-                this._list.reveal(index);
-            }
-        }
-    }
-    nextChange() {
-        let currFocus = this._list.getFocus()[0];
-        if (isNaN(currFocus) || currFocus < 0) {
-            currFocus = 0;
-        }
-        let nextChangeIndex = currFocus + 1;
-        while (nextChangeIndex < this._diffElementViewModels.length) {
-            const vm = this._diffElementViewModels[nextChangeIndex];
-            if (vm.type !== 'unchanged') {
-                break;
-            }
-            nextChangeIndex++;
-        }
-        if (nextChangeIndex < this._diffElementViewModels.length) {
-            this._list.setFocus([nextChangeIndex]);
-            this._list.reveal(nextChangeIndex);
-        }
-        else {
-            const index = this._diffElementViewModels.findIndex(vm => vm.type !== 'unchanged');
-            if (index >= 0) {
-                this._list.setFocus([index]);
-                this._list.reveal(index);
-            }
-        }
-    }
-    createOutput(cellDiffViewModel, cellViewModel, output, getOffset, diffSide) {
-        this._insetModifyQueueByOutputId.queue(output.source.model.outputId + (diffSide === DiffSide.Modified ? '-right' : 'left'), async () => {
-            const activeWebview = diffSide === DiffSide.Modified ? this._modifiedWebview : this._originalWebview;
-            if (!activeWebview) {
-                return;
-            }
-            if (!( activeWebview.insetMapping.has(output.source))) {
-                const cellTop = this._list.getCellViewScrollTop(cellDiffViewModel);
-                await activeWebview.createOutput({ diffElement: cellDiffViewModel, cellHandle: cellViewModel.handle, cellId: cellViewModel.id, cellUri: cellViewModel.uri }, output, cellTop, getOffset());
-            }
-            else {
-                const cellTop = this._list.getCellViewScrollTop(cellDiffViewModel);
-                const outputIndex = cellViewModel.outputsViewModels.indexOf(output.source);
-                const outputOffset = cellDiffViewModel.getOutputOffsetInCell(diffSide, outputIndex);
-                activeWebview.updateScrollTops([{
-                        cell: cellViewModel,
-                        output: output.source,
-                        cellTop,
-                        outputOffset,
-                        forceDisplay: true
-                    }], []);
-            }
-        });
-    }
-    updateMarkupCellHeight() {
-    }
-    getCellByInfo(cellInfo) {
-        return cellInfo.diffElement.getCellByUri(cellInfo.cellUri);
-    }
-    getCellById(cellId) {
-        throw new Error('Not implemented');
-    }
-    removeInset(cellDiffViewModel, cellViewModel, displayOutput, diffSide) {
-        this._insetModifyQueueByOutputId.queue(displayOutput.model.outputId + (diffSide === DiffSide.Modified ? '-right' : 'left'), async () => {
-            const activeWebview = diffSide === DiffSide.Modified ? this._modifiedWebview : this._originalWebview;
-            if (!activeWebview) {
-                return;
-            }
-            if (!( activeWebview.insetMapping.has(displayOutput))) {
-                return;
-            }
-            activeWebview.removeInsets([displayOutput]);
-        });
-    }
-    showInset(cellDiffViewModel, cellViewModel, displayOutput, diffSide) {
-        this._insetModifyQueueByOutputId.queue(displayOutput.model.outputId + (diffSide === DiffSide.Modified ? '-right' : 'left'), async () => {
-            const activeWebview = diffSide === DiffSide.Modified ? this._modifiedWebview : this._originalWebview;
-            if (!activeWebview) {
-                return;
-            }
-            if (!( activeWebview.insetMapping.has(displayOutput))) {
-                return;
-            }
-            const cellTop = this._list.getCellViewScrollTop(cellDiffViewModel);
-            const outputIndex = cellViewModel.outputsViewModels.indexOf(displayOutput);
-            const outputOffset = cellDiffViewModel.getOutputOffsetInCell(diffSide, outputIndex);
-            activeWebview.updateScrollTops([{
-                    cell: cellViewModel,
-                    output: displayOutput,
-                    cellTop,
-                    outputOffset,
-                    forceDisplay: true,
-                }], []);
-        });
-    }
-    hideInset(cellDiffViewModel, cellViewModel, output) {
-        this._modifiedWebview?.hideInset(output);
-        this._originalWebview?.hideInset(output);
-    }
-    getDomNode() {
-        return this._rootElement;
-    }
-    getOverflowContainerDomNode() {
-        return this._overflowContainer;
-    }
-    getControl() {
-        return this;
-    }
-    clearInput() {
-        super.clearInput();
-        this._modifiedResourceDisposableStore.clear();
-        this._list?.splice(0, this._list?.length || 0);
-        this._model = null;
-        this._diffElementViewModels.forEach(vm => vm.dispose());
-        this._diffElementViewModels = [];
-    }
-    deltaCellOutputContainerClassNames(diffSide, cellId, added, removed) {
-        if (diffSide === DiffSide.Original) {
-            this._originalWebview?.deltaCellContainerClassNames(cellId, added, removed);
-        }
-        else {
-            this._modifiedWebview?.deltaCellContainerClassNames(cellId, added, removed);
-        }
-    }
-    getLayoutInfo() {
-        if (!this._list) {
-            throw new Error('Editor is not initalized successfully');
-        }
-        return {
-            width: this._dimension.width,
-            height: this._dimension.height,
-            fontInfo: this.fontInfo,
-            scrollHeight: this._list?.getScrollHeight() ?? 0,
-            stickyHeight: 0,
-        };
-    }
-    getCellOutputLayoutInfo(nestedCell) {
-        if (!this._model) {
-            throw new Error('Editor is not attached to model yet');
-        }
-        const documentModel = CellUri.parse(nestedCell.uri);
-        if (!documentModel) {
-            throw new Error('Nested cell in the diff editor has wrong Uri');
-        }
-        const belongToOriginalDocument = ( this._model.original.notebook.uri.toString()) === ( documentModel.notebook.toString());
-        const viewModel = this._diffElementViewModels.find(element => {
-            const textModel = belongToOriginalDocument ? element.original : element.modified;
-            if (!textModel) {
-                return false;
-            }
-            if (( textModel.uri.toString()) === ( nestedCell.uri.toString())) {
-                return true;
-            }
-            return false;
-        });
-        if (!viewModel) {
-            throw new Error('Nested cell in the diff editor does not match any diff element');
-        }
-        if (viewModel.type === 'unchanged') {
-            return this.getLayoutInfo();
-        }
-        if (viewModel.type === 'insert' || viewModel.type === 'delete') {
-            return {
-                width: this._dimension.width / 2,
-                height: this._dimension.height / 2,
-                fontInfo: this.fontInfo
-            };
-        }
-        if (viewModel.checkIfOutputsModified()) {
-            return {
-                width: this._dimension.width / 2,
-                height: this._dimension.height / 2,
-                fontInfo: this.fontInfo
-            };
-        }
-        else {
-            return this.getLayoutInfo();
-        }
-    }
-    layout(dimension, _position) {
-        this._rootElement.classList.toggle('mid-width', dimension.width < 1000 && dimension.width >= 600);
-        this._rootElement.classList.toggle('narrow-width', dimension.width < 600);
-        const overviewRulerEnabled = this.isOverviewRulerEnabled();
-        this._dimension = dimension.with(dimension.width - (overviewRulerEnabled ? NotebookTextDiffEditor_1.ENTIRE_DIFF_OVERVIEW_WIDTH : 0));
-        this._listViewContainer.style.height = `${dimension.height}px`;
-        this._listViewContainer.style.width = `${this._dimension.width}px`;
-        this._list?.layout(this._dimension.height, this._dimension.width);
-        if (this._modifiedWebview) {
-            this._modifiedWebview.element.style.width = `calc(50% - 16px)`;
-            this._modifiedWebview.element.style.left = `calc(50%)`;
-        }
-        if (this._originalWebview) {
-            this._originalWebview.element.style.width = `calc(50% - 16px)`;
-            this._originalWebview.element.style.left = `16px`;
-        }
-        if (this._webviewTransparentCover) {
-            this._webviewTransparentCover.style.height = `${this._dimension.height}px`;
-            this._webviewTransparentCover.style.width = `${this._dimension.width}px`;
-        }
-        if (overviewRulerEnabled) {
-            this._overviewRuler.layout();
-        }
-        this._eventDispatcher?.emit([( new NotebookDiffLayoutChangedEvent({ width: true, fontInfo: true }, this.getLayoutInfo()))]);
-    }
-    dispose() {
-        this._isDisposed = true;
-        this._layoutCancellationTokenSource?.dispose();
-        this._detachModel();
-        super.dispose();
-    }
-};
-NotebookTextDiffEditor = NotebookTextDiffEditor_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, INotebookExecutionStateService)),
-    ( __param(9, ICodeEditorService))
-], NotebookTextDiffEditor));
-registerZIndex(ZIndex.Base, 10, 'notebook-diff-view-viewport-slider');
-registerThemingParticipant((theme, collector) => {
-    const diffDiagonalFillColor = theme.getColor(diffDiagonalFill);
-    collector.addRule(`
-	.notebook-text-diff-editor .diagonal-fill {
-		background-image: linear-gradient(
-			-45deg,
-			${diffDiagonalFillColor} 12.5%,
-			#0000 12.5%, #0000 50%,
-			${diffDiagonalFillColor} 50%, ${diffDiagonalFillColor} 62.5%,
-			#0000 62.5%, #0000 100%
-		);
-		background-size: 8px 8px;
-	}
-	`);
-    collector.addRule(`.notebook-text-diff-editor .cell-body { margin: ${DIFF_CELL_MARGIN}px; }`);
-});
-
-export { NotebookTextDiffEditor };