@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/editor/common/standaloneStrings.js

@@ -1,167 +1,108 @@
 import { localizeWithPath } from '../../nls.js';
+const _moduleId = "vs/editor/common/standaloneStrings";
 var AccessibilityHelpNLS;
-( (function(AccessibilityHelpNLS) {
-    AccessibilityHelpNLS.accessibilityHelpTitle = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        'accessibilityHelpTitle',
-        "Accessibility Help"
-    ));
-    AccessibilityHelpNLS.openingDocs = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "openingDocs",
-        "Opening the Accessibility documentation page."
-    ));
-    AccessibilityHelpNLS.readonlyDiffEditor = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "readonlyDiffEditor",
-        "You are in a read-only pane of a diff editor."
-    ));
-    AccessibilityHelpNLS.editableDiffEditor = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "editableDiffEditor",
-        "You are in a pane of a diff editor."
-    ));
-    AccessibilityHelpNLS.readonlyEditor = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "readonlyEditor",
-        "You are in a read-only code editor."
-    ));
-    AccessibilityHelpNLS.editableEditor = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "editableEditor",
-        "You are in a code editor."
-    ));
+( ((function(AccessibilityHelpNLS) {
+    AccessibilityHelpNLS.accessibilityHelpTitle = ( localizeWithPath(_moduleId, 0, "Accessibility Help"));
+    AccessibilityHelpNLS.openingDocs = ( localizeWithPath(_moduleId, 1, "Opening the Accessibility documentation page."));
+    AccessibilityHelpNLS.readonlyDiffEditor = ( localizeWithPath(_moduleId, 2, "You are in a read-only pane of a diff editor."));
+    AccessibilityHelpNLS.editableDiffEditor = ( localizeWithPath(_moduleId, 3, "You are in a pane of a diff editor."));
+    AccessibilityHelpNLS.readonlyEditor = ( localizeWithPath(_moduleId, 4, "You are in a read-only code editor."));
+    AccessibilityHelpNLS.editableEditor = ( localizeWithPath(_moduleId, 5, "You are in a code editor."));
     AccessibilityHelpNLS.changeConfigToOnMac = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "changeConfigToOnMac",
+        _moduleId,
+        6,
         "Configure the application to be optimized for usage with a Screen Reader (Command+E)."
     ));
     AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "changeConfigToOnWinLinux",
+        _moduleId,
+        7,
         "Configure the application to be optimized for usage with a Screen Reader (Control+E)."
     ));
     AccessibilityHelpNLS.auto_on = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "auto_on",
+        _moduleId,
+        8,
         "The application is configured to be optimized for usage with a Screen Reader."
     ));
     AccessibilityHelpNLS.auto_off = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "auto_off",
+        _moduleId,
+        9,
         "The application is configured to never be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.screenReaderModeEnabled = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "screenReaderModeEnabled",
-        "Screen Reader Optimized Mode enabled."
-    ));
-    AccessibilityHelpNLS.screenReaderModeDisabled = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "screenReaderModeDisabled",
-        "Screen Reader Optimized Mode disabled."
-    ));
+    AccessibilityHelpNLS.screenReaderModeEnabled = ( localizeWithPath(_moduleId, 10, "Screen Reader Optimized Mode enabled."));
+    AccessibilityHelpNLS.screenReaderModeDisabled = ( localizeWithPath(_moduleId, 11, "Screen Reader Optimized Mode disabled."));
     AccessibilityHelpNLS.tabFocusModeOnMsg = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "tabFocusModeOnMsg",
+        _moduleId,
+        12,
         "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior {0}."
     ));
     AccessibilityHelpNLS.tabFocusModeOnMsgNoKb = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "tabFocusModeOnMsgNoKb",
+        _moduleId,
+        13,
         "Pressing Tab in the current editor will move focus to the next focusable element. The command {0} is currently not triggerable by a keybinding."
     ));
     AccessibilityHelpNLS.stickScrollKb = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "stickScrollKb",
+        _moduleId,
+        14,
         "Focus Sticky Scroll ({0}) to focus the currently nested scopes."
     ));
     AccessibilityHelpNLS.stickScrollNoKb = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "stickScrollNoKb",
