@codingame/monaco-vscode-api 19.1.3 → 20.0.0

package/vscode/src/vs/editor/common/textModelEditSource.d.ts

@@ -0,0 +1,151 @@
+import { ProviderId } from "./languages.js";
+declare const privateSymbol: unique symbol;
+export declare class TextModelEditSource {
+    readonly metadata: ITextModelEditSourceMetadata;
+    constructor(metadata: ITextModelEditSourceMetadata, _privateCtorGuard: typeof privateSymbol);
+    toString(): string;
+    getType(): string;
+    toKey(level: number, filter?: {
+        [TKey in ITextModelEditSourceMetadataKeys]?: boolean;
+    }): string;
+    get props(): Record<ITextModelEditSourceMetadataKeys, string | undefined>;
+}
+type TextModelEditSourceT<T> = TextModelEditSource & {
+    metadataT: T;
+};
+export declare function isAiEdit(source: TextModelEditSource): boolean;
+export declare function isUserEdit(source: TextModelEditSource): boolean;
+export declare const EditSources: {
+    unknown(data: {
+        name?: string | null;
+    }): TextModelEditSourceT<{
+        readonly source: "unknown";
+        readonly name: string | null | undefined;
+    }>;
+    rename: () => TextModelEditSourceT<{
+        readonly source: "rename";
+    }>;
+    chatApplyEdits(data: {
+        modelId: string | undefined;
+        sessionId: string | undefined;
+        requestId: string | undefined;
+    }): TextModelEditSourceT<{
+        readonly source: "Chat.applyEdits";
+        readonly $modelId: string | undefined;
+        readonly $$sessionId: string | undefined;
+        readonly $$requestId: string | undefined;
+    }>;
+    chatUndoEdits: () => TextModelEditSourceT<{
+        readonly source: "Chat.undoEdits";
+    }>;
+    chatReset: () => TextModelEditSourceT<{
+        readonly source: "Chat.reset";
+    }>;
+    inlineCompletionAccept(data: {
+        nes: boolean;
+        requestUuid: string;
+        providerId?: ProviderId;
+    }): TextModelEditSourceT<{
+        readonly $$requestUuid: string;
+        readonly $extensionId?: undefined;
+        readonly $extensionVersion?: undefined;
+        readonly $providerId?: undefined;
+        readonly source: "inlineCompletionAccept";
+        readonly $nes: boolean;
+    } | {
+        readonly $$requestUuid: string;
+        readonly $extensionId: string | undefined;
+        readonly $extensionVersion: string | undefined;
+        readonly $providerId: string | undefined;
+        readonly source: "inlineCompletionAccept";
+        readonly $nes: boolean;
+    }>;
+    inlineCompletionPartialAccept(data: {
+        nes: boolean;
+        requestUuid: string;
+        providerId?: ProviderId;
+        type: "word" | "line";
+    }): TextModelEditSourceT<{
+        readonly $$requestUuid: string;
+        readonly $extensionId?: undefined;
+        readonly $extensionVersion?: undefined;
+        readonly $providerId?: undefined;
+        readonly source: "inlineCompletionPartialAccept";
+        readonly type: "line" | "word";
+        readonly $nes: boolean;
+    } | {
+        readonly $$requestUuid: string;
+        readonly $extensionId: string | undefined;
+        readonly $extensionVersion: string | undefined;
+        readonly $providerId: string | undefined;
+        readonly source: "inlineCompletionPartialAccept";
+        readonly type: "line" | "word";
+        readonly $nes: boolean;
+    }>;
+    inlineChatApplyEdit(data: {
+        modelId: string | undefined;
+    }): TextModelEditSourceT<{
+        readonly source: "inlineChat.applyEdits";
+        readonly $modelId: string | undefined;
+    }>;
+    reloadFromDisk: () => TextModelEditSourceT<{
+        readonly source: "reloadFromDisk";
+    }>;
+    cursor(data: {
+        kind: "compositionType" | "compositionEnd" | "type" | "paste" | "cut" | "executeCommands" | "executeCommand";
+        detailedSource?: string | null;
+    }): TextModelEditSourceT<{
+        readonly source: "cursor";
+        readonly kind: "type" | "cut" | "paste" | "compositionType" | "compositionEnd" | "executeCommands" | "executeCommand";
+        readonly detailedSource: string | null | undefined;
+    }>;
+    setValue: () => TextModelEditSourceT<{
+        readonly source: "setValue";
+    }>;
+    eolChange: () => TextModelEditSourceT<{
+        readonly source: "eolChange";
+    }>;
+    applyEdits: () => TextModelEditSourceT<{
+        readonly source: "applyEdits";
+    }>;
+    snippet: () => TextModelEditSourceT<{
+        readonly source: "snippet";
+    }>;
+    suggest: (data: {
+        providerId: ProviderId | undefined;
+    }) => TextModelEditSourceT<{
+        readonly $extensionId?: undefined;
+        readonly $extensionVersion?: undefined;
+        readonly $providerId?: undefined;
+        readonly source: "suggest";
+    } | {
+        readonly $extensionId: string | undefined;
+        readonly $extensionVersion: string | undefined;
+        readonly $providerId: string | undefined;
+        readonly source: "suggest";
+    }>;
+    codeAction: (data: {
+        kind: string | undefined;
+        providerId: ProviderId | undefined;
+    }) => TextModelEditSourceT<{
+        readonly $extensionId?: undefined;
+        readonly $extensionVersion?: undefined;
+        readonly $providerId?: undefined;
+        readonly source: "codeAction";
+        readonly $kind: string | undefined;
+    } | {
+        readonly $extensionId: string | undefined;
+        readonly $extensionVersion: string | undefined;
+        readonly $providerId: string | undefined;
+        readonly source: "codeAction";
+        readonly $kind: string | undefined;
+    }>;
+};
+type Values<T> = T[keyof T];
+type ITextModelEditSourceMetadata = Values<{
+    [TKey in keyof typeof EditSources]: ReturnType<typeof EditSources[TKey]>["metadataT"];
+}>;
+type ITextModelEditSourceMetadataKeys = Values<{
+    [TKey in keyof typeof EditSources]: keyof ReturnType<typeof EditSources[TKey]>["metadataT"];
+}>;
+export {};

package/vscode/src/vs/editor/common/{textModelEditReason.js → textModelEditSource.js}

@@ -1,7 +1,7 @@
 
 
-const privateSymbol = Symbol('TextModelEditReason');
-class TextModelEditReason {
+const privateSymbol = Symbol('TextModelEditSource');
+class TextModelEditSource {
     constructor(metadata, _privateCtorGuard) {
         this.metadata = metadata;
     }
@@ -21,70 +21,91 @@ class TextModelEditReason {
                 return metadata.source;
         }
     }
-    toKey(level) {
+    toKey(level, filter = {}) {
         const metadata = this.metadata;
         const keys = ( Object.entries(metadata).filter(([key, value]) => {
+            const filterVal = filter[key];
+            if (filterVal !== undefined) {
+                return filterVal;
+            }
             const prefixCount = (key.match(/\$/g) || []).length;
             return prefixCount <= level && value !== undefined && value !== null && value !== '';
         }).map(([key, value]) => `${key}:${value}`));
         return keys.join('-');
     }
+    get props() {
+        return this.metadata;
+    }
 }
-function createEditReason(metadata) {
-    return ( new TextModelEditReason(metadata, privateSymbol));
+function createEditSource(metadata) {
+    return ( new TextModelEditSource(metadata, privateSymbol));
 }
-const EditReasons = {
+const EditSources = {
     unknown(data) {
-        return createEditReason({
+        return createEditSource({
             source: 'unknown',
             name: data.name,
         });
     },
-    rename: () => createEditReason({ source: 'rename' }),
+    rename: () => createEditSource({ source: 'rename' }),
     chatApplyEdits(data) {
-        return createEditReason({
+        return createEditSource({
             source: 'Chat.applyEdits',
             $modelId: avoidPathRedaction(data.modelId),
+            $$sessionId: data.sessionId,
+            $$requestId: data.requestId,
         });
     },
+    chatUndoEdits: () => createEditSource({ source: 'Chat.undoEdits' }),
+    chatReset: () => createEditSource({ source: 'Chat.reset' }),
     inlineCompletionAccept(data) {
-        return createEditReason({
+        return createEditSource({
             source: 'inlineCompletionAccept',
             $nes: data.nes,
-            $extensionId: data.extensionId,
+            ...toProperties(data.providerId),
             $$requestUuid: data.requestUuid,
         });
     },
     inlineCompletionPartialAccept(data) {
-        return createEditReason({
+        return createEditSource({
             source: 'inlineCompletionPartialAccept',
             type: data.type,
             $nes: data.nes,
-            $extensionId: data.extensionId,
+            ...toProperties(data.providerId),
             $$requestUuid: data.requestUuid,
         });
     },
     inlineChatApplyEdit(data) {
-        return createEditReason({
+        return createEditSource({
             source: 'inlineChat.applyEdits',
             $modelId: avoidPathRedaction(data.modelId),
         });
     },
-    reloadFromDisk: () => createEditReason({ source: 'reloadFromDisk' }),
+    reloadFromDisk: () => createEditSource({ source: 'reloadFromDisk' }),
     cursor(data) {
-        return createEditReason({
+        return createEditSource({
             source: 'cursor',
             kind: data.kind,
             detailedSource: data.detailedSource,
         });
     },
-    setValue: () => createEditReason({ source: 'setValue' }),
-    eolChange: () => createEditReason({ source: 'eolChange' }),
-    applyEdits: () => createEditReason({ source: 'applyEdits' }),
-    snippet: () => createEditReason({ source: 'snippet' }),
-    suggest: (data) => createEditReason({ source: 'suggest', $extensionId: data.extensionId }),
-    codeAction: (data) => createEditReason({ source: 'codeAction', $kind: data.kind, $extensionId: data.extensionId })
+    setValue: () => createEditSource({ source: 'setValue' }),
+    eolChange: () => createEditSource({ source: 'eolChange' }),
+    applyEdits: () => createEditSource({ source: 'applyEdits' }),
+    snippet: () => createEditSource({ source: 'snippet' }),
+    suggest: (data) => createEditSource({ source: 'suggest', ...toProperties(data.providerId) }),
+    codeAction: (data) => createEditSource({ source: 'codeAction', $kind: data.kind, ...toProperties(data.providerId) })
 };
+function toProperties(version) {
+    if (!version) {
+        return {};
+    }
+    return {
+        $extensionId: version.extensionId,
+        $extensionVersion: version.extensionVersion,
+        $providerId: version.providerId,
+    };
+}
 function avoidPathRedaction(str) {
     if (str === undefined) {
         return undefined;
@@ -92,4 +113,4 @@ function avoidPathRedaction(str) {
     return str.replaceAll('/', '|');
 }
 
-export { EditReasons, TextModelEditReason };
+export { EditSources, TextModelEditSource };

package/vscode/src/vs/editor/common/textModelEvents.d.ts

@@ -2,7 +2,7 @@ import { IPosition } from "./core/position.js";
 import { IRange } from "./core/range.js";
 import { Selection } from "./core/selection.js";
 import { IModelDecoration, InjectedTextOptions } from "./model.js";
-import { TextModelEditReason } from "./textModelEditReason.js";
+import { TextModelEditSource } from "./textModelEditSource.js";
 export interface IModelLanguageChangedEvent {
     readonly oldLanguage: string;
     readonly newLanguage: string;
@@ -24,7 +24,7 @@ export interface IModelContentChangedEvent {
     readonly isRedoing: boolean;
     readonly isFlush: boolean;
     readonly isEolChange: boolean;
-    readonly detailedReasons: TextModelEditReason[];
+    readonly detailedReasons: TextModelEditSource[];
     readonly detailedReasonsChangeLengths: number[];
 }
 export interface ISerializedModelContentChangedEvent {

package/vscode/src/vs/editor/common/tokens/sparseMultilineTokens.js

@@ -398,7 +398,7 @@ class SparseMultilineTokensStorage {
                     console.error('Invalid Semantic Tokens Data From Extension: lineNumber > model.getLineCount()');
                 });
             }
-            if (this._getEndCharacter(i) > model.getLineLength(lineNumber)) {
+            else if (this._getEndCharacter(i) > model.getLineLength(lineNumber)) {
                 SparseMultilineTokensStorage._rateLimiter.runIfNotLimited(() => {
                     console.error('Invalid Semantic Tokens Data From Extension: end character > model.getLineLength(lineNumber)');
                 });

package/vscode/src/vs/editor/common/viewLayout/lineDecorations.d.ts

@@ -1,4 +1,4 @@
-import { InlineDecoration, InlineDecorationType } from "../viewModel.js";
+import { InlineDecoration, InlineDecorationType } from "../viewModel/inlineDecorations.js";
 export declare class LineDecoration {
     readonly startColumn: number;
     readonly endColumn: number;

package/vscode/src/vs/editor/common/viewLayout/lineDecorations.js

@@ -1,8 +1,8 @@
 
 import { isHighSurrogate } from '../../../base/common/strings.js';
 import { Constants } from '../../../base/common/uint.js';
+import { InlineDecorationType } from '../viewModel/inlineDecorations.js';
 import { LinePartMetadata } from './linePart.js';
-import { InlineDecorationType } from '../viewModel.js';
 
 class LineDecoration {
     constructor(startColumn, endColumn, className, type) {

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.d.ts

@@ -2,6 +2,7 @@ import { IViewLineTokens } from "../tokens/lineTokens.js";
 import { StringBuilder } from "../core/stringBuilder.js";
 import { LineDecoration } from "./lineDecorations.js";
 import { OffsetRange } from "../core/ranges/offsetRange.js";
+import { TextDirection } from "../model.js";
 export declare enum RenderWhitespace {
     None = 0,
     Boundary = 1,
@@ -28,8 +29,12 @@ export declare class RenderLineInput {
     readonly renderWhitespace: RenderWhitespace;
     readonly renderControlCharacters: boolean;
     readonly fontLigatures: boolean;
+    readonly textDirection: TextDirection | null;
+    readonly verticalScrollbarSize: number;
     readonly selectionsOnLine: OffsetRange[] | null;
-    constructor(useMonospaceOptimizations: boolean, canUseHalfwidthRightwardsArrow: boolean, lineContent: string, continuesWithWrappedLine: boolean, isBasicASCII: boolean, containsRTL: boolean, fauxIndentLength: number, lineTokens: IViewLineTokens, lineDecorations: LineDecoration[], tabSize: number, startVisibleColumn: number, spaceWidth: number, middotWidth: number, wsmiddotWidth: number, stopRenderingLineAfter: number, renderWhitespace: "none" | "boundary" | "selection" | "trailing" | "all", renderControlCharacters: boolean, fontLigatures: boolean, selectionsOnLine: OffsetRange[] | null);
+    readonly renderNewLineWhenEmpty: boolean;
+    get isLTR(): boolean;
+    constructor(useMonospaceOptimizations: boolean, canUseHalfwidthRightwardsArrow: boolean, lineContent: string, continuesWithWrappedLine: boolean, isBasicASCII: boolean, containsRTL: boolean, fauxIndentLength: number, lineTokens: IViewLineTokens, lineDecorations: LineDecoration[], tabSize: number, startVisibleColumn: number, spaceWidth: number, middotWidth: number, wsmiddotWidth: number, stopRenderingLineAfter: number, renderWhitespace: "none" | "boundary" | "selection" | "trailing" | "all", renderControlCharacters: boolean, fontLigatures: boolean, selectionsOnLine: OffsetRange[] | null, textDirection: TextDirection | null, verticalScrollbarSize: number, renderNewLineWhenEmpty?: boolean);
     private sameSelection;
     equals(other: RenderLineInput): boolean;
 }
@@ -65,16 +70,14 @@ export declare enum ForeignElementType {
 export declare class RenderLineOutput {
     _renderLineOutputBrand: void;
     readonly characterMapping: CharacterMapping;
-    readonly containsRTL: boolean;
     readonly containsForeignElements: ForeignElementType;
-    constructor(characterMapping: CharacterMapping, containsRTL: boolean, containsForeignElements: ForeignElementType);
+    constructor(characterMapping: CharacterMapping, containsForeignElements: ForeignElementType);
 }
 export declare function renderViewLine(input: RenderLineInput, sb: StringBuilder): RenderLineOutput;
 export declare class RenderLineOutput2 {
     readonly characterMapping: CharacterMapping;
     readonly html: string;
-    readonly containsRTL: boolean;
     readonly containsForeignElements: ForeignElementType;
-    constructor(characterMapping: CharacterMapping, html: string, containsRTL: boolean, containsForeignElements: ForeignElementType);
+    constructor(characterMapping: CharacterMapping, html: string, containsForeignElements: ForeignElementType);
 }
 export declare function renderViewLine2(input: RenderLineInput): RenderLineOutput2;

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.js

@@ -4,8 +4,9 @@ import { CharCode } from '../../../base/common/charCode.js';
 import { containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
 import { StringBuilder } from '../core/stringBuilder.js';
 import { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';
-import { InlineDecorationType } from '../viewModel.js';
 import { LinePart, LinePartMetadata } from './linePart.js';
+import { InlineDecorationType } from '../viewModel/inlineDecorations.js';
+import { TextDirection } from '../model.js';
 
 var RenderWhitespace;
 (function (RenderWhitespace) {
@@ -16,7 +17,10 @@ var RenderWhitespace;
     RenderWhitespace[RenderWhitespace["All"] = 4] = "All";
 })(RenderWhitespace || (RenderWhitespace = {}));
 class RenderLineInput {
-    constructor(useMonospaceOptimizations, canUseHalfwidthRightwardsArrow, lineContent, continuesWithWrappedLine, isBasicASCII, containsRTL, fauxIndentLength, lineTokens, lineDecorations, tabSize, startVisibleColumn, spaceWidth, middotWidth, wsmiddotWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures, selectionsOnLine) {
+    get isLTR() {
+        return !this.containsRTL && this.textDirection !== TextDirection.RTL;
+    }
+    constructor(useMonospaceOptimizations, canUseHalfwidthRightwardsArrow, lineContent, continuesWithWrappedLine, isBasicASCII, containsRTL, fauxIndentLength, lineTokens, lineDecorations, tabSize, startVisibleColumn, spaceWidth, middotWidth, wsmiddotWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures, selectionsOnLine, textDirection, verticalScrollbarSize, renderNewLineWhenEmpty = false) {
         this.useMonospaceOptimizations = useMonospaceOptimizations;
         this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;
         this.lineContent = lineContent;
@@ -42,6 +46,9 @@ class RenderLineInput {
         this.renderControlCharacters = renderControlCharacters;
         this.fontLigatures = fontLigatures;
         this.selectionsOnLine = selectionsOnLine && selectionsOnLine.sort((a, b) => a.start < b.start ? -1 : 1);
+        this.renderNewLineWhenEmpty = renderNewLineWhenEmpty;
+        this.textDirection = textDirection;
+        this.verticalScrollbarSize = verticalScrollbarSize;
         const wsmiddotDiff = Math.abs(wsmiddotWidth - spaceWidth);
         const middotDiff = Math.abs(middotWidth - spaceWidth);
         if (wsmiddotDiff < middotDiff) {
@@ -89,7 +96,10 @@ class RenderLineInput {
             && this.fontLigatures === other.fontLigatures
             && LineDecoration.equalsArr(this.lineDecorations, other.lineDecorations)
             && this.lineTokens.equals(other.lineTokens)
-            && this.sameSelection(other.selectionsOnLine));
+            && this.sameSelection(other.selectionsOnLine)
+            && this.textDirection === other.textDirection
+            && this.verticalScrollbarSize === other.verticalScrollbarSize
+            && this.renderNewLineWhenEmpty === other.renderNewLineWhenEmpty);
     }
 }
 var CharacterMappingConstants;
@@ -219,10 +229,9 @@ var ForeignElementType;
     ForeignElementType[ForeignElementType["After"] = 2] = "After";
 })(ForeignElementType || (ForeignElementType = {}));
 class RenderLineOutput {
-    constructor(characterMapping, containsRTL, containsForeignElements) {
+    constructor(characterMapping, containsForeignElements) {
         this._renderLineOutputBrand = undefined;
         this.characterMapping = characterMapping;
-        this.containsRTL = containsRTL;
         this.containsForeignElements = containsForeignElements;
     }
 }
@@ -251,33 +260,32 @@ function renderViewLine(input, sb) {
             sb.appendString(`</span>`);
             const characterMapping = ( new CharacterMapping(1, beforeCount + afterCount));
             characterMapping.setColumnInfo(1, beforeCount, 0, 0);
-            return ( new RenderLineOutput(characterMapping, false, containsForeignElements));
+            return ( new RenderLineOutput(characterMapping, containsForeignElements));
+        }
+        if (input.renderNewLineWhenEmpty) {
+            sb.appendString('<span><span>\n</span></span>');
         }
-        sb.appendString('<span><span></span></span>');
-        return ( new RenderLineOutput(( new CharacterMapping(0, 0)), false, ForeignElementType.None));
+        else {
+            sb.appendString('<span><span></span></span>');
+        }
+        return ( new RenderLineOutput(( new CharacterMapping(0, 0)), ForeignElementType.None));
     }
     return _renderLine(resolveRenderLineInput(input), sb);
 }
 class RenderLineOutput2 {
-    constructor(characterMapping, html, containsRTL, containsForeignElements) {
+    constructor(characterMapping, html, containsForeignElements) {
         this.characterMapping = characterMapping;
         this.html = html;
-        this.containsRTL = containsRTL;
         this.containsForeignElements = containsForeignElements;
     }
 }
 function renderViewLine2(input) {
     const sb = ( new StringBuilder(10000));
     const out = renderViewLine(input, sb);
-    return ( new RenderLineOutput2(
-        out.characterMapping,
-        sb.build(),
-        out.containsRTL,
-        out.containsForeignElements
-    ));
+    return ( new RenderLineOutput2(out.characterMapping, sb.build(), out.containsForeignElements));
 }
 class ResolvedRenderLineInput {
-    constructor(fontIsMonospace, canUseHalfwidthRightwardsArrow, lineContent, len, isOverflowing, overflowingCharCount, parts, containsForeignElements, fauxIndentLength, tabSize, startVisibleColumn, containsRTL, spaceWidth, renderSpaceCharCode, renderWhitespace, renderControlCharacters) {
+    constructor(fontIsMonospace, canUseHalfwidthRightwardsArrow, lineContent, len, isOverflowing, overflowingCharCount, parts, containsForeignElements, fauxIndentLength, tabSize, startVisibleColumn, spaceWidth, renderSpaceCharCode, renderWhitespace, renderControlCharacters) {
         this.fontIsMonospace = fontIsMonospace;
         this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;
         this.lineContent = lineContent;
@@ -289,7 +297,6 @@ class ResolvedRenderLineInput {
         this.fauxIndentLength = fauxIndentLength;
         this.tabSize = tabSize;
         this.startVisibleColumn = startVisibleColumn;
-        this.containsRTL = containsRTL;
         this.spaceWidth = spaceWidth;
         this.renderSpaceCharCode = renderSpaceCharCode;
         this.renderWhitespace = renderWhitespace;
@@ -352,7 +359,6 @@ function resolveRenderLineInput(input) {
         input.fauxIndentLength,
         input.tabSize,
         input.startVisibleColumn,
-        input.containsRTL,
         input.spaceWidth,
         input.renderSpaceCharCode,
         input.renderWhitespace,
@@ -702,7 +708,6 @@ function _renderLine(input, sb) {
     const fauxIndentLength = input.fauxIndentLength;
     const tabSize = input.tabSize;
     const startVisibleColumn = input.startVisibleColumn;
-    const containsRTL = input.containsRTL;
     const spaceWidth = input.spaceWidth;
     const renderSpaceCharCode = input.renderSpaceCharCode;
     const renderWhitespace = input.renderWhitespace;
@@ -714,12 +719,7 @@ function _renderLine(input, sb) {
     let charOffsetInPart = 0;
     let charHorizontalOffset = 0;
     let partDisplacement = 0;
-    if (containsRTL) {
-        sb.appendString('<span dir="ltr">');
-    }
-    else {
-        sb.appendString('<span>');
-    }
+    sb.appendString('<span>');
     for (let partIndex = 0, tokensLen = parts.length; partIndex < tokensLen; partIndex++) {
         const part = parts[partIndex];
         const partEndIndex = part.endIndex;
@@ -875,18 +875,18 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
-        sb.appendString(( localize(881, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(891, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
-    return ( new RenderLineOutput(characterMapping, containsRTL, containsForeignElements));
+    return ( new RenderLineOutput(characterMapping, containsForeignElements));
 }
 function to4CharHex(n) {
     return ( n.toString(16)).toUpperCase().padStart(4, '0');
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return localize(882, "{0} chars", n);
+        return localize(892, "{0} chars", n);
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

package/vscode/src/vs/editor/common/viewLayout/viewLinesViewportData.d.ts

@@ -1,6 +1,7 @@
 import { Range } from "../core/range.js";
 import { Selection } from "../core/selection.js";
-import { IPartialViewLinesViewportData, IViewModel, IViewWhitespaceViewportData, ViewLineRenderingData, ViewModelDecoration } from "../viewModel.js";
+import { IPartialViewLinesViewportData, IViewModel, IViewWhitespaceViewportData, ViewLineRenderingData } from "../viewModel.js";
+import { ViewModelDecoration } from "../viewModel/viewModelDecoration.js";
 export declare class ViewportData {
     readonly selections: Selection[];
     readonly startLineNumber: number;

package/vscode/src/vs/editor/common/viewModel/inlineDecorations.d.ts

@@ -0,0 +1,21 @@
+import { Range } from "../core/range.js";
+export declare enum InlineDecorationType {
+    Regular = 0,
+    Before = 1,
+    After = 2,
+    RegularAffectingLetterSpacing = 3
+}
+export declare class InlineDecoration {
+    readonly range: Range;
+    readonly inlineClassName: string;
+    readonly type: InlineDecorationType;
+    constructor(range: Range, inlineClassName: string, type: InlineDecorationType);
+}
+export declare class SingleLineInlineDecoration {
+    readonly startOffset: number;
+    readonly endOffset: number;
+    readonly inlineClassName: string;
+    readonly inlineClassNameAffectsLetterSpacing: boolean;
+    constructor(startOffset: number, endOffset: number, inlineClassName: string, inlineClassNameAffectsLetterSpacing: boolean);
+    toInlineDecoration(lineNumber: number): InlineDecoration;
+}

package/vscode/src/vs/editor/common/viewModel/inlineDecorations.js

@@ -0,0 +1,30 @@
+
+import { Range } from '../core/range.js';
+
+var InlineDecorationType;
+(function (InlineDecorationType) {
+    InlineDecorationType[InlineDecorationType["Regular"] = 0] = "Regular";
+    InlineDecorationType[InlineDecorationType["Before"] = 1] = "Before";
+    InlineDecorationType[InlineDecorationType["After"] = 2] = "After";
+    InlineDecorationType[InlineDecorationType["RegularAffectingLetterSpacing"] = 3] = "RegularAffectingLetterSpacing";
+})(InlineDecorationType || (InlineDecorationType = {}));
+class InlineDecoration {
+    constructor(range, inlineClassName, type) {
+        this.range = range;
+        this.inlineClassName = inlineClassName;
+        this.type = type;
+    }
+}
+class SingleLineInlineDecoration {
+    constructor(startOffset, endOffset, inlineClassName, inlineClassNameAffectsLetterSpacing) {
+        this.startOffset = startOffset;
+        this.endOffset = endOffset;
+        this.inlineClassName = inlineClassName;
+        this.inlineClassNameAffectsLetterSpacing = inlineClassNameAffectsLetterSpacing;
+    }
+    toInlineDecoration(lineNumber) {
+        return ( new InlineDecoration(( new Range(lineNumber, this.startOffset + 1, lineNumber, this.endOffset + 1)), this.inlineClassName, this.inlineClassNameAffectsLetterSpacing ? InlineDecorationType.RegularAffectingLetterSpacing : InlineDecorationType.Regular));
+    }
+}
+
+export { InlineDecoration, InlineDecorationType, SingleLineInlineDecoration };

package/vscode/src/vs/editor/common/viewModel/modelLineProjection.js

@@ -3,7 +3,8 @@ import { LineTokens } from '../tokens/lineTokens.js';
 import { Position } from '../core/position.js';
 import { PositionAffinity } from '../model.js';
 import { LineInjectedText } from '../textModelEvents.js';
-import { SingleLineInlineDecoration, ViewLineData } from '../viewModel.js';
+import { ViewLineData } from '../viewModel.js';
+import { SingleLineInlineDecoration } from './inlineDecorations.js';
 
 function createModelLineProjection(lineBreakData, isVisible) {
     if (lineBreakData === null) {

package/vscode/src/vs/editor/common/viewModel/monospaceLineBreaksComputer.d.ts

@@ -5,5 +5,5 @@ export declare class MonospaceLineBreaksComputerFactory implements ILineBreaksCo
     static create(options: IComputedEditorOptions): MonospaceLineBreaksComputerFactory;
     private readonly classifier;
     constructor(breakBeforeChars: string, breakAfterChars: string);
-    createLineBreaksComputer(fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll"): ILineBreaksComputer;
+    createLineBreaksComputer(fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean): ILineBreaksComputer;
 }

package/vscode/src/vs/editor/common/viewModel/monospaceLineBreaksComputer.js

@@ -16,7 +16,7 @@ class MonospaceLineBreaksComputerFactory {
     constructor(breakBeforeChars, breakAfterChars) {
         this.classifier = ( new WrappingCharacterClassifier(breakBeforeChars, breakAfterChars));
     }
-    createLineBreaksComputer(fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak) {
+    createLineBreaksComputer(fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds) {
         const requests = [];
         const injectedTexts = [];
         const previousBreakingData = [];
@@ -36,7 +36,7 @@ class MonospaceLineBreaksComputerFactory {
                         result[i] = createLineBreaksFromPreviousLineBreaks(this.classifier, previousLineBreakData, requests[i], tabSize, wrappingColumn, columnsForFullWidthChar, wrappingIndent, wordBreak);
                     }
                     else {
-                        result[i] = createLineBreaks(this.classifier, requests[i], injectedText, tabSize, wrappingColumn, columnsForFullWidthChar, wrappingIndent, wordBreak);
+                        result[i] = createLineBreaks(this.classifier, requests[i], injectedText, tabSize, wrappingColumn, columnsForFullWidthChar, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds);
                     }
                 }
                 arrPool1.length = 0;
@@ -281,7 +281,7 @@ function createLineBreaksFromPreviousLineBreaks(classifier, previousBreakingData
     previousBreakingData.wrappedTextIndentLength = wrappedTextIndentLength;
     return previousBreakingData;
 }
-function createLineBreaks(classifier, _lineText, injectedTexts, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent, wordBreak) {
+function createLineBreaks(classifier, _lineText, injectedTexts, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds) {
     const lineText = LineInjectedText.applyInjectedText(_lineText, injectedTexts);
     let injectionOptions;
     let injectionOffsets;
@@ -344,6 +344,14 @@ function createLineBreaks(classifier, _lineText, injectedTexts, tabSize, firstLi
             breakOffsetVisibleColumn = visibleColumn;
         }
         visibleColumn += charWidth;
+        if (wrapOnEscapedLineFeeds
+            && i >= 2
+            && (i < 3 || lineText.charAt(i - 3) !== '\\')
+            && lineText.charAt(i - 2) === '\\'
+            && lineText.charAt(i - 1) === 'n'
+            && lineText.includes('"')) {
+            visibleColumn += breakingColumn;
+        }
         if (visibleColumn > breakingColumn) {
             if (breakOffset === 0 || visibleColumn - breakOffsetVisibleColumn > wrappedLineBreakColumn) {
                 breakOffset = charStartOffset;