@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/concat23Trees.js

@@ -1,4 +1,4 @@
-import { ListAstNode } from './ast.js';
+import { ListAstNode, AstNodeKind } from './ast.js';
 function concat23Trees(items) {
     if (items.length === 0) {
         return null;
@@ -83,7 +83,7 @@ function append(list, nodeToAppend) {
             nodeToAppendOfCorrectHeight = nodeToAppend;
             break;
         }
-        if (curNode.kind !== 4 ) {
+        if (curNode.kind !== AstNodeKind.List) {
             throw ( new Error('unexpected'));
         }
         parents.push(curNode);
@@ -116,7 +116,7 @@ function prepend(list, nodeToAppend) {
     let curNode = list;
     const parents = [];
     while (nodeToAppend.listHeight !== curNode.listHeight) {
-        if (curNode.kind !== 4 ) {
+        if (curNode.kind !== AstNodeKind.List) {
             throw ( new Error('unexpected'));
         }
         parents.push(curNode);

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/parser.js

@@ -1,9 +1,10 @@
-import { TextAstNode, PairAstNode, InvalidBracketAstNode, ListAstNode } from './ast.js';
+import { AstNodeKind, TextAstNode, PairAstNode, InvalidBracketAstNode, ListAstNode } from './ast.js';
 import { BeforeEditPositionMapper } from './beforeEditPositionMapper.js';
 import { SmallImmutableSet } from './smallImmutableSet.js';
 import { lengthIsZero, lengthLessThan } from './length.js';
 import { concat23Trees, concat23TreesOfSameHeight } from './concat23Trees.js';
 import { NodeReader } from './nodeReader.js';
+import { TokenKind } from './tokenizer.js';
 function parseDocument(tokenizer, edits, oldNode, createImmutableLists) {
     const parser = ( new Parser(tokenizer, edits, oldNode, createImmutableLists));
     return parser.parseDocument();
@@ -42,13 +43,13 @@ class Parser {
             if (!child) {
                 const token = this.tokenizer.peek();
                 if (!token ||
-                    (token.kind === 2  &&
+                    (token.kind === TokenKind.ClosingBracket &&
                         token.bracketIds.intersects(openedBracketIds))) {
                     break;
                 }
                 child = this.parseChild(openedBracketIds, level + 1);
             }
-            if (child.kind === 4  && child.childrenLength === 0) {
+            if (child.kind === AstNodeKind.List && child.childrenLength === 0) {
                 continue;
             }
             items.push(child);
@@ -80,11 +81,11 @@ class Parser {
         this._itemsConstructed++;
         const token = this.tokenizer.read();
         switch (token.kind) {
-            case 2 :
+            case TokenKind.ClosingBracket:
                 return ( new InvalidBracketAstNode(token.bracketIds, token.length));
-            case 0 :
+            case TokenKind.Text:
                 return token.astNode;
-            case 1 : {
+            case TokenKind.OpeningBracket: {
                 if (level > 300) {
                     return ( new TextAstNode(token.length));
                 }
@@ -92,7 +93,7 @@ class Parser {
                 const child = this.parseList(set, level + 1);
                 const nextToken = this.tokenizer.peek();
                 if (nextToken &&
-                    nextToken.kind === 2  &&
+                    nextToken.kind === TokenKind.ClosingBracket &&
                     (nextToken.bracketId === token.bracketId || nextToken.bracketIds.intersects(token.bracketIds))) {
                     this.tokenizer.read();
                     return PairAstNode.create(token.astNode, child, nextToken.astNode);

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/tokenizer.js

@@ -1,8 +1,14 @@
 import { NotSupportedError } from '../../../../../base/common/errors.js';
-import { TokenMetadata } from '../../../encodedTokenAttributes.js';
+import { TokenMetadata, StandardTokenType } from '../../../encodedTokenAttributes.js';
 import { TextAstNode } from './ast.js';
 import { lengthZero, toLength, lengthAdd, lengthGetColumnCountIfZeroLineCount, lengthToObj, lengthDiff } from './length.js';
 import { SmallImmutableSet } from './smallImmutableSet.js';
+var TokenKind;
+( (function(TokenKind) {
+    TokenKind[TokenKind["Text"] = 0] = "Text";
+    TokenKind[TokenKind["OpeningBracket"] = 1] = "OpeningBracket";
+    TokenKind[TokenKind["ClosingBracket"] = 2] = "ClosingBracket";
+})(TokenKind || (TokenKind = {})));
 class Token {
     constructor(length, kind,
     bracketId,
@@ -116,7 +122,7 @@ class NonPeekableTextBufferTokenizer {
                 while (this.lineTokenOffset + 1 < tokenCount && tokenMetadata === lineTokens.getMetadata(this.lineTokenOffset + 1)) {
                     this.lineTokenOffset++;
                 }
-                const isOther = TokenMetadata.getTokenType(tokenMetadata) === 0 ;
+                const isOther = TokenMetadata.getTokenType(tokenMetadata) === StandardTokenType.Other;
                 const containsBracketType = TokenMetadata.containsBalancedBrackets(tokenMetadata);
                 const endOffset = lineTokens.getEndOffset(this.lineTokenOffset);
                 if (containsBracketType && isOther && this.lineCharOffset < endOffset) {
@@ -170,13 +176,7 @@ class NonPeekableTextBufferTokenizer {
             }
         }
         const length = lengthDiff(startLineIdx, startLineCharOffset, this.lineIdx, this.lineCharOffset);
-        return ( new Token(
-            length,
-            0 ,
-            -1,
-            SmallImmutableSet.getEmpty(),
-            ( new TextAstNode(length))
-        ));
+        return ( new Token(length, TokenKind.Text, -1, SmallImmutableSet.getEmpty(), ( new TextAstNode(length))));
     }
 }
 class FastTokenizer {
@@ -196,7 +196,7 @@ class FastTokenizer {
         for (let i = 0; i < 60; i++) {
             smallTextTokens0Line.push(( new Token(
                 toLength(0, i),
-                0 ,
+                TokenKind.Text,
                 -1,
                 SmallImmutableSet.getEmpty(),
                 ( new TextAstNode(toLength(0, i)))
@@ -206,7 +206,7 @@ class FastTokenizer {
         for (let i = 0; i < 60; i++) {
             smallTextTokens1Line.push(( new Token(
                 toLength(1, i),
-                0 ,
+                TokenKind.Text,
                 -1,
                 SmallImmutableSet.getEmpty(),
                 ( new TextAstNode(toLength(1, i)))
@@ -231,13 +231,7 @@ class FastTokenizer {
                             }
                             else {
                                 const length = toLength(0, colCount);
-                                token = ( new Token(
-                                    length,
-                                    0 ,
-                                    -1,
-                                    SmallImmutableSet.getEmpty(),
-                                    ( new TextAstNode(length))
-                                ));
+                                token = ( new Token(length, TokenKind.Text, -1, SmallImmutableSet.getEmpty(), ( new TextAstNode(length))));
                             }
                         }
                         else {
@@ -248,13 +242,7 @@ class FastTokenizer {
                             }
                             else {
                                 const length = toLength(lineCount, colCount);
-                                token = ( new Token(
-                                    length,
-                                    0 ,
-                                    -1,
-                                    SmallImmutableSet.getEmpty(),
-                                    ( new TextAstNode(length))
-                                ));
+                                token = ( new Token(length, TokenKind.Text, -1, SmallImmutableSet.getEmpty(), ( new TextAstNode(length))));
                             }
                         }
                         tokens.push(token);
@@ -270,13 +258,7 @@ class FastTokenizer {
             const length = (lastTokenEndLine === curLineCount)
                 ? toLength(0, offset - lastTokenEndOffset)
                 : toLength(curLineCount - lastTokenEndLine, offset - lastLineBreakOffset);
-            tokens.push(( new Token(
-                length,
-                0 ,
-                -1,
-                SmallImmutableSet.getEmpty(),
-                ( new TextAstNode(length))
-            )));
+            tokens.push(( new Token(length, TokenKind.Text, -1, SmallImmutableSet.getEmpty(), ( new TextAstNode(length)))));
         }
         this.length = toLength(curLineCount, offset - lastLineBreakOffset);
         this.tokens = tokens;
@@ -297,4 +279,4 @@ class FastTokenizer {
         return this.text;
     }
 }
-export { FastTokenizer, TextBufferTokenizer, Token };
+export { FastTokenizer, TextBufferTokenizer, Token, TokenKind };

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/fixBrackets.js

@@ -1,3 +1,4 @@
+import { AstNodeKind } from './bracketPairsTree/ast.js';
 import { LanguageAgnosticBracketTokens } from './bracketPairsTree/brackets.js';
 import { lengthAdd, lengthGetColumnCountIfZeroLineCount, lengthZero } from './bracketPairsTree/length.js';
 import { parseDocument } from './bracketPairsTree/parser.js';
@@ -14,7 +15,7 @@ function fixBracketsInLine(tokens, languageConfigurationService) {
     let str = '';
     const line = tokens.getLineContent();
     function processNode(node, offset) {
-        if (node.kind === 2 ) {
+        if (node.kind === AstNodeKind.Pair) {
             processNode(node.openingBracket, offset);
             offset = lengthAdd(offset, node.openingBracket.length);
             if (node.child) {
@@ -31,11 +32,11 @@ function fixBracketsInLine(tokens, languageConfigurationService) {
                 str += closingTokenText;
             }
         }
-        else if (node.kind === 3 ) ;
-        else if (node.kind === 0  || node.kind === 1 ) {
+        else if (node.kind === AstNodeKind.UnexpectedClosingBracket) ;
+        else if (node.kind === AstNodeKind.Text || node.kind === AstNodeKind.Bracket) {
             str += line.substring(lengthGetColumnCountIfZeroLineCount(offset), lengthGetColumnCountIfZeroLineCount(lengthAdd(offset, node.length)));
         }
-        else if (node.kind === 4 ) {
+        else if (node.kind === AstNodeKind.List) {
             for (const child of node.children) {
                 processNode(child, offset);
                 offset = lengthAdd(offset, child.length);

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

@@ -1,6 +1,8 @@
 import { localizeWithPath } from '../../../nls.js';
 import { onUnexpectedError } from '../../../base/common/errors.js';
 import { Selection } from '../core/selection.js';
+import { EndOfLineSequence } from '../model.js';
+import { UndoRedoElementType } from '../../../platform/undoRedo/common/undoRedo.js';
 import { URI } from '../../../base/common/uri.js';
 import { compressConsecutiveTextChanges, TextChange } from '../core/textChange.js';
 import { writeUInt32BE, writeUInt8, readUInt32BE, readUInt8 } from '../../../base/common/buffer.js';
@@ -151,7 +153,7 @@ class SingleModelEditStackData {
 }
 class SingleModelEditStackElement {
     get type() {
-        return 0 ;
+        return UndoRedoElementType.Resource;
     }
     get resource() {
         if (URI.isUri(this.model)) {
@@ -230,7 +232,7 @@ class MultiModelEditStackElement {
     constructor(label, code, editStackElements) {
         this.label = label;
         this.code = code;
-        this.type = 1 ;
+        this.type = UndoRedoElementType.Workspace;
         this._isOpen = true;
         this._editStackElementsArr = editStackElements.slice(0);
         this._editStackElementsMap = ( (new Map()));
@@ -323,10 +325,10 @@ class MultiModelEditStackElement {
 function getModelEOL(model) {
     const eol = model.getEOL();
     if (eol === '\n') {
-        return 0 ;
+        return EndOfLineSequence.LF;
     }
     else {
-        return 1 ;
+        return EndOfLineSequence.CRLF;
     }
 }
 function isEditStackElement(element) {

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

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../base/common/charCode.js';
 class SpacesDiffResult {
     constructor() {
         this.spacesDiff = 0;
@@ -18,7 +19,7 @@ function spacesDiff(a, aLength, b, bLength, result) {
     let aSpacesCnt = 0, aTabsCount = 0;
     for (let j = i; j < aLength; j++) {
         const aCharCode = a.charCodeAt(j);
-        if (aCharCode === 32 ) {
+        if (aCharCode === CharCode.Space) {
             aSpacesCnt++;
         }
         else {
@@ -28,7 +29,7 @@ function spacesDiff(a, aLength, b, bLength, result) {
     let bSpacesCnt = 0, bTabsCount = 0;
     for (let j = i; j < bLength; j++) {
         const bCharCode = b.charCodeAt(j);
-        if (bCharCode === 32 ) {
+        if (bCharCode === CharCode.Space) {
             bSpacesCnt++;
         }
         else {
@@ -46,8 +47,8 @@ function spacesDiff(a, aLength, b, bLength, result) {
     if (tabsDiff === 0) {
         result.spacesDiff = spacesDiff;
         if (spacesDiff > 0 && 0 <= bSpacesCnt - 1 && bSpacesCnt - 1 < a.length && bSpacesCnt < b.length) {
-            if (b.charCodeAt(bSpacesCnt) !== 32  && a.charCodeAt(bSpacesCnt - 1) === 32 ) {
-                if (a.charCodeAt(a.length - 1) === 44 ) {
+            if (b.charCodeAt(bSpacesCnt) !== CharCode.Space && a.charCodeAt(bSpacesCnt - 1) === CharCode.Space) {
+                if (a.charCodeAt(a.length - 1) === CharCode.Comma) {
                     result.looksLikeAlignment = true;
                 }
             }
@@ -79,10 +80,10 @@ function guessIndentation(source, defaultTabSize, defaultInsertSpaces) {
         let currentLineTabsCount = 0;
         for (let j = 0, lenJ = currentLineLength; j < lenJ; j++) {
             const charCode = (useCurrentLineText ? currentLineText.charCodeAt(j) : source.getLineCharCode(lineNumber, j));
-            if (charCode === 9 ) {
+            if (charCode === CharCode.Tab) {
                 currentLineTabsCount++;
             }
-            else if (charCode === 32 ) {
+            else if (charCode === CharCode.Space) {
                 currentLineSpacesCount++;
             }
             else {