@codingame/monaco-vscode-api 32.0.1 → 33.0.3

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

@@ -0,0 +1,41 @@
+import { Emitter } from "../../../../../base/common/event.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { PrefixSumComputer } from "../../../../../editor/common/model/prefixSumComputer.js";
+import { IDiffNestedCellViewModel } from "./notebookDiffEditorBrowser.js";
+import { ICellOutputViewModel, IGenericCellViewModel } from "../notebookBrowser.js";
+import { CellViewModelStateChangeEvent } from "../notebookViewEvents.js";
+import { NotebookCellTextModel } from "../../common/model/notebookCellTextModel.js";
+import { INotebookService } from "../../common/notebookService.service.js";
+export declare class DiffNestedCellViewModel extends Disposable implements IDiffNestedCellViewModel, IGenericCellViewModel {
+    readonly textModel: NotebookCellTextModel;
+    private _notebookService;
+    private _id;
+    get id(): string;
+    get outputs(): import("../../common/notebookCommon.js").ICellOutput[];
+    get language(): string;
+    get metadata(): import("../../common/notebookCommon.js").NotebookCellMetadata;
+    get uri(): import("../../../../../base/common/uri.js").URI;
+    get handle(): number;
+    protected readonly _onDidChangeState: Emitter<CellViewModelStateChangeEvent>;
+    private _hoveringOutput;
+    get outputIsHovered(): boolean;
+    set outputIsHovered(v: boolean);
+    private _focusOnOutput;
+    get outputIsFocused(): boolean;
+    set outputIsFocused(v: boolean);
+    private _focusInputInOutput;
+    get inputInOutputIsFocused(): boolean;
+    set inputInOutputIsFocused(v: boolean);
+    private _outputViewModels;
+    get outputsViewModels(): ICellOutputViewModel[];
+    protected _outputCollection: number[];
+    protected _outputsTop: PrefixSumComputer | null;
+    protected readonly _onDidChangeOutputLayout: Emitter<void>;
+    readonly onDidChangeOutputLayout: import("../../../../../base/common/event.js").Event<void>;
+    constructor(textModel: NotebookCellTextModel, _notebookService: INotebookService);
+    private _ensureOutputsTop;
+    getOutputOffset(index: number): number;
+    updateOutputHeight(index: number, height: number): void;
+    getOutputTotalHeight(): number;
+    dispose(): void;
+}

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

