@codingame/monaco-vscode-api 5.3.0 → 6.0.0

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

@@ -1,9 +1,19 @@
 import { localizeWithPath } 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 { LinePart } from './linePart.js';
+import { InlineDecorationType } from '../viewModel.js';
+import { LinePart, LinePartMetadata } from './linePart.js';
 const _moduleId = "vs/editor/common/viewLayout/viewLineRenderer";
+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 = {}))));
 class LineRange {
     constructor(startIndex, endIndex) {
         this.startOffset = startIndex;
@@ -29,13 +39,15 @@ class RenderLineInput {
         this.startVisibleColumn = startVisibleColumn;
         this.spaceWidth = spaceWidth;
         this.stopRenderingLineAfter = stopRenderingLineAfter;
-        this.renderWhitespace = ((renderWhitespace === 'all' ? 4  : renderWhitespace === 'boundary'
-                ? 1
+        this.renderWhitespace = (renderWhitespace === 'all'
+            ? RenderWhitespace.All
+            : renderWhitespace === 'boundary'
+                ? RenderWhitespace.Boundary
                 : renderWhitespace === 'selection'
-                    ? 2
+                    ? RenderWhitespace.Selection
                     : renderWhitespace === 'trailing'
-                        ? 3
-                        : 0) );
+                        ? RenderWhitespace.Trailing
+                        : RenderWhitespace.None);
         this.renderControlCharacters = renderControlCharacters;
         this.fontLigatures = fontLigatures;
         this.selectionsOnLine = selectionsOnLine && selectionsOnLine.sort((a, b) => a.startOffset < b.startOffset ? -1 : 1);
@@ -89,6 +101,13 @@ 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;
@@ -97,10 +116,10 @@ class DomPosition {
 }
 class CharacterMapping {
     static getPartIndex(partData) {
-        return ((partData & 4294901760) ) >>> 16 ;
+        return (partData & CharacterMappingConstants.PART_INDEX_MASK) >>> CharacterMappingConstants.PART_INDEX_OFFSET;
     }
     static getCharIndex(partData) {
-        return ((partData & 65535) ) >>> 0 ;
+        return (partData & CharacterMappingConstants.CHAR_INDEX_MASK) >>> CharacterMappingConstants.CHAR_INDEX_OFFSET;
     }
     constructor(length, partCount) {
         this.length = length;
@@ -108,8 +127,8 @@ class CharacterMapping {
         this._horizontalOffset = ( (new Uint32Array(this.length)));
     }
     setColumnInfo(column, partIndex, charIndex, horizontalOffset) {
-        const partData = (((partIndex << 16) )
-            | ((charIndex << 0) )) >>> 0;
+        const partData = ((partIndex << CharacterMappingConstants.PART_INDEX_OFFSET)
+            | (charIndex << CharacterMappingConstants.CHAR_INDEX_OFFSET)) >>> 0;
         this._data[column - 1] = partData;
         this._horizontalOffset[column - 1] = horizontalOffset;
     }
@@ -147,8 +166,8 @@ class CharacterMapping {
         if (this.length === 0) {
             return 0;
         }
-        const searchEntry = (((partIndex << 16) )
-            | ((charIndex << 0) )) >>> 0;
+        const searchEntry = ((partIndex << CharacterMappingConstants.PART_INDEX_OFFSET)
+            | (charIndex << CharacterMappingConstants.CHAR_INDEX_OFFSET)) >>> 0;
         let min = 0;
         let max = this.length - 1;
         while (min + 1 < max) {
@@ -204,6 +223,12 @@ 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;
@@ -218,18 +243,18 @@ function renderViewLine(input, sb) {
             sb.appendString(`<span>`);
             let beforeCount = 0;
             let afterCount = 0;
-            let containsForeignElements = 0 ;
+            let containsForeignElements = ForeignElementType.None;
             for (const lineDecoration of input.lineDecorations) {
-                if (lineDecoration.type === 1  || lineDecoration.type === 2 ) {
+                if (lineDecoration.type === InlineDecorationType.Before || lineDecoration.type === InlineDecorationType.After) {
                     sb.appendString(`<span class="`);
                     sb.appendString(lineDecoration.className);
                     sb.appendString(`"></span>`);
-                    if (lineDecoration.type === 1 ) {
-                        containsForeignElements |= 1 ;
+                    if (lineDecoration.type === InlineDecorationType.Before) {
+                        containsForeignElements |= ForeignElementType.Before;
                         beforeCount++;
                     }
-                    if (lineDecoration.type === 2 ) {
-                        containsForeignElements |= 2 ;
+                    if (lineDecoration.type === InlineDecorationType.After) {
+                        containsForeignElements |= ForeignElementType.After;
                         afterCount++;
                     }
                 }
@@ -243,11 +268,7 @@ function renderViewLine(input, sb) {
         }
         sb.appendString('<span><span></span></span>');
         return (
-             (new RenderLineOutput(
-                 (new CharacterMapping(0, 0)),
-                false,
-                0
-            ))
+             (new RenderLineOutput( (new CharacterMapping(0, 0)), false, ForeignElementType.None))
         );
     }
     return _renderLine(resolveRenderLineInput(input), sb);
@@ -311,24 +332,24 @@ function resolveRenderLineInput(input) {
     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)) {
+    if (input.renderWhitespace === RenderWhitespace.All ||
+        input.renderWhitespace === RenderWhitespace.Boundary ||
+        (input.renderWhitespace === RenderWhitespace.Selection && !!input.selectionsOnLine) ||
+        (input.renderWhitespace === RenderWhitespace.Trailing && !input.continuesWithWrappedLine)) {
         tokens = _applyRenderWhitespace(input, lineContent, len, tokens);
     }
-    let containsForeignElements = 0 ;
+    let containsForeignElements = ForeignElementType.None;
     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 ;
+            if (lineDecoration.type === InlineDecorationType.RegularAffectingLetterSpacing) {
+                containsForeignElements |= ForeignElementType.Before;
             }
-            else if (lineDecoration.type === 1 ) {
-                containsForeignElements |= 1 ;
+            else if (lineDecoration.type === InlineDecorationType.Before) {
+                containsForeignElements |= ForeignElementType.Before;
             }
-            else if (lineDecoration.type === 2 ) {
-                containsForeignElements |= 2 ;
+            else if (lineDecoration.type === InlineDecorationType.After) {
+                containsForeignElements |= ForeignElementType.After;
             }
         }
         tokens = _applyInlineDecorations(lineContent, len, tokens, input.lineDecorations);
@@ -381,6 +402,10 @@ 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 = [];
@@ -389,17 +414,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 + 50  < tokenEndIndex) {
+            if (lastTokenEndIndex + Constants.LongToken < 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 ) {
+                    if (lineContent.charCodeAt(j) === CharCode.Space) {
                         lastSpaceOffset = j;
                     }
-                    if (lastSpaceOffset !== -1 && j - currTokenStart >= 50 ) {
+                    if (lastSpaceOffset !== -1 && j - currTokenStart >= Constants.LongToken) {
                         result[resultLen++] = ( (new LinePart(lastSpaceOffset + 1, tokenType, tokenMetadata, tokenContainsRTL)));
                         currTokenStart = lastSpaceOffset + 1;
                         lastSpaceOffset = -1;
@@ -420,13 +445,13 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
             const token = tokens[i];
             const tokenEndIndex = token.endIndex;
             const diff = (tokenEndIndex - lastTokenEndIndex);
-            if (diff > 50 ) {
+            if (diff > Constants.LongToken) {
                 const tokenType = token.type;
                 const tokenMetadata = token.metadata;
                 const tokenContainsRTL = token.containsRTL;
-                const piecesCount = Math.ceil(diff / 50 );
+                const piecesCount = Math.ceil(diff / Constants.LongToken);
                 for (let j = 1; j < piecesCount; j++) {
-                    const pieceEndIndex = lastTokenEndIndex + ((j * 50) );
+                    const pieceEndIndex = lastTokenEndIndex + (j * Constants.LongToken);
                     result[resultLen++] = ( (new LinePart(pieceEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
                 }
                 result[resultLen++] = ( (new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
@@ -441,7 +466,7 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
 }
 function isControlCharacter(charCode) {
     if (charCode < 32) {
-        return (charCode !== 9) ;
+        return (charCode !== CharCode.Tab);
     }
     if (charCode === 127) {
         return true;
@@ -485,8 +510,8 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
     const startVisibleColumn = input.startVisibleColumn;
     const useMonospaceOptimizations = input.useMonospaceOptimizations;
     const selections = input.selectionsOnLine;
-    const onlyBoundary = ((input.renderWhitespace === 1) );
-    const onlyTrailing = ((input.renderWhitespace === 3) );
+    const onlyBoundary = (input.renderWhitespace === RenderWhitespace.Boundary);
+    const onlyTrailing = (input.renderWhitespace === RenderWhitespace.Trailing);
     const generateLinePartForEachWhitespace = (input.renderSpaceWidth !== input.spaceWidth);
     const result = [];
     let resultLen = 0;
@@ -520,17 +545,17 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
         if (charIndex < firstNonWhitespaceIndex$1 || charIndex > lastNonWhitespaceIndex$1) {
             isInWhitespace = true;
         }
-        else if (chCode === 9 ) {
+        else if (chCode === CharCode.Tab) {
             isInWhitespace = true;
         }
-        else if (chCode === 32 ) {
+        else if (chCode === CharCode.Space) {
             if (onlyBoundary) {
                 if (wasInWhitespace) {
                     isInWhitespace = true;
                 }
                 else {
-                    const nextChCode = ((charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0) );
-                    isInWhitespace = ((nextChCode === 32  || nextChCode === 9) );
+                    const nextChCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : CharCode.Null);
+                    isInWhitespace = (nextChCode === CharCode.Space || nextChCode === CharCode.Tab);
                 }
             }
             else {
@@ -556,11 +581,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', 1 , false)));
+                        result[resultLen++] = ( (new LinePart(i, 'mtkw', LinePartMetadata.IS_WHITESPACE, false)));
                     }
                 }
                 else {
-                    result[resultLen++] = ( (new LinePart(charIndex, 'mtkw', 1 , false)));
+                    result[resultLen++] = ( (new LinePart(charIndex, 'mtkw', LinePartMetadata.IS_WHITESPACE, false)));
                 }
                 tmpIndent = tmpIndent % tabSize;
             }
@@ -571,7 +596,7 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
                 tmpIndent = tmpIndent % tabSize;
             }
         }
-        if (chCode === 9 ) {
+        if (chCode === CharCode.Tab) {
             tmpIndent = tabSize;
         }
         else if (isFullWidthCharacter(chCode)) {
@@ -596,9 +621,9 @@ function _applyRenderWhitespace(input, lineContent, len, tokens) {
     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) ));
+            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));
             if (!isSingleTrailingSpace) {
                 generateWhitespace = true;
             }
@@ -611,11 +636,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', 1 , false)));
+                result[resultLen++] = ( (new LinePart(i, 'mtkw', LinePartMetadata.IS_WHITESPACE, false)));
             }
         }
         else {
-            result[resultLen++] = ( (new LinePart(len, 'mtkw', 1 , false)));
+            result[resultLen++] = ( (new LinePart(len, 'mtkw', LinePartMetadata.IS_WHITESPACE, false)));
         }
     }
     else {
@@ -719,7 +744,7 @@ function _renderLine(input, sb) {
         const partEndIndex = part.endIndex;
         const partType = part.type;
         const partContainsRTL = part.containsRTL;
-        const partRendersWhitespace = (renderWhitespace !== 0  && part.isWhitespace());
+        const partRendersWhitespace = (renderWhitespace !== RenderWhitespace.None && part.isWhitespace());
         const partRendersWhitespaceWithWidth = partRendersWhitespace && !fontIsMonospace && (partType === 'mtkw'  || !containsForeignElements);
         const partIsEmptyAndHasPseudoAfter = (charIndex === partEndIndex && part.isPseudoAfter());
         charOffsetInPart = 0;
@@ -729,7 +754,7 @@ function _renderLine(input, sb) {
         }
         sb.appendString('class="');
         sb.appendString(partRendersWhitespaceWithWidth ? 'mtkz' : partType);
-        sb.appendASCIICharCode(34 );
+        sb.appendASCIICharCode(CharCode.DoubleQuote);
         if (partRendersWhitespace) {
             let partWidth = 0;
             {
@@ -737,7 +762,7 @@ function _renderLine(input, sb) {
                 let _visibleColumn = visibleColumn;
                 for (; _charIndex < partEndIndex; _charIndex++) {
                     const charCode = lineContent.charCodeAt(_charIndex);
-                    const charWidth = (charCode === 9  ? (tabSize - (_visibleColumn % tabSize)) : 1) | 0;
+                    const charWidth = (charCode === CharCode.Tab ? (tabSize - (_visibleColumn % tabSize)) : 1) | 0;
                     partWidth += charWidth;
                     if (_charIndex >= fauxIndentLength) {
                         _visibleColumn += charWidth;
@@ -749,14 +774,14 @@ function _renderLine(input, sb) {
                 sb.appendString(String(spaceWidth * partWidth));
                 sb.appendString('px"');
             }
-            sb.appendASCIICharCode(62 );
+            sb.appendASCIICharCode(CharCode.GreaterThan);
             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 ) {
+                if (charCode === CharCode.Tab) {
                     producedCharacters = (tabSize - (visibleColumn % tabSize)) | 0;
                     charWidth = producedCharacters;
                     if (!canUseHalfwidthRightwardsArrow || charWidth > 1) {
@@ -783,7 +808,7 @@ function _renderLine(input, sb) {
             }
         }
         else {
-            sb.appendASCIICharCode(62 );
+            sb.appendASCIICharCode(CharCode.GreaterThan);
             for (; charIndex < partEndIndex; charIndex++) {
                 characterMapping.setColumnInfo(charIndex + 1, partIndex - partDisplacement, charOffsetInPart, charHorizontalOffset);
                 partDisplacement = 0;
@@ -791,26 +816,26 @@ function _renderLine(input, sb) {
                 let producedCharacters = 1;
                 let charWidth = 1;
                 switch (charCode) {
-                    case 9 :
+                    case CharCode.Tab:
                         producedCharacters = (tabSize - (visibleColumn % tabSize));
                         charWidth = producedCharacters;
                         for (let space = 1; space <= producedCharacters; space++) {
                             sb.appendCharCode(0xA0);
                         }
                         break;
-                    case 32 :
+                    case CharCode.Space:
                         sb.appendCharCode(0xA0);
                         break;
-                    case 60 :
+                    case CharCode.LessThan:
                         sb.appendString('&lt;');
                         break;
-                    case 62 :
+                    case CharCode.GreaterThan:
                         sb.appendString('&gt;');
                         break;
-                    case 38 :
+                    case CharCode.Ampersand:
                         sb.appendString('&amp;');
                         break;
-                    case 0 :
+                    case CharCode.Null:
                         if (renderControlCharacters) {
                             sb.appendCharCode(9216);
                         }
@@ -818,10 +843,10 @@ function _renderLine(input, sb) {
                             sb.appendString('&#00;');
                         }
                         break;
-                    case 65279 :
-                    case 8232 :
-                    case 8233 :
-                    case 133 :
+                    case CharCode.UTF8_BOM:
+                    case CharCode.LINE_SEPARATOR:
+                    case CharCode.PARAGRAPH_SEPARATOR:
+                    case CharCode.NEXT_LINE:
                         sb.appendCharCode(0xFFFD);
                         break;
                     default:
@@ -894,4 +919,4 @@ function renderOverflowingCharCount(n) {
     }
     return `${(n / 1024 / 1024).toFixed(1)} MB`;
 }
-export { CharacterMapping, DomPosition, LineRange, RenderLineInput, RenderLineOutput, RenderLineOutput2, renderViewLine, renderViewLine2 };
+export { CharacterMapping, DomPosition, ForeignElementType, LineRange, RenderLineInput, RenderLineOutput, RenderLineOutput2, RenderWhitespace, renderViewLine, renderViewLine2 };

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

@@ -2,6 +2,7 @@ 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() {
@@ -33,13 +34,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[2 ].getRelativeLuminance();
+        const backgroundLuminosity = colorMap[ColorId.DefaultBackground].getRelativeLuminance();
         this._backgroundIsLight = backgroundLuminosity >= 0.5;
         this._onDidChange.fire(undefined);
     }
     getColor(colorId) {
         if (colorId < 1 || colorId >= this._colors.length) {
-            colorId = 2 ;
+            colorId = ColorId.DefaultBackground;
         }
         return this._colors[colorId];
     }

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

@@ -1,5 +1,6 @@
 import { LineTokens } from '../tokens/lineTokens.js';
 import { Position } from '../core/position.js';
+import { PositionAffinity } from '../model.js';
 import { LineInjectedText } from '../textModelEvents.js';
 import { ViewLineData, SingleLineInlineDecoration } from '../viewModel.js';
 function createModelLineProjection(lineBreakData, isVisible) {
@@ -171,7 +172,7 @@ class ModelLineProjection {
         this._assertVisible();
         return this._projectionData.translateToInputOffset(outputLineIndex, outputColumn - 1) + 1;
     }
-    getViewPositionOfModelPosition(deltaLineNumber, inputColumn, affinity = 2 ) {
+    getViewPositionOfModelPosition(deltaLineNumber, inputColumn, affinity = PositionAffinity.None) {
         this._assertVisible();
         const r = this._projectionData.translateToOutputPosition(inputColumn - 1, affinity);
         return r.toPosition(deltaLineNumber);

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

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

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

@@ -1,3 +1,7 @@
+var Constants;
+( (function(Constants) {
+    Constants[Constants["MINIMUM_HEIGHT"] = 4] = "MINIMUM_HEIGHT";
+})(Constants || (Constants = {})));
 class ColorZone {
     constructor(from, to, colorId) {
         this._colorZoneBrand = undefined;
@@ -121,7 +125,7 @@ class OverviewZoneManager {
         const totalHeight = Math.floor(this.getCanvasHeight());
         const outerHeight = Math.floor(this._outerHeight);
         const heightRatio = totalHeight / outerHeight;
-        const halfMinimumHeight = Math.floor(4  * this._pixelRatio / 2);
+        const halfMinimumHeight = Math.floor(Constants.MINIMUM_HEIGHT * this._pixelRatio / 2);
         const allColorZones = [];
         for (let i = 0, len = this._zones.length; i < len; i++) {
             const zone = this._zones[i];