@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,345 @@
+import { Color, RGBA } from '../../../../base/common/color.js';
+import { ansiColorIdentifiers } from '../../terminal/common/terminalColorRegistry.js';
+function handleANSIOutput(text, linkDetector, themeService, 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 theme = themeService.getColorTheme();
+                const colorName = ansiColorIdentifiers[colorNumber];
+                const color = theme.getColor(colorName);
+                if (color) {
+                    changeColor(colorType, color.rgba);
+                }
+                return;
+            }
+            colorNumber += 30;
+            if (colorNumber >= 38) {
+                colorNumber += 52;
+            }
+            if (colorType === 'background') {
+                colorNumber += 10;
+            }
+            setBasicColor(colorNumber);
+        }
+    }
+    function setBasicColor(styleCode) {
+        const theme = themeService.getColorTheme();
+        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];
+            const color = theme.getColor(colorName);
+            if (color) {
+                changeColor(colorType, color.rgba);
+            }
+        }
+    }
+}
+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 =
+            Color.Format.CSS.formatRGB(( new Color(customTextColor)));
+    }
+    if (customBackgroundColor) {
+        container.style.backgroundColor =
+            Color.Format.CSS.formatRGB(( new Color(customBackgroundColor)));
+    }
+    if (customUnderlineColor) {
+        container.style.textDecorationColor =
+            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;
+    }
+}
+export { appendStylizedStringToContainer, calcANSI8bitColor, handleANSIOutput };

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

