@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/base/common/extpath.js

@@ -1,9 +1,10 @@
+import { CharCode } from './charCode.js';
 import { posix, sep } from './path.js';
 import { isWindows } from './platform.js';
 import { equalsIgnoreCase, startsWithIgnoreCase } from './strings.js';
 import { isNumber } from './types.js';
 function isPathSeparator(code) {
-    return code === 47  || code === 92 ;
+    return code === CharCode.Slash || code === CharCode.Backslash;
 }
 function toSlashes(osPath) {
     return osPath.replace(/[\\/]/g, posix.sep);
@@ -47,7 +48,7 @@ function getRoot(path, sep = posix.sep) {
         return sep;
     }
     else if (isWindowsDriveLetter(firstLetter)) {
-        if (path.charCodeAt(1) === 58 ) {
+        if (path.charCodeAt(1) === CharCode.Colon) {
             if (isPathSeparator(path.charCodeAt(2))) {
                 return path.slice(0, 2) + sep;
             }
@@ -75,18 +76,18 @@ function isUNC(path) {
         return false;
     }
     let code = path.charCodeAt(0);
-    if (code !== 92 ) {
+    if (code !== CharCode.Backslash) {
         return false;
     }
     code = path.charCodeAt(1);
-    if (code !== 92 ) {
+    if (code !== CharCode.Backslash) {
         return false;
     }
     let pos = 2;
     const start = pos;
     for (; pos < path.length; pos++) {
         code = path.charCodeAt(pos);
-        if (code === 92 ) {
+        if (code === CharCode.Backslash) {
             break;
         }
     }
@@ -94,13 +95,13 @@ function isUNC(path) {
         return false;
     }
     code = path.charCodeAt(pos + 1);
-    if (isNaN(code) || code === 92 ) {
+    if (isNaN(code) || code === CharCode.Backslash) {
         return false;
     }
     return true;
 }
 const WINDOWS_INVALID_FILE_CHARS = /[\\/:\*\?"<>\|]/g;
-const UNIX_INVALID_FILE_CHARS = /[\\/]/g;
+const UNIX_INVALID_FILE_CHARS = /[/]/g;
 const WINDOWS_FORBIDDEN_NAMES = /^(con|prn|aux|clock\$|nul|lpt[0-9]|com[0-9])(\.(.*?))?$/i;
 function isValidBasename(name, isWindowsOS = isWindows) {
     const invalidFileChars = isWindowsOS ? WINDOWS_INVALID_FILE_CHARS : UNIX_INVALID_FILE_CHARS;
@@ -168,11 +169,11 @@ function isEqualOrParent(base, parentCandidate, ignoreCase, separator = sep) {
     return base.indexOf(parentCandidate) === 0;
 }
 function isWindowsDriveLetter(char0) {
-    return char0 >= 65  && char0 <= 90  || char0 >= 97  && char0 <= 122 ;
+    return char0 >= CharCode.A && char0 <= CharCode.Z || char0 >= CharCode.a && char0 <= CharCode.z;
 }
 function hasDriveLetter(path, isWindowsOS = isWindows) {
     if (isWindowsOS) {
-        return isWindowsDriveLetter(path.charCodeAt(0)) && path.charCodeAt(1) === 58 ;
+        return isWindowsDriveLetter(path.charCodeAt(0)) && path.charCodeAt(1) === CharCode.Colon;
     }
     return false;
 }

package/vscode/src/vs/base/common/filters.js

@@ -1,3 +1,4 @@
+import { CharCode } from './charCode.js';
 import { LRUCache } from './map.js';
 import { getKoreanAltChars } from './naturalLanguage/korean.js';
 import { startsWithIgnoreCase, convertSimple2RegExpPattern, isEmojiImprecise } from './strings.js';
@@ -59,18 +60,19 @@ function _matchesSubString(word, wordToMatchAgainst, i, j) {
     }
 }
 function isLower(code) {
-    return 97  <= code && code <= 122 ;
+    return CharCode.a <= code && code <= CharCode.z;
 }
 function isUpper(code) {
-    return 65  <= code && code <= 90 ;
+    return CharCode.A <= code && code <= CharCode.Z;
 }
 function isNumber(code) {
-    return 48  <= code && code <= 57 ;
+    return CharCode.Digit0 <= code && code <= CharCode.Digit9;
 }
 function isWhitespace(code) {
-    return (code === 32
-        || code === 9
-        || code === 10  || code === 13) ;
+    return (code === CharCode.Space
+        || code === CharCode.Tab
+        || code === CharCode.LineFeed
+        || code === CharCode.CarriageReturn);
 }
 const wordSeparators = ( new Set());
 '()[]{}<>`\'"-/;:,.?!'
@@ -372,24 +374,24 @@ function isSeparatorAtPos(value, index) {
     }
     const code = value.codePointAt(index);
     switch (code) {
-        case 95 :
-        case 45 :
-        case 46 :
-        case 32 :
-        case 47 :
-        case 92 :
-        case 39 :
-        case 34 :
-        case 58 :
-        case 36 :
-        case 60 :
-        case 62 :
-        case 40 :
-        case 41 :
-        case 91 :
-        case 93 :
-        case 123 :
-        case 125 :
+        case CharCode.Underline:
+        case CharCode.Dash:
+        case CharCode.Period:
+        case CharCode.Space:
+        case CharCode.Slash:
+        case CharCode.Backslash:
+        case CharCode.SingleQuote:
+        case CharCode.DoubleQuote:
+        case CharCode.Colon:
+        case CharCode.DollarSign:
+        case CharCode.LessThan:
+        case CharCode.GreaterThan:
+        case CharCode.OpenParen:
+        case CharCode.CloseParen:
+        case CharCode.OpenSquareBracket:
+        case CharCode.CloseSquareBracket:
+        case CharCode.OpenCurlyBrace:
+        case CharCode.CloseCurlyBrace:
             return true;
         case undefined:
             return false;
@@ -406,8 +408,8 @@ function isWhitespaceAtPos(value, index) {
     }
     const code = value.charCodeAt(index);
     switch (code) {
-        case 32 :
-        case 9 :
+        case CharCode.Space:
+        case CharCode.Tab:
             return true;
         default:
             return false;
@@ -428,6 +430,12 @@ function isPatternInWord(patternLow, patternPos, patternLen, wordLow, wordPos, w
     }
     return patternPos === patternLen;
 }
+var Arrow;
+( (function(Arrow) {
+    Arrow[Arrow["Diag"] = 1] = "Diag";
+    Arrow[Arrow["Left"] = 2] = "Left";
+    Arrow[Arrow["LeftLeft"] = 3] = "LeftLeft";
+})(Arrow || (Arrow = {})));
 var FuzzyScore;
 ( (function(FuzzyScore) {
     FuzzyScore.Default = ([-100, 0]);
@@ -479,17 +487,17 @@ function fuzzyScore(pattern, patternLow, patternStart, word, wordLow, wordStart,
             const leftLeftScore = canComeLeftLeft ? _table[row][column - 2] + (_diag[row][column - 2] > 0 ? -5 : 0) : 0;
             if (canComeLeftLeft && (!canComeLeft || leftLeftScore >= leftScore) && (!canComeDiag || leftLeftScore >= diagScore)) {
                 _table[row][column] = leftLeftScore;
-                _arrows[row][column] = 3 ;
+                _arrows[row][column] = Arrow.LeftLeft;
                 _diag[row][column] = 0;
             }
             else if (canComeLeft && (!canComeDiag || leftScore >= diagScore)) {
                 _table[row][column] = leftScore;
-                _arrows[row][column] = 2 ;
+                _arrows[row][column] = Arrow.Left;
                 _diag[row][column] = 0;
             }
             else if (canComeDiag) {
                 _table[row][column] = diagScore;
-                _arrows[row][column] = 1 ;
+                _arrows[row][column] = Arrow.Diag;
                 _diag[row][column] = _diag[row - 1][column - 1] + 1;
             }
             else {
@@ -509,10 +517,10 @@ function fuzzyScore(pattern, patternLow, patternStart, word, wordLow, wordStart,
         let diagColumn = column;
         do {
             const arrow = _arrows[row][diagColumn];
-            if (arrow === 3 ) {
+            if (arrow === Arrow.LeftLeft) {
                 diagColumn = diagColumn - 2;
             }
-            else if (arrow === 2 ) {
+            else if (arrow === Arrow.Left) {
                 diagColumn = diagColumn - 1;
             }
             else {
@@ -539,7 +547,7 @@ function fuzzyScore(pattern, patternLow, patternStart, word, wordLow, wordStart,
         column = diagColumn - 1;
         result.push(column);
     }
-    if (wordLen === patternLen && options.boostFullMatch) {
+    if (wordLen - wordStart === patternLen && options.boostFullMatch) {
         result[0] += 2;
     }
     const skippedCharsCount = maxMatchColumn - patternLen;

package/vscode/src/vs/base/common/fuzzyScorer.js

@@ -1,3 +1,4 @@
+import { CharCode } from './charCode.js';
 import { compareAnything } from './comparers.js';
 import { fuzzyScore, createMatches as createMatches$1, matchesPrefix, isUpper } from './filters.js';
 import { hash } from './hash.js';
@@ -111,16 +112,16 @@ function considerAsEqual(a, b) {
 }
 function scoreSeparatorAtPos(charCode) {
     switch (charCode) {
-        case 47 :
-        case 92 :
+        case CharCode.Slash:
+        case CharCode.Backslash:
             return 5;
-        case 95 :
-        case 45 :
-        case 46 :
-        case 32 :
-        case 39 :
-        case 34 :
-        case 58 :
+        case CharCode.Underline:
+        case CharCode.Dash:
+        case CharCode.Period:
+        case CharCode.Space:
+        case CharCode.SingleQuote:
+        case CharCode.DoubleQuote:
+        case CharCode.Colon:
             return 4;
         default:
             return 0;

package/vscode/src/vs/base/common/glob.js

@@ -1,5 +1,6 @@
 import './arrays.js';
 import { isThenable } from './async.js';
+import { CharCode } from './charCode.js';
 import { isEqualOrParent } from './extpath.js';
 import { LRUCache } from './map.js';
 import { sep, basename, extname, posix } from './path.js';
@@ -494,7 +495,7 @@ function aggregateBasenameMatches(parsedPatterns, result) {
             let i;
             for (i = path.length; i > 0; i--) {
                 const ch = path.charCodeAt(i - 1);
-                if (ch === 47  || ch === 92 ) {
+                if (ch === CharCode.Slash || ch === CharCode.Backslash) {
                     break;
                 }
             }

package/vscode/src/vs/base/common/hash.js

@@ -60,6 +60,11 @@ class Hasher {
         return this._value;
     }
 }
+var SHA1Constant;
+( (function(SHA1Constant) {
+    SHA1Constant[SHA1Constant["BLOCK_SIZE"] = 64] = "BLOCK_SIZE";
+    SHA1Constant[SHA1Constant["UNICODE_REPLACEMENT"] = 65533] = "UNICODE_REPLACEMENT";
+})(SHA1Constant || (SHA1Constant = {})));
 function leftRotate(value, bits, totalBits = 32) {
     const delta = totalBits - bits;
     const mask = ~((1 << delta) - 1);
@@ -90,7 +95,7 @@ class StringSHA1 {
         this._h2 = 0x98BADCFE;
         this._h3 = 0x10325476;
         this._h4 = 0xC3D2E1F0;
-        this._buff = ( new Uint8Array(64  + 3 ));
+        this._buff = ( new Uint8Array(SHA1Constant.BLOCK_SIZE + 3 ));
         this._buffDV = ( new DataView(this._buff.buffer));
         this._buffLen = 0;
         this._totalLen = 0;
@@ -126,7 +131,7 @@ class StringSHA1 {
                         codePoint = computeCodePoint(charCode, nextCharCode);
                     }
                     else {
-                        codePoint = 65533 ;
+                        codePoint = SHA1Constant.UNICODE_REPLACEMENT;
                     }
                 }
                 else {
@@ -135,7 +140,7 @@ class StringSHA1 {
                 }
             }
             else if (isLowSurrogate(charCode)) {
-                codePoint = 65533 ;
+                codePoint = SHA1Constant.UNICODE_REPLACEMENT;
             }
             buffLen = this._push(buff, buffLen, codePoint);
             offset++;
@@ -168,13 +173,13 @@ class StringSHA1 {
             buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
             buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
         }
-        if (buffLen >= 64 ) {
+        if (buffLen >= SHA1Constant.BLOCK_SIZE) {
             this._step();
-            buffLen -= 64 ;
-            this._totalLen += 64 ;
-            buff[0] = buff[64  + 0];
-            buff[1] = buff[64  + 1];
-            buff[2] = buff[64  + 2];
+            buffLen -= SHA1Constant.BLOCK_SIZE;
+            this._totalLen += SHA1Constant.BLOCK_SIZE;
+            buff[0] = buff[SHA1Constant.BLOCK_SIZE + 0];
+            buff[1] = buff[SHA1Constant.BLOCK_SIZE + 1];
+            buff[2] = buff[SHA1Constant.BLOCK_SIZE + 2];
         }
         return buffLen;
     }
@@ -183,7 +188,7 @@ class StringSHA1 {
             this._finished = true;
             if (this._leftoverHighSurrogate) {
                 this._leftoverHighSurrogate = 0;
-                this._buffLen = this._push(this._buff, this._buffLen, 65533 );
+                this._buffLen = this._push(this._buff, this._buffLen, SHA1Constant.UNICODE_REPLACEMENT);
             }
             this._totalLen += this._buffLen;
             this._wrapUp();

package/vscode/src/vs/base/common/htmlContent.js

@@ -3,6 +3,11 @@ import { escapeIcons } from './iconLabels.js';
 import { isEqual } from './resources.js';
 import { escapeRegExpCharacters } from './strings.js';
 import { URI } from './uri.js';
+var MarkdownStringTextNewlineStyle;
+( (function(MarkdownStringTextNewlineStyle) {
+    MarkdownStringTextNewlineStyle[MarkdownStringTextNewlineStyle["Paragraph"] = 0] = "Paragraph";
+    MarkdownStringTextNewlineStyle[MarkdownStringTextNewlineStyle["Break"] = 1] = "Break";
+})(MarkdownStringTextNewlineStyle || (MarkdownStringTextNewlineStyle = {})));
 class MarkdownString {
     constructor(value = '', isTrustedOrOptions = false) {
         this.value = value;
@@ -20,11 +25,11 @@ class MarkdownString {
             this.supportHtml = isTrustedOrOptions.supportHtml ?? false;
         }
     }
-    appendText(value, newlineStyle = 0 ) {
+    appendText(value, newlineStyle = MarkdownStringTextNewlineStyle.Paragraph) {
         this.value += escapeMarkdownSyntaxTokens(this.supportThemeIcons ? escapeIcons(value) : value)
             .replace(/([ \t]+)/g, (_match, g1) => ' '.repeat(g1.length))
             .replace(/\>/gm, '\\>')
-            .replace(/\n/g, newlineStyle === 1  ? '\\\n' : '\n\n');
+            .replace(/\n/g, newlineStyle === MarkdownStringTextNewlineStyle.Break ? '\\\n' : '\n\n');
         return this;
     }
     appendMarkdown(value) {
@@ -138,4 +143,4 @@ function parseHrefAndDimensions(href) {
     }
     return { href, dimensions };
 }
-export { MarkdownString, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };
+export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };