@codingame/monaco-vscode-api 36.2.7 → 37.0.0

package/vscode/src/vs/editor/browser/services/openerService.d.ts

@@ -12,6 +12,7 @@ export declare class OpenerService implements IOpenerService {
     private readonly _resolvedUriTargets;
     private _defaultExternalOpener;
     private readonly _externalOpeners;
+    private readonly _externalResourceOpener;
     constructor(editorService: ICodeEditorService, commandService: ICommandService);
     registerOpener(opener: IOpener): IDisposable;
     registerValidator(validator: IValidator): IDisposable;
@@ -20,6 +21,10 @@ export declare class OpenerService implements IOpenerService {
     registerExternalOpener(opener: IExternalOpener): IDisposable;
     open(target: URI | string, options?: OpenOptions): Promise<boolean>;
     resolveExternalUri(resource: URI, options?: ResolveExternalUriOptions): Promise<IResolvedExternalUri>;
+    private _resolveExternalUriOpenTarget;
+    private _openWithContributedExternalOpeners;
+    private _openDefaultExternal;
     private _doOpenExternal;
+    private _validate;
     dispose(): void;
 }

package/vscode/src/vs/editor/browser/services/openerService.js

@@ -12,7 +12,7 @@ import { URI } from '../../../base/common/uri.js';
 import { ICodeEditorService } from './codeEditorService.service.js';
 import { ICommandService } from '../../../platform/commands/common/commands.service.js';
 import { EditorOpenSource } from '../../../platform/editor/common/editor.js';
-import { extractSelection } from '../../../platform/opener/common/opener.js';
+import { extractSelection, defaultExternalUriOpenerId } from '../../../platform/opener/common/opener.js';
 
 let CommandOpener = class CommandOpener {
     constructor(_commandService) {
@@ -77,6 +77,12 @@ let EditorOpener = class EditorOpener {
     }
 };
 EditorOpener = ( __decorate([( __param(0, ICodeEditorService))], EditorOpener));
+function shouldOpenExternal(target, options) {
+    return !!options?.openExternal || matchesSomeScheme(target, Schemas.mailto, Schemas.http, Schemas.https, Schemas.vsls);
+}
+function shouldUseContributedExternalOpeners(target, options) {
+    return !!options?.allowContributedOpeners && options.allowContributedOpeners !== defaultExternalUriOpenerId && shouldOpenExternal(target, options);
+}
 let OpenerService = class OpenerService {
     constructor(editorService, commandService) {
         this._openers = ( new LinkedList());
@@ -98,15 +104,16 @@ let OpenerService = class OpenerService {
                 return true;
             }
         };
-        this._openers.push({
+        this._externalResourceOpener = {
             open: async (target, options) => {
-                if (options?.openExternal || matchesSomeScheme(target, Schemas.mailto, Schemas.http, Schemas.https, Schemas.vsls)) {
+                if (shouldOpenExternal(target, options)) {
                     await this._doOpenExternal(target, options);
                     return true;
                 }
                 return false;
             }
-        });
+        };
+        this._openers.push(this._externalResourceOpener);
         this._openers.push(( new CommandOpener(commandService)));
         this._openers.push(( new EditorOpener(editorService)));
     }
@@ -142,15 +149,23 @@ let OpenerService = class OpenerService {
         if (targetURI.scheme === Schemas.internal) {
             return false;
         }
+        let externalUriOpenTarget;
+        if (shouldUseContributedExternalOpeners(target, options)) {
+            externalUriOpenTarget = await this._resolveExternalUriOpenTarget(target, options);
+            if (await this._openWithContributedExternalOpeners(externalUriOpenTarget, options)) {
+                return true;
+            }
+        }
         if (!options?.skipValidation) {
-            const validationTarget = this._resolvedUriTargets.get(targetURI) ?? target;
-            for (const validator of this._validators) {
-                if (!(await validator.shouldOpen(validationTarget, options))) {
-                    return false;
-                }
+            const validationTarget = externalUriOpenTarget?.validationTarget ?? this._resolvedUriTargets.get(targetURI) ?? target;
+            if (!(await this._validate(validationTarget, options))) {
+                return false;
             }
         }
         for (const opener of this._openers) {
+            if (externalUriOpenTarget && opener === this._externalResourceOpener) {
+                return this._openDefaultExternal(externalUriOpenTarget);
+            }
             const handled = await opener.open(target, options);
             if (handled) {
                 return true;
@@ -172,7 +187,7 @@ let OpenerService = class OpenerService {
         }
         throw ( new Error("Could not resolve external URI: " + ( resource.toString())));
     }
-    async _doOpenExternal(resource, options) {
+    async _resolveExternalUriOpenTarget(resource, options) {
         const uri = typeof resource === "string" ? ( URI.parse(resource)) : resource;
         let externalUri;
         try {
@@ -180,28 +195,49 @@ let OpenerService = class OpenerService {
         } catch {
             externalUri = uri;
         }
+        const preserveOriginalString = typeof resource === "string" && ( uri.toString()) === ( externalUri.toString());
         let href;
-        if (typeof resource === "string" && ( uri.toString()) === ( externalUri.toString())) {
+        if (preserveOriginalString) {
             href = resource;
         } else {
             href = encodeURI(( externalUri.toString(true)));
         }
-        if (options?.allowContributedOpeners) {
-            const preferredOpenerId = typeof options?.allowContributedOpeners === "string" ? options?.allowContributedOpeners : undefined;
-            for (const opener of this._externalOpeners) {
-                const didOpen = await opener.openExternal(href, {
-                    sourceUri: uri,
-                    preferredOpenerId
-                }, CancellationToken.None);
-                if (didOpen) {
-                    return true;
-                }
+        return {
+            sourceUri: uri,
+            href,
+            validationTarget: preserveOriginalString ? resource : externalUri
+        };
+    }
+    async _openWithContributedExternalOpeners(target, options) {
+        const preferredOpenerId = typeof options?.allowContributedOpeners === "string" ? options.allowContributedOpeners : undefined;
+        for (const opener of this._externalOpeners) {
+            const didOpen = await opener.openExternal(target.href, {
+                sourceUri: target.sourceUri,
+                preferredOpenerId
+            }, CancellationToken.None);
+            if (didOpen) {
+                return true;
             }
         }
-        return this._defaultExternalOpener.openExternal(href, {
-            sourceUri: uri
+        return false;
+    }
+    _openDefaultExternal(target) {
+        return this._defaultExternalOpener.openExternal(target.href, {
+            sourceUri: target.sourceUri
         }, CancellationToken.None);
     }
+    async _doOpenExternal(resource, options) {
+        const target = await this._resolveExternalUriOpenTarget(resource, options);
+        return this._openDefaultExternal(target);
+    }
+    async _validate(resource, options) {
+        for (const validator of this._validators) {
+            if (!(await validator.shouldOpen(resource, options))) {
+                return false;
+            }
+        }
+        return true;
+    }
     dispose() {
         this._validators.clear();
     }

package/vscode/src/vs/editor/browser/view/domLineBreaksComputer.d.ts

@@ -5,5 +5,5 @@ export declare class DOMLineBreaksComputerFactory implements ILineBreaksComputer
     private targetWindow;
     static create(targetWindow: Window): DOMLineBreaksComputerFactory;
     constructor(targetWindow: WeakRef<Window>);
-    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/browser/view/domLineBreaksComputer.js

@@ -27,7 +27,8 @@ class DOMLineBreaksComputerFactory {
         wrappingColumn,
         wrappingIndent,
         wordBreak,
-        wrapOnEscapedLineFeeds
+        wrapOnEscapedLineFeeds,
+        useTwoCellFullwidthCharacters
     ) {
         const lineNumbers = [];
         return {
@@ -43,7 +44,8 @@ class DOMLineBreaksComputerFactory {
                     tabSize,
                     wrappingColumn,
                     wrappingIndent,
-                    wordBreak
+                    wordBreak,
+                    useTwoCellFullwidthCharacters
                 );
             }
         };
@@ -57,7 +59,8 @@ function createLineBreaks(
     tabSize,
     firstLineBreakColumn,
     wrappingIndent,
-    wordBreak
+    wordBreak,
+    useTwoCellFullwidthCharacters
 ) {
     function createEmptyLineBreakWithPossiblyInjectedText(lineNumber) {
         const injectedTexts = context.getLineInjectedText(lineNumber);
@@ -82,6 +85,7 @@ function createLineBreaks(
     const additionalIndent = (wrappingIndent === WrappingIndent.DeepIndent ? 2 : wrappingIndent === WrappingIndent.Indent ? 1 : 0);
     const additionalIndentSize = Math.round(tabSize * additionalIndent);
     const additionalIndentLength = Math.ceil(fontInfo.spaceWidth * additionalIndentSize);
+    const fullwidthCharacterWidth = useTwoCellFullwidthCharacters ? 2 * fontInfo.spaceWidth : undefined;
     const containerDomNode = createElement("div");
     applyFontInfo(containerDomNode, fontInfo);
     const sb = ( new StringBuilder(10000));
@@ -89,13 +93,13 @@ function createLineBreaks(
     const wrappedTextIndentLengths = [];
     const renderLineContents = [];
     const allCharOffsets = [];
+    const allSpanStartOffsets = [];
     const allVisibleColumns = [];
     for (let i = 0; i < lineNumbers.length; i++) {
         const lineNumber = lineNumbers[i];
-        const lineContent = LineInjectedText.applyInjectedText(
-            context.getLineContent(lineNumber),
-            context.getLineInjectedText(lineNumber)
-        );
+        const injectedTexts = context.getLineInjectedText(lineNumber);
+        const lineContent = LineInjectedText.applyInjectedText(context.getLineContent(lineNumber), injectedTexts);
+        const fixedWidthRanges = LineInjectedText.getFixedWidthInjectedTextRanges(injectedTexts);
         let firstNonWhitespaceIndex$1 = 0;
         let wrappedTextIndentLength = 0;
         let width = overallWidth;
@@ -105,11 +109,18 @@ function createLineBreaks(
                 firstNonWhitespaceIndex$1 = 0;
             } else {
                 for (let i = 0; i < firstNonWhitespaceIndex$1; i++) {
-                    const charWidth = (lineContent.charCodeAt(i) === CharCode.Tab ? (tabSize - (wrappedTextIndentLength % tabSize)) : 1);
-                    wrappedTextIndentLength += charWidth;
+                    const fixedWidthRange = fixedWidthRanges[0];
+                    const isFixedWidthStart = fixedWidthRange && fixedWidthRange.startOffset === i;
+                    if (isFixedWidthStart) {
+                        firstNonWhitespaceIndex$1 = i;
+                        break;
+                    } else {
+                        const charWidth = (lineContent.charCodeAt(i) === CharCode.Tab ? (tabSize - (wrappedTextIndentLength % tabSize)) : 1);
+                        wrappedTextIndentLength += charWidth;
+                    }
                 }
                 const indentWidth = Math.ceil(fontInfo.spaceWidth * wrappedTextIndentLength);
-                if (indentWidth + fontInfo.typicalFullwidthCharacterWidth > overallWidth) {
+                if (indentWidth + (fullwidthCharacterWidth ?? fontInfo.typicalFullwidthCharacterWidth) > overallWidth) {
                     firstNonWhitespaceIndex$1 = 0;
                     wrappedTextIndentLength = 0;
                 } else {
@@ -118,18 +129,26 @@ function createLineBreaks(
             }
         }
         const renderLineContent = lineContent.substr(firstNonWhitespaceIndex$1);
+        const shiftedFixedWidthRanges = firstNonWhitespaceIndex$1 === 0 ? fixedWidthRanges : ( fixedWidthRanges.map(range => ({
+            startOffset: Math.max(0, range.startOffset - firstNonWhitespaceIndex$1),
+            endOffset: range.endOffset - firstNonWhitespaceIndex$1,
+            widthInEm: range.widthInEm
+        })));
         const tmp = renderLine(
             renderLineContent,
             wrappedTextIndentLength,
             tabSize,
             width,
             sb,
-            additionalIndentLength
+            additionalIndentLength,
+            shiftedFixedWidthRanges,
+            fullwidthCharacterWidth
         );
         firstNonWhitespaceIndices[i] = firstNonWhitespaceIndex$1;
         wrappedTextIndentLengths[i] = wrappedTextIndentLength;
         renderLineContents[i] = renderLineContent;
         allCharOffsets[i] = tmp[0];
+        allSpanStartOffsets[i] = tmp[2];
         allVisibleColumns[i] = tmp[1];
     }
     const html = sb.build();
@@ -151,7 +170,13 @@ function createLineBreaks(
     for (let i = 0; i < lineNumbers.length; i++) {
         const lineNumber = lineNumbers[i];
         const lineDomNode = lineDomNodes[i];
-        const breakOffsets = readLineBreaks(range, lineDomNode, renderLineContents[i], allCharOffsets[i]);
+        const breakOffsets = readLineBreaks(
+            range,
+            lineDomNode,
+            renderLineContents[i],
+            allCharOffsets[i],
+            allSpanStartOffsets[i]
+        );
         if (breakOffsets === null) {
             result[i] = createEmptyLineBreakWithPossiblyInjectedText(lineNumber);
             continue;
@@ -199,7 +224,9 @@ function renderLine(
     tabSize,
     width,
     sb,
-    wrappingIndentLength
+    wrappingIndentLength,
+    fixedWidthRanges,
+    fullwidthCharacterWidth
 ) {
     if (wrappingIndentLength !== 0) {
         const hangingOffset = String(wrappingIndentLength);
@@ -216,77 +243,134 @@ function renderLine(
     const len = lineContent.length;
     let visibleColumn = initialVisibleColumn;
     let charOffset = 0;
+    let fixedWidthRangeIndex = 0;
     const charOffsets = [];
+    const spanStartOffsets = [0];
     const visibleColumns = [];
-    let nextCharCode = (0 < len ? lineContent.charCodeAt(0) : CharCode.Null);
+    let spanOpen = true;
     sb.appendString("<span>");
     for (let charIndex = 0; charIndex < len; charIndex++) {
-        if (charIndex !== 0 && charIndex % Constants.SPAN_MODULO_LIMIT === 0) {
+        let fixedWidthRange = fixedWidthRanges[fixedWidthRangeIndex];
+        const startsFixedWidth = fixedWidthRange && fixedWidthRange.startOffset === charIndex;
+        const charCode = lineContent.charCodeAt(charIndex);
+        const isFullWidthCharacter$1 = fullwidthCharacterWidth !== undefined && isFullWidthCharacter(charCode);
+        if (startsFixedWidth) {
+            if (spanOpen) {
+                sb.appendString("</span>");
+            }
+            while (fixedWidthRange && fixedWidthRange.startOffset === charIndex && fixedWidthRange.endOffset === charIndex) {
+                sb.appendString(
+                    "<span style=\"display:inline-block;box-sizing:border-box;white-space:nowrap;width:"
+                );
+                sb.appendString(String(fixedWidthRange.widthInEm));
+                sb.appendString("em;\">");
+                sb.appendString("</span>");
+                spanStartOffsets.push(charOffset);
+                fixedWidthRange = fixedWidthRanges[++fixedWidthRangeIndex];
+            }
+            if (fixedWidthRange && fixedWidthRange.startOffset === charIndex) {
+                sb.appendString(
+                    "<span style=\"display:inline-block;box-sizing:border-box;white-space:nowrap;width:"
+                );
+                sb.appendString(String(fixedWidthRange.widthInEm));
+                sb.appendString("em;\">");
+            } else {
+                sb.appendString("<span>");
+            }
+            spanStartOffsets.push(charOffset);
+            spanOpen = true;
+        } else if (isFullWidthCharacter$1) {
+            if (spanOpen) {
+                sb.appendString("</span>");
+            }
+            sb.appendString("<span class=\"mtkfullwidth\" style=\"width:");
+            sb.appendString(String(fullwidthCharacterWidth));
+            sb.appendString("px;\">");
+            spanStartOffsets.push(charOffset);
+            spanOpen = true;
+        } else if (!spanOpen) {
+            sb.appendString("<span>");
+            spanStartOffsets.push(charOffset);
+            spanOpen = true;
+        } else if ((!fixedWidthRange || charIndex < fixedWidthRange.startOffset) && charIndex !== 0 && charIndex % Constants.SPAN_MODULO_LIMIT === 0) {
             sb.appendString("</span><span>");
+            spanStartOffsets.push(charOffset);
         }
         charOffsets[charIndex] = charOffset;
         visibleColumns[charIndex] = visibleColumn;
-        const charCode = nextCharCode;
-        nextCharCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : CharCode.Null);
         let producedCharacters = 1;
         let charWidth = 1;
-        switch (charCode) {
-        case CharCode.Tab:
-            producedCharacters = (tabSize - (visibleColumn % tabSize));
-            charWidth = producedCharacters;
-            for (let space = 1; space <= producedCharacters; space++) {
-                if (space < producedCharacters) {
+        if (isFullWidthCharacter$1) {
+            sb.appendCharCode(charCode);
+            charWidth = 2;
+            sb.appendString("</span>");
+            spanOpen = false;
+        } else {
+            switch (charCode) {
+            case CharCode.Tab:
+                producedCharacters = (tabSize - (visibleColumn % tabSize));
+                charWidth = producedCharacters;
+                for (let space = 1; space <= producedCharacters; space++) {
+                    if (space < producedCharacters) {
+                        sb.appendCharCode(0xA0);
+                    } else {
+                        sb.appendASCIICharCode(CharCode.Space);
+                    }
+                }
+                break;
+            case CharCode.Space:
+                if (lineContent.charCodeAt(charIndex + 1) === CharCode.Space) {
                     sb.appendCharCode(0xA0);
                 } else {
                     sb.appendASCIICharCode(CharCode.Space);
                 }
-            }
-            break;
-        case CharCode.Space:
-            if (nextCharCode === CharCode.Space) {
-                sb.appendCharCode(0xA0);
-            } else {
-                sb.appendASCIICharCode(CharCode.Space);
-            }
-            break;
-        case CharCode.LessThan:
-            sb.appendString("&lt;");
-            break;
-        case CharCode.GreaterThan:
-            sb.appendString("&gt;");
-            break;
-        case CharCode.Ampersand:
-            sb.appendString("&amp;");
-            break;
-        case CharCode.Null:
-            sb.appendString("&#00;");
-            break;
-        case CharCode.UTF8_BOM:
-        case CharCode.LINE_SEPARATOR:
-        case CharCode.PARAGRAPH_SEPARATOR:
-        case CharCode.NEXT_LINE:
-            sb.appendCharCode(0xFFFD);
-            break;
-        default:
-            if (isFullWidthCharacter(charCode)) {
-                charWidth++;
-            }
-            if (charCode < 32) {
-                sb.appendCharCode(9216 + charCode);
-            } else {
-                sb.appendCharCode(charCode);
+                break;
+            case CharCode.LessThan:
+                sb.appendString("&lt;");
+                break;
+            case CharCode.GreaterThan:
+                sb.appendString("&gt;");
+                break;
+            case CharCode.Ampersand:
+                sb.appendString("&amp;");
+                break;
+            case CharCode.Null:
+                sb.appendString("&#00;");
+                break;
+            case CharCode.UTF8_BOM:
+            case CharCode.LINE_SEPARATOR:
+            case CharCode.PARAGRAPH_SEPARATOR:
+            case CharCode.NEXT_LINE:
+                sb.appendCharCode(0xFFFD);
+                break;
+            default:
+                if (isFullWidthCharacter(charCode)) {
+                    charWidth++;
+                }
+                if (charCode < 32) {
+                    sb.appendCharCode(9216 + charCode);
+                } else {
+                    sb.appendCharCode(charCode);
+                }
             }
         }
         charOffset += producedCharacters;
         visibleColumn += charWidth;
+        if (fixedWidthRange && fixedWidthRange.startOffset < fixedWidthRange.endOffset && charIndex + 1 === fixedWidthRange.endOffset) {
+            sb.appendString("</span>");
+            spanOpen = false;
+            fixedWidthRangeIndex++;
+        }
+    }
+    if (spanOpen) {
+        sb.appendString("</span>");
     }
-    sb.appendString("</span>");
     charOffsets[lineContent.length] = charOffset;
     visibleColumns[lineContent.length] = visibleColumn;
     sb.appendString("</div>");
-    return [charOffsets, visibleColumns];
+    return [charOffsets, visibleColumns, spanStartOffsets];
 }
-function readLineBreaks(range, lineDomNode, lineContent, charOffsets) {
+function readLineBreaks(range, lineDomNode, lineContent, charOffsets, spanStartOffsets) {
     if (lineContent.length <= 1) {
         return null;
     }
@@ -297,6 +381,7 @@ function readLineBreaks(range, lineDomNode, lineContent, charOffsets) {
             range,
             spans,
             charOffsets,
+            spanStartOffsets,
             0,
             null,
             lineContent.length - 1,
@@ -313,12 +398,22 @@ function readLineBreaks(range, lineDomNode, lineContent, charOffsets) {
     breakOffsets.push(lineContent.length);
     return breakOffsets;
 }
-function discoverBreaks(range, spans, charOffsets, low, lowRects, high, highRects, result) {
+function discoverBreaks(
+    range,
+    spans,
+    charOffsets,
+    spanStartOffsets,
+    low,
+    lowRects,
+    high,
+    highRects,
+    result
+) {
     if (low === high) {
         return;
     }
-    lowRects = lowRects || readClientRect(range, spans, charOffsets[low], charOffsets[low + 1]);
-    highRects = highRects || readClientRect(range, spans, charOffsets[high], charOffsets[high + 1]);
+    lowRects = lowRects || readClientRect(range, spans, charOffsets[low], charOffsets[low + 1], spanStartOffsets);
+    highRects = highRects || readClientRect(range, spans, charOffsets[high], charOffsets[high + 1], spanStartOffsets);
     if (Math.abs(lowRects[0].top - highRects[0].top) <= 0.1) {
         return;
     }
@@ -327,20 +422,63 @@ function discoverBreaks(range, spans, charOffsets, low, lowRects, high, highRect
         return;
     }
     const mid = low + ((high - low) / 2) | 0;
-    const midRects = readClientRect(range, spans, charOffsets[mid], charOffsets[mid + 1]);
-    discoverBreaks(range, spans, charOffsets, low, lowRects, mid, midRects, result);
-    discoverBreaks(range, spans, charOffsets, mid, midRects, high, highRects, result);
+    const midRects = readClientRect(range, spans, charOffsets[mid], charOffsets[mid + 1], spanStartOffsets);
+    discoverBreaks(
+        range,
+        spans,
+        charOffsets,
+        spanStartOffsets,
+        low,
+        lowRects,
+        mid,
+        midRects,
+        result
+    );
+    discoverBreaks(
+        range,
+        spans,
+        charOffsets,
+        spanStartOffsets,
+        mid,
+        midRects,
+        high,
+        highRects,
+        result
+    );
 }
-function readClientRect(range, spans, startOffset, endOffset) {
+function readClientRect(range, spans, startOffset, endOffset, spanStartOffsets) {
+    if (!spanStartOffsets) {
+        range.setStart(
+            spans[(startOffset / Constants.SPAN_MODULO_LIMIT) | 0].firstChild,
+            startOffset % Constants.SPAN_MODULO_LIMIT
+        );
+        range.setEnd(
+            spans[(endOffset / Constants.SPAN_MODULO_LIMIT) | 0].firstChild,
+            endOffset % Constants.SPAN_MODULO_LIMIT
+        );
+        return range.getClientRects();
+    }
+    const startSpanIndex = findSpanIndex(spanStartOffsets, startOffset);
+    const endSpanIndex = findSpanIndex(spanStartOffsets, endOffset);
     range.setStart(
-        spans[(startOffset / Constants.SPAN_MODULO_LIMIT) | 0].firstChild,
-        startOffset % Constants.SPAN_MODULO_LIMIT
-    );
-    range.setEnd(
-        spans[(endOffset / Constants.SPAN_MODULO_LIMIT) | 0].firstChild,
-        endOffset % Constants.SPAN_MODULO_LIMIT
+        spans[startSpanIndex].firstChild,
+        startOffset - spanStartOffsets[startSpanIndex]
     );
+    range.setEnd(spans[endSpanIndex].firstChild, endOffset - spanStartOffsets[endSpanIndex]);
     return range.getClientRects();
 }
+function findSpanIndex(spanStartOffsets, offset) {
+    let low = 0;
+    let high = spanStartOffsets.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (spanStartOffsets[mid] <= offset) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    return low - 1;
+}
 
 export { DOMLineBreaksComputerFactory };

package/vscode/src/vs/editor/browser/viewParts/viewLines/rangeUtil.d.ts

@@ -12,5 +12,10 @@ export declare class RangeUtil {
     private static _readClientRects;
     private static _mergeAdjacentRanges;
     private static _createHorizontalRangesFromClientRects;
+    /**
+     * Reads the horizontal range occupied by a single child element. Unlike a collapsed text
+     * range, this reports the edges of the element's box rather than the edges of its glyphs.
+     */
+    static readHorizontalRangeForElement(domNode: HTMLElement, childIndex: number, context: DomReadingContext): FloatHorizontalRange | null;
     static readHorizontalRanges(domNode: HTMLElement, startChildIndex: number, startOffset: number, endChildIndex: number, endOffset: number, context: DomReadingContext): FloatHorizontalRange[] | null;
 }

package/vscode/src/vs/editor/browser/viewParts/viewLines/rangeUtil.js

@@ -58,6 +58,16 @@ class RangeUtil {
         }
         return this._mergeAdjacentRanges(result);
     }
+    static readHorizontalRangeForElement(domNode, childIndex, context) {
+        const child = domNode.children[childIndex];
+        if (!child) {
+            return null;
+        }
+        const clientRects = child.getClientRects();
+        context.markDidDomLayout();
+        const ranges = this._createHorizontalRangesFromClientRects(clientRects, context.clientRectDeltaLeft, context.clientRectScale);
+        return ranges && ranges.length > 0 ? ranges[0] : null;
+    }
     static readHorizontalRanges(domNode, startChildIndex, startOffset, endChildIndex, endOffset, context) {
         const min = 0;
         const max = domNode.children.length - 1;

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLine.js

@@ -2,6 +2,7 @@
 import { isFirefox, isSafari, isWebKit } from '../../../../base/browser/browser.js';
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
 import { isNative, isLinux } from '../../../../base/common/platform.js';
+import { isFullWidthCharacter } from '../../../../base/common/strings.js';
 import { RangeUtil } from './rangeUtil.js';
 import { VisibleRanges, FloatHorizontalRange } from '../../view/renderingContext.js';
 import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';
@@ -133,7 +134,9 @@ class ViewLine {
             options.fontLigatures !== EditorFontLigatures.OFF,
             selectionsOnLine,
             lineData.textDirection,
-            options.verticalScrollbarSize
+            options.verticalScrollbarSize,
+            false,
+            options.useTwoCellFullwidthCharacters
         ));
         if (this._renderedViewLine && this._renderedViewLine.input.equals(renderLineInput)) {
             return false;
@@ -485,6 +488,22 @@ class RenderedViewLine {
             return this.getWidth(context);
         }
         const domPosition = this._characterMapping.getDomPosition(column);
+        if (this.input.useTwoCellFullwidthCharacters) {
+            const target = this._getReadingTarget(domNode);
+            if (isFullWidthCharacter(this.input.lineContent.charCodeAt(column - 1))) {
+                const r = RangeUtil.readHorizontalRangeForElement(target, domPosition.partIndex, context);
+                if (r) {
+                    return r.left;
+                }
+            }
+            else if (isFullWidthCharacter(this.input.lineContent.charCodeAt(column - 2))) {
+                const previousDomPosition = this._characterMapping.getDomPosition(column - 1);
+                const r = RangeUtil.readHorizontalRangeForElement(target, previousDomPosition.partIndex, context);
+                if (r) {
+                    return r.left + r.width;
+                }
+            }
+        }
         const r = RangeUtil.readHorizontalRanges(
             this._getReadingTarget(domNode),
             domPosition.partIndex,

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLineOptions.d.ts

@@ -15,6 +15,7 @@ export declare class ViewLineOptions {
     readonly fontLigatures: string;
     readonly verticalScrollbarSize: number;
     readonly useGpu: boolean;
+    readonly useTwoCellFullwidthCharacters: boolean;
     constructor(config: IEditorConfiguration, themeType: ColorScheme);
     equals(other: ViewLineOptions): boolean;
 }