@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -1,7 +1,7 @@
 
 import { localize } from '../../../nls.js';
 import { CharCode } from '../../../base/common/charCode.js';
-import { containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
+import { isFullWidthCharacter, containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex } from '../../../base/common/strings.js';
 import { StringBuilder } from '../core/stringBuilder.js';
 import { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';
 import { LinePart, LinePartMetadata } from './linePart.js';
@@ -42,7 +42,8 @@ class RenderLineInput {
         selectionsOnLine,
         textDirection,
         verticalScrollbarSize,
-        renderNewLineWhenEmpty = false
+        renderNewLineWhenEmpty = false,
+        useTwoCellFullwidthCharacters = false
     ) {
         this.useMonospaceOptimizations = useMonospaceOptimizations;
         this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;
@@ -62,6 +63,7 @@ class RenderLineInput {
         this.fontLigatures = fontLigatures;
         this.selectionsOnLine = selectionsOnLine && selectionsOnLine.sort((a, b) => a.start < b.start ? -1 : 1);
         this.renderNewLineWhenEmpty = renderNewLineWhenEmpty;
+        this.useTwoCellFullwidthCharacters = useTwoCellFullwidthCharacters;
         this.textDirection = textDirection;
         this.verticalScrollbarSize = verticalScrollbarSize;
         const wsmiddotDiff = Math.abs(wsmiddotWidth - spaceWidth);
@@ -92,7 +94,7 @@ class RenderLineInput {
         return true;
     }
     equals(other) {
-        return (this.useMonospaceOptimizations === other.useMonospaceOptimizations && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow && this.lineContent === other.lineContent && this.continuesWithWrappedLine === other.continuesWithWrappedLine && this.isBasicASCII === other.isBasicASCII && this.containsRTL === other.containsRTL && this.fauxIndentLength === other.fauxIndentLength && this.tabSize === other.tabSize && this.startVisibleColumn === other.startVisibleColumn && this.spaceWidth === other.spaceWidth && this.renderSpaceWidth === other.renderSpaceWidth && this.renderSpaceCharCode === other.renderSpaceCharCode && this.stopRenderingLineAfter === other.stopRenderingLineAfter && this.renderWhitespace === other.renderWhitespace && this.renderControlCharacters === other.renderControlCharacters && this.fontLigatures === other.fontLigatures && LineDecoration.equalsArr(this.lineDecorations, other.lineDecorations) && this.lineTokens.equals(other.lineTokens) && this.sameSelection(other.selectionsOnLine) && this.textDirection === other.textDirection && this.verticalScrollbarSize === other.verticalScrollbarSize && this.renderNewLineWhenEmpty === other.renderNewLineWhenEmpty);
+        return (this.useMonospaceOptimizations === other.useMonospaceOptimizations && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow && this.lineContent === other.lineContent && this.continuesWithWrappedLine === other.continuesWithWrappedLine && this.isBasicASCII === other.isBasicASCII && this.containsRTL === other.containsRTL && this.fauxIndentLength === other.fauxIndentLength && this.tabSize === other.tabSize && this.startVisibleColumn === other.startVisibleColumn && this.spaceWidth === other.spaceWidth && this.renderSpaceWidth === other.renderSpaceWidth && this.renderSpaceCharCode === other.renderSpaceCharCode && this.stopRenderingLineAfter === other.stopRenderingLineAfter && this.renderWhitespace === other.renderWhitespace && this.renderControlCharacters === other.renderControlCharacters && this.fontLigatures === other.fontLigatures && LineDecoration.equalsArr(this.lineDecorations, other.lineDecorations) && this.lineTokens.equals(other.lineTokens) && this.sameSelection(other.selectionsOnLine) && this.textDirection === other.textDirection && this.verticalScrollbarSize === other.verticalScrollbarSize && this.renderNewLineWhenEmpty === other.renderNewLineWhenEmpty && this.useTwoCellFullwidthCharacters === other.useTwoCellFullwidthCharacters);
     }
 }
 var CharacterMappingConstants;
@@ -231,17 +233,16 @@ function renderViewLine(input, sb) {
             let afterCount = 0;
             let containsForeignElements = ForeignElementType.None;
             for (const lineDecoration of input.lineDecorations) {
-                if (lineDecoration.type === InlineDecorationType.Before || lineDecoration.type === InlineDecorationType.After) {
+                if (lineDecoration.type === InlineDecorationType.Before || lineDecoration.type === InlineDecorationType.After || lineDecoration.type === InlineDecorationType.WidthOnly) {
                     sb.appendString(`<span class="`);
                     sb.appendString(lineDecoration.className);
                     sb.appendString(`"></span>`);
-                    if (lineDecoration.type === InlineDecorationType.Before) {
-                        containsForeignElements |= ForeignElementType.Before;
-                        beforeCount++;
-                    }
                     if (lineDecoration.type === InlineDecorationType.After) {
                         containsForeignElements |= ForeignElementType.After;
                         afterCount++;
+                    } else {
+                        containsForeignElements |= ForeignElementType.Before;
+                        beforeCount++;
                     }
                 }
             }
@@ -287,7 +288,8 @@ class ResolvedRenderLineInput {
         spaceWidth,
         renderSpaceCharCode,
         renderWhitespace,
-        renderControlCharacters
+        renderControlCharacters,
+        useTwoCellFullwidthCharacters
     ) {
         this.fontIsMonospace = fontIsMonospace;
         this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;
@@ -304,6 +306,7 @@ class ResolvedRenderLineInput {
         this.renderSpaceCharCode = renderSpaceCharCode;
         this.renderWhitespace = renderWhitespace;
         this.renderControlCharacters = renderControlCharacters;
+        this.useTwoCellFullwidthCharacters = useTwoCellFullwidthCharacters;
     }
 }
 function resolveRenderLineInput(input) {
@@ -343,6 +346,8 @@ function resolveRenderLineInput(input) {
                 containsForeignElements |= ForeignElementType.Before;
             } else if (lineDecoration.type === InlineDecorationType.After) {
                 containsForeignElements |= ForeignElementType.After;
+            } else if (lineDecoration.type === InlineDecorationType.WidthOnly) {
+                containsForeignElements |= ForeignElementType.Before;
             }
         }
         tokens = _applyInlineDecorations(lineContent, len, tokens, input.lineDecorations);
@@ -352,6 +357,9 @@ function resolveRenderLineInput(input) {
     } else {
         tokens = splitLeadingWhitespaceFromRTL(lineContent, tokens);
     }
+    if (input.useTwoCellFullwidthCharacters) {
+        tokens = splitFullWidthCharacters(lineContent, tokens);
+    }
     return ( new ResolvedRenderLineInput(
         input.useMonospaceOptimizations,
         input.canUseHalfwidthRightwardsArrow,
@@ -367,9 +375,33 @@ function resolveRenderLineInput(input) {
         input.spaceWidth,
         input.renderSpaceCharCode,
         input.renderWhitespace,
-        input.renderControlCharacters
+        input.renderControlCharacters,
+        input.useTwoCellFullwidthCharacters
     ));
 }
+function splitFullWidthCharacters(lineContent, parts) {
+    const result = [];
+    let startOffset = 0;
+    for (const part of parts) {
+        let didSplit = false;
+        for (let offset = startOffset; offset < part.endIndex; offset++) {
+            if (!isFullWidthCharacter(lineContent.charCodeAt(offset))) {
+                continue;
+            }
+            if (offset > startOffset) {
+                result.push(( new LinePart(offset, part.type, part.metadata, part.containsRTL)));
+            }
+            result.push(( new LinePart(offset + 1, part.type, part.metadata, part.containsRTL)));
+            startOffset = offset + 1;
+            didSplit = true;
+        }
+        if (!didSplit || part.endIndex > startOffset) {
+            result.push(part);
+        }
+        startOffset = part.endIndex;
+    }
+    return result;
+}
 function transformAndRemoveOverflowing(lineContent, lineContainsRTL, tokens, fauxIndentLength, len) {
     const result = [];
     let resultLen = 0;
@@ -729,6 +761,8 @@ function _renderLine(input, sb) {
     const renderSpaceCharCode = input.renderSpaceCharCode;
     const renderWhitespace = input.renderWhitespace;
     const renderControlCharacters = input.renderControlCharacters;
+    const useTwoCellFullwidthCharacters = input.useTwoCellFullwidthCharacters;
+    const fullWidthCharacterWidth = 2 * input.spaceWidth;
     const characterMapping = ( new CharacterMapping(len + 1, parts.length));
     let lastCharacterMappingDefined = false;
     let charIndex = 0;
@@ -745,13 +779,21 @@ function _renderLine(input, sb) {
         const partRendersWhitespace = (renderWhitespace !== RenderWhitespace.None && part.isWhitespace());
         const partRendersWhitespaceWithWidth = partRendersWhitespace && !fontIsMonospace && (partType === "mtkw"  || !containsForeignElements);
         const partIsEmptyAndHasPseudoAfter = (charIndex === partEndIndex && part.isPseudoAfter());
+        const partIsCenteredFullWidth = !partContainsRTL && useTwoCellFullwidthCharacters && isFullWidthCharacter(lineContent.charCodeAt(charIndex));
         charOffsetInPart = 0;
         sb.appendString("<span ");
         if (partContainsRTL) {
             sb.appendString("style=\"unicode-bidi:isolate\" ");
+        } else if (partIsCenteredFullWidth) {
+            sb.appendString("style=\"width:");
+            sb.appendString(String(fullWidthCharacterWidth));
+            sb.appendString("px\" ");
         }
         sb.appendString("class=\"");
         sb.appendString(partRendersWhitespaceWithWidth ? "mtkz" : partType);
+        if (partIsCenteredFullWidth) {
+            sb.appendString(" mtkfullwidth");
+        }
         sb.appendASCIICharCode(CharCode.DoubleQuote);
         if (partRendersWhitespace) {
             let partWidth = 0;
@@ -894,7 +936,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString("<span class=\"mtkoverflow\">");
-        sb.appendString(( localize(945, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(954, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString("</span>");
     }
     sb.appendString("</span>");
@@ -905,7 +947,7 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return localize(946, "{0} chars", n);
+        return localize(955, "{0} chars", n);
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

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

@@ -6,7 +6,15 @@ export declare enum InlineDecorationType {
     Regular = 0,
     Before = 1,
     After = 2,
-    RegularAffectingLetterSpacing = 3
+    RegularAffectingLetterSpacing = 3,
+    /**
+     * A decoration that covers no character, yet is rendered as an element of its own.
+     * Used for injected text that only reserves horizontal space (e.g. `{ content: '', widthInEm: 1 }`):
+     * there is no character to decorate, so the width comes from the decoration's class instead.
+     * Unlike {@link InlineDecorationType.Before}/{@link InlineDecorationType.After}, this is not a
+     * pseudo element attached to a surrounding decoration, but the injected content itself.
+     */
+    WidthOnly = 4
 }
 export declare class InlineDecoration {
     readonly range: Range;

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

@@ -10,6 +10,7 @@ var InlineDecorationType;
     InlineDecorationType[InlineDecorationType["Before"] = 1] = "Before";
     InlineDecorationType[InlineDecorationType["After"] = 2] = "After";
     InlineDecorationType[InlineDecorationType["RegularAffectingLetterSpacing"] = 3] = "RegularAffectingLetterSpacing";
+    InlineDecorationType[InlineDecorationType["WidthOnly"] = 4] = "WidthOnly";
 })(InlineDecorationType || (InlineDecorationType = {}));
 class InlineDecoration {
     constructor(range, inlineClassName, type) {
@@ -159,14 +160,18 @@ class InjectedTextInlineDecorationsComputer {
             const lineStartOffsetInInputWithInjections = outputLineIndex > 0 ? breakOffsets[outputLineIndex - 1] : 0;
             const lineEndOffsetInInputWithInjections = breakOffsets[outputLineIndex];
             while (currentInjectedOffset < injectionOffsets.length) {
-                const length = injectionOptions[currentInjectedOffset].content.length;
+                const options = injectionOptions[currentInjectedOffset];
+                const length = options.content.length;
                 const injectedTextStartOffsetInInputWithInjections = injectionOffsets[currentInjectedOffset] + totalInjectedTextLengthBefore;
                 const injectedTextEndOffsetInInputWithInjections = injectedTextStartOffsetInInputWithInjections + length;
-                if (injectedTextStartOffsetInInputWithInjections > lineEndOffsetInInputWithInjections) {
+                const isWidthOnly = (length === 0 && options.widthInEm !== undefined);
+                const isLastOutputLine = outputLineIndex === breakOffsets.length - 1;
+                const isAtInternalWrapBoundary = injectedTextStartOffsetInInputWithInjections === lineEndOffsetInInputWithInjections && !isLastOutputLine;
+                if (injectedTextStartOffsetInInputWithInjections > lineEndOffsetInInputWithInjections || (isWidthOnly && isAtInternalWrapBoundary)) {
                     break;
                 }
-                if (lineStartOffsetInInputWithInjections < injectedTextEndOffsetInInputWithInjections) {
-                    const options = injectionOptions[currentInjectedOffset];
+                const isInLine = isWidthOnly ? lineStartOffsetInInputWithInjections <= injectedTextStartOffsetInInputWithInjections && (injectedTextStartOffsetInInputWithInjections < lineEndOffsetInInputWithInjections || isLastOutputLine) : lineStartOffsetInInputWithInjections < injectedTextEndOffsetInInputWithInjections;
+                if (isInLine) {
                     if (options.inlineClassName) {
                         const wrappedTextIndentLength = this.context.getWrappedTextIndentLength(modelLineNumber);
                         const offset = (outputLineIndex > 0 ? wrappedTextIndentLength : 0);
@@ -178,10 +183,10 @@ class InjectedTextInlineDecorationsComputer {
                             injectedTextEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections,
                             lineEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections
                         );
-                        if (start !== end) {
+                        if (start !== end || isWidthOnly) {
                             const viewLineNumber = this.context.getBaseViewLineNumber(modelLineNumber) + outputLineIndex;
                             const range = ( new Range(viewLineNumber, start + 1, viewLineNumber, end + 1));
-                            const type = options.inlineClassNameAffectsLetterSpacing ? InlineDecorationType.RegularAffectingLetterSpacing : InlineDecorationType.Regular;
+                            const type = (isWidthOnly ? InlineDecorationType.WidthOnly : options.inlineClassNameAffectsLetterSpacing ? InlineDecorationType.RegularAffectingLetterSpacing : InlineDecorationType.Regular);
                             inlineDecorations.push(( new InlineDecoration(range, options.inlineClassName, type)));
                         }
                     }

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(context: ILineBreaksComputerContext, fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean): ILineBreaksComputer;
+    createLineBreaksComputer(context: ILineBreaksComputerContext, fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean, useTwoCellFullwidthCharacters: boolean): ILineBreaksComputer;
 }

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

@@ -23,7 +23,8 @@ class MonospaceLineBreaksComputerFactory {
         wrappingColumn,
         wrappingIndent,
         wordBreak,
-        wrapOnEscapedLineFeeds
+        wrapOnEscapedLineFeeds,
+        useTwoCellFullwidthCharacters
     ) {
         const lineNumbers = [];
         const previousBreakingData = [];
@@ -50,7 +51,8 @@ class MonospaceLineBreaksComputerFactory {
                             wrappingColumn,
                             columnsForFullWidthChar,
                             wrappingIndent,
-                            wordBreak
+                            wordBreak,
+                            useTwoCellFullwidthCharacters
                         );
                     } else {
                         result[i] = createLineBreaks(
@@ -60,9 +62,11 @@ class MonospaceLineBreaksComputerFactory {
                             tabSize,
                             wrappingColumn,
                             columnsForFullWidthChar,
+                            fontInfo,
                             wrappingIndent,
                             wordBreak,
-                            isLineFeedWrappingEnabled
+                            isLineFeedWrappingEnabled,
+                            useTwoCellFullwidthCharacters
                         );
                     }
                 }
@@ -111,7 +115,8 @@ function createLineBreaksFromPreviousLineBreaks(
     firstLineBreakColumn,
     columnsForFullWidthChar,
     wrappingIndent,
-    wordBreak
+    wordBreak,
+    useTwoCellFullwidthCharacters
 ) {
     if (firstLineBreakColumn === -1) {
         return null;
@@ -127,7 +132,7 @@ function createLineBreaksFromPreviousLineBreaks(
         lineText,
         tabSize,
         firstLineBreakColumn,
-        columnsForFullWidthChar,
+        fullWidthCharacterColumns(columnsForFullWidthChar, useTwoCellFullwidthCharacters),
         wrappingIndent
     );
     const wrappedLineBreakColumn = firstLineBreakColumn - wrappedTextIndentLength;
@@ -177,7 +182,13 @@ function createLineBreaksFromPreviousLineBreaks(
                     charWidth = 2;
                 } else {
                     charCodeClass = classifier.get(charCode);
-                    charWidth = computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar);
+                    charWidth = computeCharWidth(
+                        charCode,
+                        visibleColumn,
+                        tabSize,
+                        columnsForFullWidthChar,
+                        useTwoCellFullwidthCharacters
+                    );
                 }
                 if (charStartOffset > lastBreakingOffset && canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll)) {
                     breakOffset = charStartOffset;
@@ -230,7 +241,7 @@ function createLineBreaksFromPreviousLineBreaks(
                     prevCharWidth = 2;
                 } else {
                     prevCharCodeClass = classifier.get(prevCharCode);
-                    prevCharWidth = (isFullWidthCharacter(prevCharCode) ? columnsForFullWidthChar : 1);
+                    prevCharWidth = (isFullWidthCharacter(prevCharCode) ? fullWidthCharacterColumns(columnsForFullWidthChar, useTwoCellFullwidthCharacters) : 1);
                 }
                 if (visibleColumn <= breakingColumn) {
                     if (forcedBreakOffset === 0) {
@@ -262,7 +273,8 @@ function createLineBreaksFromPreviousLineBreaks(
                             charCodeAtForcedBreakOffset,
                             forcedBreakOffsetVisibleColumn,
                             tabSize,
-                            columnsForFullWidthChar
+                            columnsForFullWidthChar,
+                            useTwoCellFullwidthCharacters
                         );
                     }
                     if (remainingWidthOfNextLine - charWidth < 0) {
@@ -290,7 +302,8 @@ function createLineBreaksFromPreviousLineBreaks(
                     charCode,
                     lastBreakingOffsetVisibleColumn,
                     tabSize,
-                    columnsForFullWidthChar
+                    columnsForFullWidthChar,
+                    useTwoCellFullwidthCharacters
                 );
             }
         }
@@ -332,11 +345,14 @@ function createLineBreaks(
     tabSize,
     firstLineBreakColumn,
     columnsForFullWidthChar,
+    fontInfo,
     wrappingIndent,
     wordBreak,
-    wrapOnEscapedLineFeeds
+    wrapOnEscapedLineFeeds,
+    useTwoCellFullwidthCharacters
 ) {
     const lineText = LineInjectedText.applyInjectedText(_lineText, injectedTexts);
+    const fixedWidthRanges = LineInjectedText.getFixedWidthInjectedTextRanges(injectedTexts);
     let injectionOptions;
     let injectionOffsets;
     if (injectedTexts && injectedTexts.length > 0) {
@@ -364,59 +380,124 @@ function createLineBreaks(
         lineText,
         tabSize,
         firstLineBreakColumn,
-        columnsForFullWidthChar,
-        wrappingIndent
+        fullWidthCharacterColumns(columnsForFullWidthChar, useTwoCellFullwidthCharacters),
+        wrappingIndent,
+        fixedWidthRanges
     );
-    const wrappedLineBreakColumn = firstLineBreakColumn - wrappedTextIndentLength;
+    const typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
+    const wrappedLineBreakPixelWidth = (firstLineBreakColumn - wrappedTextIndentLength) * typicalHalfwidthCharacterWidth;
     const breakingOffsets = [];
     const breakingOffsetsVisibleColumn = [];
     let breakingOffsetsCount = 0;
     let breakOffset = 0;
     let breakOffsetVisibleColumn = 0;
-    let breakingColumn = firstLineBreakColumn;
-    let prevCharCode = lineText.charCodeAt(0);
-    let prevCharCodeClass = classifier.get(prevCharCode);
-    let visibleColumn = computeCharWidth(prevCharCode, 0, tabSize, columnsForFullWidthChar);
-    let startOffset = 1;
-    if (isHighSurrogate(prevCharCode)) {
-        visibleColumn += 1;
-        prevCharCode = lineText.charCodeAt(1);
+    let breakOffsetPixelWidth = 0;
+    let breakingPixelWidth = firstLineBreakColumn * typicalHalfwidthCharacterWidth;
+    let fixedWidthRangeIndex = 0;
+    const firstFixedWidthRange = fixedWidthRanges.length > 0 ? fixedWidthRanges[0] : null;
+    const startsWithFixedWidth = firstFixedWidthRange && firstFixedWidthRange.startOffset === 0;
+    let prevCharCode;
+    let prevCharCodeClass;
+    let visibleColumn;
+    let currentLinePixelWidth;
+    let startOffset;
+    if (startsWithFixedWidth) {
+        prevCharCode = CharCode.Null;
+        prevCharCodeClass = CharacterClass.NONE;
+        visibleColumn = computeFixedWidthRangeColumnWidth(
+            lineText,
+            firstFixedWidthRange,
+            0,
+            tabSize,
+            columnsForFullWidthChar,
+            useTwoCellFullwidthCharacters
+        );
+        currentLinePixelWidth = firstFixedWidthRange.widthInEm * fontInfo.fontSize;
+        startOffset = firstFixedWidthRange.endOffset;
+        fixedWidthRangeIndex++;
+    } else {
+        prevCharCode = lineText.charCodeAt(0);
+        visibleColumn = computeCharWidth(
+            prevCharCode,
+            0,
+            tabSize,
+            columnsForFullWidthChar,
+            useTwoCellFullwidthCharacters
+        );
+        currentLinePixelWidth = computeCharPixelWidth(prevCharCode, 0, tabSize, fontInfo, useTwoCellFullwidthCharacters);
+        startOffset = 1;
+        if (isHighSurrogate(prevCharCode)) {
+            visibleColumn += 1;
+            currentLinePixelWidth += typicalHalfwidthCharacterWidth;
+            prevCharCode = lineText.charCodeAt(1);
+            startOffset++;
+        }
         prevCharCodeClass = classifier.get(prevCharCode);
-        startOffset++;
     }
     for (let i = startOffset; i < len; i++) {
+        const fixedWidthRange = fixedWidthRanges.length > 0 && fixedWidthRangeIndex < fixedWidthRanges.length ? fixedWidthRanges[fixedWidthRangeIndex] : null;
         const charStartOffset = i;
-        const charCode = lineText.charCodeAt(i);
+        let charCode = lineText.charCodeAt(i);
         let charCodeClass;
         let charWidth;
+        let charPixelWidth;
         let wrapEscapedLineFeed = false;
-        if (isHighSurrogate(charCode)) {
+        if (fixedWidthRange && fixedWidthRange.startOffset === i) {
+            charCode = CharCode.Null;
+            charCodeClass = CharacterClass.NONE;
+            charWidth = computeFixedWidthRangeColumnWidth(
+                lineText,
+                fixedWidthRange,
+                visibleColumn,
+                tabSize,
+                columnsForFullWidthChar,
+                useTwoCellFullwidthCharacters
+            );
+            charPixelWidth = fixedWidthRange.widthInEm * fontInfo.fontSize;
+            i = fixedWidthRange.endOffset - 1;
+            fixedWidthRangeIndex++;
+        } else if (isHighSurrogate(charCode)) {
             i++;
             charCodeClass = CharacterClass.NONE;
             charWidth = 2;
+            charPixelWidth = 2 * typicalHalfwidthCharacterWidth;
         } else {
             charCodeClass = classifier.get(charCode);
-            charWidth = computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar);
+            charWidth = computeCharWidth(
+                charCode,
+                visibleColumn,
+                tabSize,
+                columnsForFullWidthChar,
+                useTwoCellFullwidthCharacters
+            );
+            charPixelWidth = computeCharPixelWidth(charCode, visibleColumn, tabSize, fontInfo, useTwoCellFullwidthCharacters);
         }
-        if (wrapOnEscapedLineFeeds && isEscapedLineBreakAtPosition(lineText, i)) {
+        if (wrapOnEscapedLineFeeds && isEscapedLineBreakAtPosition(lineText, charStartOffset)) {
             breakOffset = charStartOffset;
             breakOffsetVisibleColumn = visibleColumn;
+            breakOffsetPixelWidth = currentLinePixelWidth;
             wrapEscapedLineFeed = true;
         } else if (canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll)) {
             breakOffset = charStartOffset;
             breakOffsetVisibleColumn = visibleColumn;
+            breakOffsetPixelWidth = currentLinePixelWidth;
         }
         visibleColumn += charWidth;
-        if (visibleColumn > breakingColumn || wrapEscapedLineFeed) {
-            if (breakOffset === 0 || visibleColumn - breakOffsetVisibleColumn > wrappedLineBreakColumn) {
+        currentLinePixelWidth += charPixelWidth;
+        if (currentLinePixelWidth > breakingPixelWidth || wrapEscapedLineFeed) {
+            if (breakOffset === 0 || currentLinePixelWidth - breakOffsetPixelWidth > wrappedLineBreakPixelWidth) {
                 breakOffset = charStartOffset;
                 breakOffsetVisibleColumn = visibleColumn - charWidth;
+                breakOffsetPixelWidth = currentLinePixelWidth - charPixelWidth;
+            }
+            const currentLineStartOffset = breakingOffsetsCount > 0 ? breakingOffsets[breakingOffsetsCount - 1] : 0;
+            if (breakOffset > currentLineStartOffset) {
+                breakingOffsets[breakingOffsetsCount] = breakOffset;
+                breakingOffsetsVisibleColumn[breakingOffsetsCount] = breakOffsetVisibleColumn;
+                breakingOffsetsCount++;
+                breakingPixelWidth = breakOffsetPixelWidth + wrappedLineBreakPixelWidth;
+                breakOffset = 0;
             }
-            breakingOffsets[breakingOffsetsCount] = breakOffset;
-            breakingOffsetsVisibleColumn[breakingOffsetsCount] = breakOffsetVisibleColumn;
-            breakingOffsetsCount++;
-            breakingColumn = breakOffsetVisibleColumn + wrappedLineBreakColumn;
-            breakOffset = 0;
         }
         prevCharCode = charCode;
         prevCharCodeClass = charCodeClass;
@@ -434,21 +515,62 @@ function createLineBreaks(
         wrappedTextIndentLength
     ));
 }
-function computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar) {
+function computeCharWidth(
+    charCode,
+    visibleColumn,
+    tabSize,
+    columnsForFullWidthChar,
+    useTwoCellFullwidthCharacters
+) {
     if (charCode === CharCode.Tab) {
         return (tabSize - (visibleColumn % tabSize));
     }
     if (isFullWidthCharacter(charCode)) {
-        return columnsForFullWidthChar;
+        return fullWidthCharacterColumns(columnsForFullWidthChar, useTwoCellFullwidthCharacters);
     }
     if (charCode < 32) {
         return columnsForFullWidthChar;
     }
     return 1;
 }
+function fullWidthCharacterColumns(columnsForFullWidthChar, useTwoCellFullwidthCharacters) {
+    return useTwoCellFullwidthCharacters ? 2 : columnsForFullWidthChar;
+}
 function tabCharacterWidth(visibleColumn, tabSize) {
     return (tabSize - (visibleColumn % tabSize));
 }
+function computeCharPixelWidth(charCode, visibleColumn, tabSize, fontInfo, useTwoCellFullwidthCharacters) {
+    if (charCode === CharCode.Tab) {
+        return tabCharacterWidth(visibleColumn, tabSize) * fontInfo.typicalHalfwidthCharacterWidth;
+    }
+    if (isFullWidthCharacter(charCode)) {
+        return useTwoCellFullwidthCharacters ? 2 * fontInfo.typicalHalfwidthCharacterWidth : fontInfo.typicalFullwidthCharacterWidth;
+    }
+    if (charCode < 32) {
+        return fontInfo.typicalFullwidthCharacterWidth;
+    }
+    return fontInfo.typicalHalfwidthCharacterWidth;
+}
+function computeFixedWidthRangeColumnWidth(
+    lineText,
+    range,
+    visibleColumn,
+    tabSize,
+    columnsForFullWidthChar,
+    useTwoCellFullwidthCharacters
+) {
+    let width = 0;
+    for (let i = range.startOffset; i < range.endOffset; i++) {
+        width += computeCharWidth(
+            lineText.charCodeAt(i),
+            visibleColumn + width,
+            tabSize,
+            columnsForFullWidthChar,
+            useTwoCellFullwidthCharacters
+        );
+    }
+    return width;
+}
 function isEscapedLineBreakAtPosition(lineText, i) {
     if (i >= 2 && lineText.charAt(i - 1) === "n") {
         let escapeCount = 0;
@@ -471,13 +593,17 @@ function computeWrappedTextIndentLength(
     tabSize,
     firstLineBreakColumn,
     columnsForFullWidthChar,
-    wrappingIndent
+    wrappingIndent,
+    fixedWidthRanges
 ) {
     let wrappedTextIndentLength = 0;
     if (wrappingIndent !== WrappingIndent.None) {
         const firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineText);
         if (firstNonWhitespaceIndex$1 !== -1) {
             for (let i = 0; i < firstNonWhitespaceIndex$1; i++) {
+                if (fixedWidthRanges?.[0]?.startOffset === i) {
+                    break;
+                }
                 const charWidth = (lineText.charCodeAt(i) === CharCode.Tab ? tabCharacterWidth(wrappedTextIndentLength, tabSize) : 1);
                 wrappedTextIndentLength += charWidth;
             }

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

@@ -74,6 +74,7 @@ class ViewModel extends Disposable {
             const wrappingIndent = options.get(EditorOption.wrappingIndent);
             const wordBreak = options.get(EditorOption.wordBreak);
             const wrapOnEscapedLineFeeds = options.get(EditorOption.wrapOnEscapedLineFeeds);
+            const useTwoCellFullwidthCharacters = options.get(EditorOption.effectiveFullwidthCharacterWidth) === "twoCells";
             this._lines = ( new ViewModelLinesFromProjectedModel(
                 this._editorId,
                 this.model,
@@ -85,7 +86,8 @@ class ViewModel extends Disposable {
                 wrappingInfo.wrappingColumn,
                 wrappingIndent,
                 wordBreak,
-                wrapOnEscapedLineFeeds
+                wrapOnEscapedLineFeeds,
+                useTwoCellFullwidthCharacters
             ));
         }
         this.coordinatesConverter = this._lines.createCoordinatesConverter();
@@ -237,12 +239,14 @@ class ViewModel extends Disposable {
         const wrappingInfo = options.get(EditorOption.wrappingInfo);
         const wrappingIndent = options.get(EditorOption.wrappingIndent);
         const wordBreak = options.get(EditorOption.wordBreak);
+        const useTwoCellFullwidthCharacters = options.get(EditorOption.effectiveFullwidthCharacterWidth) === "twoCells";
         if (this._lines.setWrappingSettings(
             fontInfo,
             wrappingStrategy,
             wrappingInfo.wrappingColumn,
             wrappingIndent,
-            wordBreak
+            wordBreak,
+            useTwoCellFullwidthCharacters
         )) {
             eventsCollector.emitViewEvent(new ViewFlushedEvent());
             eventsCollector.emitViewEvent(new ViewLineMappingChangedEvent());

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

@@ -11,7 +11,7 @@ import { ViewLineData } from "../viewModel.js";
 import { ICoordinatesConverter } from "../coordinatesConverter.js";
 export interface IViewModelLines extends IDisposable {
     createCoordinatesConverter(): ICoordinatesConverter;
-    setWrappingSettings(fontInfo: FontInfo, wrappingStrategy: "simple" | "advanced", wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll"): boolean;
+    setWrappingSettings(fontInfo: FontInfo, wrappingStrategy: "simple" | "advanced", wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", useTwoCellFullwidthCharacters: boolean): boolean;
     setTabSize(newTabSize: number): boolean;
     getHiddenAreas(): Range[];
     setHiddenAreas(_ranges: readonly Range[]): boolean;
@@ -58,13 +58,14 @@ export declare class ViewModelLinesFromProjectedModel implements IViewModelLines
     private wordBreak;
     private wrappingStrategy;
     private wrapOnEscapedLineFeeds;
+    private useTwoCellFullwidthCharacters;
     private modelLineProjections;
     /**
      * Reflects the sum of the line counts of all projected model lines.
     */
     private projectedModelLineLineCounts;
     private hiddenAreasDecorationIds;
-    constructor(editorId: number, model: ITextModel, domLineBreaksComputerFactory: ILineBreaksComputerFactory, monospaceLineBreaksComputerFactory: ILineBreaksComputerFactory, fontInfo: FontInfo, tabSize: number, wrappingStrategy: "simple" | "advanced", wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean);
+    constructor(editorId: number, model: ITextModel, domLineBreaksComputerFactory: ILineBreaksComputerFactory, monospaceLineBreaksComputerFactory: ILineBreaksComputerFactory, fontInfo: FontInfo, tabSize: number, wrappingStrategy: "simple" | "advanced", wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean, useTwoCellFullwidthCharacters: boolean);
     dispose(): void;
     createCoordinatesConverter(): ICoordinatesConverter;
     private _constructLines;
@@ -73,7 +74,7 @@ export declare class ViewModelLinesFromProjectedModel implements IViewModelLines
     modelPositionIsVisible(modelLineNumber: number, _modelColumn: number): boolean;
     getModelLineViewLineCount(modelLineNumber: number): number;
     setTabSize(newTabSize: number): boolean;
-    setWrappingSettings(fontInfo: FontInfo, wrappingStrategy: "simple" | "advanced", wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll"): boolean;
+    setWrappingSettings(fontInfo: FontInfo, wrappingStrategy: "simple" | "advanced", wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", useTwoCellFullwidthCharacters: boolean): boolean;
     createLineBreaksComputer(_context?: ILineBreaksComputerContext): ILineBreaksComputer;
     onModelFlushed(): void;
     onModelLinesDeleted(versionId: number | null, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent | null;