+        _moduleId,
+        15,
         "Focus Sticky Scroll to focus the currently nested scopes. It is currently not triggerable by a keybinding."
     ));
     AccessibilityHelpNLS.tabFocusModeOffMsg = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "tabFocusModeOffMsg",
+        _moduleId,
+        16,
         "Pressing Tab in the current editor will insert the tab character. Toggle this behavior {0}."
     ));
     AccessibilityHelpNLS.tabFocusModeOffMsgNoKb = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "tabFocusModeOffMsgNoKb",
+        _moduleId,
+        17,
         "Pressing Tab in the current editor will insert the tab character. The command {0} is currently not triggerable by a keybinding."
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "showAccessibilityHelpAction",
-        "Show Accessibility Help"
-    ));
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localizeWithPath(_moduleId, 18, "Show Accessibility Help"));
     AccessibilityHelpNLS.listSignalSounds = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "listSignalSoundsCommand",
+        _moduleId,
+        19,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
     AccessibilityHelpNLS.listAlerts = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "listAnnouncementsCommand",
+        _moduleId,
+        20,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
-    AccessibilityHelpNLS.quickChat = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "quickChatCommand",
-        "Toggle quick chat ({0}) to open or close a chat session."
-    ));
+    AccessibilityHelpNLS.quickChat = ( localizeWithPath(_moduleId, 21, "Toggle quick chat ({0}) to open or close a chat session."));
     AccessibilityHelpNLS.quickChatNoKb = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "quickChatCommandNoKb",
+        _moduleId,
+        22,
         "Toggle quick chat is not currently triggerable by a keybinding."
     ));
     AccessibilityHelpNLS.startInlineChat = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "startInlineChatCommand",
+        _moduleId,
+        23,
         "Start inline chat ({0}) to create an in editor chat session."
     ));
     AccessibilityHelpNLS.startInlineChatNoKb = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        "startInlineChatCommandNoKb",
+        _moduleId,
+        24,
         "The command: Start inline chat is not currentlyt riggerable by a keybinding."
     ));
-})(AccessibilityHelpNLS || (AccessibilityHelpNLS = {})));
+})(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}))));
 var InspectTokensNLS;
-( (function(InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        'inspectTokens',
-        "Developer: Inspect Tokens"
-    ));
-})(InspectTokensNLS || (InspectTokensNLS = {})));
+( ((function(InspectTokensNLS) {
+    InspectTokensNLS.inspectTokensAction = ( localizeWithPath(_moduleId, 25, "Developer: Inspect Tokens"));
+})(InspectTokensNLS || (InspectTokensNLS = {}))));
 var StandaloneCodeEditorNLS;
-( (function(StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        'editorViewAccessibleLabel',
-        "Editor content"
-    ));
-    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        'accessibilityHelpMessage',
-        "Press Alt+F1 for Accessibility Options."
-    ));
-})(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {})));
+( ((function(StandaloneCodeEditorNLS) {
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localizeWithPath(_moduleId, 32, "Editor content"));
+    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localizeWithPath(_moduleId, 33, "Press Alt+F1 for Accessibility Options."));
+})(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}))));
 var ToggleHighContrastNLS;
-( (function(ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        'toggleHighContrast',
-        "Toggle High Contrast Theme"
-    ));
-})(ToggleHighContrastNLS || (ToggleHighContrastNLS = {})));
+( ((function(ToggleHighContrastNLS) {
+    ToggleHighContrastNLS.toggleHighContrast = ( localizeWithPath(_moduleId, 34, "Toggle High Contrast Theme"));
+})(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}))));
 var StandaloneServicesNLS;
-( (function(StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localizeWithPath(
-        'vs/editor/common/standaloneStrings',
-        'bulkEditServiceSummary',
-        "Made {0} edits in {1} files"
-    ));
-})(StandaloneServicesNLS || (StandaloneServicesNLS = {})));
+( ((function(StandaloneServicesNLS) {
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localizeWithPath(_moduleId, 35, "Made {0} edits in {1} files"));
+})(StandaloneServicesNLS || (StandaloneServicesNLS = {}))));
 export { AccessibilityHelpNLS, InspectTokensNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/vscode/src/vs/editor/common/textModelGuides.js

@@ -15,7 +15,7 @@ class IndentGuide {
         this.forWrappedLinesAfterColumn = forWrappedLinesAfterColumn;
         this.forWrappedLinesBeforeOrAtColumn = forWrappedLinesBeforeOrAtColumn;
         if ((visibleColumn !== -1) === (column !== -1)) {
-            throw new Error();
+            throw ( new Error());
         }
     }
 }

