@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/contrib/debug/browser/debugToolBar.js

@@ -0,0 +1,312 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as browser from 'monaco-editor/esm/vs/base/browser/browser.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import "../../../../../../assets/debugToolBar.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
+import { createActionViewItem, createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuRegistry, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { widgetShadow, widgetBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { FocusSessionActionViewItem } from './debugActionViewItems.js';
+import { debugToolBarBackground, debugToolBarBorder } from './debugColors.js';
+import { DISCONNECT_ID, DISCONNECT_LABEL, STOP_ID, STOP_LABEL, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, FOCUS_SESSION_ID, CONTINUE_LABEL, CONTINUE_ID, PAUSE_LABEL, PAUSE_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, RESTART_LABEL, RESTART_SESSION_ID, STEP_BACK_ID, REVERSE_CONTINUE_ID, FOCUS_SESSION_LABEL } from './debugCommands.js';
+import { debugDisconnect, debugStop, debugGripper, debugContinue, debugPause, debugStepOver, debugStepInto, debugStepOut, debugRestart, debugStepBack, debugReverseContinue } from './debugIcons.js';
+import { VIEWLET_ID, CONTEXT_DEBUG_STATE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, IDebugService } from '../common/debug.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+const DEBUG_TOOLBAR_POSITION_KEY = 'debug.actionswidgetposition';
+const DEBUG_TOOLBAR_Y_KEY = 'debug.actionswidgety';
+let DebugToolBar = class DebugToolBar extends Themable {
+    constructor(notificationService, telemetryService, debugService, layoutService, storageService, configurationService, themeService, instantiationService, menuService, contextKeyService) {
+        super(themeService);
+        this.notificationService = notificationService;
+        this.telemetryService = telemetryService;
+        this.debugService = debugService;
+        this.layoutService = layoutService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.yCoordinate = 0;
+        this.isVisible = false;
+        this.isBuilt = false;
+        this.stopActionViewItemDisposables = this._register(( new DisposableStore()));
+        this.$el = dom.$('div.debug-toolbar');
+        this.$el.style.top = `${layoutService.offset.top}px`;
+        this.dragArea = dom.append(this.$el, dom.$('div.drag-area' + ThemeIcon.asCSSSelector(debugGripper)));
+        const actionBarContainer = dom.append(this.$el, dom.$('div.action-bar-container'));
+        this.debugToolBarMenu = menuService.createMenu(MenuId.DebugToolBar, contextKeyService);
+        this._register(this.debugToolBarMenu);
+        this.activeActions = [];
+        this.actionBar = this._register(( new ActionBar(actionBarContainer, {
+            orientation: 0 ,
+            actionViewItemProvider: (action) => {
+                if (action.id === FOCUS_SESSION_ID) {
+                    return this.instantiationService.createInstance(FocusSessionActionViewItem, action, undefined);
+                }
+                else if (action.id === STOP_ID || action.id === DISCONNECT_ID) {
+                    this.stopActionViewItemDisposables.clear();
+                    const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, this.stopActionViewItemDisposables, accessor));
+                    if (item) {
+                        return item;
+                    }
+                }
+                return createActionViewItem(this.instantiationService, action);
+            }
+        })));
+        this.updateScheduler = this._register(( new RunOnceScheduler(() => {
+            const state = this.debugService.state;
+            const toolBarLocation = this.configurationService.getValue('debug').toolBarLocation;
+            if (state === 0  ||
+                toolBarLocation === 'docked' ||
+                toolBarLocation === 'hidden' ||
+                this.debugService.getModel().getSessions().every(s => s.suppressDebugToolbar) ||
+                (state === 1  && this.debugService.initializingOptions?.suppressDebugToolbar)) {
+                return this.hide();
+            }
+            const actions = [];
+            createAndFillInActionBarActions(this.debugToolBarMenu, { shouldForwardArgs: true }, actions);
+            if (!arrays.equals(actions, this.activeActions, (first, second) => first.id === second.id && first.enabled === second.enabled)) {
+                this.actionBar.clear();
+                this.actionBar.push(actions, { icon: true, label: false });
+                this.activeActions = actions;
+            }
+            this.show();
+        }, 20)));
+        this.updateStyles();
+        this.registerListeners();
+        this.hide();
+    }
+    registerListeners() {
+        this._register(this.debugService.onDidChangeState(() => this.updateScheduler.schedule()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.toolBarLocation')) {
+                this.updateScheduler.schedule();
+            }
+        }));
+        this._register(this.debugToolBarMenu.onDidChange(() => this.updateScheduler.schedule()));
+        this._register(this.actionBar.actionRunner.onDidRun((e) => {
+            if (e.error && !errors.isCancellationError(e.error)) {
+                this.notificationService.error(e.error);
+            }
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'debugActionsWidget' });
+        }));
+        this._register(dom.addDisposableListener(window, dom.EventType.RESIZE, () => this.setCoordinates()));
+        this._register(dom.addDisposableGenericMouseUpListener(this.dragArea, (event) => {
+            const mouseClickEvent = ( new StandardMouseEvent(event));
+            if (mouseClickEvent.detail === 2) {
+                const widgetWidth = this.$el.clientWidth;
+                this.setCoordinates(0.5 * window.innerWidth - 0.5 * widgetWidth, 0);
+                this.storePosition();
+            }
+        }));
+        this._register(dom.addDisposableGenericMouseDownListener(this.dragArea, (event) => {
+            this.dragArea.classList.add('dragged');
+            const mouseMoveListener = dom.addDisposableGenericMouseMoveListener(window, (e) => {
+                const mouseMoveEvent = ( new StandardMouseEvent(e));
+                mouseMoveEvent.preventDefault();
+                this.setCoordinates(mouseMoveEvent.posx - 14, mouseMoveEvent.posy - (this.layoutService.offset.top));
+            });
+            const mouseUpListener = dom.addDisposableGenericMouseUpListener(window, (e) => {
+                this.storePosition();
+                this.dragArea.classList.remove('dragged');
+                mouseMoveListener.dispose();
+                mouseUpListener.dispose();
+            });
+        }));
+        this._register(this.layoutService.onDidChangePartVisibility(() => this.setYCoordinate()));
+        this._register(browser.PixelRatio.onDidChange(() => this.setYCoordinate()));
+    }
+    storePosition() {
+        const left = dom.getComputedStyle(this.$el).left;
+        if (left) {
+            const position = parseFloat(left) / window.innerWidth;
+            this.storageService.store(DEBUG_TOOLBAR_POSITION_KEY, position, 0 , 1 );
+        }
+    }
+    updateStyles() {
+        super.updateStyles();
+        if (this.$el) {
+            this.$el.style.backgroundColor = this.getColor(debugToolBarBackground) || '';
+            const widgetShadowColor = this.getColor(widgetShadow);
+            this.$el.style.boxShadow = widgetShadowColor ? `0 0 8px 2px ${widgetShadowColor}` : '';
+            const contrastBorderColor = this.getColor(widgetBorder);
+            const borderColor = this.getColor(debugToolBarBorder);
+            if (contrastBorderColor) {
+                this.$el.style.border = `1px solid ${contrastBorderColor}`;
+            }
+            else {
+                this.$el.style.border = borderColor ? `solid ${borderColor}` : 'none';
+                this.$el.style.border = '1px 0';
+            }
+        }
+    }
+    setYCoordinate(y = this.yCoordinate) {
+        const titlebarOffset = this.layoutService.offset.top;
+        this.$el.style.top = `${titlebarOffset + y}px`;
+        this.yCoordinate = y;
+    }
+    setCoordinates(x, y) {
+        if (!this.isVisible) {
+            return;
+        }
+        const widgetWidth = this.$el.clientWidth;
+        if (x === undefined) {
+            const positionPercentage = this.storageService.get(DEBUG_TOOLBAR_POSITION_KEY, 0 );
+            x = positionPercentage !== undefined ? parseFloat(positionPercentage) * window.innerWidth : (0.5 * window.innerWidth - 0.5 * widgetWidth);
+        }
+        x = Math.max(0, Math.min(x, window.innerWidth - widgetWidth));
+        this.$el.style.left = `${x}px`;
+        if (y === undefined) {
+            y = this.storageService.getNumber(DEBUG_TOOLBAR_Y_KEY, 0 , 0);
+        }
+        const titleAreaHeight = 35;
+        if ((y < titleAreaHeight / 2) || (y > titleAreaHeight + titleAreaHeight / 2)) {
+            const moveToTop = y < titleAreaHeight;
+            this.setYCoordinate(moveToTop ? 0 : titleAreaHeight);
+            this.storageService.store(DEBUG_TOOLBAR_Y_KEY, moveToTop ? 0 : 2 * titleAreaHeight, 0 , 1 );
+        }
+    }
+    show() {
+        if (this.isVisible) {
+            this.setCoordinates();
+            return;
+        }
+        if (!this.isBuilt) {
+            this.isBuilt = true;
+            this.layoutService.container.appendChild(this.$el);
+        }
+        this.isVisible = true;
+        dom.show(this.$el);
+        this.setCoordinates();
+    }
+    hide() {
+        this.isVisible = false;
+        dom.hide(this.$el);
+    }
+    dispose() {
+        super.dispose();
+        this.$el?.remove();
+    }
+};
+DebugToolBar = ( __decorate([
+    ( __param(0, INotificationService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IWorkbenchLayoutService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService))
+], DebugToolBar));
+function createDisconnectMenuItemAction(action, disposables, accessor) {
+    const menuService = accessor.get(IMenuService);
+    const contextKeyService = accessor.get(IContextKeyService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const contextMenuService = accessor.get(IContextMenuService);
+    const menu = menuService.createMenu(MenuId.DebugToolBarStop, contextKeyService);
+    const secondary = [];
+    createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, secondary);
+    if (!secondary.length) {
+        return undefined;
+    }
+    const dropdownAction = disposables.add(( new Action('notebook.moreRunActions', ( localize('notebook.moreRunActionsLabel', "More...")), 'codicon-chevron-down', true)));
+    const item = instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, dropdownAction, secondary, 'debug-stop-actions', contextMenuService, {});
+    return item;
+}
+const debugViewTitleItems = [];
+const registerDebugToolBarItem = (id, title, order, icon, when, precondition, alt) => {
+    MenuRegistry.appendMenuItem(MenuId.DebugToolBar, {
+        group: 'navigation',
+        when,
+        order,
+        command: {
+            id,
+            title,
+            icon,
+            precondition
+        },
+        alt
+    });
+    debugViewTitleItems.push(MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+        group: 'navigation',
+        when: ( ContextKeyExpr.and(when, ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_STATE.notEqualsTo('inactive')), ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'docked')))),
+        order,
+        command: {
+            id,
+            title,
+            icon,
+            precondition
+        }
+    }));
+};
+MenuRegistry.onDidChangeMenu(e => {
+    if (e.has(MenuId.DebugToolBar)) {
+        dispose(debugViewTitleItems);
+        const items = MenuRegistry.getMenuItems(MenuId.DebugToolBar);
+        for (const i of items) {
+            debugViewTitleItems.push(MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+                ...i,
+                when: ( ContextKeyExpr.and(i.when, ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_STATE.notEqualsTo('inactive')), ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'docked'))))
+            }));
+        }
+    }
+});
+registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, debugContinue, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(PAUSE_ID, PAUSE_LABEL, 10, debugPause, ( CONTEXT_DEBUG_STATE.notEqualsTo('stopped')), ( CONTEXT_DEBUG_STATE.isEqualTo('running')));
+registerDebugToolBarItem(STOP_ID, STOP_LABEL, 70, debugStop, ( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), undefined, { id: DISCONNECT_ID, title: DISCONNECT_LABEL, icon: debugDisconnect, precondition: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
+registerDebugToolBarItem(DISCONNECT_ID, DISCONNECT_LABEL, 70, debugDisconnect, CONTEXT_FOCUSED_SESSION_IS_ATTACH, undefined, { id: STOP_ID, title: STOP_LABEL, icon: debugStop, precondition: ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
+registerDebugToolBarItem(STEP_OVER_ID, STEP_OVER_LABEL, 20, debugStepOver, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(STEP_INTO_ID, STEP_INTO_LABEL, 30, debugStepInto, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(STEP_OUT_ID, STEP_OUT_LABEL, 40, debugStepOut, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(RESTART_SESSION_ID, RESTART_LABEL, 60, debugRestart);
+registerDebugToolBarItem(STEP_BACK_ID, ( localize('stepBackDebug', "Step Back")), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localize('reverseContinue', "Reverse")), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, undefined, CONTEXT_MULTI_SESSION_DEBUG);
+MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
+    group: 'navigation',
+    when: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)),
+    order: 0,
+    command: {
+        id: DISCONNECT_ID,
+        title: DISCONNECT_LABEL,
+        icon: debugDisconnect
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
+    group: 'navigation',
+    when: ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)),
+    order: 0,
+    command: {
+        id: STOP_ID,
+        title: STOP_LABEL,
+        icon: debugStop
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
+    group: 'navigation',
+    when: ( ContextKeyExpr.or(( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED)))),
+    order: 0,
+    command: {
+        id: DISCONNECT_AND_SUSPEND_ID,
+        title: DISCONNECT_AND_SUSPEND_LABEL,
+        icon: debugDisconnect
+    }
+});
+export { DebugToolBar, createDisconnectMenuItemAction };

package/dist/vscode/vs/workbench/contrib/debug/browser/exceptionWidget.js

@@ -0,0 +1,103 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/exceptionWidget.css";
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ZoneWidget } from 'monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.js';
+import { EDITOR_CONTRIBUTION_ID } from '../common/debug.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { LinkDetector } from './linkDetector.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { widgetClose } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const $ = dom.$;
+const debugExceptionWidgetBorder = registerColor('debugExceptionWidget.border', { dark: '#a31515', light: '#a31515', hcDark: '#a31515', hcLight: '#a31515' }, ( nls.localize('debugExceptionWidgetBorder', 'Exception widget border color.')));
+const debugExceptionWidgetBackground = registerColor('debugExceptionWidget.background', { dark: '#420b0d', light: '#f1dfde', hcDark: '#420b0d', hcLight: '#f1dfde' }, ( nls.localize('debugExceptionWidgetBackground', 'Exception widget background color.')));
+let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
+    constructor(editor, exceptionInfo, debugSession, themeService, instantiationService) {
+        super(editor, { showFrame: true, showArrow: true, isAccessible: true, frameWidth: 1, className: 'exception-widget-container' });
+        this.exceptionInfo = exceptionInfo;
+        this.debugSession = debugSession;
+        this.instantiationService = instantiationService;
+        this.applyTheme(themeService.getColorTheme());
+        this._disposables.add(themeService.onDidColorThemeChange(this.applyTheme.bind(this)));
+        this.create();
+        const onDidLayoutChangeScheduler = ( new RunOnceScheduler(() => this._doLayout(undefined, undefined), 50));
+        this._disposables.add(this.editor.onDidLayoutChange(() => onDidLayoutChangeScheduler.schedule()));
+        this._disposables.add(onDidLayoutChangeScheduler);
+    }
+    applyTheme(theme) {
+        this.backgroundColor = theme.getColor(debugExceptionWidgetBackground);
+        const frameColor = theme.getColor(debugExceptionWidgetBorder);
+        this.style({
+            arrowColor: frameColor,
+            frameColor: frameColor
+        });
+    }
+    _applyStyles() {
+        if (this.container) {
+            this.container.style.backgroundColor = this.backgroundColor ? ( this.backgroundColor.toString()) : '';
+        }
+        super._applyStyles();
+    }
+    _fillContainer(container) {
+        this.setCssClass('exception-widget');
+        const fontInfo = this.editor.getOption(48 );
+        container.style.fontSize = `${fontInfo.fontSize}px`;
+        container.style.lineHeight = `${fontInfo.lineHeight}px`;
+        container.tabIndex = 0;
+        const title = $('.title');
+        const label = $('.label');
+        dom.append(title, label);
+        const actions = $('.actions');
+        dom.append(title, actions);
+        label.textContent = this.exceptionInfo.id ? ( nls.localize(
+            'exceptionThrownWithId',
+            'Exception has occurred: {0}',
+            this.exceptionInfo.id
+        )) : ( nls.localize('exceptionThrown', 'Exception has occurred.'));
+        let ariaLabel = label.textContent;
+        const actionBar = ( new ActionBar(actions));
+        actionBar.push(( new Action('editor.closeExceptionWidget', ( nls.localize('close', "Close")), ThemeIcon.asClassName(widgetClose), true, async () => {
+            const contribution = this.editor.getContribution(EDITOR_CONTRIBUTION_ID);
+            contribution?.closeExceptionWidget();
+        })), { label: false, icon: true });
+        dom.append(container, title);
+        if (this.exceptionInfo.description) {
+            const description = $('.description');
+            description.textContent = this.exceptionInfo.description;
+            ariaLabel += ', ' + this.exceptionInfo.description;
+            dom.append(container, description);
+        }
+        if (this.exceptionInfo.details && this.exceptionInfo.details.stackTrace) {
+            const stackTrace = $('.stack-trace');
+            const linkDetector = this.instantiationService.createInstance(LinkDetector);
+            const linkedStackTrace = linkDetector.linkify(this.exceptionInfo.details.stackTrace, true, this.debugSession ? this.debugSession.root : undefined);
+            stackTrace.appendChild(linkedStackTrace);
+            dom.append(container, stackTrace);
+            ariaLabel += ', ' + this.exceptionInfo.details.stackTrace;
+        }
+        container.setAttribute('aria-label', ariaLabel);
+    }
+    _doLayout(_heightInPixel, _widthInPixel) {
+        this.container.style.height = 'initial';
+        const lineHeight = this.editor.getOption(64 );
+        const arrowHeight = Math.round(lineHeight / 3);
+        const computedLinesNumber = Math.ceil((this.container.offsetHeight + arrowHeight) / lineHeight);
+        this._relayout(computedLinesNumber);
+    }
+    focus() {
+        this.container?.focus();
+    }
+    hasFocus() {
+        return dom.isAncestor(document.activeElement, this.container);
+    }
+};
+ExceptionWidget = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IInstantiationService))
+], ExceptionWidget));
+export { ExceptionWidget };

