@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/editor/common/core/textLength.js

@@ -0,0 +1,110 @@
+import { Position } from './position.js';
+import { Range } from './range.js';
+class TextLength {
+    static { this.zero = ( new TextLength(0, 0)); }
+    static lengthDiffNonNegative(start, end) {
+        if (end.isLessThan(start)) {
+            return TextLength.zero;
+        }
+        if (start.lineCount === end.lineCount) {
+            return ( new TextLength(0, end.columnCount - start.columnCount));
+        }
+        else {
+            return ( new TextLength(end.lineCount - start.lineCount, end.columnCount));
+        }
+    }
+    static betweenPositions(position1, position2) {
+        if (position1.lineNumber === position2.lineNumber) {
+            return ( new TextLength(0, position2.column - position1.column));
+        }
+        else {
+            return ( new TextLength(position2.lineNumber - position1.lineNumber, position2.column - 1));
+        }
+    }
+    static ofRange(range) {
+        return TextLength.betweenPositions(range.getStartPosition(), range.getEndPosition());
+    }
+    static ofText(text) {
+        let line = 0;
+        let column = 0;
+        for (const c of text) {
+            if (c === '\n') {
+                line++;
+                column = 0;
+            }
+            else {
+                column++;
+            }
+        }
+        return ( new TextLength(line, column));
+    }
+    constructor(lineCount, columnCount) {
+        this.lineCount = lineCount;
+        this.columnCount = columnCount;
+    }
+    isZero() {
+        return this.lineCount === 0 && this.columnCount === 0;
+    }
+    isLessThan(other) {
+        if (this.lineCount !== other.lineCount) {
+            return this.lineCount < other.lineCount;
+        }
+        return this.columnCount < other.columnCount;
+    }
+    isGreaterThan(other) {
+        if (this.lineCount !== other.lineCount) {
+            return this.lineCount > other.lineCount;
+        }
+        return this.columnCount > other.columnCount;
+    }
+    equals(other) {
+        return this.lineCount === other.lineCount && this.columnCount === other.columnCount;
+    }
+    compare(other) {
+        if (this.lineCount !== other.lineCount) {
+            return this.lineCount - other.lineCount;
+        }
+        return this.columnCount - other.columnCount;
+    }
+    add(other) {
+        if (other.lineCount === 0) {
+            return ( new TextLength(this.lineCount, this.columnCount + other.columnCount));
+        }
+        else {
+            return ( new TextLength(this.lineCount + other.lineCount, other.columnCount));
+        }
+    }
+    createRange(startPosition) {
+        if (this.lineCount === 0) {
+            return ( new Range(
+                startPosition.lineNumber,
+                startPosition.column,
+                startPosition.lineNumber,
+                startPosition.column + this.columnCount
+            ));
+        }
+        else {
+            return ( new Range(
+                startPosition.lineNumber,
+                startPosition.column,
+                startPosition.lineNumber + this.lineCount,
+                this.columnCount + 1
+            ));
+        }
+    }
+    toRange() {
+        return ( new Range(1, 1, this.lineCount + 1, this.columnCount + 1));
+    }
+    addToPosition(position) {
+        if (this.lineCount === 0) {
+            return ( new Position(position.lineNumber, position.column + this.columnCount));
+        }
+        else {
+            return ( new Position(position.lineNumber + this.lineCount, this.columnCount + 1));
+        }
+    }
+    toString() {
+        return `${this.lineCount},${this.columnCount}`;
+    }
+}
+export { TextLength };

package/vscode/src/vs/editor/common/core/wordCharacterClassifier.d.ts

@@ -6,7 +6,19 @@ declare const enum WordCharacterClass {
     WordSeparator = 2
 }
 declare class WordCharacterClassifier extends CharacterClassifier<WordCharacterClass> {
-    constructor(wordSeparators: string);
+    readonly intlSegmenterLocales: Intl.UnicodeBCP47LocaleIdentifier[];
+    private readonly _segmenter;
+    private _cachedLine;
+    private _cachedSegments;
+    constructor(wordSeparators: string, intlSegmenterLocales: Intl.UnicodeBCP47LocaleIdentifier[]);
+    findPrevIntlWordBeforeOrAtOffset(line: string, offset: number): IntlWordSegmentData | null;
+    findNextIntlWordAtOrAfterOffset(lineContent: string, offset: number): IntlWordSegmentData | null;
+    private _getIntlSegmenterWordsOnLine;
+    private _filterWordSegments;
+    private _isWordLike;
+}
+interface IntlWordSegmentData extends Intl.SegmentData {
+    isWordLike: true;
 }
 
