@codingame/monaco-vscode-api 9.0.2 → 10.0.0

package/vscode/src/vs/workbench/contrib/debug/browser/callStackEditorContribution.js

@@ -2,9 +2,8 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { distinct } from '../../../../base/common/arrays.js';
 import { Event } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { Constants } from '../../../../base/common/uint.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { GlyphMarginLane, OverviewRulerLane, TrackedRangeStickiness } from '../../../../editor/common/model.js';
+import { GlyphMarginLane, OverviewRulerLane } from '../../../../editor/common/model.js';
 import { localize } from '../../../../nls.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
@@ -25,14 +24,14 @@ import { debugStackframe, debugStackframeFocused } from './debugIcons.js';
 import { IDebugService } from '../common/debug.service.js';
 import './media/callStackEditorContribution.css.js';
 const topStackFrameColor = registerColor('editor.stackFrameHighlightBackground', { dark: '#ffff0033', light: '#ffff6673', hcDark: '#ffff0033', hcLight: '#ffff6673' }, ( localize(
-    5896,
+    5921,
     'Background color for the highlight of line at the top stack frame position.'
 )));
 const focusedStackFrameColor = registerColor('editor.focusedStackFrameHighlightBackground', { dark: '#7abd7a4d', light: '#cee7ce73', hcDark: '#7abd7a4d', hcLight: '#cee7ce73' }, ( localize(
-    5897,
+    5922,
     'Background color for the highlight of line at focused stack frame position.'
 )));
