@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/editor/common/model/intervalTree.js

@@ -1,38 +1,77 @@
+import { TrackedRangeStickiness } from '../model.js';
+var ClassName;
+( (function(ClassName) {
+    ClassName["EditorHintDecoration"] = "squiggly-hint";
+    ClassName["EditorInfoDecoration"] = "squiggly-info";
+    ClassName["EditorWarningDecoration"] = "squiggly-warning";
+    ClassName["EditorErrorDecoration"] = "squiggly-error";
+    ClassName["EditorUnnecessaryDecoration"] = "squiggly-unnecessary";
+    ClassName["EditorUnnecessaryInlineDecoration"] = "squiggly-inline-unnecessary";
+    ClassName["EditorDeprecatedInlineDecoration"] = "squiggly-inline-deprecated";
+})(ClassName || (ClassName = {})));
+var NodeColor;
+( (function(NodeColor) {
+    NodeColor[NodeColor["Black"] = 0] = "Black";
+    NodeColor[NodeColor["Red"] = 1] = "Red";
+})(NodeColor || (NodeColor = {})));
+var Constants;
+( (function(Constants) {
+    Constants[Constants["ColorMask"] = 1] = "ColorMask";
+    Constants[Constants["ColorMaskInverse"] = 254] = "ColorMaskInverse";
+    Constants[Constants["ColorOffset"] = 0] = "ColorOffset";
+    Constants[Constants["IsVisitedMask"] = 2] = "IsVisitedMask";
+    Constants[Constants["IsVisitedMaskInverse"] = 253] = "IsVisitedMaskInverse";
+    Constants[Constants["IsVisitedOffset"] = 1] = "IsVisitedOffset";
+    Constants[Constants["IsForValidationMask"] = 4] = "IsForValidationMask";
+    Constants[Constants["IsForValidationMaskInverse"] = 251] = "IsForValidationMaskInverse";
+    Constants[Constants["IsForValidationOffset"] = 2] = "IsForValidationOffset";
+    Constants[Constants["StickinessMask"] = 24] = "StickinessMask";
+    Constants[Constants["StickinessMaskInverse"] = 231] = "StickinessMaskInverse";
+    Constants[Constants["StickinessOffset"] = 3] = "StickinessOffset";
+    Constants[Constants["CollapseOnReplaceEditMask"] = 32] = "CollapseOnReplaceEditMask";
+    Constants[Constants["CollapseOnReplaceEditMaskInverse"] = 223] = "CollapseOnReplaceEditMaskInverse";
+    Constants[Constants["CollapseOnReplaceEditOffset"] = 5] = "CollapseOnReplaceEditOffset";
+    Constants[Constants["IsMarginMask"] = 64] = "IsMarginMask";
+    Constants[Constants["IsMarginMaskInverse"] = 191] = "IsMarginMaskInverse";
+    Constants[Constants["IsMarginOffset"] = 6] = "IsMarginOffset";
+    Constants[Constants["MIN_SAFE_DELTA"] = -1073741824] = "MIN_SAFE_DELTA";
+    Constants[Constants["MAX_SAFE_DELTA"] = 1073741824] = "MAX_SAFE_DELTA";
+})(Constants || (Constants = {})));
 function getNodeColor(node) {
-    return ((node.metadata & 1)  >>> 0) ;
+    return ((node.metadata & Constants.ColorMask) >>> Constants.ColorOffset);
 }
 function setNodeColor(node, color) {
-    node.metadata = (((node.metadata & 254) ) | ((color << 0) ));
+    node.metadata = ((node.metadata & Constants.ColorMaskInverse) | (color << Constants.ColorOffset));
 }
 function getNodeIsVisited(node) {
-    return (((node.metadata & 2)  >>> 1) ) === 1;
+    return ((node.metadata & Constants.IsVisitedMask) >>> Constants.IsVisitedOffset) === 1;
 }
 function setNodeIsVisited(node, value) {
-    node.metadata = (((node.metadata & 253) ) | (((value ? 1 : 0) << 1) ));
+    node.metadata = ((node.metadata & Constants.IsVisitedMaskInverse) | ((value ? 1 : 0) << Constants.IsVisitedOffset));
 }
 function getNodeIsForValidation(node) {
-    return (((node.metadata & 4)  >>> 2) ) === 1;
+    return ((node.metadata & Constants.IsForValidationMask) >>> Constants.IsForValidationOffset) === 1;
 }
 function setNodeIsForValidation(node, value) {
-    node.metadata = (((node.metadata & 251) ) | (((value ? 1 : 0) << 2) ));
+    node.metadata = ((node.metadata & Constants.IsForValidationMaskInverse) | ((value ? 1 : 0) << Constants.IsForValidationOffset));
 }
 function getNodeIsInGlyphMargin(node) {
-    return (((node.metadata & 64)  >>> 6) ) === 1;
+    return ((node.metadata & Constants.IsMarginMask) >>> Constants.IsMarginOffset) === 1;
 }
 function setNodeIsInGlyphMargin(node, value) {
-    node.metadata = (((node.metadata & 191) ) | (((value ? 1 : 0) << 6) ));
+    node.metadata = ((node.metadata & Constants.IsMarginMaskInverse) | ((value ? 1 : 0) << Constants.IsMarginOffset));
 }
 function getNodeStickiness(node) {
-    return ((node.metadata & 24)  >>> 3) ;
+    return ((node.metadata & Constants.StickinessMask) >>> Constants.StickinessOffset);
 }
 function _setNodeStickiness(node, stickiness) {
-    node.metadata = (((node.metadata & 231) ) | ((stickiness << 3) ));
+    node.metadata = ((node.metadata & Constants.StickinessMaskInverse) | (stickiness << Constants.StickinessOffset));
 }
 function getCollapseOnReplaceEdit(node) {
-    return (((node.metadata & 32)  >>> 5) ) === 1;
+    return ((node.metadata & Constants.CollapseOnReplaceEditMask) >>> Constants.CollapseOnReplaceEditOffset) === 1;
 }
 function setCollapseOnReplaceEdit(node, value) {
-    node.metadata = (((node.metadata & 223) ) | (((value ? 1 : 0) << 5) ));
+    node.metadata = ((node.metadata & Constants.CollapseOnReplaceEditMaskInverse) | ((value ? 1 : 0) << Constants.CollapseOnReplaceEditOffset));
 }
 class IntervalNode {
     constructor(id, start, end) {
@@ -40,7 +79,7 @@ class IntervalNode {
         this.parent = this;
         this.left = this;
         this.right = this;
-        setNodeColor(this, 1 );
+        setNodeColor(this, NodeColor.Red);
         this.start = start;
         this.end = end;
         this.delta = 0;
@@ -50,7 +89,7 @@ class IntervalNode {
         this.options = null;
         setNodeIsForValidation(this, false);
         setNodeIsInGlyphMargin(this, false);
-        _setNodeStickiness(this, 1 );
+        _setNodeStickiness(this, TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges);
         setCollapseOnReplaceEdit(this, false);
         this.cachedVersionId = 0;
         this.cachedAbsoluteStart = start;
@@ -70,8 +109,9 @@ class IntervalNode {
     setOptions(options) {
         this.options = options;
         const className = this.options.className;
-        setNodeIsForValidation(this, ((className === "squiggly-error"
-            || className === "squiggly-warning"  || className === "squiggly-info") ));
+        setNodeIsForValidation(this, (className === ClassName.EditorErrorDecoration
+            || className === ClassName.EditorWarningDecoration
+            || className === ClassName.EditorInfoDecoration));
         setNodeIsInGlyphMargin(this, this.options.glyphMarginClassName !== null);
         _setNodeStickiness(this, this.options.stickiness);
         setCollapseOnReplaceEdit(this, this.options.collapseOnReplaceEdit);
@@ -94,7 +134,7 @@ const SENTINEL = ( new IntervalNode(null, 0, 0));
 SENTINEL.parent = SENTINEL;
 SENTINEL.left = SENTINEL;
 SENTINEL.right = SENTINEL;
-setNodeColor(SENTINEL, 0 );
+setNodeColor(SENTINEL, NodeColor.Black);
 class IntervalTree {
     constructor() {
         this.root = SENTINEL;
@@ -196,6 +236,12 @@ function normalizeDelta(T) {
     }
     setNodeIsVisited(T.root, false);
 }
+var MarkerMoveSemantics;
+( (function(MarkerMoveSemantics) {
+    MarkerMoveSemantics[MarkerMoveSemantics["MarkerDefined"] = 0] = "MarkerDefined";
+    MarkerMoveSemantics[MarkerMoveSemantics["ForceMove"] = 1] = "ForceMove";
+    MarkerMoveSemantics[MarkerMoveSemantics["ForceStay"] = 2] = "ForceStay";
+})(MarkerMoveSemantics || (MarkerMoveSemantics = {})));
 function adjustMarkerBeforeColumn(markerOffset, markerStickToPreviousCharacter, checkOffset, moveSemantics) {
     if (markerOffset < checkOffset) {
         return true;
@@ -203,18 +249,20 @@ function adjustMarkerBeforeColumn(markerOffset, markerStickToPreviousCharacter,
     if (markerOffset > checkOffset) {
         return false;
     }
-    if (moveSemantics === 1 ) {
+    if (moveSemantics === MarkerMoveSemantics.ForceMove) {
         return false;
     }
-    if (moveSemantics === 2 ) {
+    if (moveSemantics === MarkerMoveSemantics.ForceStay) {
         return true;
     }
     return markerStickToPreviousCharacter;
 }
 function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {
     const nodeStickiness = getNodeStickiness(node);
-    const startStickToPreviousCharacter = ((nodeStickiness === 0  || nodeStickiness === 2) );
-    const endStickToPreviousCharacter = ((nodeStickiness === 1  || nodeStickiness === 2) );
+    const startStickToPreviousCharacter = (nodeStickiness === TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges
+        || nodeStickiness === TrackedRangeStickiness.GrowsOnlyWhenTypingBefore);
+    const endStickToPreviousCharacter = (nodeStickiness === TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+        || nodeStickiness === TrackedRangeStickiness.GrowsOnlyWhenTypingBefore);
     const deletingCnt = (end - start);
     const insertingCnt = textLength;
     const commonLength = Math.min(deletingCnt, insertingCnt);
@@ -229,7 +277,7 @@ function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {
         endDone = true;
     }
     {
-        const moveSemantics = forceMoveMarkers ? 1  : ((deletingCnt > 0 ? 2  : 0) );
+        const moveSemantics = forceMoveMarkers ? MarkerMoveSemantics.ForceMove : (deletingCnt > 0 ? MarkerMoveSemantics.ForceStay : MarkerMoveSemantics.MarkerDefined);
         if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start, moveSemantics)) {
             startDone = true;
         }
@@ -238,7 +286,7 @@ function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {
         }
     }
     if (commonLength > 0 && !forceMoveMarkers) {
-        const moveSemantics = ((deletingCnt > insertingCnt ? 2  : 0) );
+        const moveSemantics = (deletingCnt > insertingCnt ? MarkerMoveSemantics.ForceStay : MarkerMoveSemantics.MarkerDefined);
         if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start + commonLength, moveSemantics)) {
             startDone = true;
         }
@@ -247,7 +295,7 @@ function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {
         }
     }
     {
-        const moveSemantics = forceMoveMarkers ? 1  : 0 ;
+        const moveSemantics = forceMoveMarkers ? MarkerMoveSemantics.ForceMove : MarkerMoveSemantics.MarkerDefined;
         if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, end, moveSemantics)) {
             node.start = start + insertingCnt;
             startDone = true;
@@ -350,7 +398,7 @@ function noOverlapReplace(T, start, end, textLength) {
             node.start += editDelta;
             node.end += editDelta;
             node.delta += editDelta;
-            if (node.delta < -1073741824  || node.delta > 1073741824 ) {
+            if (node.delta < Constants.MIN_SAFE_DELTA || node.delta > Constants.MAX_SAFE_DELTA) {
                 T.requestNormalizeDelta = true;
             }
             setNodeIsVisited(node, true);
@@ -530,20 +578,20 @@ function rbTreeInsert(T, newNode) {
         newNode.parent = SENTINEL;
         newNode.left = SENTINEL;
         newNode.right = SENTINEL;
-        setNodeColor(newNode, 0 );
+        setNodeColor(newNode, NodeColor.Black);
         T.root = newNode;
         return T.root;
     }
     treeInsert(T, newNode);
     recomputeMaxEndWalkToRoot(newNode.parent);
     let x = newNode;
-    while (x !== T.root && getNodeColor(x.parent) === 1 ) {
+    while (x !== T.root && getNodeColor(x.parent) === NodeColor.Red) {
         if (x.parent === x.parent.parent.left) {
             const y = x.parent.parent.right;
-            if (getNodeColor(y) === 1 ) {
-                setNodeColor(x.parent, 0 );
-                setNodeColor(y, 0 );
-                setNodeColor(x.parent.parent, 1 );
+            if (getNodeColor(y) === NodeColor.Red) {
+                setNodeColor(x.parent, NodeColor.Black);
+                setNodeColor(y, NodeColor.Black);
+                setNodeColor(x.parent.parent, NodeColor.Red);
                 x = x.parent.parent;
             }
             else {
@@ -551,17 +599,17 @@ function rbTreeInsert(T, newNode) {
                     x = x.parent;
                     leftRotate(T, x);
                 }
-                setNodeColor(x.parent, 0 );
-                setNodeColor(x.parent.parent, 1 );
+                setNodeColor(x.parent, NodeColor.Black);
+                setNodeColor(x.parent.parent, NodeColor.Red);
                 rightRotate(T, x.parent.parent);
             }
         }
         else {
             const y = x.parent.parent.left;
-            if (getNodeColor(y) === 1 ) {
-                setNodeColor(x.parent, 0 );
-                setNodeColor(y, 0 );
-                setNodeColor(x.parent.parent, 1 );
+            if (getNodeColor(y) === NodeColor.Red) {
+                setNodeColor(x.parent, NodeColor.Black);
+                setNodeColor(y, NodeColor.Black);
+                setNodeColor(x.parent.parent, NodeColor.Red);
                 x = x.parent.parent;
             }
             else {
@@ -569,13 +617,13 @@ function rbTreeInsert(T, newNode) {
                     x = x.parent;
                     rightRotate(T, x);
                 }
-                setNodeColor(x.parent, 0 );
-                setNodeColor(x.parent.parent, 1 );
+                setNodeColor(x.parent, NodeColor.Black);
+                setNodeColor(x.parent.parent, NodeColor.Red);
                 leftRotate(T, x.parent.parent);
             }
         }
     }
-    setNodeColor(T.root, 0 );
+    setNodeColor(T.root, NodeColor.Black);
     return newNode;
 }
 function treeInsert(T, z) {
@@ -614,7 +662,7 @@ function treeInsert(T, z) {
     z.parent = x;
     z.left = SENTINEL;
     z.right = SENTINEL;
-    setNodeColor(z, 1 );
+    setNodeColor(z, NodeColor.Red);
 }
 function rbTreeDelete(T, z) {
     let x;
@@ -623,7 +671,7 @@ function rbTreeDelete(T, z) {
         x = z.right;
         y = z;
         x.delta += z.delta;
-        if (x.delta < -1073741824  || x.delta > 1073741824 ) {
+        if (x.delta < Constants.MIN_SAFE_DELTA || x.delta > Constants.MAX_SAFE_DELTA) {
             T.requestNormalizeDelta = true;
         }
         x.start += z.delta;
@@ -639,26 +687,26 @@ function rbTreeDelete(T, z) {
         x.start += y.delta;
         x.end += y.delta;
         x.delta += y.delta;
-        if (x.delta < -1073741824  || x.delta > 1073741824 ) {
+        if (x.delta < Constants.MIN_SAFE_DELTA || x.delta > Constants.MAX_SAFE_DELTA) {
             T.requestNormalizeDelta = true;
         }
         y.start += z.delta;
         y.end += z.delta;
         y.delta = z.delta;
-        if (y.delta < -1073741824  || y.delta > 1073741824 ) {
+        if (y.delta < Constants.MIN_SAFE_DELTA || y.delta > Constants.MAX_SAFE_DELTA) {
             T.requestNormalizeDelta = true;
         }
     }
     if (y === T.root) {
         T.root = x;
-        setNodeColor(x, 0 );
+        setNodeColor(x, NodeColor.Black);
         z.detach();
         resetSentinel();
         recomputeMaxEnd(x);
         T.root.parent = SENTINEL;
         return;
     }
-    const yWasRed = ((getNodeColor(y) === 1) );
+    const yWasRed = (getNodeColor(y) === NodeColor.Red);
     if (y === y.parent.left) {
         y.parent.left = x;
     }
@@ -714,61 +762,61 @@ function rbTreeDelete(T, z) {
         recomputeMaxEndWalkToRoot(y.parent);
     }
     let w;
-    while (x !== T.root && getNodeColor(x) === 0 ) {
+    while (x !== T.root && getNodeColor(x) === NodeColor.Black) {
         if (x === x.parent.left) {
             w = x.parent.right;
-            if (getNodeColor(w) === 1 ) {
-                setNodeColor(w, 0 );
-                setNodeColor(x.parent, 1 );
+            if (getNodeColor(w) === NodeColor.Red) {
+                setNodeColor(w, NodeColor.Black);
+                setNodeColor(x.parent, NodeColor.Red);
                 leftRotate(T, x.parent);
                 w = x.parent.right;
             }
-            if (getNodeColor(w.left) === 0  && getNodeColor(w.right) === 0 ) {
-                setNodeColor(w, 1 );
+            if (getNodeColor(w.left) === NodeColor.Black && getNodeColor(w.right) === NodeColor.Black) {
+                setNodeColor(w, NodeColor.Red);
                 x = x.parent;
             }
             else {
-                if (getNodeColor(w.right) === 0 ) {
-                    setNodeColor(w.left, 0 );
-                    setNodeColor(w, 1 );
+                if (getNodeColor(w.right) === NodeColor.Black) {
+                    setNodeColor(w.left, NodeColor.Black);
+                    setNodeColor(w, NodeColor.Red);
                     rightRotate(T, w);
                     w = x.parent.right;
                 }
                 setNodeColor(w, getNodeColor(x.parent));
-                setNodeColor(x.parent, 0 );
-                setNodeColor(w.right, 0 );
+                setNodeColor(x.parent, NodeColor.Black);
+                setNodeColor(w.right, NodeColor.Black);
                 leftRotate(T, x.parent);
                 x = T.root;
             }
         }
         else {
             w = x.parent.left;
-            if (getNodeColor(w) === 1 ) {
-                setNodeColor(w, 0 );
-                setNodeColor(x.parent, 1 );
+            if (getNodeColor(w) === NodeColor.Red) {
+                setNodeColor(w, NodeColor.Black);
+                setNodeColor(x.parent, NodeColor.Red);
                 rightRotate(T, x.parent);
                 w = x.parent.left;
             }
-            if (getNodeColor(w.left) === 0  && getNodeColor(w.right) === 0 ) {
-                setNodeColor(w, 1 );
+            if (getNodeColor(w.left) === NodeColor.Black && getNodeColor(w.right) === NodeColor.Black) {
+                setNodeColor(w, NodeColor.Red);
                 x = x.parent;
             }
             else {
-                if (getNodeColor(w.left) === 0 ) {
-                    setNodeColor(w.right, 0 );
-                    setNodeColor(w, 1 );
+                if (getNodeColor(w.left) === NodeColor.Black) {
+                    setNodeColor(w.right, NodeColor.Black);
+                    setNodeColor(w, NodeColor.Red);
                     leftRotate(T, w);
                     w = x.parent.left;
                 }
                 setNodeColor(w, getNodeColor(x.parent));
-                setNodeColor(x.parent, 0 );
-                setNodeColor(w.left, 0 );
+                setNodeColor(x.parent, NodeColor.Black);
+                setNodeColor(w.left, NodeColor.Black);
                 rightRotate(T, x.parent);
                 x = T.root;
             }
         }
     }
-    setNodeColor(x, 0 );
+    setNodeColor(x, NodeColor.Black);
     resetSentinel();
 }
 function leftest(node) {
@@ -786,7 +834,7 @@ function resetSentinel() {
 function leftRotate(T, x) {
     const y = x.right;
     y.delta += x.delta;
-    if (y.delta < -1073741824  || y.delta > 1073741824 ) {
+    if (y.delta < Constants.MIN_SAFE_DELTA || y.delta > Constants.MAX_SAFE_DELTA) {
         T.requestNormalizeDelta = true;
     }
     y.start += x.delta;
@@ -813,7 +861,7 @@ function leftRotate(T, x) {
 function rightRotate(T, y) {
     const x = y.left;
     y.delta -= x.delta;
-    if (y.delta < -1073741824  || y.delta > 1073741824 ) {
+    if (y.delta < Constants.MIN_SAFE_DELTA || y.delta > Constants.MAX_SAFE_DELTA) {
         T.requestNormalizeDelta = true;
     }
     y.start -= x.delta;
@@ -872,4 +920,4 @@ function intervalCompare(aStart, aEnd, bStart, bEnd) {
     }
     return aStart - bStart;
 }
-export { IntervalNode, IntervalTree, SENTINEL, getNodeColor, intervalCompare, nodeAcceptEdit, recomputeMaxEnd };
+export { ClassName, IntervalNode, IntervalTree, NodeColor, SENTINEL, getNodeColor, intervalCompare, nodeAcceptEdit, recomputeMaxEnd };

package/vscode/src/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeBase.js

@@ -1,7 +1,8 @@
+import { CharCode } from '../../../../base/common/charCode.js';
 import { Position } from '../../core/position.js';
 import { Range } from '../../core/range.js';
 import { FindMatch } from '../../model.js';
-import { SENTINEL, rbDelete, updateTreeMetadata, leftest, fixInsert, righttest, TreeNode } from './rbTreeBase.js';
+import { SENTINEL, rbDelete, updateTreeMetadata, NodeColor, leftest, fixInsert, righttest, TreeNode } from './rbTreeBase.js';
 import { createFindMatch, isValidMatch, Searcher } from '../textModelSearch.js';
 const AverageBufferSize = 65535;
 function createUintArray(arr) {
@@ -29,8 +30,8 @@ function createLineStartsFast(str, readonly = true) {
     let rLength = 1;
     for (let i = 0, len = str.length; i < len; i++) {
         const chr = str.charCodeAt(i);
-        if (chr === 13 ) {
-            if (i + 1 < len && str.charCodeAt(i + 1) === 10 ) {
+        if (chr === CharCode.CarriageReturn) {
+            if (i + 1 < len && str.charCodeAt(i + 1) === CharCode.LineFeed) {
                 r[rLength++] = i + 2;
                 i++;
             }
@@ -38,7 +39,7 @@ function createLineStartsFast(str, readonly = true) {
                 r[rLength++] = i + 1;
             }
         }
-        else if (chr === 10 ) {
+        else if (chr === CharCode.LineFeed) {
             r[rLength++] = i + 1;
         }
     }
@@ -57,8 +58,8 @@ function createLineStarts(r, str) {
     let isBasicASCII = true;
     for (let i = 0, len = str.length; i < len; i++) {
         const chr = str.charCodeAt(i);
-        if (chr === 13 ) {
-            if (i + 1 < len && str.charCodeAt(i + 1) === 10 ) {
+        if (chr === CharCode.CarriageReturn) {
+            if (i + 1 < len && str.charCodeAt(i + 1) === CharCode.LineFeed) {
                 crlf++;
                 r[rLength++] = i + 2;
                 i++;
@@ -68,13 +69,13 @@ function createLineStarts(r, str) {
                 r[rLength++] = i + 1;
             }
         }
-        else if (chr === 10 ) {
+        else if (chr === CharCode.LineFeed) {
             lf++;
             r[rLength++] = i + 1;
         }
         else {
             if (isBasicASCII) {
-                if (chr !== 9  && (chr < 32 || chr > 126)) {
+                if (chr !== CharCode.Tab && (chr < 32 || chr > 126)) {
                     isBasicASCII = false;
                 }
             }
@@ -399,7 +400,7 @@ class PieceTreeBase {
             const pieceEndLine = piece.end.line;
             let pieceStartOffset = lineStarts[pieceStartLine] + piece.start.column;
             if (danglingCR) {
-                if (buffer.charCodeAt(pieceStartOffset) === 10 ) {
+                if (buffer.charCodeAt(pieceStartOffset) === CharCode.LineFeed) {
                     pieceStartOffset++;
                     pieceLength--;
                 }
@@ -411,7 +412,7 @@ class PieceTreeBase {
                 }
             }
             if (pieceStartLine === pieceEndLine) {
-                if (!this._EOLNormalized && buffer.charCodeAt(pieceStartOffset + pieceLength - 1) === 13 ) {
+                if (!this._EOLNormalized && buffer.charCodeAt(pieceStartOffset + pieceLength - 1) === CharCode.CarriageReturn) {
                     danglingCR = true;
                     currentLine += buffer.substr(pieceStartOffset, pieceLength - 1);
                 }
@@ -430,7 +431,7 @@ class PieceTreeBase {
                     : buffer.substring(lineStarts[line], lineStarts[line + 1]).replace(/(\r\n|\r|\n)$/, ''));
                 lines[linesLength++] = currentLine;
             }
-            if (!this._EOLNormalized && buffer.charCodeAt(lineStarts[pieceEndLine] + piece.end.column - 1) === 13 ) {
+            if (!this._EOLNormalized && buffer.charCodeAt(lineStarts[pieceEndLine] + piece.end.column - 1) === CharCode.CarriageReturn) {
                 danglingCR = true;
                 if (piece.end.column === 0) {
                     linesLength--;
@@ -905,7 +906,7 @@ class PieceTreeBase {
             while (text.length > AverageBufferSize) {
                 const lastChar = text.charCodeAt(AverageBufferSize - 1);
                 let splitText;
-                if (lastChar === 13  || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
+                if (lastChar === CharCode.CarriageReturn || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
                     splitText = text.substring(0, AverageBufferSize - 1);
                     text = text.substring(AverageBufferSize - 1);
                 }
@@ -1425,7 +1426,7 @@ class PieceTreeBase {
         return currentContent;
     }
     rbInsertRight(node, p) {
-        const z = ( new TreeNode(p, 1 ));
+        const z = ( new TreeNode(p, NodeColor.Red));
         z.left = SENTINEL;
         z.right = SENTINEL;
         z.parent = SENTINEL;
@@ -1434,7 +1435,7 @@ class PieceTreeBase {
         const x = this.root;
         if (x === SENTINEL) {
             this.root = z;
-            z.color = 0 ;
+            z.color = NodeColor.Black;
         }
         else if (node.right === SENTINEL) {
             node.right = z;
@@ -1449,7 +1450,7 @@ class PieceTreeBase {
         return z;
     }
     rbInsertLeft(node, p) {
-        const z = ( new TreeNode(p, 1 ));
+        const z = ( new TreeNode(p, NodeColor.Red));
         z.left = SENTINEL;
         z.right = SENTINEL;
         z.parent = SENTINEL;
@@ -1457,7 +1458,7 @@ class PieceTreeBase {
         z.lf_left = 0;
         if (this.root === SENTINEL) {
             this.root = z;
-            z.color = 0 ;
+            z.color = NodeColor.Black;
         }
         else if (node.left === SENTINEL) {
             node.left = z;

package/vscode/src/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.js

@@ -1,9 +1,9 @@
 import { Emitter } from '../../../../base/common/event.js';
 import { isHighSurrogate, firstNonWhitespaceIndex, lastNonWhitespaceIndex, containsRTL, isBasicASCII, containsUnusualLineTerminators } from '../../../../base/common/strings.js';
 import { Range } from '../../core/range.js';
-import { ApplyEditsResult } from '../../model.js';
+import { EndOfLinePreference, ApplyEditsResult } from '../../model.js';
 import { PieceTreeBase } from './pieceTreeBase.js';
-import { countEOL } from '../../core/eolCounter.js';
+import { countEOL, StringEOL } from '../../core/eolCounter.js';
 import { TextChange } from '../../core/textChange.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 class PieceTreeTextBuffer extends Disposable {
@@ -67,14 +67,14 @@ class PieceTreeTextBuffer extends Disposable {
             endPosition.column
         ));
     }
-    getValueInRange(range, eol = 0 ) {
+    getValueInRange(range, eol = EndOfLinePreference.TextDefined) {
         if (range.isEmpty()) {
             return '';
         }
         const lineEnding = this._getEndOfLine(eol);
         return this._pieceTree.getValueInRange(range, lineEnding);
     }
-    getValueLengthInRange(range, eol = 0 ) {
+    getValueLengthInRange(range, eol = EndOfLinePreference.TextDefined) {
         if (range.isEmpty()) {
             return 0;
         }
@@ -93,7 +93,7 @@ class PieceTreeTextBuffer extends Disposable {
         }
         return endOffset - startOffset + eolOffsetCompensation;
     }
-    getCharacterCountInRange(range, eol = 0 ) {
+    getCharacterCountInRange(range, eol = EndOfLinePreference.TextDefined) {
         if (this._mightContainNonBasicASCII) {
             let result = 0;
             const fromLineNumber = range.startLineNumber;
@@ -160,11 +160,11 @@ class PieceTreeTextBuffer extends Disposable {
     }
     _getEndOfLine(eol) {
         switch (eol) {
-            case 1 :
+            case EndOfLinePreference.LF:
                 return '\n';
-            case 2 :
+            case EndOfLinePreference.CRLF:
                 return '\r\n';
-            case 0 :
+            case EndOfLinePreference.TextDefined:
                 return this.getEOL();
             default:
                 throw ( new Error('Unknown EOL preference'));
@@ -206,8 +206,8 @@ class PieceTreeTextBuffer extends Disposable {
                 let strEOL;
                 [eolCount, firstLineLength, lastLineLength, strEOL] = countEOL(op.text);
                 const bufferEOL = this.getEOL();
-                const expectedStrEOL = ((bufferEOL === '\r\n' ? 2  : 1) );
-                if (strEOL === 0  || strEOL === expectedStrEOL) {
+                const expectedStrEOL = (bufferEOL === '\r\n' ? StringEOL.CRLF : StringEOL.LF);
+                if (strEOL === StringEOL.Unknown || strEOL === expectedStrEOL) {
                     validText = op.text;
                 }
                 else {
@@ -346,7 +346,7 @@ class PieceTreeTextBuffer extends Disposable {
             identifier: operations[0].identifier,
             range: entireEditRange,
             rangeOffset: this.getOffsetAt(entireEditRange.startLineNumber, entireEditRange.startColumn),
-            rangeLength: this.getValueLengthInRange(entireEditRange, 0 ),
+            rangeLength: this.getValueLengthInRange(entireEditRange, EndOfLinePreference.TextDefined),
             text: text,
             eolCount: eolCount,
             firstLineLength: firstLineLength,

package/vscode/src/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js

@@ -1,4 +1,6 @@
+import { CharCode } from '../../../../base/common/charCode.js';
 import { startsWithUTF8BOM, UTF8_BOM_CHARACTER, containsRTL, containsUnusualLineTerminators } from '../../../../base/common/strings.js';
+import { DefaultEndOfLine } from '../../model.js';
 import { createLineStarts, StringBuffer, createLineStartsFast } from './pieceTreeBase.js';
 import { PieceTreeTextBuffer } from './pieceTreeTextBuffer.js';
 class PieceTreeTextBufferFactory {
@@ -17,7 +19,7 @@ class PieceTreeTextBufferFactory {
         const totalEOLCount = this._cr + this._lf + this._crlf;
         const totalCRCount = this._cr + this._crlf;
         if (totalEOLCount === 0) {
-            return (defaultEOL === 1  ? '\n' : '\r\n');
+            return (defaultEOL === DefaultEndOfLine.LF ? '\n' : '\r\n');
         }
         if (totalCRCount > totalEOLCount / 2) {
             return '\r\n';
@@ -76,7 +78,7 @@ class PieceTreeTextBufferBuilder {
             }
         }
         const lastChar = chunk.charCodeAt(chunk.length - 1);
-        if (lastChar === 13  || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
+        if (lastChar === CharCode.CarriageReturn || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
             this._acceptChunk1(chunk.substr(0, chunk.length - 1), false);
             this._hasPreviousChar = true;
             this._previousChar = lastChar;
@@ -138,7 +140,7 @@ class PieceTreeTextBufferBuilder {
             lastChunk.buffer += String.fromCharCode(this._previousChar);
             const newLineStarts = createLineStartsFast(lastChunk.buffer);
             lastChunk.lineStarts = newLineStarts;
-            if (this._previousChar === 13 ) {
+            if (this._previousChar === CharCode.CarriageReturn) {
                 this.cr++;
             }
         }