@@ -0,0 +1,118 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { generateUuid } from '../../../../../base/common/uuid.js';
+import { PrefixSumComputer } from '../../../../../editor/common/model/prefixSumComputer.js';
+import { CellOutputViewModel } from '../viewModel/cellOutputViewModel.js';
+import { INotebookService } from '../../common/notebookService.service.js';
+
+let DiffNestedCellViewModel = class DiffNestedCellViewModel extends Disposable {
+    get id() {
+        return this._id;
+    }
+    get outputs() {
+        return this.textModel.outputs;
+    }
+    get language() {
+        return this.textModel.language;
+    }
+    get metadata() {
+        return this.textModel.metadata;
+    }
+    get uri() {
+        return this.textModel.uri;
+    }
+    get handle() {
+        return this.textModel.handle;
+    }
+    get outputIsHovered() {
+        return this._hoveringOutput;
+    }
+    set outputIsHovered(v) {
+        this._hoveringOutput = v;
+        this._onDidChangeState.fire({
+            outputIsHoveredChanged: true
+        });
+    }
+    get outputIsFocused() {
+        return this._focusOnOutput;
+    }
+    set outputIsFocused(v) {
+        this._focusOnOutput = v;
+        this._onDidChangeState.fire({
+            outputIsFocusedChanged: true
+        });
+    }
+    get inputInOutputIsFocused() {
+        return this._focusInputInOutput;
+    }
+    set inputInOutputIsFocused(v) {
+        this._focusInputInOutput = v;
+    }
+    get outputsViewModels() {
+        return this._outputViewModels;
+    }
+    constructor(textModel, _notebookService) {
+        super();
+        this.textModel = textModel;
+        this._notebookService = _notebookService;
+        this._onDidChangeState = this._register(( new Emitter()));
+        this._hoveringOutput = false;
+        this._focusOnOutput = false;
+        this._focusInputInOutput = false;
+        this._outputCollection = [];
+        this._outputsTop = null;
+        this._onDidChangeOutputLayout = this._register(( new Emitter()));
+        this.onDidChangeOutputLayout = this._onDidChangeOutputLayout.event;
+        this._id = generateUuid();
+        this._outputViewModels = ( this.textModel.outputs.map(output => ( new CellOutputViewModel(this, output, this._notebookService))));
+        this._register(this.textModel.onDidChangeOutputs(splice => {
+            this._outputCollection.splice(splice.start, splice.deleteCount, ...( splice.newOutputs.map(() => 0)));
+            const removed = this._outputViewModels.splice(splice.start, splice.deleteCount, ...( splice.newOutputs.map(output => ( new CellOutputViewModel(this, output, this._notebookService)))));
+            removed.forEach(vm => vm.dispose());
+            this._outputsTop = null;
+            this._onDidChangeOutputLayout.fire();
+        }));
+        this._outputCollection = ( new Array(this.textModel.outputs.length));
+    }
+    _ensureOutputsTop() {
+        if (!this._outputsTop) {
+            const values = ( new Uint32Array(this._outputCollection.length));
+            for (let i = 0; i < this._outputCollection.length; i++) {
+                values[i] = this._outputCollection[i];
+            }
+            this._outputsTop = ( new PrefixSumComputer(values));
+        }
+    }
+    getOutputOffset(index) {
+        this._ensureOutputsTop();
+        if (index >= this._outputCollection.length) {
+            throw ( new Error("Output index out of range!"));
+        }
+        return this._outputsTop.getPrefixSum(index - 1);
+    }
+    updateOutputHeight(index, height) {
+        if (index >= this._outputCollection.length) {
+            throw ( new Error("Output index out of range!"));
+        }
+        this._ensureOutputsTop();
+        this._outputCollection[index] = height;
+        if (this._outputsTop.setValue(index, height)) {
+            this._onDidChangeOutputLayout.fire();
+        }
+    }
+    getOutputTotalHeight() {
+        this._ensureOutputsTop();
+        return this._outputsTop?.getTotalSum() ?? 0;
+    }
+    dispose() {
+        super.dispose();
+        this._outputViewModels.forEach(output => {
+            output.dispose();
+        });
+    }
+};
+DiffNestedCellViewModel = ( __decorate([( __param(1, INotebookService))], DiffNestedCellViewModel));
+
+export { DiffNestedCellViewModel };

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

@@ -0,0 +1,17 @@
+import { URI } from "../../../../../base/common/uri.js";
+import { IEditorWorkerService } from "../../../../../editor/common/services/editorWorker.service.js";
+import { ITextModelService } from "../../../../../editor/common/services/resolverService.service.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
+export interface IDiffEditorHeightCalculatorService {
+    diffAndComputeHeight(original: URI, modified: URI): Promise<number>;
+    computeHeightFromLines(lineCount: number): number;
+}
+export declare class DiffEditorHeightCalculatorService {
+    private readonly lineHeight;
+    private readonly textModelResolverService;
+    private readonly editorWorkerService;
+    private readonly configurationService;
+    constructor(lineHeight: number, textModelResolverService: ITextModelService, editorWorkerService: IEditorWorkerService, configurationService: IConfigurationService);
+    diffAndComputeHeight(original: URI, modified: URI): Promise<number>;
+    computeHeightFromLines(lineCount: number): number;
+}

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

