@codingame/monaco-vscode-api 33.0.3 → 33.0.5

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

@@ -1,41 +0,0 @@
-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

@@ -1,118 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-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

@@ -1,71 +0,0 @@
-
-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

@@ -1,27 +0,0 @@
-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

@@ -1,40 +0,0 @@
-
-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

@@ -1,23 +0,0 @@
-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

@@ -1,313 +0,0 @@
-
-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 };