@codingame/monaco-vscode-api 4.4.1 → 4.5.0

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/scrollSynchronizer.js

@@ -1,159 +0,0 @@
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import '../../../../../base/common/observableInternal/derived.js';
-import { autorunWithStore } from '../../../../../base/common/observableInternal/autorun.js';
-import '../../../../../base/common/observableInternal/utils.js';
-import '../../../../../base/common/cancellation.js';
-import { DocumentLineRangeMap } from '../model/mapping.js';
-import { ReentrancyBarrier } from '../utils.js';
-class ScrollSynchronizer extends Disposable {
-    get model() { return this.viewModel.get()?.model; }
-    get shouldAlignResult() { return this.layout.get().kind === 'columns'; }
-    get shouldAlignBase() { return this.layout.get().kind === 'mixed' && !this.layout.get().showBaseAtTop; }
-    constructor(viewModel, input1View, input2View, baseView, inputResultView, layout) {
-        super();
-        this.viewModel = viewModel;
-        this.input1View = input1View;
-        this.input2View = input2View;
-        this.baseView = baseView;
-        this.inputResultView = inputResultView;
-        this.layout = layout;
-        this.reentrancyBarrier = ( new ReentrancyBarrier());
-        const handleInput1OnScroll = this.updateScrolling = () => {
-            if (!this.model) {
-                return;
-            }
-            this.input2View.editor.setScrollTop(this.input1View.editor.getScrollTop(), 1 );
-            if (this.shouldAlignResult) {
-                this.inputResultView.editor.setScrollTop(this.input1View.editor.getScrollTop(), 1 );
-            }
-            else {
-                const mappingInput1Result = this.model.input1ResultMapping.get();
-                this.synchronizeScrolling(this.input1View.editor, this.inputResultView.editor, mappingInput1Result);
-            }
-            const baseView = this.baseView.get();
-            if (baseView) {
-                if (this.shouldAlignBase) {
-                    this.baseView.get()?.editor.setScrollTop(this.input1View.editor.getScrollTop(), 1 );
-                }
-                else {
-                    const mapping = ( new DocumentLineRangeMap(this.model.baseInput1Diffs.get(), -1)).reverse();
-                    this.synchronizeScrolling(this.input1View.editor, baseView.editor, mapping);
-                }
-            }
-        };
-        this._store.add(this.input1View.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
-            if (c.scrollTopChanged) {
-                handleInput1OnScroll();
-            }
-            if (c.scrollLeftChanged) {
-                this.baseView.get()?.editor.setScrollLeft(c.scrollLeft, 1 );
-                this.input2View.editor.setScrollLeft(c.scrollLeft, 1 );
-                this.inputResultView.editor.setScrollLeft(c.scrollLeft, 1 );
-            }
-        })));
-        this._store.add(this.input2View.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
-            if (!this.model) {
-                return;
-            }
-            if (c.scrollTopChanged) {
-                this.input1View.editor.setScrollTop(c.scrollTop, 1 );
-                if (this.shouldAlignResult) {
-                    this.inputResultView.editor.setScrollTop(this.input2View.editor.getScrollTop(), 1 );
-                }
-                else {
-                    const mappingInput2Result = this.model.input2ResultMapping.get();
-                    this.synchronizeScrolling(this.input2View.editor, this.inputResultView.editor, mappingInput2Result);
-                }
-                const baseView = this.baseView.get();
-                if (baseView && this.model) {
-                    if (this.shouldAlignBase) {
-                        this.baseView.get()?.editor.setScrollTop(c.scrollTop, 1 );
-                    }
-                    else {
-                        const mapping = ( new DocumentLineRangeMap(this.model.baseInput2Diffs.get(), -1)).reverse();
-                        this.synchronizeScrolling(this.input2View.editor, baseView.editor, mapping);
-                    }
-                }
-            }
-            if (c.scrollLeftChanged) {
-                this.baseView.get()?.editor.setScrollLeft(c.scrollLeft, 1 );
-                this.input1View.editor.setScrollLeft(c.scrollLeft, 1 );
-                this.inputResultView.editor.setScrollLeft(c.scrollLeft, 1 );
-            }
-        })));
-        this._store.add(this.inputResultView.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
-            if (c.scrollTopChanged) {
-                if (this.shouldAlignResult) {
-                    this.input1View.editor.setScrollTop(c.scrollTop, 1 );
-                    this.input2View.editor.setScrollTop(c.scrollTop, 1 );
-                }
-                else {
-                    const mapping1 = this.model?.resultInput1Mapping.get();
-                    this.synchronizeScrolling(this.inputResultView.editor, this.input1View.editor, mapping1);
-                    const mapping2 = this.model?.resultInput2Mapping.get();
-                    this.synchronizeScrolling(this.inputResultView.editor, this.input2View.editor, mapping2);
-                }
-                const baseMapping = this.model?.resultBaseMapping.get();
-                const baseView = this.baseView.get();
-                if (baseView && this.model) {
-                    this.synchronizeScrolling(this.inputResultView.editor, baseView.editor, baseMapping);
-                }
-            }
-            if (c.scrollLeftChanged) {
-                this.baseView.get()?.editor?.setScrollLeft(c.scrollLeft, 1 );
-                this.input1View.editor.setScrollLeft(c.scrollLeft, 1 );
-                this.input2View.editor.setScrollLeft(c.scrollLeft, 1 );
-            }
-        })));
-        this._store.add(autorunWithStore((reader, store) => {
-            const baseView = this.baseView.read(reader);
-            if (baseView) {
-                store.add(baseView.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
-                    if (c.scrollTopChanged) {
-                        if (!this.model) {
-                            return;
-                        }
-                        if (this.shouldAlignBase) {
-                            this.input1View.editor.setScrollTop(c.scrollTop, 1 );
-                            this.input2View.editor.setScrollTop(c.scrollTop, 1 );
-                        }
-                        else {
-                            const baseInput1Mapping = ( new DocumentLineRangeMap(this.model.baseInput1Diffs.get(), -1));
-                            this.synchronizeScrolling(baseView.editor, this.input1View.editor, baseInput1Mapping);
-                            const baseInput2Mapping = ( new DocumentLineRangeMap(this.model.baseInput2Diffs.get(), -1));
-                            this.synchronizeScrolling(baseView.editor, this.input2View.editor, baseInput2Mapping);
-                        }
-                        const baseMapping = this.model?.baseResultMapping.get();
-                        this.synchronizeScrolling(baseView.editor, this.inputResultView.editor, baseMapping);
-                    }
-                    if (c.scrollLeftChanged) {
-                        this.inputResultView.editor.setScrollLeft(c.scrollLeft, 1 );
-                        this.input1View.editor.setScrollLeft(c.scrollLeft, 1 );
-                        this.input2View.editor.setScrollLeft(c.scrollLeft, 1 );
-                    }
-                })));
-            }
-        }));
-    }
-    synchronizeScrolling(scrollingEditor, targetEditor, mapping) {
-        if (!mapping) {
-            return;
-        }
-        const visibleRanges = scrollingEditor.getVisibleRanges();
-        if (visibleRanges.length === 0) {
-            return;
-        }
-        const topLineNumber = visibleRanges[0].startLineNumber - 1;
-        const result = mapping.project(topLineNumber);
-        const sourceRange = result.inputRange;
-        const targetRange = result.outputRange;
-        const resultStartTopPx = targetEditor.getTopForLineNumber(targetRange.startLineNumber);
-        const resultEndPx = targetEditor.getTopForLineNumber(targetRange.endLineNumberExclusive);
-        const sourceStartTopPx = scrollingEditor.getTopForLineNumber(sourceRange.startLineNumber);
-        const sourceEndPx = scrollingEditor.getTopForLineNumber(sourceRange.endLineNumberExclusive);
-        const factor = Math.min((scrollingEditor.getScrollTop() - sourceStartTopPx) / (sourceEndPx - sourceStartTopPx), 1);
-        const resultScrollPosition = resultStartTopPx + (resultEndPx - resultStartTopPx) * factor;
-        targetEditor.setScrollTop(resultScrollPosition, 1 );
-    }
-}
-export { ScrollSynchronizer };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/viewModel.js

