@codingame/monaco-vscode-210e86a9-a91b-5273-b05d-390c776dde1f-common 17.2.1 → 18.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-210e86a9-a91b-5273-b05d-390c776dde1f-common",
-  "version": "17.2.1",
+  "version": "18.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package (chat, extensions, interactive, notebook, terminal, view-common)",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "17.2.1"
+    "@codingame/monaco-vscode-api": "18.0.0"
   },
   "exports": {
     ".": {

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/editing.d.ts

@@ -1,10 +1,10 @@
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
 import { IIdentifiedSingleEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { LineRange } from "./lineRange.js";
+import { MergeEditorLineRange } from "./lineRange.js";
 export declare class LineRangeEdit {
-    readonly range: LineRange;
+    readonly range: MergeEditorLineRange;
     readonly newLines: string[];
-    constructor(range: LineRange, newLines: string[]);
+    constructor(range: MergeEditorLineRange, newLines: string[]);
     equals(other: LineRangeEdit): boolean;
     toEdits(modelLineCount: number): IIdentifiedSingleEditOperation[];
 }

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/lineRange.d.ts

@@ -1,29 +1,15 @@
-import { Comparator } from "@codingame/monaco-vscode-api/vscode/vs/base/common/arrays";
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { LineRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/lineRange";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-export declare class LineRange {
-    readonly startLineNumber: number;
-    readonly lineCount: number;
-    static readonly compareByStart: Comparator<LineRange>;
-    static join(ranges: LineRange[]): LineRange | undefined;
-    static fromLineNumbers(startLineNumber: number, endExclusiveLineNumber: number): LineRange;
-    constructor(startLineNumber: number, lineCount: number);
-    join(other: LineRange): LineRange;
-    get endLineNumberExclusive(): number;
-    get isEmpty(): boolean;
-    touches(other: LineRange): boolean;
-    isAfter(range: LineRange): boolean;
-    isBefore(range: LineRange): boolean;
-    delta(lineDelta: number): LineRange;
-    toString(): string;
-    equals(originalRange: LineRange): boolean;
-    contains(lineNumber: number): boolean;
-    deltaEnd(delta: number): LineRange;
-    deltaStart(lineDelta: number): LineRange;
+export declare class MergeEditorLineRange extends LineRange {
+    static fromLineNumbers(startLineNumber: number, endExclusiveLineNumber: number): MergeEditorLineRange;
+    static fromLength(startLineNumber: number, length: number): MergeEditorLineRange;
+    join(other: MergeEditorLineRange): MergeEditorLineRange;
+    isAfter(range: MergeEditorLineRange): boolean;
+    isBefore(range: MergeEditorLineRange): boolean;
+    delta(lineDelta: number): MergeEditorLineRange;
+    deltaEnd(delta: number): MergeEditorLineRange;
+    deltaStart(lineDelta: number): MergeEditorLineRange;
     getLines(model: ITextModel): string[];
-    containsRange(range: LineRange): boolean;
-    toRange(): Range;
-    toInclusiveRange(): Range | undefined;
     toInclusiveRangeOrEmpty(): Range;
-    intersects(lineRange: LineRange): boolean;
 }

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

@@ -1,45 +1,17 @@
 
-import { compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Constants } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uint';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/lineRange';
 
-class LineRange {
-    static { this.compareByStart = compareBy(l => l.startLineNumber, numberComparator); }
-    static join(ranges) {
-        if (ranges.length === 0) {
-            return undefined;
-        }
-        let startLineNumber = Number.MAX_SAFE_INTEGER;
-        let endLineNumber = 0;
-        for (const range of ranges) {
-            startLineNumber = Math.min(startLineNumber, range.startLineNumber);
-            endLineNumber = Math.max(endLineNumber, range.startLineNumber + range.lineCount);
-        }
-        return ( new LineRange(startLineNumber, endLineNumber - startLineNumber));
-    }
+class MergeEditorLineRange extends LineRange {
     static fromLineNumbers(startLineNumber, endExclusiveLineNumber) {
-        return ( new LineRange(startLineNumber, endExclusiveLineNumber - startLineNumber));
+        return MergeEditorLineRange.fromLength(startLineNumber, endExclusiveLineNumber - startLineNumber);
     }
-    constructor(startLineNumber, lineCount) {
-        this.startLineNumber = startLineNumber;
-        this.lineCount = lineCount;
-        if (lineCount < 0) {
-            throw ( new BugIndicatingError());
-        }
+    static fromLength(startLineNumber, length) {
+        return ( new MergeEditorLineRange(startLineNumber, startLineNumber + length));
     }
     join(other) {
-        return LineRange.fromLineNumbers(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));
-    }
-    get endLineNumberExclusive() {
-        return this.startLineNumber + this.lineCount;
-    }
-    get isEmpty() {
-        return this.lineCount === 0;
-    }
-    touches(other) {
-        return (this.endLineNumberExclusive >= other.startLineNumber &&
-            other.endLineNumberExclusive >= this.startLineNumber);
+        return MergeEditorLineRange.fromLineNumbers(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));
     }
     isAfter(range) {
         return this.startLineNumber >= range.endLineNumberExclusive;
@@ -48,47 +20,21 @@ class LineRange {
         return range.startLineNumber >= this.endLineNumberExclusive;
     }
     delta(lineDelta) {
-        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount));
-    }
-    toString() {
-        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
-    }
-    equals(originalRange) {
-        return this.startLineNumber === originalRange.startLineNumber && this.lineCount === originalRange.lineCount;
-    }
-    contains(lineNumber) {
-        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
+        return MergeEditorLineRange.fromLength(this.startLineNumber + lineDelta, this.length);
     }
     deltaEnd(delta) {
-        return ( new LineRange(this.startLineNumber, this.lineCount + delta));
+        return MergeEditorLineRange.fromLength(this.startLineNumber, this.length + delta);
     }
     deltaStart(lineDelta) {
-        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount - lineDelta));
+        return MergeEditorLineRange.fromLength(this.startLineNumber + lineDelta, this.length - lineDelta);
     }
     getLines(model) {
-        const result = ( new Array(this.lineCount));
-        for (let i = 0; i < this.lineCount; i++) {
+        const result = ( new Array(this.length));
+        for (let i = 0; i < this.length; i++) {
             result[i] = model.getLineContent(this.startLineNumber + i);
         }
         return result;
     }
-    containsRange(range) {
-        return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
-    }
-    toRange() {
-        return ( new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1));
-    }
-    toInclusiveRange() {
-        if (this.isEmpty) {
-            return undefined;
-        }
-        return ( new Range(
-            this.startLineNumber,
-            1,
-            this.endLineNumberExclusive - 1,
-            Constants.MAX_SAFE_SMALL_INTEGER
-        ));
-    }
     toInclusiveRangeOrEmpty() {
         if (this.isEmpty) {
             return ( new Range(this.startLineNumber, 1, this.startLineNumber, 1));
@@ -100,10 +46,6 @@ class LineRange {
             Constants.MAX_SAFE_SMALL_INTEGER
         ));
     }
-    intersects(lineRange) {
-        return this.startLineNumber <= lineRange.endLineNumberExclusive
-            && lineRange.startLineNumber <= this.endLineNumberExclusive;
-    }
 }
 
-export { LineRange };
+export { MergeEditorLineRange };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.d.ts

@@ -2,13 +2,13 @@ import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/c
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { LineRangeEdit } from "./editing.js";
-import { LineRange } from "./lineRange.js";
+import { MergeEditorLineRange } from "./lineRange.js";
 export declare class LineRangeMapping {
-    readonly inputRange: LineRange;
-    readonly outputRange: LineRange;
+    readonly inputRange: MergeEditorLineRange;
+    readonly outputRange: MergeEditorLineRange;
     static join(mappings: readonly LineRangeMapping[]): LineRangeMapping | undefined;
-    constructor(inputRange: LineRange, outputRange: LineRange);
-    extendInputRange(extendedInputRange: LineRange): LineRangeMapping;
+    constructor(inputRange: MergeEditorLineRange, outputRange: MergeEditorLineRange);
+    extendInputRange(extendedInputRange: MergeEditorLineRange): LineRangeMapping;
     join(other: LineRangeMapping): LineRangeMapping;
     get resultingDeltaFromOriginalToModified(): number;
     toString(): string;
@@ -26,13 +26,13 @@ export declare class DocumentLineRangeMap {
     reverse(): DocumentLineRangeMap;
 }
 export declare class MappingAlignment<T extends LineRangeMapping> {
-    readonly inputRange: LineRange;
-    readonly output1Range: LineRange;
+    readonly inputRange: MergeEditorLineRange;
+    readonly output1Range: MergeEditorLineRange;
     readonly output1LineMappings: T[];
-    readonly output2Range: LineRange;
+    readonly output2Range: MergeEditorLineRange;
     readonly output2LineMappings: T[];
     static compute<T extends LineRangeMapping>(fromInputToOutput1: readonly T[], fromInputToOutput2: readonly T[]): MappingAlignment<T>[];
-    constructor(inputRange: LineRange, output1Range: LineRange, output1LineMappings: T[], output2Range: LineRange, output2LineMappings: T[]);
+    constructor(inputRange: MergeEditorLineRange, output1Range: MergeEditorLineRange, output1LineMappings: T[], output2Range: MergeEditorLineRange, output2LineMappings: T[]);
     toString(): string;
 }
 export declare class DetailedLineRangeMapping extends LineRangeMapping {
@@ -40,7 +40,7 @@ export declare class DetailedLineRangeMapping extends LineRangeMapping {
     readonly outputTextModel: ITextModel;
     static join(mappings: readonly DetailedLineRangeMapping[]): DetailedLineRangeMapping | undefined;
     readonly rangeMappings: readonly RangeMapping[];
-    constructor(inputRange: LineRange, inputTextModel: ITextModel, outputRange: LineRange, outputTextModel: ITextModel, rangeMappings?: readonly RangeMapping[]);
+    constructor(inputRange: MergeEditorLineRange, inputTextModel: ITextModel, outputRange: MergeEditorLineRange, outputTextModel: ITextModel, rangeMappings?: readonly RangeMapping[]);
     addOutputLineDelta(delta: number): DetailedLineRangeMapping;
     addInputLineDelta(delta: number): DetailedLineRangeMapping;
     join(other: DetailedLineRangeMapping): DetailedLineRangeMapping;

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

@@ -5,7 +5,7 @@ import { assertFn, checkAdjacentItems } from '@codingame/monaco-vscode-api/vscod
 import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { LineRangeEdit } from './editing.js';
-import { LineRange } from './lineRange.js';
+import { MergeEditorLineRange } from './lineRange.js';
 import { rangeIsBeforeOrTouching, rangeContainsPosition, lengthBetweenPositions, addLength } from './rangeUtils.js';
 
 class LineRangeMapping {
@@ -22,10 +22,10 @@ class LineRangeMapping {
         }
         const startDelta = extendedInputRange.startLineNumber - this.inputRange.startLineNumber;
         const endDelta = extendedInputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
-        return ( new LineRangeMapping(extendedInputRange, ( new LineRange(
-            this.outputRange.startLineNumber + startDelta,
-            this.outputRange.lineCount - startDelta + endDelta
-        ))));
+        return ( new LineRangeMapping(
+            extendedInputRange,
+            MergeEditorLineRange.fromLength(this.outputRange.startLineNumber + startDelta, this.outputRange.length - startDelta + endDelta)
+        ));
     }
     join(other) {
         return ( new LineRangeMapping(
@@ -67,15 +67,18 @@ class DocumentLineRangeMap {
     project(lineNumber) {
         const lastBefore = findLast(this.lineRangeMappings, r => r.inputRange.startLineNumber <= lineNumber);
         if (!lastBefore) {
-            return ( new LineRangeMapping(( new LineRange(lineNumber, 1)), ( new LineRange(lineNumber, 1))));
+            return ( new LineRangeMapping(
+                MergeEditorLineRange.fromLength(lineNumber, 1),
+                MergeEditorLineRange.fromLength(lineNumber, 1)
+            ));
         }
         if (lastBefore.inputRange.contains(lineNumber)) {
             return lastBefore;
         }
-        const containingRange = ( new LineRange(lineNumber, 1));
-        const mappedRange = ( new LineRange(lineNumber +
+        const containingRange = MergeEditorLineRange.fromLength(lineNumber, 1);
+        const mappedRange = MergeEditorLineRange.fromLength(lineNumber +
             lastBefore.outputRange.endLineNumberExclusive -
-            lastBefore.inputRange.endLineNumberExclusive, 1));
+            lastBefore.inputRange.endLineNumberExclusive, 1);
         return ( new LineRangeMapping(containingRange, mappedRange));
     }
     get outputLineCount() {
@@ -110,7 +113,7 @@ class MappingAlignment {
         let currentInputRange;
         for (const diff of combinedDiffs) {
             const range = diff.diff.inputRange;
-            if (currentInputRange && !currentInputRange.touches(range)) {
+            if (currentInputRange && !currentInputRange.intersectsOrTouches(range)) {
                 pushAndReset(currentInputRange);
                 currentInputRange = undefined;
             }
@@ -143,7 +146,7 @@ class DetailedLineRangeMapping extends LineRangeMapping {
         super(inputRange, outputRange);
         this.inputTextModel = inputTextModel;
         this.outputTextModel = outputTextModel;
-        this.rangeMappings = rangeMappings || [( new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange()))];
+        this.rangeMappings = rangeMappings || [( new RangeMapping(this.inputRange.toExclusiveRange(), this.outputRange.toExclusiveRange()))];
     }
     addOutputLineDelta(delta) {
         return ( new DetailedLineRangeMapping(

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

@@ -1,22 +1,22 @@
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { LineRangeEdit } from "./editing.js";
-import { LineRange } from "./lineRange.js";
+import { MergeEditorLineRange } from "./lineRange.js";
 import { DetailedLineRangeMapping } from "./mapping.js";
 export declare class ModifiedBaseRange {
-    readonly baseRange: LineRange;
+    readonly baseRange: MergeEditorLineRange;
     readonly baseTextModel: ITextModel;
-    readonly input1Range: LineRange;
+    readonly input1Range: MergeEditorLineRange;
     readonly input1TextModel: ITextModel;
     readonly input1Diffs: readonly DetailedLineRangeMapping[];
-    readonly input2Range: LineRange;
+    readonly input2Range: MergeEditorLineRange;
     readonly input2TextModel: ITextModel;
     readonly input2Diffs: readonly DetailedLineRangeMapping[];
     static fromDiffs(diffs1: readonly DetailedLineRangeMapping[], diffs2: readonly DetailedLineRangeMapping[], baseTextModel: ITextModel, input1TextModel: ITextModel, input2TextModel: ITextModel): ModifiedBaseRange[];
     readonly input1CombinedDiff: DetailedLineRangeMapping | undefined;
     readonly input2CombinedDiff: DetailedLineRangeMapping | undefined;
     readonly isEqualChange: boolean;
-    constructor(baseRange: LineRange, baseTextModel: ITextModel, input1Range: LineRange, input1TextModel: ITextModel, input1Diffs: readonly DetailedLineRangeMapping[], input2Range: LineRange, input2TextModel: ITextModel, input2Diffs: readonly DetailedLineRangeMapping[]);
-    getInputRange(inputNumber: 1 | 2): LineRange;
+    constructor(baseRange: MergeEditorLineRange, baseTextModel: ITextModel, input1Range: MergeEditorLineRange, input1TextModel: ITextModel, input1Diffs: readonly DetailedLineRangeMapping[], input2Range: MergeEditorLineRange, input2TextModel: ITextModel, input2Diffs: readonly DetailedLineRangeMapping[]);
+    getInputRange(inputNumber: 1 | 2): MergeEditorLineRange;
     getInputCombinedDiff(inputNumber: 1 | 2): DetailedLineRangeMapping | undefined;
     getInputDiffs(inputNumber: 1 | 2): readonly DetailedLineRangeMapping[];
     get isConflicting(): boolean;

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

@@ -1,6 +1,6 @@
 import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
-import { TextLength } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/textLength";
+import { TextLength } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/textLength";
 export declare function rangeContainsPosition(range: Range, position: Position): boolean;
 export declare function lengthOfRange(range: Range): TextLength;
 export declare function lengthBetweenPositions(position1: Position, position2: Position): TextLength;

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

@@ -1,6 +1,6 @@
 
 import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
-import { TextLength } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/textLength';
+import { TextLength } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/textLength';
 
 function rangeContainsPosition(range, position) {
     if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/conflictActions.d.ts

@@ -19,9 +19,9 @@ export declare class ActionsSource {
     private getItemsInput;
     readonly itemsInput1: IObservable<IContentWidgetAction[]>;
     readonly itemsInput2: IObservable<IContentWidgetAction[]>;
-    readonly resultItems: IObservable<IContentWidgetAction[]>;
-    readonly isEmpty: IObservable<boolean>;
-    readonly inputIsEmpty: IObservable<boolean>;
+    readonly resultItems: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<IContentWidgetAction[], void>;
+    readonly isEmpty: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<boolean, void>;
+    readonly inputIsEmpty: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<boolean, void>;
 }
 export interface IContentWidgetAction {
     text: string;

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

@@ -9,9 +9,9 @@ import { EditorOption, EDITOR_FONT_DEFAULTS } from '@codingame/monaco-vscode-api
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ModifiedBaseRangeStateKind, ModifiedBaseRangeState } from '../model/modifiedBaseRange.js';
 import { FixedZoneWidget } from './fixedZoneWidget.js';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
-import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
 class ConflictActionsFactory extends Disposable {
     constructor(_editor) {
@@ -83,15 +83,15 @@ class ActionsSource {
             const result = [];
             if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
                 result.push({
-                    text: ( localize(7856, "Manual Resolution")),
-                    tooltip: ( localize(7857, "This conflict has been resolved manually.")),
+                    text: ( localize(8084, "Manual Resolution")),
+                    tooltip: ( localize(8085, "This conflict has been resolved manually.")),
                 });
             }
             else if (state.kind === ModifiedBaseRangeStateKind.base) {
                 result.push({
-                    text: ( localize(7858, 'No Changes Accepted')),
+                    text: ( localize(8086, 'No Changes Accepted')),
                     tooltip: ( localize(
-                        7859,
+                        8087,
                         'The current resolution of this conflict equals the common ancestor of both the right and left changes.'
                     )),
                 });
@@ -113,20 +113,20 @@ class ActionsSource {
             }
             const stateToggles = [];
             if (state.includesInput1) {
-                stateToggles.push(command(( localize(7860, 'Remove {0}', model.input1.title)), async () => {
+                stateToggles.push(command(( localize(8088, 'Remove {0}', model.input1.title)), async () => {
                     transaction((tx) => {
                         model.setState(modifiedBaseRange, state.withInputValue(1, false), true, tx);
                         model.telemetry.reportRemoveInvoked(1, state.includesInput(2));
                     });
-                }, ( localize(7861, 'Remove {0} from the result document.', model.input1.title))));
+                }, ( localize(8089, 'Remove {0} from the result document.', model.input1.title))));
             }
             if (state.includesInput2) {
-                stateToggles.push(command(( localize(7860, 'Remove {0}', model.input2.title)), async () => {
+                stateToggles.push(command(( localize(8088, 'Remove {0}', model.input2.title)), async () => {
                     transaction((tx) => {
                         model.setState(modifiedBaseRange, state.withInputValue(2, false), true, tx);
                         model.telemetry.reportRemoveInvoked(2, state.includesInput(1));
                     });
-                }, ( localize(7861, 'Remove {0} from the result document.', model.input2.title))));
+                }, ( localize(8089, 'Remove {0} from the result document.', model.input2.title))));
             }
             if (state.kind === ModifiedBaseRangeStateKind.both &&
                 state.firstInput === 2) {
@@ -134,13 +134,13 @@ class ActionsSource {
             }
             result.push(...stateToggles);
             if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
-                result.push(command(( localize(7862, 'Reset to base')), async () => {
+                result.push(command(( localize(8090, 'Reset to base')), async () => {
                     transaction((tx) => {
                         model.setState(modifiedBaseRange, ModifiedBaseRangeState.base, true, tx);
                         model.telemetry.reportResetToBaseInvoked();
                     });
                 }, ( localize(
-                    7863,
+                    8091,
                     'Reset this conflict to the common ancestor of both the right and left changes.'
                 ))));
             }
@@ -172,16 +172,16 @@ class ActionsSource {
             const otherInputNumber = inputNumber === 1 ? 2 : 1;
             if (state.kind !== ModifiedBaseRangeStateKind.unrecognized && !state.isInputIncluded(inputNumber)) {
                 if (!state.isInputIncluded(otherInputNumber) || !this.viewModel.shouldUseAppendInsteadOfAccept.read(reader)) {
-                    result.push(command(( localize(7864, "Accept {0}", inputData.title)), async () => {
+                    result.push(command(( localize(8092, "Accept {0}", inputData.title)), async () => {
                         transaction((tx) => {
                             model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
                             model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
                         });
-                    }, ( localize(7865, "Accept {0} in the result document.", inputData.title))));
+                    }, ( localize(8093, "Accept {0} in the result document.", inputData.title))));
                     if (modifiedBaseRange.canBeCombined) {
                         const commandName = modifiedBaseRange.isOrderRelevant
-                            ? ( localize(7866, "Accept Combination ({0} First)", inputData.title))
-                            : ( localize(7867, "Accept Combination"));
+                            ? ( localize(8094, "Accept Combination ({0} First)", inputData.title))
+                            : ( localize(8095, "Accept Combination"));
                         result.push(command(commandName, async () => {
                             transaction((tx) => {
                                 model.setState(modifiedBaseRange, ModifiedBaseRangeState.base
@@ -190,36 +190,36 @@ class ActionsSource {
                                 model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
                             });
                         }, ( localize(
-                            7868,
+                            8096,
                             "Accept an automatic combination of both sides in the result document."
                         ))));
                     }
                 }
                 else {
-                    result.push(command(( localize(7869, "Append {0}", inputData.title)), async () => {
+                    result.push(command(( localize(8097, "Append {0}", inputData.title)), async () => {
                         transaction((tx) => {
                             model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
                             model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
                         });
-                    }, ( localize(7870, "Append {0} to the result document.", inputData.title))));
+                    }, ( localize(8098, "Append {0} to the result document.", inputData.title))));
                     if (modifiedBaseRange.canBeCombined) {
-                        result.push(command(( localize(7871, "Accept Combination", inputData.title)), async () => {
+                        result.push(command(( localize(8099, "Accept Combination", inputData.title)), async () => {
                             transaction((tx) => {
                                 model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, true), inputNumber, tx);
                                 model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
                             });
                         }, ( localize(
-                            7868,
+                            8096,
                             "Accept an automatic combination of both sides in the result document."
                         ))));
                     }
                 }
                 if (!model.isInputHandled(modifiedBaseRange, inputNumber).read(reader)) {
-                    result.push(command(( localize(7872, 'Ignore')), async () => {
+                    result.push(command(( localize(8100, 'Ignore')), async () => {
                         transaction((tx) => {
                             model.setInputHandled(modifiedBaseRange, inputNumber, true, tx);
                         });
-                    }, ( localize(7873, "Don't take this side of the conflict."))));
+                    }, ( localize(8101, "Don't take this side of the conflict."))));
                 }
             }
             return result;