@@ -0,0 +1,335 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { append, addDisposableListener, $ as $$1, EventType } from '../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { SelectBox } from '../../../../base/browser/ui/selectBox/selectBox.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IDebugService } from '../common/debug.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import { selectBorder, selectBackground } from '../../../../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 { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { ADD_CONFIGURATION_ID } from './debugCommands.js';
+import { BaseActionViewItem, SelectActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { debugStart } from './debugIcons.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { defaultSelectBoxStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+var StartDebugActionViewItem_1;
+const $ = $$1;
+let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseActionViewItem {
+    static { StartDebugActionViewItem_1 = this; }
+    static { this.SEPARATOR = '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500'; }
+    constructor(context, action, options, debugService, configurationService, commandService, contextService, contextViewService, keybindingService) {
+        super(context, action, options);
+        this.context = context;
+        this.debugService = debugService;
+        this.configurationService = configurationService;
+        this.commandService = commandService;
+        this.contextService = contextService;
+        this.keybindingService = keybindingService;
+        this.debugOptions = [];
+        this.selected = 0;
+        this.providers = [];
+        this.toDispose = [];
+        this.selectBox = ( new SelectBox(
+            [],
+            -1,
+            contextViewService,
+            defaultSelectBoxStyles,
+            { ariaLabel: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugActionViewItems',
+                'debugLaunchConfigurations',
+                'Debug Launch Configurations'
+            )) }
+        ));
+        this.selectBox.setFocusable(false);
+        this.toDispose.push(this.selectBox);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('launch')) {
+                this.updateOptions();
+            }
+        }));
+        this.toDispose.push(this.debugService.getConfigurationManager().onDidSelectConfiguration(() => {
+            this.updateOptions();
+        }));
+    }
+    render(container) {
+        this.container = container;
+        container.classList.add('start-debug-action-item');
+        this.start = append(container, $(ThemeIcon.asCSSSelector(debugStart)));
+        const keybinding = this.keybindingService.lookupKeybinding(this.action.id)?.getLabel();
+        const keybindingLabel = keybinding ? ` (${keybinding})` : '';
+        const title = this.action.label + keybindingLabel;
+        this.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), this.start, title));
+        this.start.setAttribute('role', 'button');
+        this.start.ariaLabel = title;
+        this.toDispose.push(addDisposableListener(this.start, EventType.CLICK, () => {
+            this.start.blur();
+            if (this.debugService.state !== 1 ) {
+                this.actionRunner.run(this.action, this.context);
+            }
+        }));
+        this.toDispose.push(addDisposableListener(this.start, EventType.MOUSE_DOWN, (e) => {
+            if (this.action.enabled && e.button === 0) {
+                this.start.classList.add('active');
+            }
+        }));
+        this.toDispose.push(addDisposableListener(this.start, EventType.MOUSE_UP, () => {
+            this.start.classList.remove('active');
+        }));
+        this.toDispose.push(addDisposableListener(this.start, EventType.MOUSE_OUT, () => {
+            this.start.classList.remove('active');
+        }));
+        this.toDispose.push(addDisposableListener(this.start, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(17 )) {
+                this.start.tabIndex = -1;
+                this.selectBox.focus();
+                event.stopPropagation();
+            }
+        }));
+        this.toDispose.push(this.selectBox.onDidSelect(async (e) => {
+            const target = this.debugOptions[e.index];
+            const shouldBeSelected = target.handler ? await target.handler() : false;
+            if (shouldBeSelected) {
+                this.selected = e.index;
+            }
+            else {
+                this.selectBox.select(this.selected);
+            }
+        }));
+        const selectBoxContainer = $('.configuration');
+        this.selectBox.render(append(container, selectBoxContainer));
+        this.toDispose.push(addDisposableListener(selectBoxContainer, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(15 )) {
+                this.selectBox.setFocusable(false);
+                this.start.tabIndex = 0;
+                this.start.focus();
+                event.stopPropagation();
+            }
+        }));
+        this.container.style.border = `1px solid ${asCssVariable(selectBorder)}`;
+        selectBoxContainer.style.borderLeft = `1px solid ${asCssVariable(selectBorder)}`;
+        this.container.style.backgroundColor = asCssVariable(selectBackground);
+        const configManager = this.debugService.getConfigurationManager();
+        const updateDynamicConfigs = () => configManager.getDynamicProviders().then(providers => {
+            if (providers.length !== this.providers.length) {
+                this.providers = providers;
+                this.updateOptions();
+            }
+        });
+        this.toDispose.push(configManager.onDidChangeConfigurationProviders(updateDynamicConfigs));
+        updateDynamicConfigs();
+        this.updateOptions();
+    }
+    setActionContext(context) {
+        this.context = context;
+    }
+    isEnabled() {
+        return true;
+    }
+    focus(fromRight) {
+        if (fromRight) {
+            this.selectBox.focus();
+        }
+        else {
+            this.start.tabIndex = 0;
+            this.start.focus();
+        }
+    }
+    blur() {
+        this.start.tabIndex = -1;
+        this.selectBox.blur();
+        this.container.blur();
+    }
+    setFocusable(focusable) {
+        if (focusable) {
+            this.start.tabIndex = 0;
+        }
+        else {
+            this.start.tabIndex = -1;
+            this.selectBox.setFocusable(false);
+        }
+    }
+    dispose() {
+        this.toDispose = dispose(this.toDispose);
+        super.dispose();
+    }
+    updateOptions() {
+        this.selected = 0;
+        this.debugOptions = [];
+        const manager = this.debugService.getConfigurationManager();
+        const inWorkspace = this.contextService.getWorkbenchState() === 3 ;
+        let lastGroup;
+        const disabledIdxs = [];
+        manager.getAllConfigurations().forEach(({ launch, name, presentation }) => {
+            if (lastGroup !== presentation?.group) {
+                lastGroup = presentation?.group;
+                if (this.debugOptions.length) {
+                    this.debugOptions.push({ label: StartDebugActionViewItem_1.SEPARATOR, handler: () => Promise.resolve(false) });
+                    disabledIdxs.push(this.debugOptions.length - 1);
+                }
+            }
+            if (name === manager.selectedConfiguration.name && launch === manager.selectedConfiguration.launch) {
+                this.selected = this.debugOptions.length;
+            }
+            const label = inWorkspace ? `${name} (${launch.name})` : name;
+            this.debugOptions.push({
+                label, handler: async () => {
+                    await manager.selectConfiguration(launch, name);
+                    return true;
+                }
+            });
+        });
+        manager.getRecentDynamicConfigurations().slice(0, 3).forEach(({ name, type }) => {
+            if (type === manager.selectedConfiguration.type && manager.selectedConfiguration.name === name) {
+                this.selected = this.debugOptions.length;
+            }
+            this.debugOptions.push({
+                label: name,
+                handler: async () => {
+                    await manager.selectConfiguration(undefined, name, undefined, { type });
+                    return true;
+                }
+            });
+        });
+        if (this.debugOptions.length === 0) {
+            this.debugOptions.push({ label: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugActionViewItems',
+                'noConfigurations',
+                "No Configurations"
+            )), handler: async () => false });
+        }
+        this.debugOptions.push({ label: StartDebugActionViewItem_1.SEPARATOR, handler: () => Promise.resolve(false) });
+        disabledIdxs.push(this.debugOptions.length - 1);
+        this.providers.forEach(p => {
+            this.debugOptions.push({
+                label: `${p.label}...`,
+                handler: async () => {
+                    const picked = await p.pick();
+                    if (picked) {
+                        await manager.selectConfiguration(picked.launch, picked.config.name, picked.config, { type: p.type });
+                        return true;
+                    }
+                    return false;
+                }
+            });
+        });
+        manager.getLaunches().filter(l => !l.hidden).forEach(l => {
+            const label = inWorkspace ? ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugActionViewItems',
+                "addConfigTo",
+                "Add Config ({0})...",
+                l.name
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugActionViewItems',
+                'addConfiguration',
+                "Add Configuration..."
+            ));
+            this.debugOptions.push({
+                label, handler: async () => {
+                    await this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( l.uri.toString()));
+                    return false;
+                }
+            });
+        });
+        this.selectBox.setOptions(( this.debugOptions.map(
+            (data, index) => ({ text: data.label, isDisabled: disabledIdxs.indexOf(index) !== -1 })
+        )), this.selected);
+    }
+};
+StartDebugActionViewItem = StartDebugActionViewItem_1 = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IWorkspaceContextService)),
+    ( __param(7, IContextViewService)),
+    ( __param(8, IKeybindingService))
+], StartDebugActionViewItem));
+let FocusSessionActionViewItem = class FocusSessionActionViewItem extends SelectActionViewItem {
+    constructor(action, session, debugService, contextViewService, configurationService) {
+        super(null, action, [], -1, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/debugActionViewItems',
+            'debugSession',
+            'Debug Session'
+        )) });
+        this.debugService = debugService;
+        this.configurationService = configurationService;
+        this._register(this.debugService.getViewModel().onDidFocusSession(() => {
+            const session = this.getSelectedSession();
+            if (session) {
+                const index = this.getSessions().indexOf(session);
+                this.select(index);
+            }
+        }));
+        this._register(this.debugService.onDidNewSession(session => {
+            const sessionListeners = [];
+            sessionListeners.push(session.onDidChangeName(() => this.update()));
+            sessionListeners.push(session.onDidEndAdapter(() => dispose(sessionListeners)));
+            this.update();
+        }));
+        this.getSessions().forEach(session => {
+            this._register(session.onDidChangeName(() => this.update()));
+        });
+        this._register(this.debugService.onDidEndSession(() => this.update()));
+        const selectedSession = session ? this.mapFocusedSessionToSelected(session) : undefined;
+        this.update(selectedSession);
+    }
+    getActionContext(_, index) {
+        return this.getSessions()[index];
+    }
+    update(session) {
+        if (!session) {
+            session = this.getSelectedSession();
+        }
+        const sessions = this.getSessions();
+        const names = ( sessions.map(s => {
+            const label = s.getLabel();
+            if (s.parentSession) {
+                return `\u00A0\u00A0${label}`;
+            }
+            return label;
+        }));
+        this.setOptions(( names.map(data => ({ text: data }))), session ? sessions.indexOf(session) : undefined);
+    }
+    getSelectedSession() {
+        const session = this.debugService.getViewModel().focusedSession;
+        return session ? this.mapFocusedSessionToSelected(session) : undefined;
+    }
+    getSessions() {
+        const showSubSessions = this.configurationService.getValue('debug').showSubSessionsInToolBar;
+        const sessions = this.debugService.getModel().getSessions();
+        return showSubSessions ? sessions : sessions.filter(s => !s.parentSession);
+    }
+    mapFocusedSessionToSelected(focusedSession) {
+        const showSubSessions = this.configurationService.getValue('debug').showSubSessionsInToolBar;
+        while (focusedSession.parentSession && !showSubSessions) {
+            focusedSession = focusedSession.parentSession;
+        }
+        return focusedSession;
+    }
+};
+FocusSessionActionViewItem = ( __decorate([
+    ( __param(2, IDebugService)),
+    ( __param(3, IContextViewService)),
+    ( __param(4, IConfigurationService))
+], FocusSessionActionViewItem));
+export { FocusSessionActionViewItem, StartDebugActionViewItem };