@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/modifiedBaseRange.js

@@ -11,7 +11,7 @@ import { MappingAlignment, DetailedLineRangeMapping } from './mapping.js';
 class ModifiedBaseRange {
     static fromDiffs(diffs1, diffs2, baseTextModel, input1TextModel, input2TextModel) {
         const alignments = MappingAlignment.compute(diffs1, diffs2);
-        return ( alignments.map((a) => ( new ModifiedBaseRange(
+        return ( alignments.map(a => ( new ModifiedBaseRange(
             a.inputRange,
             baseTextModel,
             a.output1Range,
@@ -22,9 +22,16 @@ class ModifiedBaseRange {
             a.output2LineMappings
         ))));
     }
-    constructor(baseRange, baseTextModel, input1Range, input1TextModel,
-    input1Diffs, input2Range, input2TextModel,
-    input2Diffs) {
+    constructor(
+        baseRange,
+        baseTextModel,
+        input1Range,
+        input1TextModel,
+        input1Diffs,
+        input2Range,
+        input2TextModel,
+        input2Diffs
+    ) {
         this.baseRange = baseRange;
         this.baseTextModel = baseTextModel;
         this.input1Range = input1Range;
@@ -35,13 +42,17 @@ class ModifiedBaseRange {
         this.input2Diffs = input2Diffs;
         this.input1CombinedDiff = DetailedLineRangeMapping.join(this.input1Diffs);
         this.input2CombinedDiff = DetailedLineRangeMapping.join(this.input2Diffs);
-        this.isEqualChange = equals(this.input1Diffs, this.input2Diffs, (a, b) => a.getLineEdit().equals(b.getLineEdit()));
+        this.isEqualChange = equals(
+            this.input1Diffs,
+            this.input2Diffs,
+            (a, b) => a.getLineEdit().equals(b.getLineEdit())
+        );
         this.smartInput1LineRangeEdit = null;
         this.smartInput2LineRangeEdit = null;
         this.dumbInput1LineRangeEdit = null;
         this.dumbInput2LineRangeEdit = null;
         if (this.input1Diffs.length === 0 && this.input2Diffs.length === 0) {
-            throw ( new BugIndicatingError('must have at least one diff'));
+            throw ( new BugIndicatingError("must have at least one diff"));
         }
     }
     getInputRange(inputNumber) {
@@ -70,37 +81,60 @@ class ModifiedBaseRange {
     getEditForBase(state) {
         const diffs = [];
         if (state.includesInput1 && this.input1CombinedDiff) {
-            diffs.push({ diff: this.input1CombinedDiff, inputNumber: 1 });
+            diffs.push({
+                diff: this.input1CombinedDiff,
+                inputNumber: 1
+            });
         }
         if (state.includesInput2 && this.input2CombinedDiff) {
-            diffs.push({ diff: this.input2CombinedDiff, inputNumber: 2 });
+            diffs.push({
+                diff: this.input2CombinedDiff,
+                inputNumber: 2
+            });
         }
         if (diffs.length === 0) {
-            return { edit: undefined, effectiveState: ModifiedBaseRangeState.base };
+            return {
+                edit: undefined,
+                effectiveState: ModifiedBaseRangeState.base
+            };
         }
         if (diffs.length === 1) {
-            return { edit: diffs[0].diff.getLineEdit(), effectiveState: ModifiedBaseRangeState.base.withInputValue(diffs[0].inputNumber, true, false) };
+            return {
+                edit: diffs[0].diff.getLineEdit(),
+                effectiveState: ModifiedBaseRangeState.base.withInputValue(diffs[0].inputNumber, true, false)
+            };
         }
         if (state.kind !== ModifiedBaseRangeStateKind.both) {
             throw ( new BugIndicatingError());
         }
         const smartCombinedEdit = state.smartCombination ? this.smartCombineInputs(state.firstInput) : this.dumbCombineInputs(state.firstInput);
         if (smartCombinedEdit) {
-            return { edit: smartCombinedEdit, effectiveState: state };
+            return {
+                edit: smartCombinedEdit,
+                effectiveState: state
+            };
         }
         return {
             edit: diffs[getOtherInputNumber(state.firstInput) - 1].diff.getLineEdit(),
-            effectiveState: ModifiedBaseRangeState.base.withInputValue(getOtherInputNumber(state.firstInput), true, false),
+            effectiveState: ModifiedBaseRangeState.base.withInputValue(getOtherInputNumber(state.firstInput), true, false)
         };
     }
     smartCombineInputs(firstInput) {
         if (firstInput === 1 && this.smartInput1LineRangeEdit !== null) {
             return this.smartInput1LineRangeEdit;
-        }
-        else if (firstInput === 2 && this.smartInput2LineRangeEdit !== null) {
+        } else if (firstInput === 2 && this.smartInput2LineRangeEdit !== null) {
             return this.smartInput2LineRangeEdit;
         }
-        const combinedDiffs = concatArrays(this.input1Diffs.flatMap((diffs) => ( diffs.rangeMappings.map((diff) => ({ diff, input: 1 })))), this.input2Diffs.flatMap((diffs) => ( diffs.rangeMappings.map((diff) => ({ diff, input: 2 }))))).sort(tieBreakComparators(compareBy((d) => d.diff.inputRange, Range.compareRangesUsingStarts), compareBy((d) => (d.input === firstInput ? 1 : 2), numberComparator)));
+        const combinedDiffs = concatArrays(this.input1Diffs.flatMap(diffs => ( diffs.rangeMappings.map(diff => ({
+            diff,
+            input: 1
+        })))), this.input2Diffs.flatMap(diffs => ( diffs.rangeMappings.map(diff => ({
+            diff,
+            input: 2
+        }))))).sort(tieBreakComparators(
+            compareBy(d => d.diff.inputRange, Range.compareRangesUsingStarts),
+            compareBy(d => (d.input === firstInput ? 1 : 2), numberComparator)
+        ));
         const sortedEdits = ( combinedDiffs.map(d => {
             const sourceTextModel = d.input === 1 ? this.input1TextModel : this.input2TextModel;
             return ( new RangeEdit(d.diff.inputRange, sourceTextModel.getValueInRange(d.diff.outputRange)));
@@ -108,8 +142,7 @@ class ModifiedBaseRange {
         const result = editsToLineRangeEdit(this.baseRange, sortedEdits, this.baseTextModel);
         if (firstInput === 1) {
             this.smartInput1LineRangeEdit = result;
-        }
-        else {
+        } else {
             this.smartInput2LineRangeEdit = result;
         }
         return result;
@@ -117,8 +150,7 @@ class ModifiedBaseRange {
     dumbCombineInputs(firstInput) {
         if (firstInput === 1 && this.dumbInput1LineRangeEdit !== null) {
             return this.dumbInput1LineRangeEdit;
-        }
-        else if (firstInput === 2 && this.dumbInput2LineRangeEdit !== null) {
+        } else if (firstInput === 2 && this.dumbInput2LineRangeEdit !== null) {
             return this.dumbInput2LineRangeEdit;
         }
         let input1Lines = this.input1Range.getLines(this.input1TextModel);
@@ -129,22 +161,19 @@ class ModifiedBaseRange {
         const result = ( new LineRangeEdit(this.baseRange, input1Lines.concat(input2Lines)));
         if (firstInput === 1) {
             this.dumbInput1LineRangeEdit = result;
-        }
-        else {
+        } else {
             this.dumbInput2LineRangeEdit = result;
         }
         return result;
     }
 }
 function editsToLineRangeEdit(range, sortedEdits, textModel) {
-    let text = '';
+    let text = "";
     const startsLineBefore = range.startLineNumber > 1;
-    let currentPosition = startsLineBefore
-        ? ( new Position(
+    let currentPosition = startsLineBefore ? ( new Position(
         range.startLineNumber - 1,
         textModel.getLineMaxColumn(range.startLineNumber - 1)
-    ))
-        : ( new Position(range.startLineNumber, 1));
+    )) : ( new Position(range.startLineNumber, 1));
     for (const edit of sortedEdits) {
         const diffStart = edit.range.getStartPosition();
         if (!currentPosition.isBeforeOrEqual(diffStart)) {
@@ -152,7 +181,7 @@ function editsToLineRangeEdit(range, sortedEdits, textModel) {
         }
         let originalText = textModel.getValueInRange(Range.fromPositions(currentPosition, diffStart));
         if (diffStart.lineNumber > textModel.getLineCount()) {
-            originalText += '\n';
+            originalText += "\n";
         }
         text += originalText;
         text += edit.newText;
@@ -164,13 +193,13 @@ function editsToLineRangeEdit(range, sortedEdits, textModel) {
     text += originalText;
     const lines = splitLines(text);
     if (startsLineBefore) {
-        if (lines[0] !== '') {
+        if (lines[0] !== "") {
             return undefined;
         }
         lines.shift();
     }
     if (endsLineAfter) {
-        if (lines[lines.length - 1] !== '') {
+        if (lines[lines.length - 1] !== "") {
             return undefined;
         }
         lines.pop();
@@ -178,7 +207,7 @@ function editsToLineRangeEdit(range, sortedEdits, textModel) {
     return ( new LineRangeEdit(range, lines));
 }
 var ModifiedBaseRangeStateKind;
-(function (ModifiedBaseRangeStateKind) {
+(function(ModifiedBaseRangeStateKind) {
     ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["base"] = 0] = "base";
     ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["input1"] = 1] = "input1";
     ModifiedBaseRangeStateKind[ModifiedBaseRangeStateKind["input2"] = 2] = "input2";
@@ -189,9 +218,13 @@ function getOtherInputNumber(inputNumber) {
     return inputNumber === 1 ? 2 : 1;
 }
 class AbstractModifiedBaseRangeState {
-    constructor() { }
-    get includesInput1() { return false; }
-    get includesInput2() { return false; }
+    constructor() {}
+    get includesInput1() {
+        return false;
+    }
+    get includesInput2() {
+        return false;
+    }
     includesInput(inputNumber) {
         return inputNumber === 1 ? this.includesInput1 : this.includesInput2;
     }
@@ -209,14 +242,19 @@ class AbstractModifiedBaseRangeState {
     }
 }
 class ModifiedBaseRangeStateBase extends AbstractModifiedBaseRangeState {
-    get kind() { return ModifiedBaseRangeStateKind.base; }
-    toString() { return 'base'; }
-    swap() { return this; }
+    get kind() {
+        return ModifiedBaseRangeStateKind.base;
+    }
+    toString() {
+        return "base";
+    }
+    swap() {
+        return this;
+    }
     withInputValue(inputNumber, value, smartCombination = false) {
         if (inputNumber === 1) {
             return value ? ( new ModifiedBaseRangeStateInput1()) : this;
-        }
-        else {
+        } else {
             return value ? ( new ModifiedBaseRangeStateInput2()) : this;
         }
     }
@@ -225,15 +263,22 @@ class ModifiedBaseRangeStateBase extends AbstractModifiedBaseRangeState {
     }
 }
 class ModifiedBaseRangeStateInput1 extends AbstractModifiedBaseRangeState {
-    get kind() { return ModifiedBaseRangeStateKind.input1; }
-    get includesInput1() { return true; }
-    toString() { return '1✓'; }
-    swap() { return ( new ModifiedBaseRangeStateInput2()); }
+    get kind() {
+        return ModifiedBaseRangeStateKind.input1;
+    }
+    get includesInput1() {
+        return true;
+    }
+    toString() {
+        return "1✓";
+    }
+    swap() {
+        return ( new ModifiedBaseRangeStateInput2());
+    }
     withInputValue(inputNumber, value, smartCombination = false) {
         if (inputNumber === 1) {
             return value ? this : ( new ModifiedBaseRangeStateBase());
-        }
-        else {
+        } else {
             return value ? ( new ModifiedBaseRangeStateBoth(1, smartCombination)) : ( new ModifiedBaseRangeStateInput2());
         }
     }
@@ -242,15 +287,22 @@ class ModifiedBaseRangeStateInput1 extends AbstractModifiedBaseRangeState {
     }
 }
 class ModifiedBaseRangeStateInput2 extends AbstractModifiedBaseRangeState {
-    get kind() { return ModifiedBaseRangeStateKind.input2; }
-    get includesInput2() { return true; }
-    toString() { return '2✓'; }
-    swap() { return ( new ModifiedBaseRangeStateInput1()); }
+    get kind() {
+        return ModifiedBaseRangeStateKind.input2;
+    }
+    get includesInput2() {
+        return true;
+    }
+    toString() {
+        return "2✓";
+    }
+    swap() {
+        return ( new ModifiedBaseRangeStateInput1());
+    }
     withInputValue(inputNumber, value, smartCombination = false) {
         if (inputNumber === 2) {
             return value ? this : ( new ModifiedBaseRangeStateBase());
-        }
-        else {
+        } else {
             return value ? ( new ModifiedBaseRangeStateBoth(2, smartCombination)) : ( new ModifiedBaseRangeStateInput2());
         }
     }
@@ -264,13 +316,21 @@ class ModifiedBaseRangeStateBoth extends AbstractModifiedBaseRangeState {
         this.firstInput = firstInput;
         this.smartCombination = smartCombination;
     }
-    get kind() { return ModifiedBaseRangeStateKind.both; }
-    get includesInput1() { return true; }
-    get includesInput2() { return true; }
+    get kind() {
+        return ModifiedBaseRangeStateKind.both;
+    }
+    get includesInput1() {
+        return true;
+    }
+    get includesInput2() {
+        return true;
+    }
     toString() {
-        return '2✓';
+        return "2✓";
+    }
+    swap() {
+        return ( new ModifiedBaseRangeStateBoth(getOtherInputNumber(this.firstInput), this.smartCombination));
     }
-    swap() { return ( new ModifiedBaseRangeStateBoth(getOtherInputNumber(this.firstInput), this.smartCombination)); }
     withInputValue(inputNumber, value, smartCombination = false) {
         if (value) {
             return this;
@@ -285,9 +345,15 @@ class ModifiedBaseRangeStateBoth extends AbstractModifiedBaseRangeState {
     }
 }
 class ModifiedBaseRangeStateUnrecognized extends AbstractModifiedBaseRangeState {
-    get kind() { return ModifiedBaseRangeStateKind.unrecognized; }
-    toString() { return 'unrecognized'; }
-    swap() { return this; }
+    get kind() {
+        return ModifiedBaseRangeStateKind.unrecognized;
+    }
+    toString() {
+        return "unrecognized";
+    }
+    swap() {
+        return this;
+    }
     withInputValue(inputNumber, value, smartCombination = false) {
         if (!value) {
             return this;
@@ -299,12 +365,12 @@ class ModifiedBaseRangeStateUnrecognized extends AbstractModifiedBaseRangeState
     }
 }
 var ModifiedBaseRangeState;
-(function (ModifiedBaseRangeState) {
+(function(ModifiedBaseRangeState) {
     ModifiedBaseRangeState.base = ( new ModifiedBaseRangeStateBase());
     ModifiedBaseRangeState.unrecognized = ( new ModifiedBaseRangeStateUnrecognized());
 })(ModifiedBaseRangeState || (ModifiedBaseRangeState = {}));
 var InputState;
-(function (InputState) {
+(function(InputState) {
     InputState[InputState["excluded"] = 0] = "excluded";
     InputState[InputState["first"] = 1] = "first";
     InputState[InputState["second"] = 2] = "second";

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/rangeUtils.js

@@ -17,31 +17,26 @@ function rangeContainsPosition(range, position) {
 function lengthOfRange(range) {
     if (range.startLineNumber === range.endLineNumber) {
         return ( new TextLength(0, range.endColumn - range.startColumn));
-    }
-    else {
+    } else {
         return ( new TextLength(range.endLineNumber - range.startLineNumber, range.endColumn - 1));
     }
 }
 function lengthBetweenPositions(position1, position2) {
     if (position1.lineNumber === position2.lineNumber) {
         return ( new TextLength(0, position2.column - position1.column));
-    }
-    else {
+    } else {
         return ( new TextLength(position2.lineNumber - position1.lineNumber, position2.column - 1));
     }
 }
 function addLength(position, length) {
     if (length.lineCount === 0) {
         return ( new Position(position.lineNumber, position.column + length.columnCount));
-    }
-    else {
+    } else {
         return ( new Position(position.lineNumber + length.lineCount, length.columnCount + 1));
     }
 }
 function rangeIsBeforeOrTouching(range, other) {
-    return (range.endLineNumber < other.startLineNumber ||
-        (range.endLineNumber === other.startLineNumber &&
-            range.endColumn <= other.startColumn));
+    return (range.endLineNumber < other.startLineNumber || (range.endLineNumber === other.startLineNumber && range.endColumn <= other.startColumn));
 }
 
 export { addLength, lengthBetweenPositions, lengthOfRange, rangeContainsPosition, rangeIsBeforeOrTouching };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/textModelDiffs.js

@@ -27,7 +27,7 @@ class TextModelDiffs extends Disposable {
         this._barrier = ( new ReentrancyBarrier());
         this._isDisposed = false;
         this._isInitializing = true;
-        const recomputeSignal = observableSignal('recompute');
+        const recomputeSignal = observableSignal("recompute");
         this._register(autorun(reader => {
             recomputeSignal.read(reader);
             this._recompute(reader);
@@ -55,10 +55,14 @@ class TextModelDiffs extends Disposable {
             this._isInitializing = true;
         }
         transaction(tx => {
-            this._state.set(this._isInitializing ? TextModelDiffState.initializing : TextModelDiffState.updating, tx, TextModelDiffChangeReason.other);
+            this._state.set(
+                this._isInitializing ? TextModelDiffState.initializing : TextModelDiffState.updating,
+                tx,
+                TextModelDiffChangeReason.other
+            );
         });
         const result = this.diffComputer.computeDiff(this.baseTextModel, this.textModel, reader);
-        result.then((result) => {
+        result.then(result => {
             if (this._isDisposed) {
                 return;
             }
@@ -69,8 +73,7 @@ class TextModelDiffs extends Disposable {
                 if (result.diffs) {
                     this._state.set(TextModelDiffState.upToDate, tx, TextModelDiffChangeReason.textChange);
                     this._diffs.set(result.diffs, tx, TextModelDiffChangeReason.textChange);
-                }
-                else {
+                } else {
                     this._state.set(TextModelDiffState.error, tx, TextModelDiffChangeReason.textChange);
                 }
                 this._isInitializing = false;
@@ -79,17 +82,17 @@ class TextModelDiffs extends Disposable {
     }
     ensureUpToDate() {
         if (this.state.get() !== TextModelDiffState.upToDate) {
-            throw ( new BugIndicatingError('Cannot remove diffs when the model is not up to date'));
+            throw ( new BugIndicatingError("Cannot remove diffs when the model is not up to date"));
         }
     }
     removeDiffs(diffToRemoves, transaction, group) {
         this.ensureUpToDate();
-        diffToRemoves.sort(compareBy((d) => d.inputRange.startLineNumber, numberComparator));
+        diffToRemoves.sort(compareBy(d => d.inputRange.startLineNumber, numberComparator));
         diffToRemoves.reverse();
         let diffs = this._diffs.get();
         for (const diffToRemove of diffToRemoves) {
             const len = diffs.length;
-            diffs = diffs.filter((d) => d !== diffToRemove);
+            diffs = diffs.filter(d => d !== diffToRemove);
             if (len === diffs.length) {
                 throw ( new BugIndicatingError());
             }
@@ -97,9 +100,9 @@ class TextModelDiffs extends Disposable {
                 const edits = diffToRemove.getReverseLineEdit().toEdits(this.textModel.getLineCount());
                 this.textModel.pushEditOperations(null, edits, () => null, group);
             });
-            diffs = ( diffs.map((d) => d.outputRange.isAfter(diffToRemove.outputRange)
-                ? d.addOutputLineDelta(diffToRemove.inputRange.length - diffToRemove.outputRange.length)
-                : d));
+            diffs = ( diffs.map(
+                d => d.outputRange.isAfter(diffToRemove.outputRange) ? d.addOutputLineDelta(diffToRemove.inputRange.length - diffToRemove.outputRange.length) : d
+            ));
         }
         this._diffs.set(diffs, transaction, TextModelDiffChangeReason.other);
     }
@@ -116,16 +119,14 @@ class TextModelDiffs extends Disposable {
         const newDiffs = ( new Array());
         for (const diff of this.diffs.get()) {
             if (diff.inputRange.intersectsOrTouches(edit.range)) {
-                throw ( new BugIndicatingError('Edit must be conflict free.'));
-            }
-            else if (diff.inputRange.isAfter(edit.range)) {
+                throw ( new BugIndicatingError("Edit must be conflict free."));
+            } else if (diff.inputRange.isAfter(edit.range)) {
                 if (!firstAfter) {
                     firstAfter = true;
                     newDiffs.push(editMapping.addOutputLineDelta(delta));
                 }
                 newDiffs.push(diff.addOutputLineDelta(edit.newLines.length - edit.range.length));
-            }
-            else {
+            } else {
                 newDiffs.push(diff);
             }
             if (!firstAfter) {
@@ -151,11 +152,9 @@ class TextModelDiffs extends Disposable {
         for (const diff of diffs) {
             if (diff.inputRange.contains(lineNumber) || diff.inputRange.endLineNumberExclusive === lineNumber) {
                 return diff;
-            }
-            else if (diff.inputRange.endLineNumberExclusive < lineNumber) {
+            } else if (diff.inputRange.endLineNumberExclusive < lineNumber) {
                 offset = diff.resultingDeltaFromOriginalToModified;
-            }
-            else {
+            } else {
                 break;
             }
         }
@@ -163,23 +162,23 @@ class TextModelDiffs extends Disposable {
     }
     getResultLineRange(baseRange, reader) {
         let start = this.getResultLine(baseRange.startLineNumber, reader);
-        if (typeof start !== 'number') {
+        if (typeof start !== "number") {
             start = start.outputRange.startLineNumber;
         }
         let endExclusive = this.getResultLine(baseRange.endLineNumberExclusive, reader);
-        if (typeof endExclusive !== 'number') {
+        if (typeof endExclusive !== "number") {
             endExclusive = endExclusive.outputRange.endLineNumberExclusive;
         }
         return MergeEditorLineRange.fromLineNumbers(start, endExclusive);
     }
 }
 var TextModelDiffChangeReason;
-(function (TextModelDiffChangeReason) {
+(function(TextModelDiffChangeReason) {
     TextModelDiffChangeReason[TextModelDiffChangeReason["other"] = 0] = "other";
     TextModelDiffChangeReason[TextModelDiffChangeReason["textChange"] = 1] = "textChange";
 })(TextModelDiffChangeReason || (TextModelDiffChangeReason = {}));
 var TextModelDiffState;
-(function (TextModelDiffState) {
+(function(TextModelDiffState) {
     TextModelDiffState[TextModelDiffState["initializing"] = 1] = "initializing";
     TextModelDiffState[TextModelDiffState["upToDate"] = 2] = "upToDate";
     TextModelDiffState[TextModelDiffState["updating"] = 3] = "updating";

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/telemetry.js

@@ -7,23 +7,23 @@ let MergeEditorTelemetry = class MergeEditorTelemetry {
         this.telemetryService = telemetryService;
     }
     reportMergeEditorOpened(args) {
-        this.telemetryService.publicLog2('mergeEditor.opened', {
+        this.telemetryService.publicLog2("mergeEditor.opened", {
             conflictCount: args.conflictCount,
             combinableConflictCount: args.combinableConflictCount,
             baseVisible: args.baseVisible,
             isColumnView: args.isColumnView,
-            baseTop: args.baseTop,
+            baseTop: args.baseTop
         });
     }
     reportLayoutChange(args) {
-        this.telemetryService.publicLog2('mergeEditor.layoutChanged', {
+        this.telemetryService.publicLog2("mergeEditor.layoutChanged", {
             baseVisible: args.baseVisible,
             isColumnView: args.isColumnView,
-            baseTop: args.baseTop,
+            baseTop: args.baseTop
         });
     }
     reportMergeEditorClosed(args) {
-        this.telemetryService.publicLog2('mergeEditor.closed', {
+        this.telemetryService.publicLog2("mergeEditor.closed", {
             conflictCount: args.conflictCount,
             combinableConflictCount: args.combinableConflictCount,
             durationOpenedSecs: args.durationOpenedSecs,
@@ -41,41 +41,39 @@ let MergeEditorTelemetry = class MergeEditorTelemetry {
             manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1,
             manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2,
             manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart,
-            manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart,
+            manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: args.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart
         });
     }
     reportAcceptInvoked(inputNumber, otherAccepted) {
-        this.telemetryService.publicLog2('mergeEditor.action.accept', {
+        this.telemetryService.publicLog2("mergeEditor.action.accept", {
             otherAccepted: otherAccepted,
-            isInput1: inputNumber === 1,
+            isInput1: inputNumber === 1
         });
     }
     reportSmartCombinationInvoked(otherAccepted) {
-        this.telemetryService.publicLog2('mergeEditor.action.smartCombination', {
-            otherAccepted: otherAccepted,
+        this.telemetryService.publicLog2("mergeEditor.action.smartCombination", {
+            otherAccepted: otherAccepted
         });
     }
     reportRemoveInvoked(inputNumber, otherAccepted) {
-        this.telemetryService.publicLog2('mergeEditor.action.remove', {
+        this.telemetryService.publicLog2("mergeEditor.action.remove", {
             otherAccepted: otherAccepted,
-            isInput1: inputNumber === 1,
+            isInput1: inputNumber === 1
         });
     }
     reportResetToBaseInvoked() {
-        this.telemetryService.publicLog2('mergeEditor.action.resetToBase', {});
+        this.telemetryService.publicLog2("mergeEditor.action.resetToBase", {});
     }
     reportNavigationToNextConflict() {
-        this.telemetryService.publicLog2('mergeEditor.action.goToNextConflict', {});
+        this.telemetryService.publicLog2("mergeEditor.action.goToNextConflict", {});
     }
     reportNavigationToPreviousConflict() {
-        this.telemetryService.publicLog2('mergeEditor.action.goToPreviousConflict', {});
+        this.telemetryService.publicLog2("mergeEditor.action.goToPreviousConflict", {});
     }
     reportConflictCounterClicked() {
-        this.telemetryService.publicLog2('mergeEditor.action.conflictCounterClicked', {});
+        this.telemetryService.publicLog2("mergeEditor.action.conflictCounterClicked", {});
     }
 };
-MergeEditorTelemetry = ( __decorate([
-    ( __param(0, ITelemetryService))
-], MergeEditorTelemetry));
+MergeEditorTelemetry = ( __decorate([( __param(0, ITelemetryService))], MergeEditorTelemetry));
 
 export { MergeEditorTelemetry };