package/dist/vscode/vs/workbench/contrib/debug/browser/linkDetector.js

@@ -0,0 +1,229 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IPathService } from '../../../services/path/common/pathService.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+const CONTROL_CODES = '\\u0000-\\u0020\\u007f-\\u009f';
+const WEB_LINK_REGEX = ( new RegExp(
+    '(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s' + CONTROL_CODES + '"]{2,}[^\\s' + CONTROL_CODES + '"\')}\\],:;.!?]',
+    'ug'
+));
+const WIN_ABSOLUTE_PATH = /(?:[a-zA-Z]:(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_RELATIVE_PATH = /(?:(?:\~|\.)(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_PATH = ( new RegExp(`(${WIN_ABSOLUTE_PATH.source}|${WIN_RELATIVE_PATH.source})`));
+const POSIX_PATH = /((?:\~|\.)?(?:\/[\w\.-]*)+)/;
+const LINE_COLUMN = /(?:\:([\d]+))?(?:\:([\d]+))?/;
+const PATH_LINK_REGEX = ( new RegExp(
+    `${platform.isWindows ? WIN_PATH.source : POSIX_PATH.source}${LINE_COLUMN.source}`,
+    'g'
+));
+const LINE_COLUMN_REGEX = /:([\d]+)(?::([\d]+))?$/;
+const MAX_LENGTH = 2000;
+let LinkDetector = class LinkDetector {
+    constructor(editorService, fileService, openerService, pathService, tunnelService, environmentService, configurationService) {
+        this.editorService = editorService;
+        this.fileService = fileService;
+        this.openerService = openerService;
+        this.pathService = pathService;
+        this.tunnelService = tunnelService;
+        this.environmentService = environmentService;
+        this.configurationService = configurationService;
+    }
+    linkify(text, splitLines, workspaceFolder, includeFulltext) {
+        if (splitLines) {
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length - 1; i++) {
+                lines[i] = lines[i] + '\n';
+            }
+            if (!lines[lines.length - 1]) {
+                lines.pop();
+            }
+            const elements = ( lines.map(line => this.linkify(line, false, workspaceFolder, includeFulltext)));
+            if (elements.length === 1) {
+                return elements[0];
+            }
+            const container = document.createElement('span');
+            elements.forEach(e => container.appendChild(e));
+            return container;
+        }
+        const container = document.createElement('span');
+        for (const part of this.detectLinks(text)) {
+            try {
+                switch (part.kind) {
+                    case 'text':
+                        container.appendChild(document.createTextNode(part.value));
+                        break;
+                    case 'web':
+                        container.appendChild(this.createWebLink(includeFulltext ? text : undefined, part.value));
+                        break;
+                    case 'path': {
+                        const path = part.captures[0];
+                        const lineNumber = part.captures[1] ? Number(part.captures[1]) : 0;
+                        const columnNumber = part.captures[2] ? Number(part.captures[2]) : 0;
+                        container.appendChild(this.createPathLink(includeFulltext ? text : undefined, part.value, path, lineNumber, columnNumber, workspaceFolder));
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                container.appendChild(document.createTextNode(part.value));
+            }
+        }
+        return container;
+    }
+    createWebLink(fulltext, url) {
+        const link = this.createLink(url);
+        let uri = ( URI.parse(url));
+        const lineCol = LINE_COLUMN_REGEX.exec(uri.path);
+        if (lineCol) {
+            uri = uri.with({
+                path: uri.path.slice(0, lineCol.index),
+                fragment: `L${lineCol[0].slice(1)}`
+            });
+        }
+        this.decorateLink(link, uri, fulltext, async () => {
+            if (uri.scheme === Schemas.file) {
+                const fsPath = uri.fsPath;
+                const path = await this.pathService.path;
+                const fileUrl = paths.normalize(((path.sep === paths.posix.sep) && platform.isWindows) ? fsPath.replace(/\\/g, paths.posix.sep) : fsPath);
+                const fileUri = ( URI.parse(fileUrl));
+                const exists = await this.fileService.exists(fileUri);
+                if (!exists) {
+                    return;
+                }
+                await this.editorService.openEditor({
+                    resource: fileUri,
+                    options: {
+                        pinned: true,
+                        selection: lineCol ? { startLineNumber: +lineCol[1], startColumn: +lineCol[2] } : undefined,
+                    },
+                });
+                return;
+            }
+            this.openerService.open(url, { allowTunneling: (!!this.environmentService.remoteAuthority && this.configurationService.getValue('remote.forwardOnOpen')) });
+        });
+        return link;
+    }
+    createPathLink(fulltext, text, path, lineNumber, columnNumber, workspaceFolder) {
+        if (path[0] === '/' && path[1] === '/') {
+            return document.createTextNode(text);
+        }
+        const options = { selection: { startLineNumber: lineNumber, startColumn: columnNumber } };
+        if (path[0] === '.') {
+            if (!workspaceFolder) {
+                return document.createTextNode(text);
+            }
+            const uri = workspaceFolder.toResource(path);
+            const link = this.createLink(text);
+            this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
+            return link;
+        }
+        if (path[0] === '~') {
+            const userHome = this.pathService.resolvedUserHome;
+            if (userHome) {
+                path = paths.join(userHome.fsPath, path.substring(1));
+            }
+        }
+        const link = this.createLink(text);
+        link.tabIndex = 0;
+        const uri = URI.file(paths.normalize(path));
+        this.fileService.stat(uri).then(stat => {
+            if (stat.isDirectory) {
+                return;
+            }
+            this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
+        }).catch(() => {
+        });
+        return link;
+    }
+    createLink(text) {
+        const link = document.createElement('a');
+        link.textContent = text;
+        return link;
+    }
+    decorateLink(link, uri, fulltext, onClick) {
+        link.classList.add('link');
+        const followLink = this.tunnelService.canTunnel(uri) ? ( localize('followForwardedLink', "follow link using forwarded port")) : ( localize('followLink', "follow link"));
+        link.title = fulltext
+            ? (platform.isMacintosh ? ( localize('fileLinkWithPathMac', "Cmd + click to {0}\n{1}", followLink, fulltext)) : ( localize('fileLinkWithPath', "Ctrl + click to {0}\n{1}", followLink, fulltext)))
+            : (platform.isMacintosh ? ( localize('fileLinkMac', "Cmd + click to {0}", followLink)) : ( localize('fileLink', "Ctrl + click to {0}", followLink)));
+        link.onmousemove = (event) => { link.classList.toggle('pointer', platform.isMacintosh ? event.metaKey : event.ctrlKey); };
+        link.onmouseleave = () => link.classList.remove('pointer');
+        link.onclick = (event) => {
+            const selection = window.getSelection();
+            if (!selection || selection.type === 'Range') {
+                return;
+            }
+            if (!(platform.isMacintosh ? event.metaKey : event.ctrlKey)) {
+                return;
+            }
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            onClick(false);
+        };
+        link.onkeydown = e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.keyCode === 3  || event.keyCode === 10 ) {
+                event.preventDefault();
+                event.stopPropagation();
+                onClick(event.keyCode === 10 );
+            }
+        };
+    }
+    detectLinks(text) {
+        if (text.length > MAX_LENGTH) {
+            return [{ kind: 'text', value: text, captures: [] }];
+        }
+        const regexes = [WEB_LINK_REGEX, PATH_LINK_REGEX];
+        const kinds = ['web', 'path'];
+        const result = [];
+        const splitOne = (text, regexIndex) => {
+            if (regexIndex >= regexes.length) {
+                result.push({ value: text, kind: 'text', captures: [] });
+                return;
+            }
+            const regex = regexes[regexIndex];
+            let currentIndex = 0;
+            let match;
+            regex.lastIndex = 0;
+            while ((match = regex.exec(text)) !== null) {
+                const stringBeforeMatch = text.substring(currentIndex, match.index);
+                if (stringBeforeMatch) {
+                    splitOne(stringBeforeMatch, regexIndex + 1);
+                }
+                const value = match[0];
+                result.push({
+                    value: value,
+                    kind: kinds[regexIndex],
+                    captures: match.slice(1)
+                });
+                currentIndex = match.index + value.length;
+            }
+            const stringAfterMatches = text.substring(currentIndex);
+            if (stringAfterMatches) {
+                splitOne(stringAfterMatches, regexIndex + 1);
+            }
+        };
+        splitOne(text, 0);
+        return result;
+    }
+};
+LinkDetector = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IPathService)),
+    ( __param(4, ITunnelService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IConfigurationService))
+], LinkDetector));
+export { LinkDetector };