-const stickiness = TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges;
+const stickiness = 1 ;
 const TOP_STACK_FRAME_MARGIN = {
     description: 'top-stack-frame-margin',
     glyphMarginClassName: ThemeIcon.asClassName(debugStackframe),
@@ -81,7 +80,7 @@ function createDecorationsForStackFrame(stackFrame, isFocusedSession, noCharacte
         stackFrame.range.startLineNumber,
         stackFrame.range.startColumn,
         stackFrame.range.startLineNumber,
-        Constants.MAX_SAFE_SMALL_INTEGER
+        1073741824
     )));
     const range = ( (new Range(
         stackFrame.range.startLineNumber,

package/vscode/src/vs/workbench/contrib/debug/browser/debugANSIHandling.js

@@ -0,0 +1,370 @@
+import { Color, RGBA } from '../../../../base/common/color.js';
+import { isDefined } from '../../../../base/common/types.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorHoverBackground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+import { SIDE_BAR_BACKGROUND, PANEL_BACKGROUND } from '../../../common/theme.js';
+import { ansiColorIdentifiers } from '../../terminal/common/terminalColorRegistry.js';
+function handleANSIOutput(text, linkDetector, workspaceFolder) {
+    const root = document.createElement('span');
+    const textLength = text.length;
+    let styleNames = [];
+    let customFgColor;
+    let customBgColor;
+    let customUnderlineColor;
+    let colorsInverted = false;
+    let currentPos = 0;
+    let buffer = '';
+    while (currentPos < textLength) {
+        let sequenceFound = false;
+        if (text.charCodeAt(currentPos) === 27 && text.charAt(currentPos + 1) === '[') {
+            const startPos = currentPos;
+            currentPos += 2;
+            let ansiSequence = '';
+            while (currentPos < textLength) {
+                const char = text.charAt(currentPos);
+                ansiSequence += char;
+                currentPos++;
+                if (char.match(/^[ABCDHIJKfhmpsu]$/)) {
+                    sequenceFound = true;
+                    break;
+                }
+            }
+            if (sequenceFound) {
+                appendStylizedStringToContainer(root, buffer, styleNames, linkDetector, workspaceFolder, customFgColor, customBgColor, customUnderlineColor);
+                buffer = '';
+                if (ansiSequence.match(/^(?:[34][0-8]|9[0-7]|10[0-7]|[0-9]|2[1-5,7-9]|[34]9|5[8,9]|1[0-9])(?:;[349][0-7]|10[0-7]|[013]|[245]|[34]9)?(?:;[012]?[0-9]?[0-9])*;?m$/)) {
+                    const styleCodes = ( ansiSequence.slice(0, -1)
+                        .split(';')
+                        .filter(elem => elem !== '')
+                        .map(elem => parseInt(elem, 10)));
+                    if (styleCodes[0] === 38 || styleCodes[0] === 48 || styleCodes[0] === 58) {
+                        const colorType = (styleCodes[0] === 38) ? 'foreground' : ((styleCodes[0] === 48) ? 'background' : 'underline');
+                        if (styleCodes[1] === 5) {
+                            set8BitColor(styleCodes, colorType);
+                        }
+                        else if (styleCodes[1] === 2) {
+                            set24BitColor(styleCodes, colorType);
+                        }
+                    }
+                    else {
+                        setBasicFormatters(styleCodes);
+                    }
+                }
+            }
+            else {
+                currentPos = startPos;
+            }
+        }
+        if (sequenceFound === false) {
+            buffer += text.charAt(currentPos);
+            currentPos++;
+        }
+    }
+    if (buffer) {
+        appendStylizedStringToContainer(root, buffer, styleNames, linkDetector, workspaceFolder, customFgColor, customBgColor, customUnderlineColor);
+    }
+    return root;
+    function changeColor(colorType, color) {
+        if (colorType === 'foreground') {
+            customFgColor = color;
+        }
+        else if (colorType === 'background') {
+            customBgColor = color;
+        }
+        else if (colorType === 'underline') {
+            customUnderlineColor = color;
+        }
+        styleNames = styleNames.filter(style => style !== `code-${colorType}-colored`);
+        if (color !== undefined) {
+            styleNames.push(`code-${colorType}-colored`);
+        }
+    }
+    function reverseForegroundAndBackgroundColors() {
+        const oldFgColor = customFgColor;
+        changeColor('foreground', customBgColor);
+        changeColor('background', oldFgColor);
+    }
+    function setBasicFormatters(styleCodes) {
+        for (const code of styleCodes) {
+            switch (code) {
+                case 0: {
+                    styleNames = [];
+                    customFgColor = undefined;
+                    customBgColor = undefined;
+                    break;
+                }
+                case 1: {
+                    styleNames = styleNames.filter(style => style !== `code-bold`);
+                    styleNames.push('code-bold');
+                    break;
+                }
+                case 2: {
+                    styleNames = styleNames.filter(style => style !== `code-dim`);
+                    styleNames.push('code-dim');
+                    break;
+                }
+                case 3: {
+                    styleNames = styleNames.filter(style => style !== `code-italic`);
+                    styleNames.push('code-italic');
+                    break;
+                }
+                case 4: {
+                    styleNames = styleNames.filter(style => (style !== `code-underline` && style !== `code-double-underline`));
+                    styleNames.push('code-underline');
+                    break;
+                }
+                case 5: {
+                    styleNames = styleNames.filter(style => style !== `code-blink`);
+                    styleNames.push('code-blink');
+                    break;
+                }
+                case 6: {
+                    styleNames = styleNames.filter(style => style !== `code-rapid-blink`);
+                    styleNames.push('code-rapid-blink');
+                    break;
+                }
+                case 7: {
+                    if (!colorsInverted) {
+                        colorsInverted = true;
+                        reverseForegroundAndBackgroundColors();
+                    }
+                    break;
+                }
+                case 8: {
+                    styleNames = styleNames.filter(style => style !== `code-hidden`);
+                    styleNames.push('code-hidden');
+                    break;
+                }
+                case 9: {
+                    styleNames = styleNames.filter(style => style !== `code-strike-through`);
+                    styleNames.push('code-strike-through');
+                    break;
+                }
+                case 10: {
+                    styleNames = styleNames.filter(style => !style.startsWith('code-font'));
+                    break;
+                }
+                case 11:
+                case 12:
+                case 13:
+                case 14:
+                case 15:
+                case 16:
+                case 17:
+                case 18:
+                case 19:
+                case 20: {
+                    styleNames = styleNames.filter(style => !style.startsWith('code-font'));
+                    styleNames.push(`code-font-${code - 10}`);
+                    break;
+                }
+                case 21: {
+                    styleNames = styleNames.filter(style => (style !== `code-underline` && style !== `code-double-underline`));
+                    styleNames.push('code-double-underline');
+                    break;
+                }
+                case 22: {
+                    styleNames = styleNames.filter(style => (style !== `code-bold` && style !== `code-dim`));
+                    break;
+                }
+                case 23: {
+                    styleNames = styleNames.filter(style => (style !== `code-italic` && style !== `code-font-10`));
+                    break;
+                }
+                case 24: {
+                    styleNames = styleNames.filter(style => (style !== `code-underline` && style !== `code-double-underline`));
+                    break;
+                }
+                case 25: {
+                    styleNames = styleNames.filter(style => (style !== `code-blink` && style !== `code-rapid-blink`));
+                    break;
+                }
+                case 27: {
+                    if (colorsInverted) {
+                        colorsInverted = false;
+                        reverseForegroundAndBackgroundColors();
+                    }
+                    break;
+                }
+                case 28: {
+                    styleNames = styleNames.filter(style => style !== `code-hidden`);
+                    break;
+                }
+                case 29: {
+                    styleNames = styleNames.filter(style => style !== `code-strike-through`);
+                    break;
+                }
+                case 53: {
+                    styleNames = styleNames.filter(style => style !== `code-overline`);
+                    styleNames.push('code-overline');
+                    break;
+                }
+                case 55: {
+                    styleNames = styleNames.filter(style => style !== `code-overline`);
+                    break;
+                }
+                case 39: {
+                    changeColor('foreground', undefined);
+                    break;
+                }
+                case 49: {
+                    changeColor('background', undefined);
+                    break;
+                }
+                case 59: {
+                    changeColor('underline', undefined);
+                    break;
+                }
+                case 73: {
+                    styleNames = styleNames.filter(style => (style !== `code-superscript` && style !== `code-subscript`));
+                    styleNames.push('code-superscript');
+                    break;
+                }
+                case 74: {
+                    styleNames = styleNames.filter(style => (style !== `code-superscript` && style !== `code-subscript`));
+                    styleNames.push('code-subscript');
+                    break;
+                }
+                case 75: {
+                    styleNames = styleNames.filter(style => (style !== `code-superscript` && style !== `code-subscript`));
+                    break;
+                }
+                default: {
+                    setBasicColor(code);
+                    break;
+                }
+            }
+        }
+    }
+    function set24BitColor(styleCodes, colorType) {
+        if (styleCodes.length >= 5 &&
+            styleCodes[2] >= 0 && styleCodes[2] <= 255 &&
+            styleCodes[3] >= 0 && styleCodes[3] <= 255 &&
+            styleCodes[4] >= 0 && styleCodes[4] <= 255) {
+            const customColor = ( new RGBA(styleCodes[2], styleCodes[3], styleCodes[4]));
+            changeColor(colorType, customColor);
+        }
+    }
+    function set8BitColor(styleCodes, colorType) {
+        let colorNumber = styleCodes[2];
+        const color = calcANSI8bitColor(colorNumber);
+        if (color) {
+            changeColor(colorType, color);
+        }
+        else if (colorNumber >= 0 && colorNumber <= 15) {
+            if (colorType === 'underline') {
+                const colorName = ansiColorIdentifiers[colorNumber];
+                changeColor(colorType, `--vscode-debug-ansi-${colorName}`);
+                return;
+            }
+            colorNumber += 30;
+            if (colorNumber >= 38) {
+                colorNumber += 52;
+            }
+            if (colorType === 'background') {
+                colorNumber += 10;
+            }
+            setBasicColor(colorNumber);
+        }
+    }
+    function setBasicColor(styleCode) {
+        let colorType;
+        let colorIndex;
+        if (styleCode >= 30 && styleCode <= 37) {
+            colorIndex = styleCode - 30;
+            colorType = 'foreground';
+        }
+        else if (styleCode >= 90 && styleCode <= 97) {
+            colorIndex = (styleCode - 90) + 8;
+            colorType = 'foreground';
+        }
+        else if (styleCode >= 40 && styleCode <= 47) {
+            colorIndex = styleCode - 40;
+            colorType = 'background';
+        }
+        else if (styleCode >= 100 && styleCode <= 107) {
+            colorIndex = (styleCode - 100) + 8;
+            colorType = 'background';
+        }
+        if (colorIndex !== undefined && colorType) {
+            const colorName = ansiColorIdentifiers[colorIndex];
+            changeColor(colorType, `--vscode-debug-ansi-${colorName.replaceAll('.', '-')}`);
+        }
+    }
+}
+function appendStylizedStringToContainer(root, stringContent, cssClasses, linkDetector, workspaceFolder, customTextColor, customBackgroundColor, customUnderlineColor) {
+    if (!root || !stringContent) {
+        return;
+    }
+    const container = linkDetector.linkify(stringContent, true, workspaceFolder);
+    container.className = cssClasses.join(' ');
+    if (customTextColor) {
+        container.style.color =
+            typeof customTextColor === 'string' ? `var(${customTextColor})` : Color.Format.CSS.formatRGB(( new Color(customTextColor)));
+    }
+    if (customBackgroundColor) {
+        container.style.backgroundColor =
+            typeof customBackgroundColor === 'string' ? `var(${customBackgroundColor})` : Color.Format.CSS.formatRGB(( new Color(customBackgroundColor)));
+    }
+    if (customUnderlineColor) {
+        container.style.textDecorationColor =
+            typeof customUnderlineColor === 'string' ? `var(${customUnderlineColor})` : Color.Format.CSS.formatRGB(( new Color(customUnderlineColor)));
+    }
+    root.appendChild(container);
+}
+function calcANSI8bitColor(colorNumber) {
+    if (colorNumber % 1 !== 0) {
+        return;
+    }
+    if (colorNumber >= 16 && colorNumber <= 231) {
+        colorNumber -= 16;
+        let blue = colorNumber % 6;
+        colorNumber = (colorNumber - blue) / 6;
+        let green = colorNumber % 6;
+        colorNumber = (colorNumber - green) / 6;
+        let red = colorNumber;
+        const convFactor = 255 / 5;
+        blue = Math.round(blue * convFactor);
+        green = Math.round(green * convFactor);
+        red = Math.round(red * convFactor);
+        return ( new RGBA(red, green, blue));
+    }
+    else if (colorNumber >= 232 && colorNumber <= 255) {
+        colorNumber -= 232;
+        const colorLevel = Math.round(colorNumber / 23 * 255);
+        return ( new RGBA(colorLevel, colorLevel, colorLevel));
+    }
+    else {
+        return;
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const areas = [
+        { selector: '.monaco-workbench .sidebar, .monaco-workbench .auxiliarybar', bg: theme.getColor(SIDE_BAR_BACKGROUND) },
+        { selector: '.monaco-workbench .panel', bg: theme.getColor(PANEL_BACKGROUND) },
+        { selector: '.debug-hover-widget', bg: theme.getColor(editorHoverBackground) },
+    ];
+    for (const { selector, bg } of areas) {
+        const content = ( ansiColorIdentifiers
+            .map(color => {
+            const actual = theme.getColor(color);
+            if (!actual) {
+                return undefined;
+            }
+            return `--vscode-debug-ansi-${color.replaceAll('.', '-')}:${bg ? bg.ensureConstrast(actual, 4) : actual}`;
+        }))
+            .filter(isDefined);
+        collector.addRule(`${selector} { ${content.join(';')} }`);
+    }
+});
+export { appendStylizedStringToContainer, calcANSI8bitColor, handleANSIOutput };

package/vscode/src/vs/workbench/contrib/debug/browser/debugColors.js

@@ -20,14 +20,14 @@ const debugToolBarBackground = registerColor('debugToolBar.background', {
     light: '#F3F3F3',
     hcDark: '#000000',
     hcLight: '#FFFFFF'
-}, ( localize(5912, "Debug toolbar background color.")));
-const debugToolBarBorder = registerColor('debugToolBar.border', null, ( localize(5913, "Debug toolbar border color.")));
+}, ( localize(5937, "Debug toolbar background color.")));
+const debugToolBarBorder = registerColor('debugToolBar.border', null, ( localize(5938, "Debug toolbar border color.")));
 const debugIconStartForeground = registerColor('debugIcon.startForeground', {
     dark: '#89D185',
     light: '#388A34',
     hcDark: '#89D185',
     hcLight: '#388A34'
-}, ( localize(5914, "Debug toolbar icon for start debugging.")));
+}, ( localize(5939, "Debug toolbar icon for start debugging.")));
 function registerColors() {
     const debugTokenExpressionName = registerColor('debugTokenExpression.name', { dark: '#c586c0', light: '#9b46b0', hcDark: foreground, hcLight: foreground }, 'Foreground color for the token names shown in the debug views (ie. the Variables or Watch view).');
     const debugTokenExpressionType = registerColor('debugTokenExpression.type', { dark: '#4A90E2', light: '#4A90E2', hcDark: foreground, hcLight: foreground }, 'Foreground color for the token types shown in the debug views (ie. the Variables or Watch view).');
@@ -51,55 +51,55 @@ function registerColors() {
         light: '#007ACC',
         hcDark: '#75BEFF',
         hcLight: '#007ACC'
-    }, ( localize(5915, "Debug toolbar icon for pause.")));
+    }, ( localize(5940, "Debug toolbar icon for pause.")));
     const debugIconStopForeground = registerColor('debugIcon.stopForeground', {
         dark: '#F48771',
         light: '#A1260D',
         hcDark: '#F48771',
         hcLight: '#A1260D'
-    }, ( localize(5916, "Debug toolbar icon for stop.")));
+    }, ( localize(5941, "Debug toolbar icon for stop.")));
     const debugIconDisconnectForeground = registerColor('debugIcon.disconnectForeground', {
         dark: '#F48771',
         light: '#A1260D',
         hcDark: '#F48771',
         hcLight: '#A1260D'
-    }, ( localize(5917, "Debug toolbar icon for disconnect.")));
+    }, ( localize(5942, "Debug toolbar icon for disconnect.")));
     const debugIconRestartForeground = registerColor('debugIcon.restartForeground', {
         dark: '#89D185',
         light: '#388A34',
         hcDark: '#89D185',
         hcLight: '#388A34'
-    }, ( localize(5918, "Debug toolbar icon for restart.")));
+    }, ( localize(5943, "Debug toolbar icon for restart.")));
     const debugIconStepOverForeground = registerColor('debugIcon.stepOverForeground', {
         dark: '#75BEFF',
         light: '#007ACC',
         hcDark: '#75BEFF',
         hcLight: '#007ACC'
-    }, ( localize(5919, "Debug toolbar icon for step over.")));
+    }, ( localize(5944, "Debug toolbar icon for step over.")));
     const debugIconStepIntoForeground = registerColor('debugIcon.stepIntoForeground', {
         dark: '#75BEFF',
         light: '#007ACC',
         hcDark: '#75BEFF',
         hcLight: '#007ACC'
-    }, ( localize(5920, "Debug toolbar icon for step into.")));
+    }, ( localize(5945, "Debug toolbar icon for step into.")));
     const debugIconStepOutForeground = registerColor('debugIcon.stepOutForeground', {
         dark: '#75BEFF',
         light: '#007ACC',
         hcDark: '#75BEFF',
         hcLight: '#007ACC'
-    }, ( localize(5921, "Debug toolbar icon for step over.")));
+    }, ( localize(5946, "Debug toolbar icon for step over.")));
     const debugIconContinueForeground = registerColor('debugIcon.continueForeground', {
         dark: '#75BEFF',
         light: '#007ACC',
         hcDark: '#75BEFF',
         hcLight: '#007ACC'
-    }, ( localize(5922, "Debug toolbar icon for continue.")));
+    }, ( localize(5947, "Debug toolbar icon for continue.")));
     const debugIconStepBackForeground = registerColor('debugIcon.stepBackForeground', {
         dark: '#75BEFF',
         light: '#007ACC',
         hcDark: '#75BEFF',
         hcLight: '#007ACC'
-    }, ( localize(5923, "Debug toolbar icon for step back.")));
+    }, ( localize(5948, "Debug toolbar icon for step back.")));
     registerThemingParticipant((theme, collector) => {
         const badgeBackgroundColor = theme.getColor(badgeBackground);
         const badgeForegroundColor = theme.getColor(badgeForeground);