@@ -1,264 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { findLast } from '../../../../../base/common/arraysFind.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
-import { derived } from '../../../../../base/common/observableInternal/derived.js';
-import '../../../../../base/common/observableInternal/autorun.js';
-import { derivedObservableWithWritableCache } from '../../../../../base/common/observableInternal/utils.js';
-import '../../../../../base/common/cancellation.js';
-import { Range } from '../../../../../editor/common/core/range.js';
-import { localizeWithPath } from '../../../../../nls.js';
-import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
-import { INotificationService } from '../../../../../platform/notification/common/notification.js';
-import { LineRange } from '../model/lineRange.js';
-import { observableConfigValue } from '../utils.js';
-let MergeEditorViewModel = class MergeEditorViewModel extends Disposable {
-    constructor(model, inputCodeEditorView1, inputCodeEditorView2, resultCodeEditorView, baseCodeEditorView, showNonConflictingChanges, configurationService, notificationService) {
-        super();
-        this.model = model;
-        this.inputCodeEditorView1 = inputCodeEditorView1;
-        this.inputCodeEditorView2 = inputCodeEditorView2;
-        this.resultCodeEditorView = resultCodeEditorView;
-        this.baseCodeEditorView = baseCodeEditorView;
-        this.showNonConflictingChanges = showNonConflictingChanges;
-        this.configurationService = configurationService;
-        this.notificationService = notificationService;
-        this.manuallySetActiveModifiedBaseRange = observableValue(this, { range: undefined, counter: 0 });
-        this.attachedHistory = this._register(( new AttachedHistory(this.model.resultTextModel)));
-        this.shouldUseAppendInsteadOfAccept = observableConfigValue('mergeEditor.shouldUseAppendInsteadOfAccept', false, this.configurationService);
-        this.counter = 0;
-        this.lastFocusedEditor = derivedObservableWithWritableCache(this, (reader, lastValue) => {
-            const editors = [
-                this.inputCodeEditorView1,
-                this.inputCodeEditorView2,
-                this.resultCodeEditorView,
-                this.baseCodeEditorView.read(reader),
-            ];
-            const view = editors.find((e) => e && e.isFocused.read(reader));
-            return view ? { view, counter: this.counter++ } : lastValue || { view: undefined, counter: this.counter++ };
-        });
-        this.baseShowDiffAgainst = derived(this, reader => {
-            const lastFocusedEditor = this.lastFocusedEditor.read(reader);
-            if (lastFocusedEditor.view === this.inputCodeEditorView1) {
-                return 1;
-            }
-            else if (lastFocusedEditor.view === this.inputCodeEditorView2) {
-                return 2;
-            }
-            return undefined;
-        });
-        this.selectionInBase = derived(this, reader => {
-            const sourceEditor = this.lastFocusedEditor.read(reader).view;
-            if (!sourceEditor) {
-                return undefined;
-            }
-            const selections = sourceEditor.selection.read(reader) || [];
-            const rangesInBase = ( selections.map((selection) => {
-                if (sourceEditor === this.inputCodeEditorView1) {
-                    return this.model.translateInputRangeToBase(1, selection);
-                }
-                else if (sourceEditor === this.inputCodeEditorView2) {
-                    return this.model.translateInputRangeToBase(2, selection);
-                }
-                else if (sourceEditor === this.resultCodeEditorView) {
-                    return this.model.translateResultRangeToBase(selection);
-                }
-                else if (sourceEditor === this.baseCodeEditorView.read(reader)) {
-                    return selection;
-                }
-                else {
-                    return selection;
-                }
-            }));
-            return {
-                rangesInBase,
-                sourceEditor
-            };
-        });
-        this.activeModifiedBaseRange = derived(this, (reader) => {
-            const focusedEditor = this.lastFocusedEditor.read(reader);
-            const manualRange = this.manuallySetActiveModifiedBaseRange.read(reader);
-            if (manualRange.counter > focusedEditor.counter) {
-                return manualRange.range;
-            }
-            if (!focusedEditor.view) {
-                return;
-            }
-            const cursorLineNumber = focusedEditor.view.cursorLineNumber.read(reader);
-            if (!cursorLineNumber) {
-                return undefined;
-            }
-            const modifiedBaseRanges = this.model.modifiedBaseRanges.read(reader);
-            return modifiedBaseRanges.find((r) => {
-                const range = this.getRangeOfModifiedBaseRange(focusedEditor.view, r, reader);
-                return range.isEmpty
-                    ? range.startLineNumber === cursorLineNumber
-                    : range.contains(cursorLineNumber);
-            });
-        });
-        this._register(resultCodeEditorView.editor.onDidChangeModelContent(e => {
-            if (this.model.isApplyingEditInResult || e.isRedoing || e.isUndoing) {
-                return;
-            }
-            const baseRangeStates = [];
-            for (const change of e.changes) {
-                const rangeInBase = this.model.translateResultRangeToBase(Range.lift(change.range));
-                const baseRanges = this.model.findModifiedBaseRangesInRange(( new LineRange(
-                    rangeInBase.startLineNumber,
-                    rangeInBase.endLineNumber - rangeInBase.startLineNumber
-                )));
-                if (baseRanges.length === 1) {
-                    const isHandled = this.model.isHandled(baseRanges[0]).get();
-                    if (!isHandled) {
-                        baseRangeStates.push(baseRanges[0]);
-                    }
-                }
-            }
-            if (baseRangeStates.length === 0) {
-                return;
-            }
-            const element = {
-                model: this.model,
-                redo() {
-                    transaction(tx => {
-                        for (const r of baseRangeStates) {
-                            this.model.setHandled(r, true, tx);
-                        }
-                    });
-                },
-                undo() {
-                    transaction(tx => {
-                        for (const r of baseRangeStates) {
-                            this.model.setHandled(r, false, tx);
-                        }
-                    });
-                },
-            };
-            this.attachedHistory.pushAttachedHistoryElement(element);
-            element.redo();
-        }));
-    }
-    getRangeOfModifiedBaseRange(editor, modifiedBaseRange, reader) {
-        if (editor === this.resultCodeEditorView) {
-            return this.model.getLineRangeInResult(modifiedBaseRange.baseRange, reader);
-        }
-        else if (editor === this.baseCodeEditorView.get()) {
-            return modifiedBaseRange.baseRange;
-        }
-        else {
-            const input = editor === this.inputCodeEditorView1 ? 1 : 2;
-            return modifiedBaseRange.getInputRange(input);
-        }
-    }
-    setActiveModifiedBaseRange(range, tx) {
-        this.manuallySetActiveModifiedBaseRange.set({ range, counter: this.counter++ }, tx);
-    }
-    setState(baseRange, state, tx, inputNumber) {
-        this.manuallySetActiveModifiedBaseRange.set({ range: baseRange, counter: this.counter++ }, tx);
-        this.model.setState(baseRange, state, inputNumber, tx);
-    }
-    goToConflict(getModifiedBaseRange) {
-        let editor = this.lastFocusedEditor.get().view;
-        if (!editor) {
-            editor = this.resultCodeEditorView;
-        }
-        const curLineNumber = editor.editor.getPosition()?.lineNumber;
-        if (curLineNumber === undefined) {
-            return;
-        }
-        const modifiedBaseRange = getModifiedBaseRange(editor, curLineNumber);
-        if (modifiedBaseRange) {
-            const range = this.getRangeOfModifiedBaseRange(editor, modifiedBaseRange, undefined);
-            editor.editor.focus();
-            let startLineNumber = range.startLineNumber;
-            let endLineNumberExclusive = range.endLineNumberExclusive;
-            if (range.startLineNumber > editor.editor.getModel().getLineCount()) {
-                transaction(tx => {
-                    this.setActiveModifiedBaseRange(modifiedBaseRange, tx);
-                });
-                startLineNumber = endLineNumberExclusive = editor.editor.getModel().getLineCount();
-            }
-            editor.editor.setPosition({
-                lineNumber: startLineNumber,
-                column: editor.editor.getModel().getLineFirstNonWhitespaceColumn(startLineNumber),
-            });
-            editor.editor.revealLinesNearTop(startLineNumber, endLineNumberExclusive, 0 );
-        }
-    }
-    goToNextModifiedBaseRange(predicate) {
-        this.goToConflict((e, l) => this.model.modifiedBaseRanges
-            .get()
-            .find((r) => predicate(r) &&
-            this.getRangeOfModifiedBaseRange(e, r, undefined).startLineNumber > l) ||
-            this.model.modifiedBaseRanges
-                .get()
-                .find((r) => predicate(r)));
-    }
-    goToPreviousModifiedBaseRange(predicate) {
-        this.goToConflict((e, l) => findLast(this.model.modifiedBaseRanges.get(), (r) => predicate(r) &&
-            this.getRangeOfModifiedBaseRange(e, r, undefined).endLineNumberExclusive < l) ||
-            findLast(this.model.modifiedBaseRanges.get(), (r) => predicate(r)));
-    }
-    toggleActiveConflict(inputNumber) {
-        const activeModifiedBaseRange = this.activeModifiedBaseRange.get();
-        if (!activeModifiedBaseRange) {
-            this.notificationService.error(( localizeWithPath(
-                'vs/workbench/contrib/mergeEditor/browser/view/viewModel',
-                'noConflictMessage',
-                "There is currently no conflict focused that can be toggled."
-            )));
-            return;
-        }
-        transaction(tx => {
-            this.setState(activeModifiedBaseRange, this.model.getState(activeModifiedBaseRange).get().toggle(inputNumber), tx, inputNumber);
-        });
-    }
-    acceptAll(inputNumber) {
-        transaction(tx => {
-            for (const range of this.model.modifiedBaseRanges.get()) {
-                this.setState(range, this.model.getState(range).get().withInputValue(inputNumber, true), tx, inputNumber);
-            }
-        });
-    }
-};
-MergeEditorViewModel = ( __decorate([
-    ( __param(6, IConfigurationService)),
-    ( __param(7, INotificationService))
-], MergeEditorViewModel));
-class AttachedHistory extends Disposable {
-    constructor(model) {
-        super();
-        this.model = model;
-        this.attachedHistory = [];
-        this.previousAltId = this.model.getAlternativeVersionId();
-        this._register(model.onDidChangeContent((e) => {
-            const currentAltId = model.getAlternativeVersionId();
-            if (e.isRedoing) {
-                for (const item of this.attachedHistory) {
-                    if (this.previousAltId < item.altId && item.altId <= currentAltId) {
-                        item.element.redo();
-                    }
-                }
-            }
-            else if (e.isUndoing) {
-                for (let i = this.attachedHistory.length - 1; i >= 0; i--) {
-                    const item = this.attachedHistory[i];
-                    if (currentAltId < item.altId && item.altId <= this.previousAltId) {
-                        item.element.undo();
-                    }
-                }
-            }
-            else {
-                while (this.attachedHistory.length > 0
-                    && this.attachedHistory[this.attachedHistory.length - 1].altId > this.previousAltId) {
-                    this.attachedHistory.pop();
-                }
-            }
-            this.previousAltId = currentAltId;
-        }));
-    }
-    pushAttachedHistoryElement(element) {
-        this.attachedHistory.push({ altId: this.model.getAlternativeVersionId(), element });
-    }
-}
-export { MergeEditorViewModel };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/viewZones.js

