@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -1,18 +1,8 @@
 import { localize } from '../../../nls.js';
-import { CharCode } from '../../../base/common/charCode.js';
 import { containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
 import { StringBuilder } from '../core/stringBuilder.js';
 import { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';
-import { InlineDecorationType } from '../viewModel.js';
-import { LinePart, LinePartMetadata } from './linePart.js';
-var RenderWhitespace;
-( ((function(RenderWhitespace) {
-    RenderWhitespace[RenderWhitespace["None"] = 0] = "None";
-    RenderWhitespace[RenderWhitespace["Boundary"] = 1] = "Boundary";
-    RenderWhitespace[RenderWhitespace["Selection"] = 2] = "Selection";
-    RenderWhitespace[RenderWhitespace["Trailing"] = 3] = "Trailing";
-    RenderWhitespace[RenderWhitespace["All"] = 4] = "All";
-})(RenderWhitespace || (RenderWhitespace = {}))));
+import { LinePart } from './linePart.js';
 class LineRange {
     constructor(startIndex, endIndex) {
         this.startOffset = startIndex;
@@ -38,15 +28,13 @@ class RenderLineInput {
         this.startVisibleColumn = startVisibleColumn;
         this.spaceWidth = spaceWidth;
         this.stopRenderingLineAfter = stopRenderingLineAfter;
-        this.renderWhitespace = (renderWhitespace === 'all'
-            ? RenderWhitespace.All
-            : renderWhitespace === 'boundary'
-                ? RenderWhitespace.Boundary
+        this.renderWhitespace = ((renderWhitespace === 'all' ? 4  : renderWhitespace === 'boundary'
+                ? 1
                 : renderWhitespace === 'selection'
-                    ? RenderWhitespace.Selection
+                    ? 2
                     : renderWhitespace === 'trailing'
-                        ? RenderWhitespace.Trailing
-                        : RenderWhitespace.None);
+                        ? 3
+                        : 0) );
         this.renderControlCharacters = renderControlCharacters;
         this.fontLigatures = fontLigatures;
         this.selectionsOnLine = selectionsOnLine && selectionsOnLine.sort((a, b) => a.startOffset < b.startOffset ? -1 : 1);
@@ -100,13 +88,6 @@ class RenderLineInput {
             && this.sameSelection(other.selectionsOnLine));
     }
 }
-var CharacterMappingConstants;
-( ((function(CharacterMappingConstants) {
-    CharacterMappingConstants[CharacterMappingConstants["PART_INDEX_MASK"] = 4294901760] = "PART_INDEX_MASK";
-    CharacterMappingConstants[CharacterMappingConstants["CHAR_INDEX_MASK"] = 65535] = "CHAR_INDEX_MASK";
-    CharacterMappingConstants[CharacterMappingConstants["CHAR_INDEX_OFFSET"] = 0] = "CHAR_INDEX_OFFSET";
-    CharacterMappingConstants[CharacterMappingConstants["PART_INDEX_OFFSET"] = 16] = "PART_INDEX_OFFSET";
-})(CharacterMappingConstants || (CharacterMappingConstants = {}))));
 class DomPosition {
     constructor(partIndex, charIndex) {
         this.partIndex = partIndex;
@@ -115,10 +96,10 @@ class DomPosition {
 }
 class CharacterMapping {
     static getPartIndex(partData) {
-        return (partData & CharacterMappingConstants.PART_INDEX_MASK) >>> CharacterMappingConstants.PART_INDEX_OFFSET;
+        return ((partData & 4294901760) ) >>> 16 ;
     }
     static getCharIndex(partData) {
-        return (partData & CharacterMappingConstants.CHAR_INDEX_MASK) >>> CharacterMappingConstants.CHAR_INDEX_OFFSET;
+        return ((partData & 65535) ) >>> 0 ;
     }
     constructor(length, partCount) {
         this.length = length;
@@ -126,8 +107,8 @@ class CharacterMapping {
         this._horizontalOffset = ( (new Uint32Array(this.length)));
     }
     setColumnInfo(column, partIndex, charIndex, horizontalOffset) {
-        const partData = ((partIndex << CharacterMappingConstants.PART_INDEX_OFFSET)
-            | (charIndex << CharacterMappingConstants.CHAR_INDEX_OFFSET)) >>> 0;
+        const partData = (((partIndex << 16) )
+            | ((charIndex << 0) )) >>> 0;
         this._data[column - 1] = partData;
         this._horizontalOffset[column - 1] = horizontalOffset;
     }
@@ -165,8 +146,8 @@ class CharacterMapping {
         if (this.length === 0) {
             return 0;
         }
-        const searchEntry = ((partIndex << CharacterMappingConstants.PART_INDEX_OFFSET)
-            | (charIndex << CharacterMappingConstants.CHAR_INDEX_OFFSET)) >>> 0;
+        const searchEntry = (((partIndex << 16) )
+            | ((charIndex << 0) )) >>> 0;
         let min = 0;
         let max = this.length - 1;
         while (min + 1 < max) {
@@ -222,12 +203,6 @@ class CharacterMapping {
         return result;
     }
 }
-var ForeignElementType;
-( ((function(ForeignElementType) {
-    ForeignElementType[ForeignElementType["None"] = 0] = "None";
-    ForeignElementType[ForeignElementType["Before"] = 1] = "Before";
-    ForeignElementType[ForeignElementType["After"] = 2] = "After";
-})(ForeignElementType || (ForeignElementType = {}))));
 class RenderLineOutput {
     constructor(characterMapping, containsRTL, containsForeignElements) {
         this._renderLineOutputBrand = undefined;
@@ -242,18 +217,18 @@ function renderViewLine(input, sb) {
             sb.appendString(`<span>`);
             let beforeCount = 0;
             let afterCount = 0;
-            let containsForeignElements = ForeignElementType.None;
+            let containsForeignElements = 0 ;
             for (const lineDecoration of input.lineDecorations) {
-                if (lineDecoration.type === InlineDecorationType.Before || lineDecoration.type === InlineDecorationType.After) {
+                if (lineDecoration.type === 1  || lineDecoration.type === 2 ) {
                     sb.appendString(`<span class="`);
                     sb.appendString(lineDecoration.className);
                     sb.appendString(`"></span>`);
-                    if (lineDecoration.type === InlineDecorationType.Before) {
-                        containsForeignElements |= ForeignElementType.Before;
+                    if (lineDecoration.type === 1 ) {
+                        containsForeignElements |= 1 ;
                         beforeCount++;
                     }
-                    if (lineDecoration.type === InlineDecorationType.After) {
-                        containsForeignElements |= ForeignElementType.After;
+                    if (lineDecoration.type === 2 ) {
+                        containsForeignElements |= 2 ;
                         afterCount++;
                     }
                 }
@@ -267,7 +242,11 @@ function renderViewLine(input, sb) {
         }
         sb.appendString('<span><span></span></span>');
         return (
-             (new RenderLineOutput( (new CharacterMapping(0, 0)), false, ForeignElementType.None))
+             (new RenderLineOutput(
+                 (new CharacterMapping(0, 0)),
+                false,
+                0
+            ))
         );
     }
     return _renderLine(resolveRenderLineInput(input), sb);
@@ -331,24 +310,24 @@ function resolveRenderLineInput(input) {
     if (input.renderControlCharacters && !input.isBasicASCII) {
         tokens = extractControlCharacters(lineContent, tokens);
     }
-    if (input.renderWhitespace === RenderWhitespace.All ||
-        input.renderWhitespace === RenderWhitespace.Boundary ||
-        (input.renderWhitespace === RenderWhitespace.Selection && !!input.selectionsOnLine) ||
-        (input.renderWhitespace === RenderWhitespace.Trailing && !input.continuesWithWrappedLine)) {
+    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 = ForeignElementType.None;
+    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 === InlineDecorationType.RegularAffectingLetterSpacing) {
-                containsForeignElements |= ForeignElementType.Before;
+            if (lineDecoration.type === 3 ) {
+                containsForeignElements |= 1 ;
             }
-            else if (lineDecoration.type === InlineDecorationType.Before) {
-                containsForeignElements |= ForeignElementType.Before;
+            else if (lineDecoration.type === 1 ) {
+                containsForeignElements |= 1 ;
             }
-            else if (lineDecoration.type === InlineDecorationType.After) {
-                containsForeignElements |= ForeignElementType.After;
+            else if (lineDecoration.type === 2 ) {
+                containsForeignElements |= 2 ;
             }
         }
         tokens = _applyInlineDecorations(lineContent, len, tokens, input.lineDecorations);
@@ -401,10 +380,6 @@ function transformAndRemoveOverflowing(lineContent, lineContainsRTL, tokens, fau
     }
     return result;
 }
-var Constants;
-( ((function(Constants) {
-    Constants[Constants["LongToken"] = 50] = "LongToken";
-})(Constants || (Constants = {}))));
 function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
     let lastTokenEndIndex = 0;
     const result = [];
@@ -413,17 +388,17 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
         for (let i = 0, len = tokens.length; i < len; i++) {
             const token = tokens[i];
             const tokenEndIndex = token.endIndex;
-            if (lastTokenEndIndex + Constants.LongToken < tokenEndIndex) {
+            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) === CharCode.Space) {
+                    if (lineContent.charCodeAt(j) === 32 ) {
                         lastSpaceOffset = j;
                     }
-                    if (lastSpaceOffset !== -1 && j - currTokenStart >= Constants.LongToken) {
+                    if (lastSpaceOffset !== -1 && j - currTokenStart >= 50 ) {
                         result[resultLen++] = ( (new LinePart(lastSpaceOffset + 1, tokenType, tokenMetadata, tokenContainsRTL)));
                         currTokenStart = lastSpaceOffset + 1;
                         lastSpaceOffset = -1;
@@ -444,13 +419,13 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
             const token = tokens[i];
             const tokenEndIndex = token.endIndex;
             const diff = (tokenEndIndex - lastTokenEndIndex);
-            if (diff > Constants.LongToken) {
+            if (diff > 50 ) {
                 const tokenType = token.type;
                 const tokenMetadata = token.metadata;
                 const tokenContainsRTL = token.containsRTL;
-                const piecesCount = Math.ceil(diff / Constants.LongToken);
+                const piecesCount = Math.ceil(diff / 50 );
                 for (let j = 1; j < piecesCount; j++) {
-                    const pieceEndIndex = lastTokenEndIndex + (j * Constants.LongToken);
+                    const pieceEndIndex = lastTokenEndIndex + ((j * 50) );
                     result[resultLen++] = ( (new LinePart(pieceEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
                 }
                 result[resultLen++] = ( (new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
@@ -465,7 +440,7 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
 }
 function isControlCharacter(charCode) {
     if (charCode < 32) {
-        return (charCode !== CharCode.Tab);
+        return (charCode !== 9) ;
     }
     if (charCode === 127) {
         return true;
@@ -509,8 +484,8 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
     const startVisibleColumn = input.startVisibleColumn;
     const useMonospaceOptimizations = input.useMonospaceOptimizations;
     const selections = input.selectionsOnLine;
-    const onlyBoundary = (input.renderWhitespace === RenderWhitespace.Boundary);
-    const onlyTrailing = (input.renderWhitespace === RenderWhitespace.Trailing);
+    const onlyBoundary = ((input.renderWhitespace === 1) );
+    const onlyTrailing = ((input.renderWhitespace === 3) );
     const generateLinePartForEachWhitespace = (input.renderSpaceWidth !== input.spaceWidth);
     const result = [];
     let resultLen = 0;
@@ -544,17 +519,17 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
         if (charIndex < firstNonWhitespaceIndex$1 || charIndex > lastNonWhitespaceIndex$1) {
             isInWhitespace = true;
         }
-        else if (chCode === CharCode.Tab) {
+        else if (chCode === 9 ) {
             isInWhitespace = true;
         }
-        else if (chCode === CharCode.Space) {
+        else if (chCode === 32 ) {
             if (onlyBoundary) {
                 if (wasInWhitespace) {
                     isInWhitespace = true;
                 }
                 else {
-                    const nextChCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : CharCode.Null);
-                    isInWhitespace = (nextChCode === CharCode.Space || nextChCode === CharCode.Tab);
+                    const nextChCode = ((charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0) );
+                    isInWhitespace = ((nextChCode === 32  || nextChCode === 9) );
                 }
             }
             else {
@@ -580,11 +555,11 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
                 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', LinePartMetadata.IS_WHITESPACE, false)));
+                        result[resultLen++] = ( (new LinePart(i, 'mtkw', 1 , false)));
                     }
                 }
                 else {
-                    result[resultLen++] = ( (new LinePart(charIndex, 'mtkw', LinePartMetadata.IS_WHITESPACE, false)));
+                    result[resultLen++] = ( (new LinePart(charIndex, 'mtkw', 1 , false)));
                 }
                 tmpIndent = tmpIndent % tabSize;
             }
@@ -595,7 +570,7 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
                 tmpIndent = tmpIndent % tabSize;
             }
         }
-        if (chCode === CharCode.Tab) {
+        if (chCode === 9 ) {
             tmpIndent = tabSize;
         }
         else if (isFullWidthCharacter(chCode)) {
@@ -620,9 +595,9 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
     let generateWhitespace = false;
     if (wasInWhitespace) {
         if (continuesWithWrappedLine && onlyBoundary) {
-            const lastCharCode = (len > 0 ? lineContent.charCodeAt(len - 1) : CharCode.Null);
-            const prevCharCode = (len > 1 ? lineContent.charCodeAt(len - 2) : CharCode.Null);
-            const isSingleTrailingSpace = (lastCharCode === CharCode.Space && (prevCharCode !== CharCode.Space && prevCharCode !== CharCode.Tab));
+            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;
             }
@@ -635,11 +610,11 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
         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', LinePartMetadata.IS_WHITESPACE, false)));
+                result[resultLen++] = ( (new LinePart(i, 'mtkw', 1 , false)));
             }
         }
         else {
-            result[resultLen++] = ( (new LinePart(len, 'mtkw', LinePartMetadata.IS_WHITESPACE, false)));
+            result[resultLen++] = ( (new LinePart(len, 'mtkw', 1 , false)));
         }
     }
     else {
@@ -743,7 +718,7 @@ function _renderLine(input, sb) {
         const partEndIndex = part.endIndex;
         const partType = part.type;
         const partContainsRTL = part.containsRTL;
-        const partRendersWhitespace = (renderWhitespace !== RenderWhitespace.None && part.isWhitespace());
+        const partRendersWhitespace = (renderWhitespace !== 0  && part.isWhitespace());
         const partRendersWhitespaceWithWidth = partRendersWhitespace && !fontIsMonospace && (partType === 'mtkw'  || !containsForeignElements);
         const partIsEmptyAndHasPseudoAfter = (charIndex === partEndIndex && part.isPseudoAfter());
         charOffsetInPart = 0;
@@ -753,7 +728,7 @@ function _renderLine(input, sb) {
         }
         sb.appendString('class="');
         sb.appendString(partRendersWhitespaceWithWidth ? 'mtkz' : partType);
-        sb.appendASCIICharCode(CharCode.DoubleQuote);
+        sb.appendASCIICharCode(34 );
         if (partRendersWhitespace) {
             let partWidth = 0;
             {
@@ -761,7 +736,7 @@ function _renderLine(input, sb) {
                 let _visibleColumn = visibleColumn;
                 for (; _charIndex < partEndIndex; _charIndex++) {
                     const charCode = lineContent.charCodeAt(_charIndex);
-                    const charWidth = (charCode === CharCode.Tab ? (tabSize - (_visibleColumn % tabSize)) : 1) | 0;
+                    const charWidth = (charCode === 9  ? (tabSize - (_visibleColumn % tabSize)) : 1) | 0;
                     partWidth += charWidth;
                     if (_charIndex >= fauxIndentLength) {
                         _visibleColumn += charWidth;
@@ -773,14 +748,14 @@ function _renderLine(input, sb) {
                 sb.appendString(String(spaceWidth * partWidth));
                 sb.appendString('px"');
             }
-            sb.appendASCIICharCode(CharCode.GreaterThan);
+            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 === CharCode.Tab) {
+                if (charCode === 9 ) {
                     producedCharacters = (tabSize - (visibleColumn % tabSize)) | 0;
                     charWidth = producedCharacters;
                     if (!canUseHalfwidthRightwardsArrow || charWidth > 1) {
@@ -807,7 +782,7 @@ function _renderLine(input, sb) {
             }
         }
         else {
-            sb.appendASCIICharCode(CharCode.GreaterThan);
+            sb.appendASCIICharCode(62 );
             for (; charIndex < partEndIndex; charIndex++) {
                 characterMapping.setColumnInfo(charIndex + 1, partIndex - partDisplacement, charOffsetInPart, charHorizontalOffset);
                 partDisplacement = 0;
@@ -815,26 +790,26 @@ function _renderLine(input, sb) {
                 let producedCharacters = 1;
                 let charWidth = 1;
                 switch (charCode) {
-                    case CharCode.Tab:
+                    case 9 :
                         producedCharacters = (tabSize - (visibleColumn % tabSize));
                         charWidth = producedCharacters;
                         for (let space = 1; space <= producedCharacters; space++) {
                             sb.appendCharCode(0xA0);
                         }
                         break;
-                    case CharCode.Space:
+                    case 32 :
                         sb.appendCharCode(0xA0);
                         break;
-                    case CharCode.LessThan:
+                    case 60 :
                         sb.appendString('&lt;');
                         break;
-                    case CharCode.GreaterThan:
+                    case 62 :
                         sb.appendString('&gt;');
                         break;
-                    case CharCode.Ampersand:
+                    case 38 :
                         sb.appendString('&amp;');
                         break;
-                    case CharCode.Null:
+                    case 0 :
                         if (renderControlCharacters) {
                             sb.appendCharCode(9216);
                         }
@@ -842,10 +817,10 @@ function _renderLine(input, sb) {
                             sb.appendString('&#00;');
                         }
                         break;
-                    case CharCode.UTF8_BOM:
-                    case CharCode.LINE_SEPARATOR:
-                    case CharCode.PARAGRAPH_SEPARATOR:
-                    case CharCode.NEXT_LINE:
+                    case 65279 :
+                    case 8232 :
+                    case 8233 :
+                    case 133 :
                         sb.appendCharCode(0xFFFD);
                         break;
                     default:
@@ -893,7 +868,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
-        sb.appendString(( localize(9987, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(9459, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
@@ -906,11 +881,11 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return ( localize(9988, "{0} chars", n));
+        return ( localize(9460, "{0} chars", n));
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;
     }
     return `${(n / 1024 / 1024).toFixed(1)} MB`;
 }
-export { CharacterMapping, DomPosition, ForeignElementType, LineRange, RenderLineInput, RenderLineOutput, RenderLineOutput2, RenderWhitespace, renderViewLine, renderViewLine2 };
+export { CharacterMapping, DomPosition, LineRange, RenderLineInput, RenderLineOutput, RenderLineOutput2, renderViewLine, renderViewLine2 };

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

@@ -2,7 +2,6 @@ import { Emitter } from '../../../base/common/event.js';
 import { Disposable, markAsSingleton } from '../../../base/common/lifecycle.js';
 import { RGBA8 } from '../core/rgba.js';
 import { TokenizationRegistry } from '../languages.js';
-import { ColorId } from '../encodedTokenAttributes.js';
 class MinimapTokensColorTracker extends Disposable {
     static { this._INSTANCE = null; }
     static getInstance() {
@@ -34,13 +33,13 @@ class MinimapTokensColorTracker extends Disposable {
             const source = colorMap[colorId].rgba;
             this._colors[colorId] = ( new RGBA8(source.r, source.g, source.b, Math.round(source.a * 255)));
         }
-        const backgroundLuminosity = colorMap[ColorId.DefaultBackground].getRelativeLuminance();
+        const backgroundLuminosity = colorMap[2 ].getRelativeLuminance();
         this._backgroundIsLight = backgroundLuminosity >= 0.5;
         this._onDidChange.fire(undefined);
     }
     getColor(colorId) {
         if (colorId < 1 || colorId >= this._colors.length) {
-            colorId = ColorId.DefaultBackground;
+            colorId = 2 ;
         }
         return this._colors[colorId];
     }

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

@@ -1,6 +1,5 @@
 import { LineTokens } from '../tokens/lineTokens.js';
 import { Position } from '../core/position.js';
-import { PositionAffinity } from '../model.js';
 import { LineInjectedText } from '../textModelEvents.js';
 import { SingleLineInlineDecoration, ViewLineData } from '../viewModel.js';
 function createModelLineProjection(lineBreakData, isVisible) {
@@ -125,11 +124,28 @@ class ModelLineProjection {
         }
         let lineWithInjections;
         if (injectionOffsets) {
-            lineWithInjections = model.tokenization.getLineTokens(modelLineNumber).withInserted(( injectionOffsets.map((offset, idx) => ({
-                offset,
-                text: injectionOptions[idx].content,
-                tokenMetadata: LineTokens.defaultTokenMetadata
-            }))));
+            const tokensToInsert = [];
+            for (let idx = 0; idx < injectionOffsets.length; idx++) {
+                const offset = injectionOffsets[idx];
+                const tokens = injectionOptions[idx].tokens;
+                if (tokens) {
+                    tokens.forEach((range, info) => {
+                        tokensToInsert.push({
+                            offset,
+                            text: range.substring(injectionOptions[idx].content),
+                            tokenMetadata: info.metadata,
+                        });
+                    });
+                }
+                else {
+                    tokensToInsert.push({
+                        offset,
+                        text: injectionOptions[idx].content,
+                        tokenMetadata: LineTokens.defaultTokenMetadata,
+                    });
+                }
+            }
+            lineWithInjections = model.tokenization.getLineTokens(modelLineNumber).withInserted(tokensToInsert);
         }
         else {
             lineWithInjections = model.tokenization.getLineTokens(modelLineNumber);
@@ -172,7 +188,7 @@ class ModelLineProjection {
         this._assertVisible();
         return this._projectionData.translateToInputOffset(outputLineIndex, outputColumn - 1) + 1;
     }
-    getViewPositionOfModelPosition(deltaLineNumber, inputColumn, affinity = PositionAffinity.None) {
+    getViewPositionOfModelPosition(deltaLineNumber, inputColumn, affinity = 2 ) {
         this._assertVisible();
         const r = this._projectionData.translateToOutputPosition(inputColumn - 1, affinity);
         return r.toPosition(deltaLineNumber);

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

@@ -1,14 +1,12 @@
-import { CharCode } from '../../../base/common/charCode.js';
 import { isHighSurrogate, isLowSurrogate, firstNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
-import { EditorOption, WrappingIndent } from '../config/editorOptions.js';
 import { CharacterClassifier } from '../core/characterClassifier.js';
 import { LineInjectedText } from '../textModelEvents.js';
 import { ModelLineProjectionData } from '../modelLineProjectionData.js';
 class MonospaceLineBreaksComputerFactory {
     static create(options) {
         return ( new MonospaceLineBreaksComputerFactory(
-            options.get(EditorOption.wordWrapBreakBeforeCharacters),
-            options.get(EditorOption.wordWrapBreakAfterCharacters)
+            options.get(137 ),
+            options.get(136 )
         ));
     }
     constructor(breakBeforeChars, breakAfterChars) {
@@ -44,21 +42,14 @@ class MonospaceLineBreaksComputerFactory {
         };
     }
 }
-var CharacterClass;
-( (function(CharacterClass) {
-    CharacterClass[CharacterClass["NONE"] = 0] = "NONE";
-    CharacterClass[CharacterClass["BREAK_BEFORE"] = 1] = "BREAK_BEFORE";
-    CharacterClass[CharacterClass["BREAK_AFTER"] = 2] = "BREAK_AFTER";
-    CharacterClass[CharacterClass["BREAK_IDEOGRAPHIC"] = 3] = "BREAK_IDEOGRAPHIC";
-})(CharacterClass || (CharacterClass = {})));
 class WrappingCharacterClassifier extends CharacterClassifier {
     constructor(BREAK_BEFORE, BREAK_AFTER) {
-        super(CharacterClass.NONE);
+        super(0 );
         for (let i = 0; i < BREAK_BEFORE.length; i++) {
-            this.set(BREAK_BEFORE.charCodeAt(i), CharacterClass.BREAK_BEFORE);
+            this.set(BREAK_BEFORE.charCodeAt(i), 1 );
         }
         for (let i = 0; i < BREAK_AFTER.length; i++) {
-            this.set(BREAK_AFTER.charCodeAt(i), CharacterClass.BREAK_AFTER);
+            this.set(BREAK_AFTER.charCodeAt(i), 2 );
         }
     }
     get(charCode) {
@@ -69,7 +60,7 @@ class WrappingCharacterClassifier extends CharacterClassifier {
             if ((charCode >= 0x3040 && charCode <= 0x30FF)
                 || (charCode >= 0x3400 && charCode <= 0x4DBF)
                 || (charCode >= 0x4E00 && charCode <= 0x9FFF)) {
-                return CharacterClass.BREAK_IDEOGRAPHIC;
+                return 3 ;
             }
             return (this._map.get(charCode) || this._defaultValue);
         }
@@ -122,8 +113,8 @@ function createLineBreaksFromPreviousLineBreaks(classifier, previousBreakingData
         let forcedBreakOffsetVisibleColumn = 0;
         if (prevBreakOffsetVisibleColumn <= breakingColumn) {
             let visibleColumn = prevBreakOffsetVisibleColumn;
-            let prevCharCode = prevBreakOffset === 0 ? CharCode.Null : lineText.charCodeAt(prevBreakOffset - 1);
-            let prevCharCodeClass = prevBreakOffset === 0 ? CharacterClass.NONE : classifier.get(prevCharCode);
+            let prevCharCode = prevBreakOffset === 0 ? 0  : lineText.charCodeAt(prevBreakOffset - 1);
+            let prevCharCodeClass = prevBreakOffset === 0 ? 0  : classifier.get(prevCharCode);
             let entireLineFits = true;
             for (let i = prevBreakOffset; i < len; i++) {
                 const charStartOffset = i;
@@ -132,7 +123,7 @@ function createLineBreaksFromPreviousLineBreaks(classifier, previousBreakingData
                 let charWidth;
                 if (isHighSurrogate(charCode)) {
                     i++;
-                    charCodeClass = CharacterClass.NONE;
+                    charCodeClass = 0 ;
                     charWidth = 2;
                 }
                 else {
@@ -179,7 +170,7 @@ function createLineBreaksFromPreviousLineBreaks(classifier, previousBreakingData
             for (let i = prevBreakOffset - 1; i >= lastBreakingOffset; i--) {
                 const charStartOffset = i + 1;
                 const prevCharCode = lineText.charCodeAt(i);
-                if (prevCharCode === CharCode.Tab) {
+                if (prevCharCode === 9 ) {
                     hitATabCharacter = true;
                     break;
                 }
@@ -187,7 +178,7 @@ function createLineBreaksFromPreviousLineBreaks(classifier, previousBreakingData
                 let prevCharWidth;
                 if (isLowSurrogate(prevCharCode)) {
                     i--;
-                    prevCharCodeClass = CharacterClass.NONE;
+                    prevCharCodeClass = 0 ;
                     prevCharWidth = 2;
                 }
                 else {
@@ -330,7 +321,7 @@ function createLineBreaks(classifier, _lineText, injectedTexts, tabSize, firstLi
         let charWidth;
         if (isHighSurrogate(charCode)) {
             i++;
-            charCodeClass = CharacterClass.NONE;
+            charCodeClass = 0 ;
             charWidth = 2;
         }
         else {
@@ -370,7 +361,7 @@ function createLineBreaks(classifier, _lineText, injectedTexts, tabSize, firstLi
     ));
 }
 function computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar) {
-    if (charCode === CharCode.Tab) {
+    if (charCode === 9 ) {
         return (tabSize - (visibleColumn % tabSize));
     }
     if (isFullWidthCharacter(charCode)) {
@@ -385,22 +376,20 @@ function tabCharacterWidth(visibleColumn, tabSize) {
     return (tabSize - (visibleColumn % tabSize));
 }
 function canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll) {
-    return (charCode !== CharCode.Space
-        && ((prevCharCodeClass === CharacterClass.BREAK_AFTER && charCodeClass !== CharacterClass.BREAK_AFTER)
-            || (prevCharCodeClass !== CharacterClass.BREAK_BEFORE && charCodeClass === CharacterClass.BREAK_BEFORE)
-            || (!isKeepAll && prevCharCodeClass === CharacterClass.BREAK_IDEOGRAPHIC && charCodeClass !== CharacterClass.BREAK_AFTER)
-            || (!isKeepAll && charCodeClass === CharacterClass.BREAK_IDEOGRAPHIC && prevCharCodeClass !== CharacterClass.BREAK_BEFORE)));
+    return (charCode !== 32  && (((prevCharCodeClass === 2  && charCodeClass !== 2) )
+            || ((prevCharCodeClass !== 1  && charCodeClass === 1) )
+            || ((!isKeepAll && prevCharCodeClass === 3  && charCodeClass !== 2) ) || (!isKeepAll && charCodeClass === 3  && prevCharCodeClass !== 1) ));
 }
 function computeWrappedTextIndentLength(lineText, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent) {
     let wrappedTextIndentLength = 0;
-    if (wrappingIndent !== WrappingIndent.None) {
+    if (wrappingIndent !== 0 ) {
         const firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineText);
         if (firstNonWhitespaceIndex$1 !== -1) {
             for (let i = 0; i < firstNonWhitespaceIndex$1; i++) {
-                const charWidth = (lineText.charCodeAt(i) === CharCode.Tab ? tabCharacterWidth(wrappedTextIndentLength, tabSize) : 1);
+                const charWidth = (lineText.charCodeAt(i) === 9  ? tabCharacterWidth(wrappedTextIndentLength, tabSize) : 1);
                 wrappedTextIndentLength += charWidth;
             }
-            const numberOfAdditionalTabs = (wrappingIndent === WrappingIndent.DeepIndent ? 2 : wrappingIndent === WrappingIndent.Indent ? 1 : 0);
+            const numberOfAdditionalTabs = (wrappingIndent === 3  ? 2 : wrappingIndent === 2  ? 1 : 0);
             for (let i = 0; i < numberOfAdditionalTabs; i++) {
                 const charWidth = tabCharacterWidth(wrappedTextIndentLength, tabSize);
                 wrappedTextIndentLength += charWidth;