@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

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

@@ -0,0 +1,885 @@
+import { localizeWithPath } from '../../../nls.js';
+import { containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
+import { StringBuilder } from '../core/stringBuilder.js';
+import { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';
+import { LinePart } from './linePart.js';
+class LineRange {
+    constructor(startIndex, endIndex) {
+        this.startOffset = startIndex;
+        this.endOffset = endIndex;
+    }
+    equals(otherLineRange) {
+        return this.startOffset === otherLineRange.startOffset
+            && this.endOffset === otherLineRange.endOffset;
+    }
+}
+class RenderLineInput {
+    constructor(useMonospaceOptimizations, canUseHalfwidthRightwardsArrow, lineContent, continuesWithWrappedLine, isBasicASCII, containsRTL, fauxIndentLength, lineTokens, lineDecorations, tabSize, startVisibleColumn, spaceWidth, middotWidth, wsmiddotWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures, selectionsOnLine) {
+        this.useMonospaceOptimizations = useMonospaceOptimizations;
+        this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;
+        this.lineContent = lineContent;
+        this.continuesWithWrappedLine = continuesWithWrappedLine;
+        this.isBasicASCII = isBasicASCII;
+        this.containsRTL = containsRTL;
+        this.fauxIndentLength = fauxIndentLength;
+        this.lineTokens = lineTokens;
+        this.lineDecorations = lineDecorations.sort(LineDecoration.compare);
+        this.tabSize = tabSize;
+        this.startVisibleColumn = startVisibleColumn;
+        this.spaceWidth = spaceWidth;
+        this.stopRenderingLineAfter = stopRenderingLineAfter;
+        this.renderWhitespace = ((renderWhitespace === 'all' ? 4  : renderWhitespace === 'boundary'
+                ? 1
+                : renderWhitespace === 'selection'
+                    ? 2
+                    : renderWhitespace === 'trailing'
+                        ? 3
+                        : 0) );
+        this.renderControlCharacters = renderControlCharacters;
+        this.fontLigatures = fontLigatures;
+        this.selectionsOnLine = selectionsOnLine && selectionsOnLine.sort((a, b) => a.startOffset < b.startOffset ? -1 : 1);
+        const wsmiddotDiff = Math.abs(wsmiddotWidth - spaceWidth);
+        const middotDiff = Math.abs(middotWidth - spaceWidth);
+        if (wsmiddotDiff < middotDiff) {
+            this.renderSpaceWidth = wsmiddotWidth;
+            this.renderSpaceCharCode = 0x2E31;
+        }
+        else {
+            this.renderSpaceWidth = middotWidth;
+            this.renderSpaceCharCode = 0xB7;
+        }
+    }
+    sameSelection(otherSelections) {
+        if (this.selectionsOnLine === null) {
+            return otherSelections === null;
+        }
+        if (otherSelections === null) {
+            return false;
+        }
+        if (otherSelections.length !== this.selectionsOnLine.length) {
+            return false;
+        }
+        for (let i = 0; i < this.selectionsOnLine.length; i++) {
+            if (!this.selectionsOnLine[i].equals(otherSelections[i])) {
+                return false;
+            }
+        }
+        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));
+    }
+}
+class DomPosition {
+    constructor(partIndex, charIndex) {
+        this.partIndex = partIndex;
+        this.charIndex = charIndex;
+    }
+}
+class CharacterMapping {
+    static getPartIndex(partData) {
+        return ((partData & 4294901760) ) >>> 16 ;
+    }
+    static getCharIndex(partData) {
+        return ((partData & 65535) ) >>> 0 ;
+    }
+    constructor(length, partCount) {
+        this.length = length;
+        this._data = ( new Uint32Array(this.length));
+        this._horizontalOffset = ( new Uint32Array(this.length));
+    }
+    setColumnInfo(column, partIndex, charIndex, horizontalOffset) {
+        const partData = (((partIndex << 16) )
+            | ((charIndex << 0) )) >>> 0;
+        this._data[column - 1] = partData;
+        this._horizontalOffset[column - 1] = horizontalOffset;
+    }
+    getHorizontalOffset(column) {
+        if (this._horizontalOffset.length === 0) {
+            return 0;
+        }
+        return this._horizontalOffset[column - 1];
+    }
+    charOffsetToPartData(charOffset) {
+        if (this.length === 0) {
+            return 0;
+        }
+        if (charOffset < 0) {
+            return this._data[0];
+        }
+        if (charOffset >= this.length) {
+            return this._data[this.length - 1];
+        }
+        return this._data[charOffset];
+    }
+    getDomPosition(column) {
+        const partData = this.charOffsetToPartData(column - 1);
+        const partIndex = CharacterMapping.getPartIndex(partData);
+        const charIndex = CharacterMapping.getCharIndex(partData);
+        return ( new DomPosition(partIndex, charIndex));
+    }
+    getColumn(domPosition, partLength) {
+        const charOffset = this.partDataToCharOffset(domPosition.partIndex, partLength, domPosition.charIndex);
+        return charOffset + 1;
+    }
+    partDataToCharOffset(partIndex, partLength, charIndex) {
+        if (this.length === 0) {
+            return 0;
+        }
+        const searchEntry = (((partIndex << 16) )
+            | ((charIndex << 0) )) >>> 0;
+        let min = 0;
+        let max = this.length - 1;
+        while (min + 1 < max) {
+            const mid = ((min + max) >>> 1);
+            const midEntry = this._data[mid];
+            if (midEntry === searchEntry) {
+                return mid;
+            }
+            else if (midEntry > searchEntry) {
+                max = mid;
+            }
+            else {
+                min = mid;
+            }
+        }
+        if (min === max) {
+            return min;
+        }
+        const minEntry = this._data[min];
+        const maxEntry = this._data[max];
+        if (minEntry === searchEntry) {
+            return min;
+        }
+        if (maxEntry === searchEntry) {
+            return max;
+        }
+        const minPartIndex = CharacterMapping.getPartIndex(minEntry);
+        const minCharIndex = CharacterMapping.getCharIndex(minEntry);
+        const maxPartIndex = CharacterMapping.getPartIndex(maxEntry);
+        let maxCharIndex;
+        if (minPartIndex !== maxPartIndex) {
+            maxCharIndex = partLength;
+        }
+        else {
+            maxCharIndex = CharacterMapping.getCharIndex(maxEntry);
+        }
+        const minEntryDistance = charIndex - minCharIndex;
+        const maxEntryDistance = maxCharIndex - charIndex;
+        if (minEntryDistance <= maxEntryDistance) {
+            return min;
+        }
+        return max;
+    }
+    inflate() {
+        const result = [];
+        for (let i = 0; i < this.length; i++) {
+            const partData = this._data[i];
+            const partIndex = CharacterMapping.getPartIndex(partData);
+            const charIndex = CharacterMapping.getCharIndex(partData);
+            const visibleColumn = this._horizontalOffset[i];
+            result.push([partIndex, charIndex, visibleColumn]);
+        }
+        return result;
+    }
+}
+class RenderLineOutput {
+    constructor(characterMapping, containsRTL, containsForeignElements) {
+        this._renderLineOutputBrand = undefined;
+        this.characterMapping = characterMapping;
+        this.containsRTL = containsRTL;
+        this.containsForeignElements = containsForeignElements;
+    }
+}
+function renderViewLine(input, sb) {
+    if (input.lineContent.length === 0) {
+        if (input.lineDecorations.length > 0) {
+            sb.appendString(`<span>`);
+            let beforeCount = 0;
+            let afterCount = 0;
+            let containsForeignElements = 0 ;
+            for (const lineDecoration of input.lineDecorations) {
+                if (lineDecoration.type === 1  || lineDecoration.type === 2 ) {
+                    sb.appendString(`<span class="`);
+                    sb.appendString(lineDecoration.className);
+                    sb.appendString(`"></span>`);
+                    if (lineDecoration.type === 1 ) {
+                        containsForeignElements |= 1 ;
+                        beforeCount++;
+                    }
+                    if (lineDecoration.type === 2 ) {
+                        containsForeignElements |= 2 ;
+                        afterCount++;
+                    }
+                }
+            }
+            sb.appendString(`</span>`);
+            const characterMapping = ( new CharacterMapping(1, beforeCount + afterCount));
+            characterMapping.setColumnInfo(1, beforeCount, 0, 0);
+            return ( new RenderLineOutput(characterMapping, false, containsForeignElements));
+        }
+        sb.appendString('<span><span></span></span>');
+        return ( new RenderLineOutput(( new CharacterMapping(0, 0)), false, 0 ));
+    }
+    return _renderLine(resolveRenderLineInput(input), sb);
+}
+class RenderLineOutput2 {
+    constructor(characterMapping, html, containsRTL, 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
+    ));
+}
+class ResolvedRenderLineInput {
+    constructor(fontIsMonospace, canUseHalfwidthRightwardsArrow, lineContent, len, isOverflowing, overflowingCharCount, parts, containsForeignElements, fauxIndentLength, tabSize, startVisibleColumn, containsRTL, spaceWidth, renderSpaceCharCode, renderWhitespace, renderControlCharacters) {
+        this.fontIsMonospace = fontIsMonospace;
+        this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;
+        this.lineContent = lineContent;
+        this.len = len;
+        this.isOverflowing = isOverflowing;
+        this.overflowingCharCount = overflowingCharCount;
+        this.parts = parts;
+        this.containsForeignElements = containsForeignElements;
+        this.fauxIndentLength = fauxIndentLength;
+        this.tabSize = tabSize;
+        this.startVisibleColumn = startVisibleColumn;
+        this.containsRTL = containsRTL;
+        this.spaceWidth = spaceWidth;
+        this.renderSpaceCharCode = renderSpaceCharCode;
+        this.renderWhitespace = renderWhitespace;
+        this.renderControlCharacters = renderControlCharacters;
+    }
+}
+function resolveRenderLineInput(input) {
+    const lineContent = input.lineContent;
+    let isOverflowing;
+    let overflowingCharCount;
+    let len;
+    if (input.stopRenderingLineAfter !== -1 && input.stopRenderingLineAfter < lineContent.length) {
+        isOverflowing = true;
+        overflowingCharCount = lineContent.length - input.stopRenderingLineAfter;
+        len = input.stopRenderingLineAfter;
+    }
+    else {
+        isOverflowing = false;
+        overflowingCharCount = 0;
+        len = lineContent.length;
+    }
+    let tokens = transformAndRemoveOverflowing(lineContent, input.containsRTL, input.lineTokens, input.fauxIndentLength, len);
+    if (input.renderControlCharacters && !input.isBasicASCII) {
+        tokens = extractControlCharacters(lineContent, tokens);
+    }
+    if (input.renderWhitespace === 4  ||
+        input.renderWhitespace === 1  ||
+        (input.renderWhitespace === 2  && !!input.selectionsOnLine) ||
+        (input.renderWhitespace === 3  && !input.continuesWithWrappedLine)) {
+        tokens = _applyRenderWhitespace(input, lineContent, len, tokens);
+    }
+    let containsForeignElements = 0 ;
+    if (input.lineDecorations.length > 0) {
+        for (let i = 0, len = input.lineDecorations.length; i < len; i++) {
+            const lineDecoration = input.lineDecorations[i];
+            if (lineDecoration.type === 3 ) {
+                containsForeignElements |= 1 ;
+            }
+            else if (lineDecoration.type === 1 ) {
+                containsForeignElements |= 1 ;
+            }
+            else if (lineDecoration.type === 2 ) {
+                containsForeignElements |= 2 ;
+            }
+        }
+        tokens = _applyInlineDecorations(lineContent, len, tokens, input.lineDecorations);
+    }
+    if (!input.containsRTL) {
+        tokens = splitLargeTokens(lineContent, tokens, !input.isBasicASCII || input.fontLigatures);
+    }
+    return ( new ResolvedRenderLineInput(
+        input.useMonospaceOptimizations,
+        input.canUseHalfwidthRightwardsArrow,
+        lineContent,
+        len,
+        isOverflowing,
+        overflowingCharCount,
+        tokens,
+        containsForeignElements,
+        input.fauxIndentLength,
+        input.tabSize,
+        input.startVisibleColumn,
+        input.containsRTL,
+        input.spaceWidth,
+        input.renderSpaceCharCode,
+        input.renderWhitespace,
+        input.renderControlCharacters
+    ));
+}
+function transformAndRemoveOverflowing(lineContent, lineContainsRTL, tokens, fauxIndentLength, len) {
+    const result = [];
+    let resultLen = 0;
+    if (fauxIndentLength > 0) {
+        result[resultLen++] = ( new LinePart(fauxIndentLength, '', 0, false));
+    }
+    let startOffset = fauxIndentLength;
+    for (let tokenIndex = 0, tokensLen = tokens.getCount(); tokenIndex < tokensLen; tokenIndex++) {
+        const endIndex = tokens.getEndOffset(tokenIndex);
+        if (endIndex <= fauxIndentLength) {
+            continue;
+        }
+        const type = tokens.getClassName(tokenIndex);
+        if (endIndex >= len) {
+            const tokenContainsRTL = (lineContainsRTL ? containsRTL(lineContent.substring(startOffset, len)) : false);
+            result[resultLen++] = ( new LinePart(len, type, 0, tokenContainsRTL));
+            break;
+        }
+        const tokenContainsRTL = (lineContainsRTL ? containsRTL(lineContent.substring(startOffset, endIndex)) : false);
+        result[resultLen++] = ( new LinePart(endIndex, type, 0, tokenContainsRTL));
+        startOffset = endIndex;
+    }
+    return result;
+}
+function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
+    let lastTokenEndIndex = 0;
+    const result = [];
+    let resultLen = 0;
+    if (onlyAtSpaces) {
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const token = tokens[i];
+            const tokenEndIndex = token.endIndex;
+            if (lastTokenEndIndex + 50  < tokenEndIndex) {
+                const tokenType = token.type;
+                const tokenMetadata = token.metadata;
+                const tokenContainsRTL = token.containsRTL;
+                let lastSpaceOffset = -1;
+                let currTokenStart = lastTokenEndIndex;
+                for (let j = lastTokenEndIndex; j < tokenEndIndex; j++) {
+                    if (lineContent.charCodeAt(j) === 32 ) {
+                        lastSpaceOffset = j;
+                    }
+                    if (lastSpaceOffset !== -1 && j - currTokenStart >= 50 ) {
+                        result[resultLen++] = ( new LinePart(lastSpaceOffset + 1, tokenType, tokenMetadata, tokenContainsRTL));
+                        currTokenStart = lastSpaceOffset + 1;
+                        lastSpaceOffset = -1;
+                    }
+                }
+                if (currTokenStart !== tokenEndIndex) {
+                    result[resultLen++] = ( new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+                }
+            }
+            else {
+                result[resultLen++] = token;
+            }
+            lastTokenEndIndex = tokenEndIndex;
+        }
+    }
+    else {
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const token = tokens[i];
+            const tokenEndIndex = token.endIndex;
+            const diff = (tokenEndIndex - lastTokenEndIndex);
+            if (diff > 50 ) {
+                const tokenType = token.type;
+                const tokenMetadata = token.metadata;
+                const tokenContainsRTL = token.containsRTL;
+                const piecesCount = Math.ceil(diff / 50 );
+                for (let j = 1; j < piecesCount; j++) {
+                    const pieceEndIndex = lastTokenEndIndex + ((j * 50) );
+                    result[resultLen++] = ( new LinePart(pieceEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+                }
+                result[resultLen++] = ( new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+            }
+            else {
+                result[resultLen++] = token;
+            }
+            lastTokenEndIndex = tokenEndIndex;
+        }
+    }
+    return result;
+}
+function isControlCharacter(charCode) {
+    if (charCode < 32) {
+        return (charCode !== 9) ;
+    }
+    if (charCode === 127) {
+        return true;
+    }
+    if ((charCode >= 0x202A && charCode <= 0x202E)
+        || (charCode >= 0x2066 && charCode <= 0x2069)
+        || (charCode >= 0x200E && charCode <= 0x200F)
+        || charCode === 0x061C) {
+        return true;
+    }
+    return false;
+}
+function extractControlCharacters(lineContent, tokens) {
+    const result = [];
+    let lastLinePart = ( new LinePart(0, '', 0, false));
+    let charOffset = 0;
+    for (const token of tokens) {
+        const tokenEndIndex = token.endIndex;
+        for (; charOffset < tokenEndIndex; charOffset++) {
+            const charCode = lineContent.charCodeAt(charOffset);
+            if (isControlCharacter(charCode)) {
+                if (charOffset > lastLinePart.endIndex) {
+                    lastLinePart = ( new LinePart(charOffset, token.type, token.metadata, token.containsRTL));
+                    result.push(lastLinePart);
+                }
+                lastLinePart = ( new LinePart(charOffset + 1, 'mtkcontrol', token.metadata, false));
+                result.push(lastLinePart);
+            }
+        }
+        if (charOffset > lastLinePart.endIndex) {
+            lastLinePart = ( new LinePart(tokenEndIndex, token.type, token.metadata, token.containsRTL));
+            result.push(lastLinePart);
+        }
+    }
+    return result;
+}
+function _applyRenderWhitespace(input, lineContent, len, tokens) {
+    const continuesWithWrappedLine = input.continuesWithWrappedLine;
+    const fauxIndentLength = input.fauxIndentLength;
+    const tabSize = input.tabSize;
+    const startVisibleColumn = input.startVisibleColumn;
+    const useMonospaceOptimizations = input.useMonospaceOptimizations;
+    const selections = input.selectionsOnLine;
+    const onlyBoundary = ((input.renderWhitespace === 1) );
+    const onlyTrailing = ((input.renderWhitespace === 3) );
+    const generateLinePartForEachWhitespace = (input.renderSpaceWidth !== input.spaceWidth);
+    const result = [];
+    let resultLen = 0;
+    let tokenIndex = 0;
+    let tokenType = tokens[tokenIndex].type;
+    let tokenContainsRTL = tokens[tokenIndex].containsRTL;
+    let tokenEndIndex = tokens[tokenIndex].endIndex;
+    const tokensLength = tokens.length;
+    let lineIsEmptyOrWhitespace = false;
+    let firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineContent);
+    let lastNonWhitespaceIndex$1;
+    if (firstNonWhitespaceIndex$1 === -1) {
+        lineIsEmptyOrWhitespace = true;
+        firstNonWhitespaceIndex$1 = len;
+        lastNonWhitespaceIndex$1 = len;
+    }
+    else {
+        lastNonWhitespaceIndex$1 = lastNonWhitespaceIndex(lineContent);
+    }
+    let wasInWhitespace = false;
+    let currentSelectionIndex = 0;
+    let currentSelection = selections && selections[currentSelectionIndex];
+    let tmpIndent = startVisibleColumn % tabSize;
+    for (let charIndex = fauxIndentLength; charIndex < len; charIndex++) {
+        const chCode = lineContent.charCodeAt(charIndex);
+        if (currentSelection && charIndex >= currentSelection.endOffset) {
+            currentSelectionIndex++;
+            currentSelection = selections && selections[currentSelectionIndex];
+        }
+        let isInWhitespace;
+        if (charIndex < firstNonWhitespaceIndex$1 || charIndex > lastNonWhitespaceIndex$1) {
+            isInWhitespace = true;
+        }
+        else if (chCode === 9 ) {
+            isInWhitespace = true;
+        }
+        else if (chCode === 32 ) {
+            if (onlyBoundary) {
+                if (wasInWhitespace) {
+                    isInWhitespace = true;
+                }
+                else {
+                    const nextChCode = ((charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0) );
+                    isInWhitespace = ((nextChCode === 32  || nextChCode === 9) );
+                }
+            }
+            else {
+                isInWhitespace = true;
+            }
+        }
+        else {
+            isInWhitespace = false;
+        }
+        if (isInWhitespace && selections) {
+            isInWhitespace = !!currentSelection && currentSelection.startOffset <= charIndex && currentSelection.endOffset > charIndex;
+        }
+        if (isInWhitespace && onlyTrailing) {
+            isInWhitespace = lineIsEmptyOrWhitespace || charIndex > lastNonWhitespaceIndex$1;
+        }
+        if (isInWhitespace && tokenContainsRTL) {
+            if (charIndex >= firstNonWhitespaceIndex$1 && charIndex <= lastNonWhitespaceIndex$1) {
+                isInWhitespace = false;
+            }
+        }
+        if (wasInWhitespace) {
+            if (!isInWhitespace || (!useMonospaceOptimizations && tmpIndent >= tabSize)) {
+                if (generateLinePartForEachWhitespace) {
+                    const lastEndIndex = (resultLen > 0 ? result[resultLen - 1].endIndex : fauxIndentLength);
+                    for (let i = lastEndIndex + 1; i <= charIndex; i++) {
+                        result[resultLen++] = ( new LinePart(i, 'mtkw', 1 , false));
+                    }
+                }
+                else {
+                    result[resultLen++] = ( new LinePart(charIndex, 'mtkw', 1 , false));
+                }
+                tmpIndent = tmpIndent % tabSize;
+            }
+        }
+        else {
+            if (charIndex === tokenEndIndex || (isInWhitespace && charIndex > fauxIndentLength)) {
+                result[resultLen++] = ( new LinePart(charIndex, tokenType, 0, tokenContainsRTL));
+                tmpIndent = tmpIndent % tabSize;
+            }
+        }
+        if (chCode === 9 ) {
+            tmpIndent = tabSize;
+        }
+        else if (isFullWidthCharacter(chCode)) {
+            tmpIndent += 2;
+        }
+        else {
+            tmpIndent++;
+        }
+        wasInWhitespace = isInWhitespace;
+        while (charIndex === tokenEndIndex) {
+            tokenIndex++;
+            if (tokenIndex < tokensLength) {
+                tokenType = tokens[tokenIndex].type;
+                tokenContainsRTL = tokens[tokenIndex].containsRTL;
+                tokenEndIndex = tokens[tokenIndex].endIndex;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    let generateWhitespace = false;
+    if (wasInWhitespace) {
+        if (continuesWithWrappedLine && onlyBoundary) {
+            const lastCharCode = ((len > 0 ? lineContent.charCodeAt(len - 1) : 0) );
+            const prevCharCode = ((len > 1 ? lineContent.charCodeAt(len - 2) : 0) );
+            const isSingleTrailingSpace = (lastCharCode === 32  && ((prevCharCode !== 32  && prevCharCode !== 9) ));
+            if (!isSingleTrailingSpace) {
+                generateWhitespace = true;
+            }
+        }
+        else {
+            generateWhitespace = true;
+        }
+    }
+    if (generateWhitespace) {
+        if (generateLinePartForEachWhitespace) {
+            const lastEndIndex = (resultLen > 0 ? result[resultLen - 1].endIndex : fauxIndentLength);
+            for (let i = lastEndIndex + 1; i <= len; i++) {
+                result[resultLen++] = ( new LinePart(i, 'mtkw', 1 , false));
+            }
+        }
+        else {
+            result[resultLen++] = ( new LinePart(len, 'mtkw', 1 , false));
+        }
+    }
+    else {
+        result[resultLen++] = ( new LinePart(len, tokenType, 0, tokenContainsRTL));
+    }
+    return result;
+}
+function _applyInlineDecorations(lineContent, len, tokens, _lineDecorations) {
+    _lineDecorations.sort(LineDecoration.compare);
+    const lineDecorations = LineDecorationsNormalizer.normalize(lineContent, _lineDecorations);
+    const lineDecorationsLen = lineDecorations.length;
+    let lineDecorationIndex = 0;
+    const result = [];
+    let resultLen = 0;
+    let lastResultEndIndex = 0;
+    for (let tokenIndex = 0, len = tokens.length; tokenIndex < len; tokenIndex++) {
+        const token = tokens[tokenIndex];
+        const tokenEndIndex = token.endIndex;
+        const tokenType = token.type;
+        const tokenMetadata = token.metadata;
+        const tokenContainsRTL = token.containsRTL;
+        while (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset < tokenEndIndex) {
+            const lineDecoration = lineDecorations[lineDecorationIndex];
+            if (lineDecoration.startOffset > lastResultEndIndex) {
+                lastResultEndIndex = lineDecoration.startOffset;
+                result[resultLen++] = ( new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+            }
+            if (lineDecoration.endOffset + 1 <= tokenEndIndex) {
+                lastResultEndIndex = lineDecoration.endOffset + 1;
+                result[resultLen++] = ( new LinePart(
+                    lastResultEndIndex,
+                    tokenType + ' ' + lineDecoration.className,
+                    tokenMetadata | lineDecoration.metadata,
+                    tokenContainsRTL
+                ));
+                lineDecorationIndex++;
+            }
+            else {
+                lastResultEndIndex = tokenEndIndex;
+                result[resultLen++] = ( new LinePart(
+                    lastResultEndIndex,
+                    tokenType + ' ' + lineDecoration.className,
+                    tokenMetadata | lineDecoration.metadata,
+                    tokenContainsRTL
+                ));
+                break;
+            }
+        }
+        if (tokenEndIndex > lastResultEndIndex) {
+            lastResultEndIndex = tokenEndIndex;
+            result[resultLen++] = ( new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+        }
+    }
+    const lastTokenEndIndex = tokens[tokens.length - 1].endIndex;
+    if (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset === lastTokenEndIndex) {
+        while (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset === lastTokenEndIndex) {
+            const lineDecoration = lineDecorations[lineDecorationIndex];
+            result[resultLen++] = ( new LinePart(
+                lastResultEndIndex,
+                lineDecoration.className,
+                lineDecoration.metadata,
+                false
+            ));
+            lineDecorationIndex++;
+        }
+    }
+    return result;
+}
+function _renderLine(input, sb) {
+    const fontIsMonospace = input.fontIsMonospace;
+    const canUseHalfwidthRightwardsArrow = input.canUseHalfwidthRightwardsArrow;
+    const containsForeignElements = input.containsForeignElements;
+    const lineContent = input.lineContent;
+    const len = input.len;
+    const isOverflowing = input.isOverflowing;
+    const overflowingCharCount = input.overflowingCharCount;
+    const parts = input.parts;
+    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;
+    const renderControlCharacters = input.renderControlCharacters;
+    const characterMapping = ( new CharacterMapping(len + 1, parts.length));
+    let lastCharacterMappingDefined = false;
+    let charIndex = 0;
+    let visibleColumn = startVisibleColumn;
+    let charOffsetInPart = 0;
+    let charHorizontalOffset = 0;
+    let partDisplacement = 0;
+    if (containsRTL) {
+        sb.appendString('<span dir="ltr">');
+    }
+    else {
+        sb.appendString('<span>');
+    }
+    for (let partIndex = 0, tokensLen = parts.length; partIndex < tokensLen; partIndex++) {
+        const part = parts[partIndex];
+        const partEndIndex = part.endIndex;
+        const partType = part.type;
+        const partContainsRTL = part.containsRTL;
+        const partRendersWhitespace = (renderWhitespace !== 0  && part.isWhitespace());
+        const partRendersWhitespaceWithWidth = partRendersWhitespace && !fontIsMonospace && (partType === 'mtkw'  || !containsForeignElements);
+        const partIsEmptyAndHasPseudoAfter = (charIndex === partEndIndex && part.isPseudoAfter());
+        charOffsetInPart = 0;
+        sb.appendString('<span ');
+        if (partContainsRTL) {
+            sb.appendString('style="unicode-bidi:isolate" ');
+        }
+        sb.appendString('class="');
+        sb.appendString(partRendersWhitespaceWithWidth ? 'mtkz' : partType);
+        sb.appendASCIICharCode(34 );
+        if (partRendersWhitespace) {
+            let partWidth = 0;
+            {
+                let _charIndex = charIndex;
+                let _visibleColumn = visibleColumn;
+                for (; _charIndex < partEndIndex; _charIndex++) {
+                    const charCode = lineContent.charCodeAt(_charIndex);
+                    const charWidth = (charCode === 9  ? (tabSize - (_visibleColumn % tabSize)) : 1) | 0;
+                    partWidth += charWidth;
+                    if (_charIndex >= fauxIndentLength) {
+                        _visibleColumn += charWidth;
+                    }
+                }
+            }
+            if (partRendersWhitespaceWithWidth) {
+                sb.appendString(' style="width:');
+                sb.appendString(String(spaceWidth * partWidth));
+                sb.appendString('px"');
+            }
+            sb.appendASCIICharCode(62 );
+            for (; charIndex < partEndIndex; charIndex++) {
+                characterMapping.setColumnInfo(charIndex + 1, partIndex - partDisplacement, charOffsetInPart, charHorizontalOffset);
+                partDisplacement = 0;
+                const charCode = lineContent.charCodeAt(charIndex);
+                let producedCharacters;
+                let charWidth;
+                if (charCode === 9 ) {
+                    producedCharacters = (tabSize - (visibleColumn % tabSize)) | 0;
+                    charWidth = producedCharacters;
+                    if (!canUseHalfwidthRightwardsArrow || charWidth > 1) {
+                        sb.appendCharCode(0x2192);
+                    }
+                    else {
+                        sb.appendCharCode(0xFFEB);
+                    }
+                    for (let space = 2; space <= charWidth; space++) {
+                        sb.appendCharCode(0xA0);
+                    }
+                }
+                else {
+                    producedCharacters = 2;
+                    charWidth = 1;
+                    sb.appendCharCode(renderSpaceCharCode);
+                    sb.appendCharCode(0x200C);
+                }
+                charOffsetInPart += producedCharacters;
+                charHorizontalOffset += charWidth;
+                if (charIndex >= fauxIndentLength) {
+                    visibleColumn += charWidth;
+                }
+            }
+        }
+        else {
+            sb.appendASCIICharCode(62 );
+            for (; charIndex < partEndIndex; charIndex++) {
+                characterMapping.setColumnInfo(charIndex + 1, partIndex - partDisplacement, charOffsetInPart, charHorizontalOffset);
+                partDisplacement = 0;
+                const charCode = lineContent.charCodeAt(charIndex);
+                let producedCharacters = 1;
+                let charWidth = 1;
+                switch (charCode) {
+                    case 9 :
+                        producedCharacters = (tabSize - (visibleColumn % tabSize));
+                        charWidth = producedCharacters;
+                        for (let space = 1; space <= producedCharacters; space++) {
+                            sb.appendCharCode(0xA0);
+                        }
+                        break;
+                    case 32 :
+                        sb.appendCharCode(0xA0);
+                        break;
+                    case 60 :
+                        sb.appendString('&lt;');
+                        break;
+                    case 62 :
+                        sb.appendString('&gt;');
+                        break;
+                    case 38 :
+                        sb.appendString('&amp;');
+                        break;
+                    case 0 :
+                        if (renderControlCharacters) {
+                            sb.appendCharCode(9216);
+                        }
+                        else {
+                            sb.appendString('&#00;');
+                        }
+                        break;
+                    case 65279 :
+                    case 8232 :
+                    case 8233 :
+                    case 133 :
+                        sb.appendCharCode(0xFFFD);
+                        break;
+                    default:
+                        if (isFullWidthCharacter(charCode)) {
+                            charWidth++;
+                        }
+                        if (renderControlCharacters && charCode < 32) {
+                            sb.appendCharCode(9216 + charCode);
+                        }
+                        else if (renderControlCharacters && charCode === 127) {
+                            sb.appendCharCode(9249);
+                        }
+                        else if (renderControlCharacters && isControlCharacter(charCode)) {
+                            sb.appendString('[U+');
+                            sb.appendString(to4CharHex(charCode));
+                            sb.appendString(']');
+                            producedCharacters = 8;
+                            charWidth = producedCharacters;
+                        }
+                        else {
+                            sb.appendCharCode(charCode);
+                        }
+                }
+                charOffsetInPart += producedCharacters;
+                charHorizontalOffset += charWidth;
+                if (charIndex >= fauxIndentLength) {
+                    visibleColumn += charWidth;
+                }
+            }
+        }
+        if (partIsEmptyAndHasPseudoAfter) {
+            partDisplacement++;
+        }
+        else {
+            partDisplacement = 0;
+        }
+        if (charIndex >= len && !lastCharacterMappingDefined && part.isPseudoAfter()) {
+            lastCharacterMappingDefined = true;
+            characterMapping.setColumnInfo(charIndex + 1, partIndex, charOffsetInPart, charHorizontalOffset);
+        }
+        sb.appendString('</span>');
+    }
+    if (!lastCharacterMappingDefined) {
+        characterMapping.setColumnInfo(len + 1, parts.length - 1, charOffsetInPart, charHorizontalOffset);
+    }
+    if (isOverflowing) {
+        sb.appendString('<span class="mtkoverflow">');
+        sb.appendString(( localizeWithPath(
+            'vs/editor/common/viewLayout/viewLineRenderer',
+            'showMore',
+            "Show more ({0})",
+            renderOverflowingCharCount(overflowingCharCount)
+        )));
+        sb.appendString('</span>');
+    }
+    sb.appendString('</span>');
+    return ( new RenderLineOutput(characterMapping, containsRTL, containsForeignElements));
+}
+function to4CharHex(n) {
+    return ( n.toString(16)).toUpperCase().padStart(4, '0');
+}
+function renderOverflowingCharCount(n) {
+    if (n < 1024) {
+        return ( localizeWithPath(
+            'vs/editor/common/viewLayout/viewLineRenderer',
+            'overflow.chars',
+            "{0} chars",
+            n
+        ));
+    }
+    if (n < 1024 * 1024) {
+        return `${(n / 1024).toFixed(1)} KB`;
+    }
+    return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+export { CharacterMapping, DomPosition, LineRange, RenderLineInput, RenderLineOutput, RenderLineOutput2, renderViewLine, renderViewLine2 };