@@ -0,0 +1,71 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { UnchangedRegion } from '../../../../../editor/browser/widget/diffEditor/diffEditorViewModel.js';
+import { IEditorWorkerService } from '../../../../../editor/common/services/editorWorker.service.js';
+import { ITextModelService } from '../../../../../editor/common/services/resolverService.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { getEditorPadding } from './diffCellEditorOptions.js';
+import { HeightOfHiddenLinesRegionInDiffEditor } from './diffElementViewModel.js';
+
+let DiffEditorHeightCalculatorService = class DiffEditorHeightCalculatorService {
+    constructor(
+        lineHeight,
+        textModelResolverService,
+        editorWorkerService,
+        configurationService
+    ) {
+        this.lineHeight = lineHeight;
+        this.textModelResolverService = textModelResolverService;
+        this.editorWorkerService = editorWorkerService;
+        this.configurationService = configurationService;
+    }
+    async diffAndComputeHeight(original, modified) {
+        const [originalModel, modifiedModel] = await Promise.all([
+            this.textModelResolverService.createModelReference(original),
+            this.textModelResolverService.createModelReference(modified)
+        ]);
+        try {
+            const diffChanges = await this.editorWorkerService.computeDiff(original, modified, {
+                ignoreTrimWhitespace: true,
+                maxComputationTimeMs: 0,
+                computeMoves: false
+            }, "advanced").then(diff => diff?.changes || []);
+            const unchangedRegionFeatureEnabled = this.configurationService.getValue("diffEditor.hideUnchangedRegions.enabled");
+            const minimumLineCount = this.configurationService.getValue("diffEditor.hideUnchangedRegions.minimumLineCount");
+            const contextLineCount = this.configurationService.getValue("diffEditor.hideUnchangedRegions.contextLineCount");
+            const originalLineCount = originalModel.object.textEditorModel.getLineCount();
+            const modifiedLineCount = modifiedModel.object.textEditorModel.getLineCount();
+            const unchanged = unchangedRegionFeatureEnabled ? UnchangedRegion.fromDiffs(
+                diffChanges,
+                originalLineCount,
+                modifiedLineCount,
+                minimumLineCount ?? 3,
+                contextLineCount ?? 3
+            ) : [];
+            const numberOfNewLines = diffChanges.reduce((prev, curr) => {
+                if (curr.original.isEmpty && !curr.modified.isEmpty) {
+                    return prev + curr.modified.length;
+                }
+                if (!curr.original.isEmpty && !curr.modified.isEmpty && curr.modified.length > curr.original.length) {
+                    return prev + curr.modified.length - curr.original.length;
+                }
+                return prev;
+            }, 0);
+            const orginalNumberOfLines = originalModel.object.textEditorModel.getLineCount();
+            const numberOfHiddenLines = unchanged.reduce((prev, curr) => prev + curr.lineCount, 0);
+            const numberOfHiddenSections = unchanged.length;
+            const unchangeRegionsHeight = numberOfHiddenSections * HeightOfHiddenLinesRegionInDiffEditor;
+            const visibleLineCount = orginalNumberOfLines + numberOfNewLines - numberOfHiddenLines;
+            return (visibleLineCount * this.lineHeight) + getEditorPadding(visibleLineCount).top + getEditorPadding(visibleLineCount).bottom + unchangeRegionsHeight;
+        } finally {
+            originalModel.dispose();
+            modifiedModel.dispose();
+        }
+    }
+    computeHeightFromLines(lineCount) {
+        return lineCount * this.lineHeight + getEditorPadding(lineCount).top + getEditorPadding(lineCount).bottom;
+    }
+};
+DiffEditorHeightCalculatorService = ( __decorate([( __param(1, ITextModelService)), ( __param(2, IEditorWorkerService)), ( __param(3, IConfigurationService))], DiffEditorHeightCalculatorService));
+
+export { DiffEditorHeightCalculatorService };

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

@@ -0,0 +1,27 @@
+import { Emitter } from "../../../../../base/common/event.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { IDiffElementLayoutInfo } from "./notebookDiffEditorBrowser.js";
+import { NotebookLayoutChangeEvent, NotebookLayoutInfo } from "../notebookViewEvents.js";
+export declare enum NotebookDiffViewEventType {
+    LayoutChanged = 1,
+    CellLayoutChanged = 2
+}
+export declare class NotebookDiffLayoutChangedEvent {
+    readonly source: NotebookLayoutChangeEvent;
+    readonly value: NotebookLayoutInfo;
+    readonly type = NotebookDiffViewEventType.LayoutChanged;
+    constructor(source: NotebookLayoutChangeEvent, value: NotebookLayoutInfo);
+}
+export declare class NotebookCellLayoutChangedEvent {
+    readonly source: IDiffElementLayoutInfo;
+    readonly type = NotebookDiffViewEventType.CellLayoutChanged;
+    constructor(source: IDiffElementLayoutInfo);
+}
+export type NotebookDiffViewEvent = NotebookDiffLayoutChangedEvent | NotebookCellLayoutChangedEvent;
+export declare class NotebookDiffEditorEventDispatcher extends Disposable {
+    protected readonly _onDidChangeLayout: Emitter<NotebookDiffLayoutChangedEvent>;
+    readonly onDidChangeLayout: import("../../../../../base/common/event.js").Event<NotebookDiffLayoutChangedEvent>;
+    protected readonly _onDidChangeCellLayout: Emitter<NotebookCellLayoutChangedEvent>;
+    readonly onDidChangeCellLayout: import("../../../../../base/common/event.js").Event<NotebookCellLayoutChangedEvent>;
+    emit(events: NotebookDiffViewEvent[]): void;
+}

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