-export { WordCharacterClass, WordCharacterClassifier };
+export { type IntlWordSegmentData, WordCharacterClass, WordCharacterClassifier };

package/vscode/src/vs/editor/common/core/wordCharacterClassifier.js

@@ -1,22 +1,78 @@
+import { LRUCache } from '../../../base/common/map.js';
 import { CharacterClassifier } from './characterClassifier.js';
 class WordCharacterClassifier extends CharacterClassifier {
-    constructor(wordSeparators) {
+    constructor(wordSeparators, intlSegmenterLocales) {
         super(0 );
+        this._segmenter = null;
+        this._cachedLine = null;
+        this._cachedSegments = [];
+        this.intlSegmenterLocales = intlSegmenterLocales;
+        if (this.intlSegmenterLocales.length > 0) {
+            this._segmenter = new Intl.Segmenter(this.intlSegmenterLocales, { granularity: 'word' });
+        }
+        else {
+            this._segmenter = null;
+        }
         for (let i = 0, len = wordSeparators.length; i < len; i++) {
             this.set(wordSeparators.charCodeAt(i), 2 );
         }
         this.set(32 , 1 );
         this.set(9 , 1 );
     }
+    findPrevIntlWordBeforeOrAtOffset(line, offset) {
+        let candidate = null;
+        for (const segment of this._getIntlSegmenterWordsOnLine(line)) {
+            if (segment.index > offset) {
+                break;
+            }
+            candidate = segment;
+        }
+        return candidate;
+    }
+    findNextIntlWordAtOrAfterOffset(lineContent, offset) {
+        for (const segment of this._getIntlSegmenterWordsOnLine(lineContent)) {
+            if (segment.index < offset) {
+                continue;
+            }
+            return segment;
+        }
+        return null;
+    }
+    _getIntlSegmenterWordsOnLine(line) {
+        if (!this._segmenter) {
+            return [];
+        }
+        if (this._cachedLine === line) {
+            return this._cachedSegments;
+        }
+        this._cachedLine = line;
+        this._cachedSegments = this._filterWordSegments(this._segmenter.segment(line));
+        return this._cachedSegments;
+    }
+    _filterWordSegments(segments) {
+        const result = [];
+        for (const segment of segments) {
+            if (this._isWordLike(segment)) {
+                result.push(segment);
+            }
+        }
+        return result;
+    }
+    _isWordLike(segment) {
+        if (segment.isWordLike) {
+            return true;
+        }
+        return false;
+    }
 }
-function once(computeFn) {
-    const cache = {};
-    return (input) => {
-        if (!cache.hasOwnProperty(input)) {
-            cache[input] = computeFn(input);
-        }
-        return cache[input];
-    };
+const wordClassifierCache = ( new LRUCache(10));
+function getMapForWordSeparators(wordSeparators, intlSegmenterLocales) {
+    const key = `${wordSeparators}/${intlSegmenterLocales.join(',')}`;
+    let result = wordClassifierCache.get(key);
+    if (!result) {
+        result = ( new WordCharacterClassifier(wordSeparators, intlSegmenterLocales));
+        wordClassifierCache.set(key, result);
+    }
+    return result;
 }
-const getMapForWordSeparators = once((input) => ( new WordCharacterClassifier(input)));
 export { WordCharacterClassifier, getMapForWordSeparators };

package/vscode/src/vs/editor/common/core/wordHelper.js

@@ -1,4 +1,5 @@
 import { Iterable } from '../../../base/common/iterator.js';
+import '../../../base/common/lifecycle.js';
 import { LinkedList } from '../../../base/common/linkedList.js';
 const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
 function createWordRegExp(allowInWords = '') {

package/vscode/src/vs/editor/common/cursor/cursor.js

@@ -84,7 +84,7 @@ class CursorsController extends Disposable {
     setCursorColumnSelectData(columnSelectData) {
         this._columnSelectData = columnSelectData;
     }
-    revealPrimary(eventsCollector, source, minimalReveal, verticalType, revealHorizontal, scrollType) {
+    revealAll(eventsCollector, source, minimalReveal, verticalType, revealHorizontal, scrollType) {
         const viewPositions = this._cursors.getViewPositions();
         let revealViewRange = null;
         let revealViewSelections = null;
@@ -104,6 +104,19 @@ class CursorsController extends Disposable {
             scrollType
         )));
     }
+    revealPrimary(eventsCollector, source, minimalReveal, verticalType, revealHorizontal, scrollType) {
+        const primaryCursor = this._cursors.getPrimaryCursor();
+        const revealViewSelections = [primaryCursor.viewState.selection];
+        eventsCollector.emitViewEvent(( new ViewRevealRangeRequestEvent(
+            source,
+            minimalReveal,
+            null,
+            revealViewSelections,
+            verticalType,
+            revealHorizontal,
+            scrollType
+        )));
+    }
     saveState() {
         const result = [];
         const selections = this._cursors.getSelections();
@@ -151,7 +164,7 @@ class CursorsController extends Disposable {
             });
         }
         this.setStates(eventsCollector, 'restoreState', 0 , CursorState.fromModelSelections(desiredSelections));
-        this.revealPrimary(eventsCollector, 'restoreState', false, 0 , true, 1 );
+        this.revealAll(eventsCollector, 'restoreState', false, 0 , true, 1 );
     }
     onModelContentChanged(eventsCollector, event) {
         if (event instanceof ModelInjectedTextChangedEvent) {
@@ -184,7 +197,7 @@ class CursorsController extends Disposable {
                 if (this._hasFocus && e.resultingSelection && e.resultingSelection.length > 0) {
                     const cursorState = CursorState.fromModelSelections(e.resultingSelection);
                     if (this.setStates(eventsCollector, 'modelChange', e.isUndoing ? 5  : e.isRedoing ? 6  : 2 , cursorState)) {
-                        this.revealPrimary(eventsCollector, 'modelChange', false, 0 , true, 0 );
+                        this.revealAll(eventsCollector, 'modelChange', false, 0 , true, 0 );
                     }
                 }
                 else {
@@ -407,7 +420,7 @@ class CursorsController extends Disposable {
         this._cursors.startTrackingSelections();
         this._validateAutoClosedActions();
         if (this._emitStateChangedIfNecessary(eventsCollector, source, cursorChangeReason, oldState, false)) {
-            this.revealPrimary(eventsCollector, source, false, 0 , true, 0 );
+            this.revealAll(eventsCollector, source, false, 0 , true, 0 );
         }
     }
     getAutoClosedCharacters() {

package/vscode/src/vs/editor/common/cursor/cursorTypeOperations.js

@@ -528,7 +528,7 @@ class TypeOperations {
                 }
             }
             if (pair.open.length === 1 && (ch === '\'' || ch === '"') && autoCloseConfig !== 'always') {
-                const wordSeparators = getMapForWordSeparators(config.wordSeparators);
+                const wordSeparators = getMapForWordSeparators(config.wordSeparators, []);
                 if (lineBefore.length > 0) {
                     const characterBefore = lineBefore.charCodeAt(lineBefore.length - 1);
                     if (wordSeparators.get(characterBefore) === 0 ) {

package/vscode/src/vs/editor/common/cursor/cursorWordOperations.js

@@ -8,15 +8,22 @@ class WordOperations {
     static _createWord(lineContent, wordType, nextCharClass, start, end) {
         return { start: start, end: end, wordType: wordType, nextCharClass: nextCharClass };
     }
+    static _createIntlWord(intlWord, nextCharClass) {
+        return { start: intlWord.index, end: intlWord.index + intlWord.segment.length, wordType: 1 , nextCharClass: nextCharClass };
+    }
     static _findPreviousWordOnLine(wordSeparators, model, position) {
         const lineContent = model.getLineContent(position.lineNumber);
         return this._doFindPreviousWordOnLine(lineContent, wordSeparators, position);
     }
     static _doFindPreviousWordOnLine(lineContent, wordSeparators, position) {
         let wordType = 0 ;
+        const previousIntlWord = wordSeparators.findPrevIntlWordBeforeOrAtOffset(lineContent, position.column - 2);
         for (let chIndex = position.column - 2; chIndex >= 0; chIndex--) {
             const chCode = lineContent.charCodeAt(chIndex);
             const chClass = wordSeparators.get(chCode);
+            if (previousIntlWord && chIndex === previousIntlWord.index) {
+                return this._createIntlWord(previousIntlWord, chClass);
+            }
             if (chClass === 0 ) {
                 if (wordType === 2 ) {
                     return this._createWord(lineContent, wordType, chClass, chIndex + 1, this._findEndOfWord(lineContent, wordSeparators, wordType, chIndex + 1));
@@ -41,10 +48,14 @@ class WordOperations {
         return null;
     }
     static _findEndOfWord(lineContent, wordSeparators, wordType, startIndex) {
+        const nextIntlWord = wordSeparators.findNextIntlWordAtOrAfterOffset(lineContent, startIndex);
         const len = lineContent.length;
         for (let chIndex = startIndex; chIndex < len; chIndex++) {
             const chCode = lineContent.charCodeAt(chIndex);
             const chClass = wordSeparators.get(chCode);
+            if (nextIntlWord && chIndex === nextIntlWord.index + nextIntlWord.segment.length) {
+                return chIndex;
+            }
             if (chClass === 1 ) {
                 return chIndex;
             }
@@ -64,9 +75,13 @@ class WordOperations {
     static _doFindNextWordOnLine(lineContent, wordSeparators, position) {
         let wordType = 0 ;
         const len = lineContent.length;
+        const nextIntlWord = wordSeparators.findNextIntlWordAtOrAfterOffset(lineContent, position.column - 1);
         for (let chIndex = position.column - 1; chIndex < len; chIndex++) {
             const chCode = lineContent.charCodeAt(chIndex);
             const chClass = wordSeparators.get(chCode);
+            if (nextIntlWord && chIndex === nextIntlWord.index) {
+                return this._createIntlWord(nextIntlWord, chClass);
+            }
             if (chClass === 0 ) {
                 if (wordType === 2 ) {
                     return this._createWord(lineContent, wordType, chClass, this._findStartOfWord(lineContent, wordSeparators, wordType, chIndex - 1), chIndex);
@@ -91,9 +106,13 @@ class WordOperations {
         return null;
     }
     static _findStartOfWord(lineContent, wordSeparators, wordType, startIndex) {
+        const previousIntlWord = wordSeparators.findPrevIntlWordBeforeOrAtOffset(lineContent, startIndex);
         for (let chIndex = startIndex; chIndex >= 0; chIndex--) {
             const chCode = lineContent.charCodeAt(chIndex);
             const chClass = wordSeparators.get(chCode);
+            if (previousIntlWord && chIndex === previousIntlWord.index) {
+                return chIndex;
+            }
             if (chClass === 1 ) {
                 return chIndex + 1;
             }
@@ -547,8 +566,8 @@ class WordOperations {
             endColumn: range.endColumn
         };
     }
-    static getWordAtPosition(model, _wordSeparators, position) {
-        const wordSeparators = getMapForWordSeparators(_wordSeparators);
+    static getWordAtPosition(model, _wordSeparators, _intlSegmenterLocales, position) {
+        const wordSeparators = getMapForWordSeparators(_wordSeparators, _intlSegmenterLocales);
         const prevWord = WordOperations._findPreviousWordOnLine(wordSeparators, model, position);
         if (prevWord && prevWord.wordType === 1  && prevWord.start <= position.column - 1 && position.column - 1 <= prevWord.end) {
             return WordOperations._createWordAtPosition(model, position.lineNumber, prevWord);
@@ -560,7 +579,7 @@ class WordOperations {
         return null;
     }
     static word(config, model, cursor, inSelectionMode, position) {
-        const wordSeparators = getMapForWordSeparators(config.wordSeparators);
+        const wordSeparators = getMapForWordSeparators(config.wordSeparators, config.wordSegmenterLocales);
         const prevWord = WordOperations._findPreviousWordOnLine(wordSeparators, model, position);
         const nextWord = WordOperations._findNextWordOnLine(wordSeparators, model, position);
         if (!inSelectionMode) {

package/vscode/src/vs/editor/common/cursorCommon.js

@@ -9,8 +9,8 @@ const autoCloseNever = () => false;
 const autoCloseBeforeWhitespace = (chr) => (chr === ' ' || chr === '\t');
 class CursorConfiguration {
     static shouldRecreate(e) {
-        return (e.hasChanged(144 )
-            || e.hasChanged(130 )
+        return (e.hasChanged(145 )
+            || e.hasChanged(131 )
             || e.hasChanged(37 )
             || e.hasChanged(77 )
             || e.hasChanged(79 )
@@ -23,14 +23,15 @@ class CursorConfiguration {
             || e.hasChanged(14 )
             || e.hasChanged(128 )
             || e.hasChanged(50 )
-            || e.hasChanged(91 ));
+            || e.hasChanged(91 )
+            || e.hasChanged(130 ));
     }
     constructor(languageId, modelOptions, configuration, languageConfigurationService) {
         this.languageConfigurationService = languageConfigurationService;
         this._cursorMoveConfigurationBrand = undefined;
         this._languageId = languageId;
         const options = configuration.options;
-        const layoutInfo = options.get(144 );
+        const layoutInfo = options.get(145 );
         const fontInfo = options.get(50 );
         this.readOnly = options.get(91 );
         this.tabSize = modelOptions.tabSize;
@@ -41,7 +42,7 @@ class CursorConfiguration {
         this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this.pageSize = Math.max(1, Math.floor(layoutInfo.height / this.lineHeight) - 2);
         this.useTabStops = options.get(128 );
-        this.wordSeparators = options.get(130 );
+        this.wordSeparators = options.get(131 );
         this.emptySelectionClipboard = options.get(37 );
         this.copyWithSyntaxHighlighting = options.get(25 );
         this.multiCursorMergeOverlapping = options.get(77 );
@@ -54,6 +55,7 @@ class CursorConfiguration {
         this.autoClosingOvertype = options.get(10 );
         this.autoSurround = options.get(14 );
         this.autoIndent = options.get(12 );
+        this.wordSegmenterLocales = options.get(130 );
         this.surroundingPairs = {};
         this._electricChars = null;
         this.shouldAutoCloseBefore = {

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js

@@ -8,10 +8,10 @@ import { DynamicProgrammingDiffing } from './algorithms/dynamicProgrammingDiffin
 import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';
 import { computeMovedLines } from './computeMovedLines.js';
 import { optimizeSequenceDiffs, removeVeryShortMatchingLinesBetweenDiffs, extendDiffsToEntireWordIfAppropriate, removeShortMatches, removeVeryShortMatchingTextBetweenLongDiffs } from './heuristicSequenceOptimizations.js';
+import { LineSequence } from './lineSequence.js';
+import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
 import { LinesDiff, MovedText } from '../linesDiffComputer.js';
 import { DetailedLineRangeMapping, RangeMapping } from '../rangeMapping.js';
-import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
-import { LineSequence } from './lineSequence.js';
 class DefaultLinesDiffComputer {
     constructor() {
         this.dynamicProgrammingDiffing = ( new DynamicProgrammingDiffing());
@@ -177,8 +177,11 @@ function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLi
         )));
     }
     assertFn(() => {
-        if (!dontAssertStartLine) {
-            if (changes.length > 0 && changes[0].original.startLineNumber !== changes[0].modified.startLineNumber) {
+        if (!dontAssertStartLine && changes.length > 0) {
+            if (changes[0].modified.startLineNumber !== changes[0].original.startLineNumber) {
+                return false;
+            }
+            if (modifiedLines.length - changes[changes.length - 1].modified.endLineNumberExclusive !== originalLines.length - changes[changes.length - 1].original.endLineNumberExclusive) {
                 return false;
             }
         }

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js

@@ -156,7 +156,7 @@ function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiff
         let equalChars2 = equalPart.seq2Range.length;
         while (equalMappings.length > 0) {
             const next = equalMappings[0];
-            const intersects = next.seq1Range.intersects(w1) || next.seq2Range.intersects(w2);
+            const intersects = next.seq1Range.intersects(w.seq1Range) || next.seq2Range.intersects(w.seq2Range);
             if (!intersects) {
                 break;
             }

package/vscode/src/vs/editor/common/diff/rangeMapping.d.ts

@@ -26,6 +26,7 @@ declare class LineRangeMapping {
  * Also contains inner range mappings.
  */
 declare class DetailedLineRangeMapping extends LineRangeMapping {
+    static fromRangeMappings(rangeMappings: RangeMapping[]): DetailedLineRangeMapping;
     /**
      * If inner changes have not been computed, this is set to undefined.
      * Otherwise, it represents the character-level diff in this line range.
@@ -35,6 +36,7 @@ declare class DetailedLineRangeMapping extends LineRangeMapping {
     readonly innerChanges: RangeMapping[] | undefined;
     constructor(originalRange: LineRange, modifiedRange: LineRange, innerChanges: RangeMapping[] | undefined);
     flip(): DetailedLineRangeMapping;
+    withInnerChangesFromLineRanges(): DetailedLineRangeMapping;
 }
 /**
  * Maps a range in the original text model to a range in the modified text model.

package/vscode/src/vs/editor/common/diff/rangeMapping.js

@@ -47,6 +47,11 @@ class LineRangeMapping {
     }
 }
 class DetailedLineRangeMapping extends LineRangeMapping {
+    static fromRangeMappings(rangeMappings) {
+        const originalRange = LineRange.join(( rangeMappings.map(r => LineRange.fromRangeInclusive(r.originalRange))));
+        const modifiedRange = LineRange.join(( rangeMappings.map(r => LineRange.fromRangeInclusive(r.modifiedRange))));
+        return ( new DetailedLineRangeMapping(originalRange, modifiedRange, rangeMappings));
+    }
     constructor(originalRange, modifiedRange, innerChanges) {
         super(originalRange, modifiedRange);
         this.innerChanges = innerChanges;
@@ -54,6 +59,11 @@ class DetailedLineRangeMapping extends LineRangeMapping {
     flip() {
         return ( new DetailedLineRangeMapping(this.modified, this.original, this.innerChanges?.map(c => c.flip())));
     }
+    withInnerChangesFromLineRanges() {
+        return ( new DetailedLineRangeMapping(this.original, this.modified, [
+            ( new RangeMapping(this.original.toExclusiveRange(), this.modified.toExclusiveRange())),
+        ]));
+    }
 }
 class RangeMapping {
     constructor(originalRange, modifiedRange) {

package/vscode/src/vs/editor/common/editorContextKeys.js

@@ -63,6 +63,31 @@ var EditorContextKeys;
      'diffEditorRenderSideBySideInlineBreakpointReached',
      "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
+    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localizeWithPath(
+     'vs/editor/common/editorContextKeys',
+     'diffEditorInlineMode',
+     "Whether inline mode is active"
+    ))));
+    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localizeWithPath(
+     'vs/editor/common/editorContextKeys',
+     'diffEditorOriginalWritable',
+     "Whether modified is writable in the diff editor"
+    ))));
+    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localizeWithPath(
+     'vs/editor/common/editorContextKeys',
+     'diffEditorModifiedWritable',
+     "Whether modified is writable in the diff editor"
+    ))));
+    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localizeWithPath(
+     'vs/editor/common/editorContextKeys',
+     'diffEditorOriginalUri',
+     "The uri of the original document"
+    ))));
+    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localizeWithPath(
+     'vs/editor/common/editorContextKeys',
+     'diffEditorModifiedUri',
+     "The uri of the modified document"
+    ))));
     EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localizeWithPath(
      'vs/editor/common/editorContextKeys',
      'editorColumnSelection',