@@ -1,171 +0,0 @@
-import { $ } from '../../../../../base/browser/dom.js';
-import { CompareResult, lastOrDefault } from '../../../../../base/common/arrays.js';
-import { LineRange } from '../model/lineRange.js';
-import { join } from '../utils.js';
-import { ConflictActionsFactory, ActionsSource } from './conflictActions.js';
-import { getAlignments } from './lineAlignment.js';
-class ViewZoneComputer {
-    constructor(input1Editor, input2Editor, resultEditor) {
-        this.input1Editor = input1Editor;
-        this.input2Editor = input2Editor;
-        this.resultEditor = resultEditor;
-        this.conflictActionsFactoryInput1 = ( new ConflictActionsFactory(this.input1Editor));
-        this.conflictActionsFactoryInput2 = ( new ConflictActionsFactory(this.input2Editor));
-        this.conflictActionsFactoryResult = ( new ConflictActionsFactory(this.resultEditor));
-    }
-    computeViewZones(reader, viewModel, options) {
-        let input1LinesAdded = 0;
-        let input2LinesAdded = 0;
-        let baseLinesAdded = 0;
-        let resultLinesAdded = 0;
-        const input1ViewZones = [];
-        const input2ViewZones = [];
-        const baseViewZones = [];
-        const resultViewZones = [];
-        const model = viewModel.model;
-        const resultDiffs = model.baseResultDiffs.read(reader);
-        const baseRangeWithStoreAndTouchingDiffs = join(model.modifiedBaseRanges.read(reader), resultDiffs, (baseRange, diff) => baseRange.baseRange.touches(diff.inputRange)
-            ? CompareResult.neitherLessOrGreaterThan
-            : LineRange.compareByStart(baseRange.baseRange, diff.inputRange));
-        const shouldShowCodeLenses = options.codeLensesVisible;
-        const showNonConflictingChanges = options.showNonConflictingChanges;
-        let lastModifiedBaseRange = undefined;
-        let lastBaseResultDiff = undefined;
-        for (const m of baseRangeWithStoreAndTouchingDiffs) {
-            if (shouldShowCodeLenses && m.left && (m.left.isConflicting || showNonConflictingChanges || !model.isHandled(m.left).read(reader))) {
-                const actions = ( new ActionsSource(viewModel, m.left));
-                if (options.shouldAlignResult || !actions.inputIsEmpty.read(reader)) {
-                    input1ViewZones.push(( new CommandViewZone(
-                        this.conflictActionsFactoryInput1,
-                        m.left.input1Range.startLineNumber - 1,
-                        actions.itemsInput1
-                    )));
-                    input2ViewZones.push(( new CommandViewZone(
-                        this.conflictActionsFactoryInput2,
-                        m.left.input2Range.startLineNumber - 1,
-                        actions.itemsInput2
-                    )));
-                    if (options.shouldAlignBase) {
-                        baseViewZones.push(( new Placeholder(m.left.baseRange.startLineNumber - 1, 16)));
-                    }
-                }
-                const afterLineNumber = m.left.baseRange.startLineNumber + (lastBaseResultDiff?.resultingDeltaFromOriginalToModified ?? 0) - 1;
-                resultViewZones.push(( new CommandViewZone(this.conflictActionsFactoryResult, afterLineNumber, actions.resultItems)));
-            }
-            const lastResultDiff = lastOrDefault(m.rights);
-            if (lastResultDiff) {
-                lastBaseResultDiff = lastResultDiff;
-            }
-            let alignedLines;
-            if (m.left) {
-                alignedLines = ( getAlignments(m.left).map(a => ({
-                    input1Line: a[0],
-                    baseLine: a[1],
-                    input2Line: a[2],
-                    resultLine: undefined,
-                })));
-                lastModifiedBaseRange = m.left;
-                alignedLines[alignedLines.length - 1].resultLine =
-                    m.left.baseRange.endLineNumberExclusive
-                        + (lastBaseResultDiff ? lastBaseResultDiff.resultingDeltaFromOriginalToModified : 0);
-            }
-            else {
-                alignedLines = [{
-                        baseLine: lastResultDiff.inputRange.endLineNumberExclusive,
-                        input1Line: lastResultDiff.inputRange.endLineNumberExclusive + (lastModifiedBaseRange ? (lastModifiedBaseRange.input1Range.endLineNumberExclusive - lastModifiedBaseRange.baseRange.endLineNumberExclusive) : 0),
-                        input2Line: lastResultDiff.inputRange.endLineNumberExclusive + (lastModifiedBaseRange ? (lastModifiedBaseRange.input2Range.endLineNumberExclusive - lastModifiedBaseRange.baseRange.endLineNumberExclusive) : 0),
-                        resultLine: lastResultDiff.outputRange.endLineNumberExclusive,
-                    }];
-            }
-            for (const { input1Line, baseLine, input2Line, resultLine } of alignedLines) {
-                if (!options.shouldAlignBase && (input1Line === undefined || input2Line === undefined)) {
-                    continue;
-                }
-                const input1Line_ = input1Line !== undefined ? input1Line + input1LinesAdded : -1;
-                const input2Line_ = input2Line !== undefined ? input2Line + input2LinesAdded : -1;
-                const baseLine_ = baseLine + baseLinesAdded;
-                const resultLine_ = resultLine !== undefined ? resultLine + resultLinesAdded : -1;
-                const max = Math.max(options.shouldAlignBase ? baseLine_ : 0, input1Line_, input2Line_, options.shouldAlignResult ? resultLine_ : 0);
-                if (input1Line !== undefined) {
-                    const diffInput1 = max - input1Line_;
-                    if (diffInput1 > 0) {
-                        input1ViewZones.push(( new Spacer(input1Line - 1, diffInput1)));
-                        input1LinesAdded += diffInput1;
-                    }
-                }
-                if (input2Line !== undefined) {
-                    const diffInput2 = max - input2Line_;
-                    if (diffInput2 > 0) {
-                        input2ViewZones.push(( new Spacer(input2Line - 1, diffInput2)));
-                        input2LinesAdded += diffInput2;
-                    }
-                }
-                if (options.shouldAlignBase) {
-                    const diffBase = max - baseLine_;
-                    if (diffBase > 0) {
-                        baseViewZones.push(( new Spacer(baseLine - 1, diffBase)));
-                        baseLinesAdded += diffBase;
-                    }
-                }
-                if (options.shouldAlignResult && resultLine !== undefined) {
-                    const diffResult = max - resultLine_;
-                    if (diffResult > 0) {
-                        resultViewZones.push(( new Spacer(resultLine - 1, diffResult)));
-                        resultLinesAdded += diffResult;
-                    }
-                }
-            }
-        }
-        return ( new MergeEditorViewZones(input1ViewZones, input2ViewZones, baseViewZones, resultViewZones));
-    }
-}
-class MergeEditorViewZones {
-    constructor(input1ViewZones, input2ViewZones, baseViewZones, resultViewZones) {
-        this.input1ViewZones = input1ViewZones;
-        this.input2ViewZones = input2ViewZones;
-        this.baseViewZones = baseViewZones;
-        this.resultViewZones = resultViewZones;
-    }
-}
-class MergeEditorViewZone {
-}
-class Spacer extends MergeEditorViewZone {
-    constructor(afterLineNumber, heightInLines) {
-        super();
-        this.afterLineNumber = afterLineNumber;
-        this.heightInLines = heightInLines;
-    }
-    create(viewZoneChangeAccessor, viewZoneIdsToCleanUp, disposableStore) {
-        viewZoneIdsToCleanUp.push(viewZoneChangeAccessor.addZone({
-            afterLineNumber: this.afterLineNumber,
-            heightInLines: this.heightInLines,
-            domNode: $('div.diagonal-fill'),
-        }));
-    }
-}
-class Placeholder extends MergeEditorViewZone {
-    constructor(afterLineNumber, heightPx) {
-        super();
-        this.afterLineNumber = afterLineNumber;
-        this.heightPx = heightPx;
-    }
-    create(viewZoneChangeAccessor, viewZoneIdsToCleanUp, disposableStore) {
-        viewZoneIdsToCleanUp.push(viewZoneChangeAccessor.addZone({
-            afterLineNumber: this.afterLineNumber,
-            heightInPx: this.heightPx,
-            domNode: $('div.conflict-actions-placeholder'),
-        }));
-    }
-}
-class CommandViewZone extends MergeEditorViewZone {
-    constructor(conflictActionsFactory, lineNumber, items) {
-        super();
-        this.conflictActionsFactory = conflictActionsFactory;
-        this.lineNumber = lineNumber;
-        this.items = items;
-    }
-    create(viewZoneChangeAccessor, viewZoneIdsToCleanUp, disposableStore) {
-        disposableStore.add(this.conflictActionsFactory.createWidget(viewZoneChangeAccessor, this.lineNumber, this.items, viewZoneIdsToCleanUp));
-    }
-}
-export { MergeEditorViewZone, MergeEditorViewZones, ViewZoneComputer };