@codingame/monaco-vscode-api 38.0.2 → 38.0.3

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

@@ -20,8 +20,7 @@ function format(documentText, range, options) {
         }
         formatText = documentText.substring(formatTextStart, endOffset);
         initialIndentLevel = computeIndentLevel(formatText, options);
-    }
-    else {
+    } else {
         formatText = documentText;
         initialIndentLevel = 0;
         formatTextStart = 0;
@@ -33,10 +32,9 @@ function format(documentText, range, options) {
     let indentLevel = 0;
     let indentValue;
     if (options.insertSpaces) {
-        indentValue = repeat(' ', options.tabSize || 4);
-    }
-    else {
-        indentValue = '\t';
+        indentValue = repeat(" ", options.tabSize || 4);
+    } else {
+        indentValue = "\t";
     }
     const scanner = createScanner(formatText, false);
     let hasError = false;
@@ -56,7 +54,11 @@ function format(documentText, range, options) {
     const editOperations = [];
     function addEdit(text, startOffset, endOffset) {
         if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
-            editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+            editOperations.push({
+                offset: startOffset,
+                length: endOffset - startOffset,
+                content: text
+            });
         }
     }
     let firstToken = scanNext();
@@ -68,12 +70,12 @@ function format(documentText, range, options) {
     while (firstToken !== SyntaxKind.EOF) {
         let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
         let secondToken = scanNext();
-        let replaceContent = '';
+        let replaceContent = "";
         while (!lineBreak && (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia)) {
             const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
-            addEdit(' ', firstTokenEnd, commentTokenStart);
+            addEdit(" ", firstTokenEnd, commentTokenStart);
             firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-            replaceContent = secondToken === SyntaxKind.LineCommentTrivia ? newLineAndIndent() : '';
+            replaceContent = secondToken === SyntaxKind.LineCommentTrivia ? newLineAndIndent() : "";
             secondToken = scanNext();
         }
         if (secondToken === SyntaxKind.CloseBraceToken) {
@@ -81,56 +83,52 @@ function format(documentText, range, options) {
                 indentLevel--;
                 replaceContent = newLineAndIndent();
             }
-        }
-        else if (secondToken === SyntaxKind.CloseBracketToken) {
+        } else if (secondToken === SyntaxKind.CloseBracketToken) {
             if (firstToken !== SyntaxKind.OpenBracketToken) {
                 indentLevel--;
                 replaceContent = newLineAndIndent();
             }
-        }
-        else {
+        } else {
             switch (firstToken) {
-                case SyntaxKind.OpenBracketToken:
-                case SyntaxKind.OpenBraceToken:
-                    indentLevel++;
-                    replaceContent = newLineAndIndent();
-                    break;
-                case SyntaxKind.CommaToken:
-                case SyntaxKind.LineCommentTrivia:
+            case SyntaxKind.OpenBracketToken:
+            case SyntaxKind.OpenBraceToken:
+                indentLevel++;
+                replaceContent = newLineAndIndent();
+                break;
+            case SyntaxKind.CommaToken:
+            case SyntaxKind.LineCommentTrivia:
+                replaceContent = newLineAndIndent();
+                break;
+            case SyntaxKind.BlockCommentTrivia:
+                if (lineBreak) {
                     replaceContent = newLineAndIndent();
+                } else {
+                    replaceContent = " ";
+                }
+                break;
+            case SyntaxKind.ColonToken:
+                replaceContent = " ";
+                break;
+            case SyntaxKind.StringLiteral:
+                if (secondToken === SyntaxKind.ColonToken) {
+                    replaceContent = "";
                     break;
-                case SyntaxKind.BlockCommentTrivia:
-                    if (lineBreak) {
-                        replaceContent = newLineAndIndent();
-                    }
-                    else {
-                        replaceContent = ' ';
-                    }
-                    break;
-                case SyntaxKind.ColonToken:
-                    replaceContent = ' ';
-                    break;
-                case SyntaxKind.StringLiteral:
-                    if (secondToken === SyntaxKind.ColonToken) {
-                        replaceContent = '';
-                        break;
-                    }
-                case SyntaxKind.NullKeyword:
-                case SyntaxKind.TrueKeyword:
-                case SyntaxKind.FalseKeyword:
-                case SyntaxKind.NumericLiteral:
-                case SyntaxKind.CloseBraceToken:
-                case SyntaxKind.CloseBracketToken:
-                    if (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia) {
-                        replaceContent = ' ';
-                    }
-                    else if (secondToken !== SyntaxKind.CommaToken && secondToken !== SyntaxKind.EOF) {
-                        hasError = true;
-                    }
-                    break;
-                case SyntaxKind.Unknown:
+                }
+            case SyntaxKind.NullKeyword:
+            case SyntaxKind.TrueKeyword:
+            case SyntaxKind.FalseKeyword:
+            case SyntaxKind.NumericLiteral:
+            case SyntaxKind.CloseBraceToken:
+            case SyntaxKind.CloseBracketToken:
+                if (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia) {
+                    replaceContent = " ";
+                } else if (secondToken !== SyntaxKind.CommaToken && secondToken !== SyntaxKind.EOF) {
                     hasError = true;
-                    break;
+                }
+                break;
+            case SyntaxKind.Unknown:
+                hasError = true;
+                break;
             }
             if (lineBreak && (secondToken === SyntaxKind.LineCommentTrivia || secondToken === SyntaxKind.BlockCommentTrivia)) {
                 replaceContent = newLineAndIndent();
@@ -143,14 +141,14 @@ function format(documentText, range, options) {
     return editOperations;
 }
 function toFormattedString(obj, options) {
-    const content = JSON.stringify(obj, undefined, options.insertSpaces ? options.tabSize || 4 : '\t');
+    const content = JSON.stringify(obj, undefined, options.insertSpaces ? options.tabSize || 4 : "\t");
     if (options.eol !== undefined) {
         return content.replace(/\r\n|\r|\n/g, options.eol);
     }
     return content;
 }
 function repeat(s, count) {
-    let result = '';
+    let result = "";
     for (let i = 0; i < count; i++) {
         result += s;
     }
@@ -162,13 +160,11 @@ function computeIndentLevel(content, options) {
     const tabSize = options.tabSize || 4;
     while (i < content.length) {
         const ch = content.charAt(i);
-        if (ch === ' ') {
+        if (ch === " ") {
             nChars++;
-        }
-        else if (ch === '\t') {
+        } else if (ch === "\t") {
             nChars += tabSize;
-        }
-        else {
+        } else {
             break;
         }
         i++;
@@ -178,20 +174,19 @@ function computeIndentLevel(content, options) {
 function getEOL(options, text) {
     for (let i = 0; i < text.length; i++) {
         const ch = text.charAt(i);
-        if (ch === '\r') {
-            if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
-                return '\r\n';
+        if (ch === "\r") {
+            if (i + 1 < text.length && text.charAt(i + 1) === "\n") {
+                return "\r\n";
             }
-            return '\r';
-        }
-        else if (ch === '\n') {
-            return '\n';
+            return "\r";
+        } else if (ch === "\n") {
+            return "\n";
         }
     }
-    return (options && options.eol) || '\n';
+    return (options && options.eol) || "\n";
 }
 function isEOL(text, offset) {
-    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+    return ( "\r\n".indexOf(text.charAt(offset))) !== -1;
 }
 
 export { format, getEOL, isEOL, toFormattedString };

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

@@ -44,7 +44,7 @@ class KeybindingParser {
             }
         } while (matchedModifier);
         let key;
-        const firstSpaceIdx = input.indexOf(" ");
+        const firstSpaceIdx = ( input.indexOf(" "));
         if (firstSpaceIdx > 0) {
             key = input.substring(0, firstSpaceIdx);
             input = input.substring(firstSpaceIdx);

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

@@ -127,18 +127,18 @@ function shorten(paths, defaultPathSeparator = sep) {
         let prefix = "";
         let trimmedPath = originalPath;
         if (urlSchemaRegexp.test(trimmedPath)) {
-            prefix = trimmedPath.substr(0, trimmedPath.indexOf("//") + 2);
-            trimmedPath = trimmedPath.substr(trimmedPath.indexOf("//") + 2);
+            prefix = trimmedPath.substr(0, ( trimmedPath.indexOf("//")) + 2);
+            trimmedPath = trimmedPath.substr(( trimmedPath.indexOf("//")) + 2);
             pathSeparator = "/";
-        } else if (trimmedPath.indexOf(unc) === 0) {
-            prefix = trimmedPath.substr(0, trimmedPath.indexOf(unc) + unc.length);
-            trimmedPath = trimmedPath.substr(trimmedPath.indexOf(unc) + unc.length);
-        } else if (trimmedPath.indexOf(pathSeparator) === 0) {
-            prefix = trimmedPath.substr(0, trimmedPath.indexOf(pathSeparator) + pathSeparator.length);
-            trimmedPath = trimmedPath.substr(trimmedPath.indexOf(pathSeparator) + pathSeparator.length);
-        } else if (trimmedPath.indexOf(home) === 0) {
-            prefix = trimmedPath.substr(0, trimmedPath.indexOf(home) + home.length);
-            trimmedPath = trimmedPath.substr(trimmedPath.indexOf(home) + home.length);
+        } else if (( trimmedPath.indexOf(unc)) === 0) {
+            prefix = trimmedPath.substr(0, ( trimmedPath.indexOf(unc)) + unc.length);
+            trimmedPath = trimmedPath.substr(( trimmedPath.indexOf(unc)) + unc.length);
+        } else if (( trimmedPath.indexOf(pathSeparator)) === 0) {
+            prefix = trimmedPath.substr(0, ( trimmedPath.indexOf(pathSeparator)) + pathSeparator.length);
+            trimmedPath = trimmedPath.substr(( trimmedPath.indexOf(pathSeparator)) + pathSeparator.length);
+        } else if (( trimmedPath.indexOf(home)) === 0) {
+            prefix = trimmedPath.substr(0, ( trimmedPath.indexOf(home)) + home.length);
+            trimmedPath = trimmedPath.substr(( trimmedPath.indexOf(home)) + home.length);
         }
         const segments = trimmedPath.split(pathSeparator);
         for (let subpathLength = 1; match && subpathLength <= segments.length; subpathLength++) {
@@ -146,9 +146,9 @@ function shorten(paths, defaultPathSeparator = sep) {
                 match = false;
                 let subpath = segments.slice(start, start + subpathLength).join(pathSeparator);
                 for (let otherPathIndex = 0; !match && otherPathIndex < paths.length; otherPathIndex++) {
-                    if (otherPathIndex !== pathIndex && paths[otherPathIndex] && paths[otherPathIndex].indexOf(subpath) > -1) {
+                    if (otherPathIndex !== pathIndex && paths[otherPathIndex] && ( paths[otherPathIndex].indexOf(subpath)) > -1) {
                         const isSubpathEnding = (start + subpathLength === segments.length);
-                        const subpathWithSep = (start > 0 && paths[otherPathIndex].indexOf(pathSeparator) > -1) ? pathSeparator + subpath : subpath;
+                        const subpathWithSep = (start > 0 && ( paths[otherPathIndex].indexOf(pathSeparator)) > -1) ? pathSeparator + subpath : subpath;
                         const isOtherPathEnding = paths[otherPathIndex].endsWith(subpathWithSep);
                         match = !isSubpathEnding || isOtherPathEnding;
                     }
@@ -297,7 +297,7 @@ function splitRecentLabel(recentLabel) {
     return splitName(recentLabel);
 }
 function splitName(fullPath) {
-    const p = fullPath.indexOf("/") !== -1 ? posix : win32;
+    const p = ( fullPath.indexOf("/")) !== -1 ? posix : win32;
     const name = p.basename(fullPath);
     const parentPath = p.dirname(fullPath);
     if (name.length) {

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

@@ -3,15 +3,15 @@ import { lexer } from 'marked';
 
 function isOpaque(token) {
     switch (token.type) {
-        case 'code':
-        case 'codespan':
-        case 'html':
-        case 'link':
-        case 'image':
-        case 'def':
-            return true;
-        default:
-            return false;
+    case "code":
+    case "codespan":
+    case "html":
+    case "link":
+    case "image":
+    case "def":
+        return true;
+    default:
+        return false;
     }
 }
 function childrenOf(token) {
@@ -26,12 +26,10 @@ function childrenOf(token) {
     return candidate.tokens ?? [];
 }
 function markdownTokensToPlainText(tokens) {
-    let text = '';
+    let text = "";
     for (const token of tokens) {
         const children = token.tokens;
-        text += children?.length
-            ? markdownTokensToPlainText(children)
-            : token.text ?? token.raw ?? '';
+        text += children?.length ? markdownTokensToPlainText(children) : token.text ?? token.raw ?? "";
     }
     return text;
 }
@@ -44,29 +42,42 @@ function collectEdits(tokens, markdown, cursor, rewriter, edits, codeRanges, unl
                 continue;
             }
         }
-        const raw = token.raw ?? '';
+        const raw = token.raw ?? "";
         if (!raw) {
             continue;
         }
-        const start = markdown.indexOf(raw, cursor);
+        const start = ( markdown.indexOf(raw, cursor));
         if (start < 0) {
-            if (token.type === 'link' || token.type === 'image') {
+            if (token.type === "link" || token.type === "image") {
                 unlocatable.push(token);
             }
             continue;
         }
         const end = start + raw.length;
         cursor = end;
-        if (token.type === 'code' || token.type === 'codespan') {
-            codeRanges.push({ start, end });
-        }
-        else if (token.type === 'link' || token.type === 'image') {
+        if (token.type === "code" || token.type === "codespan") {
+            codeRanges.push({
+                start,
+                end
+            });
+        } else if (token.type === "link" || token.type === "image") {
             const replacement = rewriter.rewriteLink(token);
             if (replacement !== undefined) {
-                edits.push({ start, end, replacement });
-            }
-            else {
-                collectEdits(childrenOf(token), markdown, start, rewriter, edits, codeRanges, unlocatable);
+                edits.push({
+                    start,
+                    end,
+                    replacement
+                });
+            } else {
+                collectEdits(
+                    childrenOf(token),
+                    markdown,
+                    start,
+                    rewriter,
+                    edits,
+                    codeRanges,
+                    unlocatable
+                );
             }
         }
     }
@@ -76,18 +87,24 @@ function findDefinitionRanges(tokens, markdown) {
     const ranges = [];
     let cursor = 0;
     for (const token of tokens) {
-        const raw = token.raw ?? '';
-        const start = raw ? markdown.indexOf(raw, cursor) : -1;
+        const raw = token.raw ?? "";
+        const start = raw ? ( markdown.indexOf(raw, cursor)) : -1;
         if (start < 0) {
             return [];
         }
         if (start > cursor && markdown.substring(cursor, start).trim()) {
-            ranges.push({ start: cursor, end: start });
+            ranges.push({
+                start: cursor,
+                end: start
+            });
         }
         cursor = start + raw.length;
     }
     if (markdown.substring(cursor).trim()) {
-        ranges.push({ start: cursor, end: markdown.length });
+        ranges.push({
+            start: cursor,
+            end: markdown.length
+        });
     }
     return ranges;
 }
@@ -95,8 +112,7 @@ function rewriteMarkdownLinks(markdown, rewriter) {
     let tokens;
     try {
         tokens = lexer(markdown);
-    }
-    catch {
+    } catch {
         return markdown;
     }
     const edits = [];
@@ -106,13 +122,13 @@ function rewriteMarkdownLinks(markdown, rewriter) {
     edits.push(...(rewriter.additionalEdits?.(markdown, {
         codeRanges,
         definitionRanges: findDefinitionRanges(tokens, markdown),
-        unlocatable,
+        unlocatable
     }) ?? []));
     if (!edits.length) {
         return markdown;
     }
     edits.sort((a, b) => a.start - b.start);
-    let result = '';
+    let result = "";
     let position = 0;
     for (const edit of edits) {
         if (edit.start < position) {

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

@@ -119,7 +119,7 @@ class RemoteAuthoritiesImpl {
         }
         const authority = uri.authority;
         let host = this._hosts[authority];
-        if (host && host.indexOf(":") !== -1 && host.indexOf("[") === -1) {
+        if (host && ( host.indexOf(":")) !== -1 && ( host.indexOf("[")) === -1) {
             host = `[${host}]`;
         }
         const port = this._ports[authority];

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

@@ -239,7 +239,7 @@ function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue) {
                 params: {}
             };
         } else {
-            const spaceIndex = token.indexOf(" ");
+            const spaceIndex = ( token.indexOf(" "));
             if (spaceIndex > 0) {
                 const beforeSpace = token.substring(0, spaceIndex);
                 const afterSpace = token.substring(spaceIndex + 1);
@@ -251,7 +251,7 @@ function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue) {
                         scheme: beforeSpace.trim(),
                         params: {}
                     };
-                    const equalIndex = afterSpace.indexOf("=");
+                    const equalIndex = ( afterSpace.indexOf("="));
                     if (equalIndex > 0) {
                         const key = afterSpace.substring(0, equalIndex).trim();
                         const value = afterSpace.substring(equalIndex + 1).trim().replace(/^"|"$/g, "");
@@ -263,7 +263,7 @@ function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue) {
                 }
             }
             if (currentChallenge) {
-                const equalIndex = token.indexOf("=");
+                const equalIndex = ( token.indexOf("="));
                 if (equalIndex > 0) {
                     const key = token.substring(0, equalIndex).trim();
                     const value = token.substring(equalIndex + 1).trim().replace(/^"|"$/g, "");

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

@@ -13,13 +13,13 @@ const CHAR_QUESTION_MARK = 63;
 class ErrorInvalidArgType extends Error {
     constructor(name, expected, actual) {
         let determiner;
-        if (typeof expected === "string" && expected.indexOf("not ") === 0) {
+        if (typeof expected === "string" && ( expected.indexOf("not ")) === 0) {
             determiner = "must not be";
             expected = expected.replace(/^not /, "");
         } else {
             determiner = "must be";
         }
-        const type = name.indexOf(".") !== -1 ? "property" : "argument";
+        const type = ( name.indexOf(".")) !== -1 ? "property" : "argument";
         let msg = `The "${name}" ${type} ${determiner} of type ${expected}`;
         msg += `. Received type ${typeof actual}`;
         super(msg);
@@ -272,12 +272,12 @@ const win32 = {
             if (tail.length >= 2 && isWindowsDeviceRoot(tail.charCodeAt(0)) && tail.charCodeAt(1) === CHAR_COLON) {
                 return `.\\${tail}`;
             }
-            let index = path.indexOf(":");
+            let index = ( path.indexOf(":"));
             do {
                 if (index === len - 1 || isPathSeparator(path.charCodeAt(index + 1))) {
                     return `.\\${tail}`;
                 }
-            } while ((index = path.indexOf(":", index + 1)) !== -1);
+            } while ((index = ( path.indexOf(":", index + 1))) !== -1);
         }
         if (device === undefined) {
             return isAbsolute ? `\\${tail}` : tail;
@@ -769,7 +769,7 @@ const posixCwd = (() => {
         const regexp = /\\/g;
         return () => {
             const cwd$1 = cwd().replace(regexp, "/");
-            return cwd$1.slice(cwd$1.indexOf("/"));
+            return cwd$1.slice(( cwd$1.indexOf("/")));
         };
     }
     return () => cwd();

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

@@ -50,11 +50,11 @@ if (typeof nodeProcess === "object") {
 }
 else if (typeof navigator === "object" && !isElectronRenderer) {
     _userAgent = navigator.userAgent;
-    _isWindows = _userAgent.indexOf("Windows") >= 0;
-    _isMacintosh = _userAgent.indexOf("Macintosh") >= 0;
-    _isIOS = (_userAgent.indexOf("Macintosh") >= 0 || _userAgent.indexOf("iPad") >= 0 || _userAgent.indexOf("iPhone") >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;
-    _isLinux = _userAgent.indexOf("Linux") >= 0;
-    _isChromeOS = _userAgent.indexOf("CrOS") >= 0;
+    _isWindows = ( _userAgent.indexOf("Windows")) >= 0;
+    _isMacintosh = ( _userAgent.indexOf("Macintosh")) >= 0;
+    _isIOS = (( _userAgent.indexOf("Macintosh")) >= 0 || ( _userAgent.indexOf("iPad")) >= 0 || ( _userAgent.indexOf("iPhone")) >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;
+    _isLinux = ( _userAgent.indexOf("Linux")) >= 0;
+    _isChromeOS = ( _userAgent.indexOf("CrOS")) >= 0;
     _isMobile = _userAgent?.indexOf("Mobi") >= 0;
     _isWeb = true;
     _language = getNLSLanguage() || LANGUAGE_DEFAULT;
@@ -180,11 +180,10 @@ function isLittleEndian() {
     }
     return _isLittleEndian;
 }
-const isChrome = !!(userAgent && userAgent.indexOf("Chrome") >= 0);
-const isFirefox = !!(userAgent && userAgent.indexOf("Firefox") >= 0);
-const isSafari = !!(!isChrome && (userAgent && userAgent.indexOf("Safari") >= 0));
-const isEdge = !!(userAgent && userAgent.indexOf("Edg/") >= 0);
-const isAndroid = !!(userAgent && userAgent.indexOf("Android") >= 0);
-!!(userAgent && userAgent.indexOf("Electron") >= 0);
+const isChrome = !!(userAgent && ( userAgent.indexOf("Chrome")) >= 0);
+const isFirefox = !!(userAgent && ( userAgent.indexOf("Firefox")) >= 0);
+const isSafari = !!(!isChrome && (userAgent && ( userAgent.indexOf("Safari")) >= 0));
+const isEdge = !!(userAgent && ( userAgent.indexOf("Edg/")) >= 0);
+const isAndroid = !!(userAgent && ( userAgent.indexOf("Android")) >= 0);
 
 export { LANGUAGE_DEFAULT, Language, OS, OperatingSystem, Platform, PlatformToString, isAndroid, isCI, isChrome, isChromeOS, isEdge, isElectron, isFirefox, isIOS, isLinux, isLinuxSnap, isLittleEndian, isMacintosh, isMobile, isNative, isSafari, isWeb, isWebWorker, isWindows, language, locale, platform, platformLocale, setTimeout0, setTimeout0IsFaster, userAgent, webWorkerOrigin };

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

@@ -1,5 +1,4 @@
 
-import '../../nls.js';
 
 var PolicyCategory;
 (function(PolicyCategory) {

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

@@ -233,14 +233,14 @@ var DataUri;
     DataUri.META_DATA_MIME = "mime";
     function parseMetaData(dataUri) {
         const metadata = ( new Map());
-        const meta = dataUri.path.substring(dataUri.path.indexOf(";") + 1, dataUri.path.lastIndexOf(";"));
+        const meta = dataUri.path.substring(( dataUri.path.indexOf(";")) + 1, dataUri.path.lastIndexOf(";"));
         meta.split(";").forEach(property => {
             const [key, value] = property.split(":");
             if (key && value) {
                 metadata.set(key, value);
             }
         });
-        const mime = dataUri.path.substring(0, dataUri.path.indexOf(";"));
+        const mime = dataUri.path.substring(0, ( dataUri.path.indexOf(";")));
         if (mime) {
             metadata.set(DataUri.META_DATA_MIME, mime);
         }

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

@@ -2,43 +2,37 @@
 import { containsUppercaseCharacter } from './strings.js';
 
 function buildReplaceStringWithCasePreserved(matches, pattern) {
-    if (matches && (matches[0] !== '')) {
-        const containsHyphens = validateSpecificSpecialCharacter(matches, pattern, '-');
-        const containsUnderscores = validateSpecificSpecialCharacter(matches, pattern, '_');
+    if (matches && (matches[0] !== "")) {
+        const containsHyphens = validateSpecificSpecialCharacter(matches, pattern, "-");
+        const containsUnderscores = validateSpecificSpecialCharacter(matches, pattern, "_");
         if (containsHyphens && !containsUnderscores) {
-            return buildReplaceStringForSpecificSpecialCharacter(matches, pattern, '-');
-        }
-        else if (!containsHyphens && containsUnderscores) {
-            return buildReplaceStringForSpecificSpecialCharacter(matches, pattern, '_');
+            return buildReplaceStringForSpecificSpecialCharacter(matches, pattern, "-");
+        } else if (!containsHyphens && containsUnderscores) {
+            return buildReplaceStringForSpecificSpecialCharacter(matches, pattern, "_");
         }
         if (matches[0].toUpperCase() === matches[0]) {
             return pattern.toUpperCase();
-        }
-        else if (matches[0].toLowerCase() === matches[0]) {
+        } else if (matches[0].toLowerCase() === matches[0]) {
             return pattern.toLowerCase();
-        }
-        else if (containsUppercaseCharacter(matches[0][0]) && pattern.length > 0) {
+        } else if (containsUppercaseCharacter(matches[0][0]) && pattern.length > 0) {
             return pattern[0].toUpperCase() + pattern.substr(1);
-        }
-        else if (matches[0][0].toUpperCase() !== matches[0][0] && pattern.length > 0) {
+        } else if (matches[0][0].toUpperCase() !== matches[0][0] && pattern.length > 0) {
             return pattern[0].toLowerCase() + pattern.substr(1);
-        }
-        else {
+        } else {
             return pattern;
         }
-    }
-    else {
+    } else {
         return pattern;
     }
 }
 function validateSpecificSpecialCharacter(matches, pattern, specialCharacter) {
-    const doesContainSpecialCharacter = matches[0].indexOf(specialCharacter) !== -1 && pattern.indexOf(specialCharacter) !== -1;
+    const doesContainSpecialCharacter = ( matches[0].indexOf(specialCharacter)) !== -1 && ( pattern.indexOf(specialCharacter)) !== -1;
     return doesContainSpecialCharacter && matches[0].split(specialCharacter).length === pattern.split(specialCharacter).length;
 }
 function buildReplaceStringForSpecificSpecialCharacter(matches, pattern, specialCharacter) {
     const splitPatternAtSpecialCharacter = pattern.split(specialCharacter);
     const splitMatchAtSpecialCharacter = matches[0].split(specialCharacter);
-    let replaceString = '';
+    let replaceString = "";
     splitPatternAtSpecialCharacter.forEach((splitValue, index) => {
         replaceString += buildReplaceStringWithCasePreserved([splitMatchAtSpecialCharacter[index]], splitValue) + specialCharacter;
     });

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

@@ -32,8 +32,8 @@ class SSEParser {
         }
         this.endedOnCR = false;
         while (offset < chunk.length) {
-            const indexCR = chunk.indexOf(Chr.CR, offset);
-            const indexLF = chunk.indexOf(Chr.LF, offset);
+            const indexCR = ( chunk.indexOf(Chr.CR, offset));
+            const indexLF = ( chunk.indexOf(Chr.LF, offset));
             const index = indexCR === -1 ? indexLF : (indexLF === -1 ? indexCR : Math.min(indexCR, indexLF));
             if (index === -1) {
                 break;
@@ -65,7 +65,7 @@ class SSEParser {
         }
         let field;
         let value;
-        const colonIndex = line.indexOf(":");
+        const colonIndex = ( line.indexOf(":"));
         if (colonIndex === -1) {
             field = line;
             value = "";

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

@@ -149,7 +149,7 @@ class WriteableStreamImpl {
             break;
         }
         if (listeners) {
-            const index = listeners.indexOf(callback);
+            const index = ( listeners.indexOf(callback));
             if (index >= 0) {
                 listeners.splice(index, 1);
             }