@@ -0,0 +1,40 @@
+
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+
+var NotebookDiffViewEventType;
+(function(NotebookDiffViewEventType) {
+    NotebookDiffViewEventType[NotebookDiffViewEventType["LayoutChanged"] = 1] = "LayoutChanged";
+    NotebookDiffViewEventType[NotebookDiffViewEventType["CellLayoutChanged"] = 2] = "CellLayoutChanged";
+})(NotebookDiffViewEventType || (NotebookDiffViewEventType = {}));
+class NotebookDiffLayoutChangedEvent {
+    constructor(source, value) {
+        this.source = source;
+        this.value = value;
+        this.type = NotebookDiffViewEventType.LayoutChanged;
+    }
+}
+class NotebookDiffEditorEventDispatcher extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeLayout = this._register(( new Emitter()));
+        this.onDidChangeLayout = this._onDidChangeLayout.event;
+        this._onDidChangeCellLayout = this._register(( new Emitter()));
+        this.onDidChangeCellLayout = this._onDidChangeCellLayout.event;
+    }
+    emit(events) {
+        for (let i = 0, len = events.length; i < len; i++) {
+            const e = events[i];
+            switch (e.type) {
+            case NotebookDiffViewEventType.LayoutChanged:
+                this._onDidChangeLayout.fire(e);
+                break;
+            case NotebookDiffViewEventType.CellLayoutChanged:
+                this._onDidChangeCellLayout.fire(e);
+                break;
+            }
+        }
+    }
+}
+
+export { NotebookDiffEditorEventDispatcher, NotebookDiffLayoutChangedEvent, NotebookDiffViewEventType };

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

@@ -0,0 +1,23 @@
+import { DisposableStore } from "../../../../../../base/common/lifecycle.js";
+import { INotebookEditor } from "../../notebookBrowser.js";
+import { ICodeEditor } from "../../../../../../editor/browser/editorBrowser.js";
+import { IEditorWorkerService } from "../../../../../../editor/common/services/editorWorker.service.js";
+import { NotebookCellTextModel } from "../../../common/model/notebookCellTextModel.js";
+import { INotebookOriginalCellModelFactory } from "./notebookOriginalCellModelFactory.service.js";
+export declare class NotebookCellDiffDecorator extends DisposableStore {
+    readonly modifiedCell: NotebookCellTextModel;
+    readonly originalCell: NotebookCellTextModel;
+    private readonly editor;
+    private readonly _editorWorkerService;
+    private readonly originalCellModelFactory;
+    private _viewZones;
+    private readonly throttledDecorator;
+    private diffForPreviouslyAppliedDecorators?;
+    private readonly perEditorDisposables;
+    constructor(notebookEditor: INotebookEditor, modifiedCell: NotebookCellTextModel, originalCell: NotebookCellTextModel, editor: ICodeEditor, _editorWorkerService: IEditorWorkerService, originalCellModelFactory: INotebookOriginalCellModelFactory);
+    update(editor: ICodeEditor): void;
+    private _updateImpl;
+    private _originalModel?;
+    private getOrCreateOriginalModel;
+    private _updateWithDiff;
+}

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

@@ -0,0 +1,313 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, toDisposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { ThrottledDelayer } from '../../../../../../base/common/async.js';
+import { IEditorWorkerService } from '../../../../../../editor/common/services/editorWorker.service.js';
+import { EditorOption } from '../../../../../../editor/common/config/editorOptions.js';
+import { themeColorFromId } from '../../../../../../base/common/themables.js';
+import { RenderOptions, LineSource, renderLines } from '../../../../../../editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.js';
+import { diffAddDecoration, diffWholeLineAddDecoration, diffDeleteDecoration } from '../../../../../../editor/browser/widget/diffEditor/registrations.contribution.js';
+import { TrackedRangeStickiness, MinimapPosition, OverviewRulerLane } from '../../../../../../editor/common/model.js';
+import { ModelDecorationOptions } from '../../../../../../editor/common/model/textModel.js';
+import { Range } from '../../../../../../editor/common/core/range.js';
+import { overviewRulerModifiedForeground, minimapGutterModifiedBackground, overviewRulerAddedForeground, minimapGutterAddedBackground, overviewRulerDeletedForeground, minimapGutterDeletedBackground } from '../../../../scm/common/quickDiff.js';
+import { INotebookOriginalCellModelFactory } from './notebookOriginalCellModelFactory.service.js';
+import { InlineDecoration, InlineDecorationType } from '../../../../../../editor/common/viewModel/inlineDecorations.js';
+import { createElement } from '../../../../../../base/browser/dom.js';
+import { observableFromEvent } from '../../../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { derived } from '../../../../../../base/common/observableInternal/observables/derived.js';
+import { autorunWithStore } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
+
+let NotebookCellDiffDecorator = class NotebookCellDiffDecorator extends DisposableStore {
+    constructor(
+        notebookEditor,
+        modifiedCell,
+        originalCell,
+        editor,
+        _editorWorkerService,
+        originalCellModelFactory
+    ) {
+        super();
+        this.modifiedCell = modifiedCell;
+        this.originalCell = originalCell;
+        this.editor = editor;
+        this._editorWorkerService = _editorWorkerService;
+        this.originalCellModelFactory = originalCellModelFactory;
+        this._viewZones = [];
+        this.throttledDecorator = this.add(( new ThrottledDelayer(50)));
+        this.perEditorDisposables = this.add(( new DisposableStore()));
+        const onDidChangeVisibleRanges = observableFromEvent(
+            notebookEditor.onDidChangeVisibleRanges,
+            () => notebookEditor.visibleRanges
+        );
+        const editorObs = derived(r => {
+            const visibleRanges = onDidChangeVisibleRanges.read(r);
+            const visibleCellHandles = ( ( visibleRanges.map(range => notebookEditor.getCellsInRange(range))).flat().map(c => c.handle));
+            if (!visibleCellHandles.includes(modifiedCell.handle)) {
+                return;
+            }
+            const editor = notebookEditor.codeEditors.find(item => item[0].handle === modifiedCell.handle)?.[1];
+            if (editor?.getModel() !== this.modifiedCell.textModel) {
+                return;
+            }
+            return editor;
+        });
+        this.add(autorunWithStore((r, store) => {
+            const editor = editorObs.read(r);
+            this.perEditorDisposables.clear();
+            if (editor) {
+                store.add(editor.onDidChangeModel(() => {
+                    this.perEditorDisposables.clear();
+                }));
+                store.add(editor.onDidChangeModelContent(() => {
+                    this.update(editor);
+                }));
+                store.add(editor.onDidChangeConfiguration(e => {
+                    if (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.lineHeight)) {
+                        this.update(editor);
+                    }
+                }));
+                this.update(editor);
+            }
+        }));
+    }
+    update(editor) {
+        this.throttledDecorator.trigger(() => this._updateImpl(editor));
+    }
+    async _updateImpl(editor) {
+        if (this.isDisposed) {
+            return;
+        }
+        if (editor.getOption(EditorOption.inDiffEditor)) {
+            this.perEditorDisposables.clear();
+            return;
+        }
+        const model = editor.getModel();
+        if (!model || model !== this.modifiedCell.textModel) {
+            this.perEditorDisposables.clear();
+            return;
+        }
+        const originalModel = this.getOrCreateOriginalModel(editor);
+        if (!originalModel) {
+            this.perEditorDisposables.clear();
+            return;
+        }
+        const version = model.getVersionId();
+        const diff = await this._editorWorkerService.computeDiff(originalModel.uri, model.uri, {
+            computeMoves: true,
+            ignoreTrimWhitespace: false,
+            maxComputationTimeMs: Number.MAX_SAFE_INTEGER
+        }, "advanced");
+        if (this.isDisposed) {
+            return;
+        }
+        if (diff && !diff.identical && this.modifiedCell.textModel && originalModel && model === editor.getModel() && editor.getModel()?.getVersionId() === version) {
+            this._updateWithDiff(editor, originalModel, diff, this.modifiedCell.textModel);
+        } else {
+            this.perEditorDisposables.clear();
+        }
+    }
+    getOrCreateOriginalModel(editor) {
+        if (!this._originalModel) {
+            const model = editor.getModel();
+            if (!model) {
+                return;
+            }
+            this._originalModel = this.add(this.originalCellModelFactory.getOrCreate(
+                model.uri,
+                this.originalCell.getValue(),
+                model.getLanguageId(),
+                this.modifiedCell.cellKind
+            )).object;
+        }
+        return this._originalModel;
+    }
+    _updateWithDiff(editor, originalModel, diff, currentModel) {
+        if (areDiffsEqual(diff, this.diffForPreviouslyAppliedDecorators)) {
+            return;
+        }
+        this.perEditorDisposables.clear();
+        const decorations = editor.createDecorationsCollection();
+        this.perEditorDisposables.add(toDisposable(() => {
+            editor.changeViewZones(viewZoneChangeAccessor => {
+                for (const id of this._viewZones) {
+                    viewZoneChangeAccessor.removeZone(id);
+                }
+            });
+            this._viewZones = [];
+            decorations.clear();
+            this.diffForPreviouslyAppliedDecorators = undefined;
+        }));
+        this.diffForPreviouslyAppliedDecorators = diff;
+        const chatDiffAddDecoration = ModelDecorationOptions.createDynamic({
+            ...diffAddDecoration,
+            stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+        });
+        const chatDiffWholeLineAddDecoration = ModelDecorationOptions.createDynamic({
+            ...diffWholeLineAddDecoration,
+            stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+        });
+        const createOverviewDecoration = (overviewRulerColor, minimapColor) => {
+            return ModelDecorationOptions.createDynamic({
+                description: "chat-editing-decoration",
+                overviewRuler: {
+                    color: themeColorFromId(overviewRulerColor),
+                    position: OverviewRulerLane.Left
+                },
+                minimap: {
+                    color: themeColorFromId(minimapColor),
+                    position: MinimapPosition.Gutter
+                }
+            });
+        };
+        const modifiedDecoration = createOverviewDecoration(overviewRulerModifiedForeground, minimapGutterModifiedBackground);
+        const addedDecoration = createOverviewDecoration(overviewRulerAddedForeground, minimapGutterAddedBackground);
+        const deletedDecoration = createOverviewDecoration(overviewRulerDeletedForeground, minimapGutterDeletedBackground);
+        editor.changeViewZones(viewZoneChangeAccessor => {
+            for (const id of this._viewZones) {
+                viewZoneChangeAccessor.removeZone(id);
+            }
+            this._viewZones = [];
+            const modifiedVisualDecorations = [];
+            const mightContainNonBasicASCII = originalModel.mightContainNonBasicASCII();
+            const mightContainRTL = originalModel.mightContainRTL();
+            const renderOptions = RenderOptions.fromEditor(this.editor);
+            const editorLineCount = currentModel.getLineCount();
+            for (const diffEntry of diff.changes) {
+                const originalRange = diffEntry.original;
+                originalModel.tokenization.forceTokenization(Math.max(1, originalRange.endLineNumberExclusive - 1));
+                const source = ( new LineSource(
+                    originalRange.mapToLineArray(l => originalModel.tokenization.getLineTokens(l)),
+                    [],
+                    mightContainNonBasicASCII,
+                    mightContainRTL
+                ));
+                const decorations = [];
+                for (const i of diffEntry.innerChanges || []) {
+                    decorations.push(( new InlineDecoration(
+                        i.originalRange.delta(-(diffEntry.original.startLineNumber - 1)),
+                        diffDeleteDecoration.className,
+                        InlineDecorationType.Regular
+                    )));
+                    if (!(i.originalRange.isEmpty() && i.originalRange.startLineNumber === 1 && i.modifiedRange.endLineNumber === editorLineCount) && !i.modifiedRange.isEmpty()) {
+                        modifiedVisualDecorations.push({
+                            range: i.modifiedRange,
+                            options: chatDiffAddDecoration
+                        });
+                    }
+                }
+                const isCreatedContent = decorations.length === 1 && decorations[0].range.isEmpty() && diffEntry.original.startLineNumber === 1;
+                if (!diffEntry.modified.isEmpty && !(isCreatedContent && (diffEntry.modified.endLineNumberExclusive - 1) === editorLineCount)) {
+                    modifiedVisualDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: chatDiffWholeLineAddDecoration
+                    });
+                }
+                if (diffEntry.original.isEmpty) {
+                    modifiedVisualDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: addedDecoration
+                    });
+                } else if (diffEntry.modified.isEmpty) {
+                    modifiedVisualDecorations.push({
+                        range: ( new Range(
+                            diffEntry.modified.startLineNumber - 1,
+                            1,
+                            diffEntry.modified.startLineNumber,
+                            1
+                        )),
+                        options: deletedDecoration
+                    });
+                } else {
+                    modifiedVisualDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: modifiedDecoration
+                    });
+                }
+                const domNode = createElement("div");
+                domNode.className = "chat-editing-original-zone view-lines line-delete monaco-mouse-cursor-text";
+                const result = renderLines(source, renderOptions, decorations, domNode);
+                if (!isCreatedContent) {
+                    const viewZoneData = {
+                        afterLineNumber: diffEntry.modified.startLineNumber - 1,
+                        heightInLines: result.heightInLines,
+                        domNode,
+                        ordinal: 50000 + 2
+                    };
+                    this._viewZones.push(viewZoneChangeAccessor.addZone(viewZoneData));
+                }
+            }
+            decorations.set(modifiedVisualDecorations);
+        });
+    }
+};
+NotebookCellDiffDecorator = ( __decorate([( __param(4, IEditorWorkerService)), ( __param(5, INotebookOriginalCellModelFactory))], NotebookCellDiffDecorator));
+function areDiffsEqual(a, b) {
+    if (a && b) {
+        if (a.changes.length !== b.changes.length) {
+            return false;
+        }
+        if (a.moves.length !== b.moves.length) {
+            return false;
+        }
+        if (!areLineRangeMappinsEqual(a.changes, b.changes)) {
+            return false;
+        }
+        if (!( a.moves.some((move, i) => {
+            const bMove = b.moves[i];
+            if (!areLineRangeMappinsEqual(move.changes, bMove.changes)) {
+                return true;
+            }
+            if (move.lineRangeMapping.changedLineCount !== bMove.lineRangeMapping.changedLineCount) {
+                return true;
+            }
+            if (!move.lineRangeMapping.modified.equals(bMove.lineRangeMapping.modified)) {
+                return true;
+            }
+            if (!move.lineRangeMapping.original.equals(bMove.lineRangeMapping.original)) {
+                return true;
+            }
+            return false;
+        }))) {
+            return false;
+        }
+        return true;
+    } else if (!a && !b) {
+        return true;
+    } else {
+        return false;
+    }
+}
+function areLineRangeMappinsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    if (( a.some((c, i) => {
+        const bChange = b[i];
+        if (c.changedLineCount !== bChange.changedLineCount) {
+            return true;
+        }
+        if ((c.innerChanges || []).length !== (bChange.innerChanges || []).length) {
+            return true;
+        }
+        if (( (c.innerChanges || []).some((innerC, innerIdx) => {
+            const bInnerC = bChange.innerChanges[innerIdx];
+            if (!innerC.modifiedRange.equalsRange(bInnerC.modifiedRange)) {
+                return true;
+            }
+            if (!innerC.originalRange.equalsRange(bInnerC.originalRange)) {
+                return true;
+            }
+            return false;
+        }))) {
+            return true;
+        }
+        return false;
+    }))) {
+        return false;
+    }
+    return true;
+}
+
+export { NotebookCellDiffDecorator };