@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/contrib/mergeEditor/browser/model/mergeEditorModel.js

@@ -0,0 +1,606 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { equals, CompareResult } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { derived, waitForState, keepAlive, autorunHandleChanges, transaction, observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IUndoRedoService, UndoRedoGroup } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { EditorModel } from '../../../../common/editor/editorModel.js';
+import { LineRange } from './lineRange.js';
+import { DocumentLineRangeMap, LineRangeMapping, DocumentRangeMap } from './mapping.js';
+import { TextModelDiffs } from './textModelDiffs.js';
+import { leftJoin } from '../utils.js';
+import { ModifiedBaseRange, ModifiedBaseRangeState, ModifiedBaseRangeStateKind } from './modifiedBaseRange.js';
+let MergeEditorModel = class MergeEditorModel extends EditorModel {
+    constructor(base, input1, input2, resultTextModel, diffComputer, options, telemetry, languageService, undoRedoService) {
+        super();
+        this.base = base;
+        this.input1 = input1;
+        this.input2 = input2;
+        this.resultTextModel = resultTextModel;
+        this.diffComputer = diffComputer;
+        this.options = options;
+        this.telemetry = telemetry;
+        this.languageService = languageService;
+        this.undoRedoService = undoRedoService;
+        this.input1TextModelDiffs = this._register(( new TextModelDiffs(this.base, this.input1.textModel, this.diffComputer)));
+        this.input2TextModelDiffs = this._register(( new TextModelDiffs(this.base, this.input2.textModel, this.diffComputer)));
+        this.resultTextModelDiffs = this._register(( new TextModelDiffs(this.base, this.resultTextModel, this.diffComputer)));
+        this.modifiedBaseRanges = derived('modifiedBaseRanges', (reader) => {
+            const input1Diffs = this.input1TextModelDiffs.diffs.read(reader);
+            const input2Diffs = this.input2TextModelDiffs.diffs.read(reader);
+            return ModifiedBaseRange.fromDiffs(input1Diffs, input2Diffs, this.base, this.input1.textModel, this.input2.textModel);
+        });
+        this.modifiedBaseRangeResultStates = derived('modifiedBaseRangeResultStates', reader => {
+            const map = ( new Map(( this.modifiedBaseRanges.read(reader).map((s) => [
+                s, ( new ModifiedBaseRangeData(s))
+            ]))));
+            return map;
+        });
+        this.resultSnapshot = this.resultTextModel.createSnapshot();
+        this.baseInput1Diffs = this.input1TextModelDiffs.diffs;
+        this.baseInput2Diffs = this.input2TextModelDiffs.diffs;
+        this.baseResultDiffs = this.resultTextModelDiffs.diffs;
+        this.input1ResultMapping = derived('input1ResultMapping', reader => {
+            return this.getInputResultMapping(this.baseInput1Diffs.read(reader), this.baseResultDiffs.read(reader), this.input1.textModel.getLineCount());
+        });
+        this.resultInput1Mapping = derived('resultInput1Mapping', reader => this.input1ResultMapping.read(reader).reverse());
+        this.input2ResultMapping = derived('input2ResultMapping', reader => {
+            return this.getInputResultMapping(this.baseInput2Diffs.read(reader), this.baseResultDiffs.read(reader), this.input2.textModel.getLineCount());
+        });
+        this.resultInput2Mapping = derived('resultInput2Mapping', reader => this.input2ResultMapping.read(reader).reverse());
+        this.baseResultMapping = derived('baseResultMapping', reader => {
+            const map = ( new DocumentLineRangeMap(this.baseResultDiffs.read(reader), -1));
+            return ( new DocumentLineRangeMap(( map.lineRangeMappings.map((m) => m.inputRange.isEmpty || m.outputRange.isEmpty
+                ? ( new LineRangeMapping(
+            m.inputRange.deltaStart(-1), m.outputRange.deltaStart(-1)))
+                : m)), map.inputLineCount));
+        });
+        this.resultBaseMapping = derived('resultBaseMapping', reader => this.baseResultMapping.read(reader).reverse());
+        this.diffComputingState = derived('diffComputingState', reader => {
+            const states = ( [
+                this.input1TextModelDiffs,
+                this.input2TextModelDiffs,
+                this.resultTextModelDiffs,
+            ].map((s) => s.state.read(reader)));
+            if (( states.some((s) => s === 1 ))) {
+                return 1 ;
+            }
+            if (( states.some((s) => s === 3 ))) {
+                return 3 ;
+            }
+            return 2 ;
+        });
+        this.inputDiffComputingState = derived('inputDiffComputingState', reader => {
+            const states = ( [
+                this.input1TextModelDiffs,
+                this.input2TextModelDiffs,
+            ].map((s) => s.state.read(reader)));
+            if (( states.some((s) => s === 1 ))) {
+                return 1 ;
+            }
+            if (( states.some((s) => s === 3 ))) {
+                return 3 ;
+            }
+            return 2 ;
+        });
+        this.isUpToDate = derived('isUpToDate', reader => this.diffComputingState.read(reader) === 2 );
+        this.onInitialized = waitForState(this.diffComputingState, state => state === 2 ).then(() => { });
+        this.firstRun = true;
+        this.unhandledConflictsCount = derived('unhandledConflictsCount', reader => {
+            const map = this.modifiedBaseRangeResultStates.read(reader);
+            let unhandledCount = 0;
+            for (const [_key, value] of map) {
+                if (!value.handled.read(reader)) {
+                    unhandledCount++;
+                }
+            }
+            return unhandledCount;
+        });
+        this.hasUnhandledConflicts = ( this.unhandledConflictsCount.map(value =>  value > 0));
+        this._register(keepAlive(this.modifiedBaseRangeResultStates));
+        this._register(keepAlive(this.input1ResultMapping));
+        this._register(keepAlive(this.input2ResultMapping));
+        const initializePromise = this.initialize();
+        this.onInitialized = this.onInitialized.then(async () => {
+            await initializePromise;
+        });
+        initializePromise.then(() => {
+            let shouldRecomputeHandledFromAccepted = true;
+            this._register(autorunHandleChanges('Merge Editor Model: Recompute State From Result', {
+                handleChange: (ctx) => {
+                    if (ctx.didChange(this.modifiedBaseRangeResultStates)) {
+                        shouldRecomputeHandledFromAccepted = true;
+                    }
+                    return ctx.didChange(this.resultTextModelDiffs.diffs)
+                        ? ctx.change === 1
+                        : true;
+                },
+            }, (reader) => {
+                const states = this.modifiedBaseRangeResultStates.read(reader);
+                if (!this.isUpToDate.read(reader)) {
+                    return;
+                }
+                const resultDiffs = this.resultTextModelDiffs.diffs.read(reader);
+                transaction(tx => {
+                    this.updateBaseRangeAcceptedState(resultDiffs, states, tx);
+                    if (shouldRecomputeHandledFromAccepted) {
+                        shouldRecomputeHandledFromAccepted = false;
+                        for (const [_range, observableState] of states) {
+                            const state = observableState.accepted.get();
+                            const handled = !(state.kind === ModifiedBaseRangeStateKind.base || state.kind === ModifiedBaseRangeStateKind.unrecognized);
+                            observableState.handledInput1.set(handled, tx);
+                            observableState.handledInput2.set(handled, tx);
+                        }
+                    }
+                });
+            }));
+        });
+    }
+    async initialize() {
+        if (this.options.resetResult) {
+            await this.reset();
+        }
+    }
+    async reset() {
+        await waitForState(this.inputDiffComputingState, state => state === 2 );
+        const states = this.modifiedBaseRangeResultStates.get();
+        transaction(tx => {
+            for (const [range, state] of states) {
+                let newState;
+                let handled = false;
+                if (range.input1Diffs.length === 0) {
+                    newState = ModifiedBaseRangeState.base.withInputValue(2, true);
+                    handled = true;
+                }
+                else if (range.input2Diffs.length === 0) {
+                    newState = ModifiedBaseRangeState.base.withInputValue(1, true);
+                    handled = true;
+                }
+                else if (range.isEqualChange) {
+                    newState = ModifiedBaseRangeState.base.withInputValue(1, true);
+                    handled = true;
+                }
+                else {
+                    newState = ModifiedBaseRangeState.base;
+                    handled = false;
+                }
+                state.accepted.set(newState, tx);
+                state.computedFromDiffing = false;
+                state.previousNonDiffingState = undefined;
+                state.handledInput1.set(handled, tx);
+                state.handledInput2.set(handled, tx);
+            }
+            this.resultTextModel.pushEditOperations(null, [{
+                    range: ( new Range(1, 1, Number.MAX_SAFE_INTEGER, 1)),
+                    text: this.computeAutoMergedResult()
+                }], () => null);
+        });
+    }
+    computeAutoMergedResult() {
+        const baseRanges = this.modifiedBaseRanges.get();
+        const baseLines = this.base.getLinesContent();
+        const input1Lines = this.input1.textModel.getLinesContent();
+        const input2Lines = this.input2.textModel.getLinesContent();
+        const resultLines = [];
+        function appendLinesToResult(source, lineRange) {
+            for (let i = lineRange.startLineNumber; i < lineRange.endLineNumberExclusive; i++) {
+                resultLines.push(source[i - 1]);
+            }
+        }
+        let baseStartLineNumber = 1;
+        for (const baseRange of baseRanges) {
+            appendLinesToResult(baseLines, LineRange.fromLineNumbers(baseStartLineNumber, baseRange.baseRange.startLineNumber));
+            baseStartLineNumber = baseRange.baseRange.endLineNumberExclusive;
+            if (baseRange.input1Diffs.length === 0) {
+                appendLinesToResult(input2Lines, baseRange.input2Range);
+            }
+            else if (baseRange.input2Diffs.length === 0) {
+                appendLinesToResult(input1Lines, baseRange.input1Range);
+            }
+            else if (baseRange.isEqualChange) {
+                appendLinesToResult(input1Lines, baseRange.input1Range);
+            }
+            else {
+                appendLinesToResult(baseLines, baseRange.baseRange);
+            }
+        }
+        appendLinesToResult(baseLines, LineRange.fromLineNumbers(baseStartLineNumber, baseLines.length + 1));
+        return resultLines.join(this.resultTextModel.getEOL());
+    }
+    hasBaseRange(baseRange) {
+        return ( this.modifiedBaseRangeResultStates.get().has(baseRange));
+    }
+    get isApplyingEditInResult() { return this.resultTextModelDiffs.isApplyingChange; }
+    getInputResultMapping(inputLinesDiffs, resultDiffs, inputLineCount) {
+        const map = DocumentLineRangeMap.betweenOutputs(inputLinesDiffs, resultDiffs, inputLineCount);
+        return ( new DocumentLineRangeMap(( map.lineRangeMappings.map((m) => m.inputRange.isEmpty || m.outputRange.isEmpty
+            ? ( new LineRangeMapping(
+        m.inputRange.deltaStart(-1), m.outputRange.deltaStart(-1)))
+            : m)), map.inputLineCount));
+    }
+    translateInputRangeToBase(input, range) {
+        const baseInputDiffs = input === 1 ? this.baseInput1Diffs.get() : this.baseInput2Diffs.get();
+        const map = ( new DocumentRangeMap(baseInputDiffs.flatMap(d => d.rangeMappings), 0)).reverse();
+        return map.projectRange(range).outputRange;
+    }
+    translateBaseRangeToInput(input, range) {
+        const baseInputDiffs = input === 1 ? this.baseInput1Diffs.get() : this.baseInput2Diffs.get();
+        const map = ( new DocumentRangeMap(baseInputDiffs.flatMap(d => d.rangeMappings), 0));
+        return map.projectRange(range).outputRange;
+    }
+    getLineRangeInResult(baseRange, reader) {
+        return this.resultTextModelDiffs.getResultLineRange(baseRange, reader);
+    }
+    translateResultRangeToBase(range) {
+        const map = ( new DocumentRangeMap(this.baseResultDiffs.get().flatMap(d => d.rangeMappings), 0)).reverse();
+        return map.projectRange(range).outputRange;
+    }
+    translateBaseRangeToResult(range) {
+        const map = ( new DocumentRangeMap(this.baseResultDiffs.get().flatMap(d => d.rangeMappings), 0));
+        return map.projectRange(range).outputRange;
+    }
+    findModifiedBaseRangesInRange(rangeInBase) {
+        return this.modifiedBaseRanges.get().filter(r => r.baseRange.intersects(rangeInBase));
+    }
+    updateBaseRangeAcceptedState(resultDiffs, states, tx) {
+        const baseRangeWithStoreAndTouchingDiffs = leftJoin(states, resultDiffs, (baseRange, diff) => baseRange[0].baseRange.touches(diff.inputRange)
+            ? CompareResult.neitherLessOrGreaterThan
+            : LineRange.compareByStart(baseRange[0].baseRange, diff.inputRange));
+        for (const row of baseRangeWithStoreAndTouchingDiffs) {
+            const newState = this.computeState(row.left[0], row.rights);
+            const data = row.left[1];
+            const oldState = data.accepted.get();
+            if (!oldState.equals(newState)) {
+                if (!this.firstRun && !data.computedFromDiffing) {
+                    data.computedFromDiffing = true;
+                    data.previousNonDiffingState = oldState;
+                }
+                data.accepted.set(newState, tx);
+            }
+        }
+        if (this.firstRun) {
+            this.firstRun = false;
+        }
+    }
+    computeState(baseRange, conflictingDiffs) {
+        if (conflictingDiffs.length === 0) {
+            return ModifiedBaseRangeState.base;
+        }
+        const conflictingEdits = ( conflictingDiffs.map((d) => d.getLineEdit()));
+        function editsAgreeWithDiffs(diffs) {
+            return equals(conflictingEdits, ( diffs.map((d) => d.getLineEdit())), (a, b) => a.equals(b));
+        }
+        if (editsAgreeWithDiffs(baseRange.input1Diffs)) {
+            return ModifiedBaseRangeState.base.withInputValue(1, true);
+        }
+        if (editsAgreeWithDiffs(baseRange.input2Diffs)) {
+            return ModifiedBaseRangeState.base.withInputValue(2, true);
+        }
+        const states = [
+            ModifiedBaseRangeState.base.withInputValue(1, true).withInputValue(2, true, true),
+            ModifiedBaseRangeState.base.withInputValue(2, true).withInputValue(1, true, true),
+            ModifiedBaseRangeState.base.withInputValue(1, true).withInputValue(2, true, false),
+            ModifiedBaseRangeState.base.withInputValue(2, true).withInputValue(1, true, false),
+        ];
+        for (const s of states) {
+            const { edit } = baseRange.getEditForBase(s);
+            if (edit) {
+                const resultRange = this.resultTextModelDiffs.getResultLineRange(baseRange.baseRange);
+                const existingLines = resultRange.getLines(this.resultTextModel);
+                if (equals(edit.newLines, existingLines, (a, b) => a === b)) {
+                    return s;
+                }
+            }
+        }
+        return ModifiedBaseRangeState.unrecognized;
+    }
+    getState(baseRange) {
+        const existingState = this.modifiedBaseRangeResultStates.get().get(baseRange);
+        if (!existingState) {
+            throw new BugIndicatingError('object must be from this instance');
+        }
+        return existingState.accepted;
+    }
+    setState(baseRange, state, _markInputAsHandled, tx, _pushStackElement = false) {
+        if (!this.isUpToDate.get()) {
+            throw new BugIndicatingError('Cannot set state while updating');
+        }
+        const existingState = this.modifiedBaseRangeResultStates.get().get(baseRange);
+        if (!existingState) {
+            throw new BugIndicatingError('object must be from this instance');
+        }
+        const conflictingDiffs = this.resultTextModelDiffs.findTouchingDiffs(baseRange.baseRange);
+        const group = ( new UndoRedoGroup());
+        if (conflictingDiffs) {
+            this.resultTextModelDiffs.removeDiffs(conflictingDiffs, tx, group);
+        }
+        const { edit, effectiveState } = baseRange.getEditForBase(state);
+        existingState.accepted.set(effectiveState, tx);
+        existingState.previousNonDiffingState = undefined;
+        existingState.computedFromDiffing = false;
+        const input1Handled = existingState.handledInput1.get();
+        const input2Handled = existingState.handledInput2.get();
+        if (!input1Handled || !input2Handled) {
+            this.undoRedoService.pushElement(( new MarkAsHandledUndoRedoElement(this.resultTextModel.uri, ( new WeakRef(this)), ( new WeakRef(existingState)), input1Handled, input2Handled)), group);
+        }
+        if (edit) {
+            this.resultTextModel.pushStackElement();
+            this.resultTextModelDiffs.applyEditRelativeToOriginal(edit, tx, group);
+            this.resultTextModel.pushStackElement();
+        }
+        existingState.handledInput1.set(true, tx);
+        existingState.handledInput2.set(true, tx);
+    }
+    resetDirtyConflictsToBase() {
+        transaction(tx => {
+            this.resultTextModel.pushStackElement();
+            for (const range of this.modifiedBaseRanges.get()) {
+                if (this.getState(range).get().kind === ModifiedBaseRangeStateKind.unrecognized) {
+                    this.setState(range, ModifiedBaseRangeState.base, false, tx, false);
+                }
+            }
+            this.resultTextModel.pushStackElement();
+        });
+    }
+    isHandled(baseRange) {
+        return this.modifiedBaseRangeResultStates.get().get(baseRange).handled;
+    }
+    isInputHandled(baseRange, inputNumber) {
+        const state = this.modifiedBaseRangeResultStates.get().get(baseRange);
+        return inputNumber === 1 ? state.handledInput1 : state.handledInput2;
+    }
+    setInputHandled(baseRange, inputNumber, handled, tx) {
+        const state = this.modifiedBaseRangeResultStates.get().get(baseRange);
+        if (state.handled.get() === handled) {
+            return;
+        }
+        const dataRef = ( new WeakRef(ModifiedBaseRangeData));
+        const modelRef = ( new WeakRef(this));
+        this.undoRedoService.pushElement({
+            type: 0 ,
+            resource: this.resultTextModel.uri,
+            code: 'setInputHandled',
+            label: ( localize('setInputHandled', "Set Input Handled")),
+            redo() {
+                const model = modelRef.deref();
+                const data = dataRef.deref();
+                if (model && !model.isDisposed() && data) {
+                    transaction(tx => {
+                        if (inputNumber === 1) {
+                            state.handledInput1.set(handled, tx);
+                        }
+                        else {
+                            state.handledInput2.set(handled, tx);
+                        }
+                    });
+                }
+            },
+            undo() {
+                const model = modelRef.deref();
+                const data = dataRef.deref();
+                if (model && !model.isDisposed() && data) {
+                    transaction(tx => {
+                        if (inputNumber === 1) {
+                            state.handledInput1.set(!handled, tx);
+                        }
+                        else {
+                            state.handledInput2.set(!handled, tx);
+                        }
+                    });
+                }
+            },
+        });
+        if (inputNumber === 1) {
+            state.handledInput1.set(handled, tx);
+        }
+        else {
+            state.handledInput2.set(handled, tx);
+        }
+    }
+    setHandled(baseRange, handled, tx) {
+        const state = this.modifiedBaseRangeResultStates.get().get(baseRange);
+        if (state.handled.get() === handled) {
+            return;
+        }
+        state.handledInput1.set(handled, tx);
+        state.handledInput2.set(handled, tx);
+    }
+    setLanguageId(languageId, source) {
+        const language = this.languageService.createById(languageId);
+        this.base.setLanguage(language, source);
+        this.input1.textModel.setLanguage(language, source);
+        this.input2.textModel.setLanguage(language, source);
+        this.resultTextModel.setLanguage(language, source);
+    }
+    getInitialResultValue() {
+        const chunks = [];
+        while (true) {
+            const chunk = this.resultSnapshot.read();
+            if (chunk === null) {
+                break;
+            }
+            chunks.push(chunk);
+        }
+        return chunks.join();
+    }
+    async getResultValueWithConflictMarkers() {
+        await waitForState(this.diffComputingState, state => state === 2 );
+        if (this.unhandledConflictsCount.get() === 0) {
+            return this.resultTextModel.getValue();
+        }
+        const resultLines = this.resultTextModel.getLinesContent();
+        const input1Lines = this.input1.textModel.getLinesContent();
+        const input2Lines = this.input2.textModel.getLinesContent();
+        const states = this.modifiedBaseRangeResultStates.get();
+        const outputLines = [];
+        function appendLinesToResult(source, lineRange) {
+            for (let i = lineRange.startLineNumber; i < lineRange.endLineNumberExclusive; i++) {
+                outputLines.push(source[i - 1]);
+            }
+        }
+        let resultStartLineNumber = 1;
+        for (const [range, state] of states) {
+            if (state.handled.get()) {
+                continue;
+            }
+            const resultRange = this.resultTextModelDiffs.getResultLineRange(range.baseRange);
+            appendLinesToResult(resultLines, LineRange.fromLineNumbers(resultStartLineNumber, Math.max(resultStartLineNumber, resultRange.startLineNumber)));
+            resultStartLineNumber = resultRange.endLineNumberExclusive;
+            outputLines.push('<<<<<<<');
+            if (state.accepted.get().kind === ModifiedBaseRangeStateKind.unrecognized) {
+                appendLinesToResult(resultLines, resultRange);
+            }
+            else {
+                appendLinesToResult(input1Lines, range.input1Range);
+            }
+            outputLines.push('=======');
+            appendLinesToResult(input2Lines, range.input2Range);
+            outputLines.push('>>>>>>>');
+        }
+        appendLinesToResult(resultLines, LineRange.fromLineNumbers(resultStartLineNumber, resultLines.length + 1));
+        return outputLines.join('\n');
+    }
+    get conflictCount() {
+        return arrayCount(this.modifiedBaseRanges.get(), r => r.isConflicting);
+    }
+    get combinableConflictCount() {
+        return arrayCount(this.modifiedBaseRanges.get(), r => r.isConflicting && r.canBeCombined);
+    }
+    get conflictsResolvedWithBase() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => r.isConflicting &&
+            s.accepted.get().kind === ModifiedBaseRangeStateKind.base);
+    }
+    get conflictsResolvedWithInput1() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => r.isConflicting &&
+            s.accepted.get().kind === ModifiedBaseRangeStateKind.input1);
+    }
+    get conflictsResolvedWithInput2() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => r.isConflicting &&
+            s.accepted.get().kind === ModifiedBaseRangeStateKind.input2);
+    }
+    get conflictsResolvedWithSmartCombination() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && state.kind === ModifiedBaseRangeStateKind.both && state.smartCombination;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualNone() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => r.isConflicting &&
+            s.accepted.get().kind === ModifiedBaseRangeStateKind.unrecognized);
+    }
+    get manuallySolvedConflictCountThatEqualSmartCombine() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && s.computedFromDiffing && state.kind === ModifiedBaseRangeStateKind.both && state.smartCombination;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualInput1() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && s.computedFromDiffing && state.kind === ModifiedBaseRangeStateKind.input1;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualInput2() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && s.computedFromDiffing && state.kind === ModifiedBaseRangeStateKind.input2;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualNoneAndStartedWithBase() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && state.kind === ModifiedBaseRangeStateKind.unrecognized && s.previousNonDiffingState?.kind === ModifiedBaseRangeStateKind.base;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && state.kind === ModifiedBaseRangeStateKind.unrecognized && s.previousNonDiffingState?.kind === ModifiedBaseRangeStateKind.input1;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && state.kind === ModifiedBaseRangeStateKind.unrecognized && s.previousNonDiffingState?.kind === ModifiedBaseRangeStateKind.input2;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && state.kind === ModifiedBaseRangeStateKind.unrecognized && s.previousNonDiffingState?.kind === ModifiedBaseRangeStateKind.both && !s.previousNonDiffingState?.smartCombination;
+        });
+    }
+    get manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart() {
+        return arrayCount(this.modifiedBaseRangeResultStates.get().entries(), ([r, s]) => {
+            const state = s.accepted.get();
+            return r.isConflicting && state.kind === ModifiedBaseRangeStateKind.unrecognized && s.previousNonDiffingState?.kind === ModifiedBaseRangeStateKind.both && s.previousNonDiffingState?.smartCombination;
+        });
+    }
+};
+MergeEditorModel = ( __decorate([
+    ( __param(7, ILanguageService)),
+    ( __param(8, IUndoRedoService))
+], MergeEditorModel));
+function arrayCount(array, predicate) {
+    let count = 0;
+    for (const value of array) {
+        if (predicate(value)) {
+            count++;
+        }
+    }
+    return count;
+}
+class ModifiedBaseRangeData {
+    constructor(baseRange) {
+        this.baseRange = baseRange;
+        this.accepted = observableValue(`BaseRangeState${this.baseRange.baseRange}`, ModifiedBaseRangeState.base);
+        this.handledInput1 = observableValue(`BaseRangeHandledState${this.baseRange.baseRange}.Input1`, false);
+        this.handledInput2 = observableValue(`BaseRangeHandledState${this.baseRange.baseRange}.Input2`, false);
+        this.computedFromDiffing = false;
+        this.previousNonDiffingState = undefined;
+        this.handled = derived('handled', reader => this.handledInput1.read(reader) && this.handledInput2.read(reader));
+    }
+}
+class MarkAsHandledUndoRedoElement {
+    constructor(resource, mergeEditorModelRef, stateRef, input1Handled, input2Handled) {
+        this.resource = resource;
+        this.mergeEditorModelRef = mergeEditorModelRef;
+        this.stateRef = stateRef;
+        this.input1Handled = input1Handled;
+        this.input2Handled = input2Handled;
+        this.code = 'undoMarkAsHandled';
+        this.label = ( localize('undoMarkAsHandled', 'Undo Mark As Handled'));
+        this.type = 0 ;
+    }
+    redo() {
+        const mergeEditorModel = this.mergeEditorModelRef.deref();
+        if (!mergeEditorModel || mergeEditorModel.isDisposed()) {
+            return;
+        }
+        const state = this.stateRef.deref();
+        if (!state) {
+            return;
+        }
+        transaction(tx => {
+            state.handledInput1.set(true, tx);
+            state.handledInput2.set(true, tx);
+        });
+    }
+    undo() {
+        const mergeEditorModel = this.mergeEditorModelRef.deref();
+        if (!mergeEditorModel || mergeEditorModel.isDisposed()) {
+            return;
+        }
+        const state = this.stateRef.deref();
+        if (!state) {
+            return;
+        }
+        transaction(tx => {
+            state.handledInput1.set(this.input1Handled, tx);
+            state.handledInput2.set(this.input2Handled, tx);
+        });
+    }
+}
+export { MergeEditorModel };