package/vscode/src/vs/editor/common/tokens/contiguousMultilineTokens.js

@@ -47,7 +47,7 @@ class ContiguousMultilineTokens {
         for (let i = 0; i < this._tokens.length; i++) {
             const lineTokens = this._tokens[i];
             if (!(lineTokens instanceof Uint32Array)) {
-                throw new Error(`Not supported!`);
+                throw ( new Error(`Not supported!`));
             }
             result += 4;
             result += lineTokens.byteLength;
@@ -62,7 +62,7 @@ class ContiguousMultilineTokens {
         for (let i = 0; i < this._tokens.length; i++) {
             const lineTokens = this._tokens[i];
             if (!(lineTokens instanceof Uint32Array)) {
-                throw new Error(`Not supported!`);
+                throw ( new Error(`Not supported!`));
             }
             writeUInt32BE(destination, lineTokens.byteLength, offset);
             offset += 4;

package/vscode/src/vs/editor/common/tokens/sparseMultilineTokens.js

@@ -312,7 +312,7 @@ class SparseMultilineTokensStorage {
                 tokenEndCharacter -= (endCharacter - startCharacter);
             }
             else {
-                throw new Error(`Not possible!`);
+                throw ( new Error(`Not possible!`));
             }
             const destOffset = 4 * newTokenCount;
             tokens[destOffset] = tokenDeltaLine;

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

@@ -3,6 +3,7 @@ import { containsRTL, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isFullWid
 import { StringBuilder } from '../core/stringBuilder.js';
 import { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';
 import { LinePart } from './linePart.js';
+const _moduleId = "vs/editor/common/viewLayout/viewLineRenderer";
 class LineRange {
     constructor(startIndex, endIndex) {
         this.startOffset = startIndex;
@@ -103,8 +104,8 @@ class CharacterMapping {
     }
     constructor(length, partCount) {
         this.length = length;
-        this._data = ( new Uint32Array(this.length));
-        this._horizontalOffset = ( new Uint32Array(this.length));
+        this._data = ( (new Uint32Array(this.length)));
+        this._horizontalOffset = ( (new Uint32Array(this.length)));
     }
     setColumnInfo(column, partIndex, charIndex, horizontalOffset) {
         const partData = (((partIndex << 16) )
@@ -134,7 +135,9 @@ class CharacterMapping {
         const partData = this.charOffsetToPartData(column - 1);
         const partIndex = CharacterMapping.getPartIndex(partData);
         const charIndex = CharacterMapping.getCharIndex(partData);
-        return ( new DomPosition(partIndex, charIndex));
+        return (
+             (new DomPosition(partIndex, charIndex))
+        );
     }
     getColumn(domPosition, partLength) {
         const charOffset = this.partDataToCharOffset(domPosition.partIndex, partLength, domPosition.charIndex);
@@ -232,12 +235,20 @@ function renderViewLine(input, sb) {
                 }
             }
             sb.appendString(`</span>`);
-            const characterMapping = ( new CharacterMapping(1, beforeCount + afterCount));
+            const characterMapping = ( (new CharacterMapping(1, beforeCount + afterCount)));
             characterMapping.setColumnInfo(1, beforeCount, 0, 0);
-            return ( new RenderLineOutput(characterMapping, false, containsForeignElements));
+            return (
+                 (new RenderLineOutput(characterMapping, false, containsForeignElements))
+            );
         }
         sb.appendString('<span><span></span></span>');
-        return ( new RenderLineOutput(( new CharacterMapping(0, 0)), false, 0 ));
+        return (
+             (new RenderLineOutput(
+                 (new CharacterMapping(0, 0)),
+                false,
+                0
+            ))
+        );
     }
     return _renderLine(resolveRenderLineInput(input), sb);
 }
@@ -250,14 +261,16 @@ class RenderLineOutput2 {
     }
 }
 function renderViewLine2(input) {
-    const sb = ( new StringBuilder(10000));
+    const sb = ( (new StringBuilder(10000)));
     const out = renderViewLine(input, sb);
-    return ( new RenderLineOutput2(
-        out.characterMapping,
-        sb.build(),
-        out.containsRTL,
-        out.containsForeignElements
-    ));
+    return (
+         (new RenderLineOutput2(
+            out.characterMapping,
+            sb.build(),
+            out.containsRTL,
+            out.containsForeignElements
+        ))
+    );
 }
 class ResolvedRenderLineInput {
     constructor(fontIsMonospace, canUseHalfwidthRightwardsArrow, lineContent, len, isOverflowing, overflowingCharCount, parts, containsForeignElements, fauxIndentLength, tabSize, startVisibleColumn, containsRTL, spaceWidth, renderSpaceCharCode, renderWhitespace, renderControlCharacters) {
@@ -323,30 +336,32 @@ function resolveRenderLineInput(input) {
     if (!input.containsRTL) {
         tokens = splitLargeTokens(lineContent, tokens, !input.isBasicASCII || input.fontLigatures);
     }
-    return ( new ResolvedRenderLineInput(
-        input.useMonospaceOptimizations,
-        input.canUseHalfwidthRightwardsArrow,
-        lineContent,
-        len,
-        isOverflowing,
-        overflowingCharCount,
-        tokens,
-        containsForeignElements,
-        input.fauxIndentLength,
-        input.tabSize,
-        input.startVisibleColumn,
-        input.containsRTL,
-        input.spaceWidth,
-        input.renderSpaceCharCode,
-        input.renderWhitespace,
-        input.renderControlCharacters
-    ));
+    return (
+         (new ResolvedRenderLineInput(
+            input.useMonospaceOptimizations,
+            input.canUseHalfwidthRightwardsArrow,
+            lineContent,
+            len,
+            isOverflowing,
+            overflowingCharCount,
+            tokens,
+            containsForeignElements,
+            input.fauxIndentLength,
+            input.tabSize,
+            input.startVisibleColumn,
+            input.containsRTL,
+            input.spaceWidth,
+            input.renderSpaceCharCode,
+            input.renderWhitespace,
+            input.renderControlCharacters
+        ))
+    );
 }
 function transformAndRemoveOverflowing(lineContent, lineContainsRTL, tokens, fauxIndentLength, len) {
     const result = [];
     let resultLen = 0;
     if (fauxIndentLength > 0) {
-        result[resultLen++] = ( new LinePart(fauxIndentLength, '', 0, false));
+        result[resultLen++] = ( (new LinePart(fauxIndentLength, '', 0, false)));
     }
     let startOffset = fauxIndentLength;
     for (let tokenIndex = 0, tokensLen = tokens.getCount(); tokenIndex < tokensLen; tokenIndex++) {
@@ -357,11 +372,11 @@ function transformAndRemoveOverflowing(lineContent, lineContainsRTL, tokens, fau
         const type = tokens.getClassName(tokenIndex);
         if (endIndex >= len) {
             const tokenContainsRTL = (lineContainsRTL ? containsRTL(lineContent.substring(startOffset, len)) : false);
-            result[resultLen++] = ( new LinePart(len, type, 0, tokenContainsRTL));
+            result[resultLen++] = ( (new LinePart(len, type, 0, tokenContainsRTL)));
             break;
         }
         const tokenContainsRTL = (lineContainsRTL ? containsRTL(lineContent.substring(startOffset, endIndex)) : false);
-        result[resultLen++] = ( new LinePart(endIndex, type, 0, tokenContainsRTL));
+        result[resultLen++] = ( (new LinePart(endIndex, type, 0, tokenContainsRTL)));
         startOffset = endIndex;
     }
     return result;
@@ -385,13 +400,13 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
                         lastSpaceOffset = j;
                     }
                     if (lastSpaceOffset !== -1 && j - currTokenStart >= 50 ) {
-                        result[resultLen++] = ( new LinePart(lastSpaceOffset + 1, tokenType, tokenMetadata, tokenContainsRTL));
+                        result[resultLen++] = ( (new LinePart(lastSpaceOffset + 1, tokenType, tokenMetadata, tokenContainsRTL)));
                         currTokenStart = lastSpaceOffset + 1;
                         lastSpaceOffset = -1;
                     }
                 }
                 if (currTokenStart !== tokenEndIndex) {
-                    result[resultLen++] = ( new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+                    result[resultLen++] = ( (new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
                 }
             }
             else {
@@ -412,9 +427,9 @@ function splitLargeTokens(lineContent, tokens, onlyAtSpaces) {
                 const piecesCount = Math.ceil(diff / 50 );
                 for (let j = 1; j < piecesCount; j++) {
                     const pieceEndIndex = lastTokenEndIndex + ((j * 50) );
-                    result[resultLen++] = ( new LinePart(pieceEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+                    result[resultLen++] = ( (new LinePart(pieceEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
                 }
-                result[resultLen++] = ( new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+                result[resultLen++] = ( (new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
             }
             else {
                 result[resultLen++] = token;
@@ -441,7 +456,7 @@ function isControlCharacter(charCode) {
 }
 function extractControlCharacters(lineContent, tokens) {
     const result = [];
-    let lastLinePart = ( new LinePart(0, '', 0, false));
+    let lastLinePart = ( (new LinePart(0, '', 0, false)));
     let charOffset = 0;
     for (const token of tokens) {
         const tokenEndIndex = token.endIndex;
@@ -449,15 +464,15 @@ function extractControlCharacters(lineContent, tokens) {
             const charCode = lineContent.charCodeAt(charOffset);
             if (isControlCharacter(charCode)) {
                 if (charOffset > lastLinePart.endIndex) {
-                    lastLinePart = ( new LinePart(charOffset, token.type, token.metadata, token.containsRTL));
+                    lastLinePart = ( (new LinePart(charOffset, token.type, token.metadata, token.containsRTL)));
                     result.push(lastLinePart);
                 }
-                lastLinePart = ( new LinePart(charOffset + 1, 'mtkcontrol', token.metadata, false));
+                lastLinePart = ( (new LinePart(charOffset + 1, 'mtkcontrol', token.metadata, false)));
                 result.push(lastLinePart);
             }
         }
         if (charOffset > lastLinePart.endIndex) {
-            lastLinePart = ( new LinePart(tokenEndIndex, token.type, token.metadata, token.containsRTL));
+            lastLinePart = ( (new LinePart(tokenEndIndex, token.type, token.metadata, token.containsRTL)));
             result.push(lastLinePart);
         }
     }
@@ -541,18 +556,18 @@ 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', 1 , false)));
                     }
                 }
                 else {
-                    result[resultLen++] = ( new LinePart(charIndex, 'mtkw', 1 , false));
+                    result[resultLen++] = ( (new LinePart(charIndex, 'mtkw', 1 , false)));
                 }
                 tmpIndent = tmpIndent % tabSize;
             }
         }
         else {
             if (charIndex === tokenEndIndex || (isInWhitespace && charIndex > fauxIndentLength)) {
-                result[resultLen++] = ( new LinePart(charIndex, tokenType, 0, tokenContainsRTL));
+                result[resultLen++] = ( (new LinePart(charIndex, tokenType, 0, tokenContainsRTL)));
                 tmpIndent = tmpIndent % tabSize;
             }
         }
@@ -596,15 +611,15 @@ 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', 1 , false)));
             }
         }
         else {
-            result[resultLen++] = ( new LinePart(len, 'mtkw', 1 , false));
+            result[resultLen++] = ( (new LinePart(len, 'mtkw', 1 , false)));
         }
     }
     else {
-        result[resultLen++] = ( new LinePart(len, tokenType, 0, tokenContainsRTL));
+        result[resultLen++] = ( (new LinePart(len, tokenType, 0, tokenContainsRTL)));
     }
     return result;
 }
@@ -626,44 +641,44 @@ function _applyInlineDecorations(lineContent, len, tokens, _lineDecorations) {
             const lineDecoration = lineDecorations[lineDecorationIndex];
             if (lineDecoration.startOffset > lastResultEndIndex) {
                 lastResultEndIndex = lineDecoration.startOffset;
-                result[resultLen++] = ( new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+                result[resultLen++] = ( (new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
             }
             if (lineDecoration.endOffset + 1 <= tokenEndIndex) {
                 lastResultEndIndex = lineDecoration.endOffset + 1;
-                result[resultLen++] = ( new LinePart(
+                result[resultLen++] = ( (new LinePart(
                     lastResultEndIndex,
                     tokenType + ' ' + lineDecoration.className,
                     tokenMetadata | lineDecoration.metadata,
                     tokenContainsRTL
-                ));
+                )));
                 lineDecorationIndex++;
             }
             else {
                 lastResultEndIndex = tokenEndIndex;
-                result[resultLen++] = ( new LinePart(
+                result[resultLen++] = ( (new LinePart(
                     lastResultEndIndex,
                     tokenType + ' ' + lineDecoration.className,
                     tokenMetadata | lineDecoration.metadata,
                     tokenContainsRTL
-                ));
+                )));
                 break;
             }
         }
         if (tokenEndIndex > lastResultEndIndex) {
             lastResultEndIndex = tokenEndIndex;
-            result[resultLen++] = ( new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL));
+            result[resultLen++] = ( (new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL)));
         }
     }
     const lastTokenEndIndex = tokens[tokens.length - 1].endIndex;
     if (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset === lastTokenEndIndex) {
         while (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset === lastTokenEndIndex) {
             const lineDecoration = lineDecorations[lineDecorationIndex];
-            result[resultLen++] = ( new LinePart(
+            result[resultLen++] = ( (new LinePart(
                 lastResultEndIndex,
                 lineDecoration.className,
                 lineDecoration.metadata,
                 false
-            ));
+            )));
             lineDecorationIndex++;
         }
     }
@@ -686,7 +701,7 @@ function _renderLine(input, sb) {
     const renderSpaceCharCode = input.renderSpaceCharCode;
     const renderWhitespace = input.renderWhitespace;
     const renderControlCharacters = input.renderControlCharacters;
-    const characterMapping = ( new CharacterMapping(len + 1, parts.length));
+    const characterMapping = ( (new CharacterMapping(len + 1, parts.length)));
     let lastCharacterMappingDefined = false;
     let charIndex = 0;
     let visibleColumn = startVisibleColumn;
@@ -855,27 +870,24 @@ function _renderLine(input, sb) {
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
         sb.appendString(( localizeWithPath(
-            'vs/editor/common/viewLayout/viewLineRenderer',
-            'showMore',
+            _moduleId,
+            0,
             "Show more ({0})",
             renderOverflowingCharCount(overflowingCharCount)
         )));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
-    return ( new RenderLineOutput(characterMapping, containsRTL, containsForeignElements));
+    return (
+         (new RenderLineOutput(characterMapping, containsRTL, containsForeignElements))
+    );
 }
 function to4CharHex(n) {
-    return ( n.toString(16)).toUpperCase().padStart(4, '0');
+    return ( (n.toString(16))).toUpperCase().padStart(4, '0');
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return ( localizeWithPath(
-            'vs/editor/common/viewLayout/viewLineRenderer',
-            'overflow.chars',
-            "{0} chars",
-            n
-        ));
+        return ( localizeWithPath(_moduleId, 1, "{0} chars", n));
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

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

@@ -192,7 +192,7 @@ class ModelLineProjection {
     }
     _assertVisible() {
         if (!this._isVisible) {
-            throw new Error('Not supported');
+            throw ( new Error('Not supported'));
         }
     }
 }
@@ -281,37 +281,37 @@ class HiddenModelLineProjection {
         return 0;
     }
     getViewLineContent(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewLineLength(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewLineMinColumn(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewLineMaxColumn(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewLineData(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewLinesData(_model, _modelLineNumber, _fromOuputLineIndex, _toOutputLineIndex, _globalStartIndex, _needed, _result) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getModelColumnOfViewPosition(_outputLineIndex, _outputColumn) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewPositionOfModelPosition(_deltaLineNumber, _inputColumn) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getViewLineNumberOfModelPosition(_deltaLineNumber, _inputColumn) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     normalizePosition(outputLineIndex, outputPosition, affinity) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
     getInjectedTextAt(_outputLineIndex, _outputColumn) {
-        throw new Error('Not supported');
+        throw ( new Error('Not supported'));
     }
 }
 const _spaces = [''];