@codingame/monaco-vscode-api 1.68.7 → 1.69.2

package/dist/messages.js

@@ -0,0 +1,3624 @@
+import { e as ILifecycleService, E as Emitter, f as IntervalCounter, g as assertAllDefined, u as unsupported } from './missing-services.js';
+import { _ as __decorate, a as __param } from './tslib.es6.js';
+import { focusBorder, registerColor, textLinkForeground, editorErrorForeground, editorWarningForeground, editorInfoForeground, widgetShadow, contrastBorder, editorWidgetBackground, editorWidgetForeground, buttonForeground, buttonSeparator, buttonBackground, buttonHoverBackground, buttonSecondaryForeground, buttonSecondaryBackground, buttonSecondaryHoverBackground, buttonBorder, progressBarBackground, resolveColorValue, checkboxBorder, checkboxBackground, checkboxForeground, problemsErrorIconForeground, problemsWarningIconForeground, problemsInfoIconForeground, inputBackground, inputForeground, inputBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { I as IFileService, f as IEditorGroupsService, l as IHostService, j as IProductService, g as IWorkbenchEnvironmentService, w as NotificationsFilter, x as NeverShowAgainScope } from './services2.js';
+import { Disposable, toDisposable, DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { NoOpNotification, Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { equals, isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Action, ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { RawContextKey, IContextKeyService, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { isEqual, basename, dirname, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { WorkbenchList, IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Codicon, CSSIcon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { registerThemingParticipant, ThemeIcon, IThemeService, Themable } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { addDisposableListener, EventType, EventHelper, clearNode, Dimension, scheduleAtNextAnimationFrame, isAncestor, $, trackFocus, getClientArea, reset, hide, show } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ProgressBar } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.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 { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { I as IWorkbenchLayoutService } from './layoutService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { isMacintosh, isLinux, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
+import Severity$1 from 'monaco-editor/esm/vs/base/common/severity.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { o as onServicesInitialized } from './tools.js';
+function isErrorWithActions(obj) {
+    const candidate = obj;
+    return candidate instanceof Error && Array.isArray(candidate.actions);
+}
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+const defaultOpts = {
+    inputActiveOptionBorder: ( (Color.fromHex('#007ACC00'))),
+    inputActiveOptionForeground: ( (Color.fromHex('#FFFFFF'))),
+    inputActiveOptionBackground: ( (Color.fromHex('#0E639C50')))
+};
+class Toggle extends Widget {
+    constructor(opts) {
+        super();
+        this._onChange = this._register(( (new Emitter())));
+        this.onChange = this._onChange.event;
+        this._onKeyDown = this._register(( (new Emitter())));
+        this.onKeyDown = this._onKeyDown.event;
+        this._opts = { ...defaultOpts, ...opts };
+        this._checked = this._opts.isChecked;
+        const classes = ['monaco-custom-toggle'];
+        if (this._opts.icon) {
+            this._icon = this._opts.icon;
+            classes.push(...CSSIcon.asClassNameArray(this._icon));
+        }
+        if (this._opts.actionClassName) {
+            classes.push(...this._opts.actionClassName.split(' '));
+        }
+        if (this._checked) {
+            classes.push('checked');
+        }
+        this.domNode = document.createElement('div');
+        this.domNode.title = this._opts.title;
+        this.domNode.classList.add(...classes);
+        if (!this._opts.notFocusable) {
+            this.domNode.tabIndex = 0;
+        }
+        this.domNode.setAttribute('role', 'checkbox');
+        this.domNode.setAttribute('aria-checked', String(this._checked));
+        this.domNode.setAttribute('aria-label', this._opts.title);
+        this.applyStyles();
+        this.onclick(this.domNode, (ev) => {
+            if (this.enabled) {
+                this.checked = !this._checked;
+                this._onChange.fire(false);
+                ev.preventDefault();
+            }
+        });
+        this.ignoreGesture(this.domNode);
+        this.onkeydown(this.domNode, (keyboardEvent) => {
+            if (keyboardEvent.keyCode === 10  || keyboardEvent.keyCode === 3 ) {
+                this.checked = !this._checked;
+                this._onChange.fire(true);
+                keyboardEvent.preventDefault();
+                keyboardEvent.stopPropagation();
+                return;
+            }
+            this._onKeyDown.fire(keyboardEvent);
+        });
+    }
+    get enabled() {
+        return this.domNode.getAttribute('aria-disabled') !== 'true';
+    }
+    focus() {
+        this.domNode.focus();
+    }
+    get checked() {
+        return this._checked;
+    }
+    set checked(newIsChecked) {
+        this._checked = newIsChecked;
+        this.domNode.setAttribute('aria-checked', String(this._checked));
+        this.domNode.classList.toggle('checked', this._checked);
+        this.applyStyles();
+    }
+    setIcon(icon) {
+        if (this._icon) {
+            this.domNode.classList.remove(...CSSIcon.asClassNameArray(this._icon));
+        }
+        this._icon = icon;
+        if (this._icon) {
+            this.domNode.classList.add(...CSSIcon.asClassNameArray(this._icon));
+        }
+    }
+    width() {
+        return 2  + 2  + 2  + 16 ;
+    }
+    style(styles) {
+        if (styles.inputActiveOptionBorder) {
+            this._opts.inputActiveOptionBorder = styles.inputActiveOptionBorder;
+        }
+        if (styles.inputActiveOptionForeground) {
+            this._opts.inputActiveOptionForeground = styles.inputActiveOptionForeground;
+        }
+        if (styles.inputActiveOptionBackground) {
+            this._opts.inputActiveOptionBackground = styles.inputActiveOptionBackground;
+        }
+        this.applyStyles();
+    }
+    applyStyles() {
+        if (this.domNode) {
+            this.domNode.style.borderColor = this._checked && this._opts.inputActiveOptionBorder ? ( (this._opts.inputActiveOptionBorder.toString())) : '';
+            this.domNode.style.color = this._checked && this._opts.inputActiveOptionForeground ? ( (this._opts.inputActiveOptionForeground.toString())) : 'inherit';
+            this.domNode.style.backgroundColor = this._checked && this._opts.inputActiveOptionBackground ? ( (this._opts.inputActiveOptionBackground.toString())) : '';
+        }
+    }
+    enable() {
+        this.domNode.setAttribute('aria-disabled', String(false));
+    }
+    disable() {
+        this.domNode.setAttribute('aria-disabled', String(true));
+    }
+    setTitle(newTitle) {
+        this.domNode.title = newTitle;
+        this.domNode.setAttribute('aria-label', newTitle);
+    }
+}
+class Checkbox extends Widget {
+    constructor(title, isChecked) {
+        super();
+        this.title = title;
+        this.isChecked = isChecked;
+        this.checkbox = ( (new Toggle(
+            { title: this.title, isChecked: this.isChecked, icon: Codicon.check, actionClassName: 'monaco-checkbox' }
+        )));
+        this.domNode = this.checkbox.domNode;
+        this.styles = {};
+        this.checkbox.onChange(() => {
+            this.applyStyles();
+        });
+    }
+    get checked() {
+        return this.checkbox.checked;
+    }
+    set checked(newIsChecked) {
+        this.checkbox.checked = newIsChecked;
+        this.applyStyles();
+    }
+    focus() {
+        this.domNode.focus();
+    }
+    hasFocus() {
+        return this.domNode === document.activeElement;
+    }
+    style(styles) {
+        this.styles = styles;
+        this.applyStyles();
+    }
+    applyStyles() {
+        this.domNode.style.color = this.styles.checkboxForeground ? ( (this.styles.checkboxForeground.toString())) : '';
+        this.domNode.style.backgroundColor = this.styles.checkboxBackground ? ( (this.styles.checkboxBackground.toString())) : '';
+        this.domNode.style.borderColor = this.styles.checkboxBorder ? ( (this.styles.checkboxBorder.toString())) : '';
+    }
+}
+function computeStyles(theme, styleMap) {
+    const styles = Object.create(null);
+    for (const key in styleMap) {
+        const value = styleMap[key];
+        if (value) {
+            styles[key] = resolveColorValue(value, theme);
+        }
+    }
+    return styles;
+}
+function attachStyler(themeService, styleMap, widgetOrCallback) {
+    function applyStyles() {
+        const styles = computeStyles(themeService.getColorTheme(), styleMap);
+        if (typeof widgetOrCallback === 'function') {
+            widgetOrCallback(styles);
+        }
+        else {
+            widgetOrCallback.style(styles);
+        }
+    }
+    applyStyles();
+    return themeService.onDidColorThemeChange(applyStyles);
+}
+function attachButtonStyler(widget, themeService, style) {
+    return attachStyler(themeService, {
+        buttonForeground: style?.buttonForeground || buttonForeground,
+        buttonSeparator: style?.buttonSeparator || buttonSeparator,
+        buttonBackground: style?.buttonBackground || buttonBackground,
+        buttonHoverBackground: style?.buttonHoverBackground || buttonHoverBackground,
+        buttonSecondaryForeground: style?.buttonSecondaryForeground || buttonSecondaryForeground,
+        buttonSecondaryBackground: style?.buttonSecondaryBackground || buttonSecondaryBackground,
+        buttonSecondaryHoverBackground: style?.buttonSecondaryHoverBackground || buttonSecondaryHoverBackground,
+        buttonBorder: style?.buttonBorder || buttonBorder,
+    }, widget);
+}
+function attachProgressBarStyler(widget, themeService, style) {
+    return attachStyler(themeService, {
+        progressBarBackground: style?.progressBarBackground || progressBarBackground
+    }, widget);
+}
+const defaultDialogStyles = {
+    dialogBackground: editorWidgetBackground,
+    dialogForeground: editorWidgetForeground,
+    dialogShadow: widgetShadow,
+    dialogBorder: contrastBorder,
+    buttonForeground: buttonForeground,
+    buttonSeparator: buttonSeparator,
+    buttonBackground: buttonBackground,
+    buttonSecondaryBackground: buttonSecondaryBackground,
+    buttonSecondaryForeground: buttonSecondaryForeground,
+    buttonSecondaryHoverBackground: buttonSecondaryHoverBackground,
+    buttonHoverBackground: buttonHoverBackground,
+    buttonBorder: buttonBorder,
+    checkboxBorder: checkboxBorder,
+    checkboxBackground: checkboxBackground,
+    checkboxForeground: checkboxForeground,
+    errorIconForeground: problemsErrorIconForeground,
+    warningIconForeground: problemsWarningIconForeground,
+    infoIconForeground: problemsInfoIconForeground,
+    inputBackground: inputBackground,
+    inputForeground: inputForeground,
+    inputBorder: inputBorder,
+    textLinkForeground: textLinkForeground
+};
+function attachDialogStyler(widget, themeService, style) {
+    return attachStyler(themeService, { ...defaultDialogStyles, ...style }, widget);
+}
+var css$3 = "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-workbench > .notifications-toasts {\n\tposition: absolute;\n\tz-index: 1000;\n\tright: 3px;\n\tbottom: 26px;\n\tdisplay: none;\n\toverflow: hidden;\n}\n\n.monaco-workbench.nostatusbar > .notifications-toasts {\n\tbottom: 3px;\n}\n\n.monaco-workbench > .notifications-toasts.visible {\n\tdisplay: flex;\n\tflex-direction: column;\n}\n\n.monaco-workbench > .notifications-toasts .notification-toast-container {\n\toverflow: hidden; /* this ensures that the notification toast does not shine through */\n}\n\n.monaco-workbench > .notifications-toasts .notification-toast-container > .notification-toast {\n\tmargin: 8px; /* enables separation and drop shadows around toasts */\n\ttransform: translate3d(0px, 100%, 0px); /* move the notification 50px to the bottom (to prevent bleed through) */\n\topacity: 0; /*  fade the toast in */\n\ttransition:\ttransform 300ms ease-out, opacity 300ms ease-out;\n}\n\n.monaco-workbench.reduce-motion > .notifications-toasts .notification-toast-container > .notification-toast {\n\ttransition:\ttransform 0ms ease-out, opacity 0ms ease-out;\n}\n\n.monaco-workbench > .notifications-toasts .notification-toast-container > .notification-toast.notification-fade-in {\n\topacity: 1;\n\ttransform: none;\n}\n\n.monaco-workbench > .notifications-toasts .notification-toast-container > .notification-toast.notification-fade-in-done {\n\topacity: 1;\n\ttransform: none;\n\ttransition:\tnone;\n}\n";
+n(css$3,{});
+var css$2 = "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/** Notification: Container */\n\n.monaco-workbench .notifications-list-container .notification-list-item {\n\tdisplay: flex;\n\tflex-direction: column;\n\tflex-direction: column-reverse; /* the details row appears first in order for better keyboard access to notification buttons */\n\tpadding: 10px 5px;\n\theight: 100%;\n\tbox-sizing: border-box;\n}\n\n.monaco-workbench .notifications-list-container .notification-offset-helper {\n\topacity: 0;\n\tposition: absolute;\n\tline-height: 22px;\n\tword-wrap: break-word; /* never overflow long words, but break to next line */\n}\n\n/** Notification: Main Row */\n\n.monaco-workbench .notifications-list-container .notification-list-item > .notification-list-item-main-row {\n\tdisplay: flex;\n\tflex-grow: 1;\n}\n\n/** Notification: Icon */\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-icon {\n\tdisplay: flex;\n\talign-items: center;\n\tflex: 0 0 16px;\n\theight: 22px;\n\tmargin-right: 4px;\n\tmargin-left: 4px;\n\tfont-size: 18px;\n\tbackground-position: center;\n\tbackground-repeat: no-repeat;\n}\n\n/** Notification: Message */\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message {\n\tline-height: 22px;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tflex: 1; /* let the message always grow */\n\tuser-select: text;\n\t-webkit-user-select: text;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message a:focus {\n\toutline-width: 1px;\n\toutline-style: solid;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item.expanded .notification-list-item-message {\n\twhite-space: normal;\n\tword-wrap: break-word; /* never overflow long words, but break to next line */\n}\n\n/** Notification: Toolbar Container */\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-toolbar-container {\n\tdisplay: none;\n\theight: 22px;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item:hover .notification-list-item-toolbar-container,\n.monaco-workbench .notifications-list-container .monaco-list-row.focused .notification-list-item .notification-list-item-toolbar-container,\n.monaco-workbench .notifications-list-container .notification-list-item.expanded .notification-list-item-toolbar-container {\n\tdisplay: block;\n}\n\n/** Notification: Details Row */\n\n.monaco-workbench .notifications-list-container .notification-list-item > .notification-list-item-details-row {\n\tdisplay: none;\n\talign-items: center;\n\tpadding-left: 5px;\n\toverflow: hidden; /* details row should never overflow */\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item.expanded > .notification-list-item-details-row {\n\tdisplay: flex;\n}\n\n/** Notification: Source */\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-source {\n\tflex: 1;\n\tfont-size: 12px;\n\toverflow: hidden; /* always give away space to buttons container */\n\ttext-overflow: ellipsis;\n}\n\n/** Notification: Buttons */\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container {\n\tdisplay: flex;\n\toverflow: hidden;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container > .monaco-button-dropdown,\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container > .monaco-button {\n\tmargin: 4px 5px; /* allows button focus outline to be visible */\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container .monaco-button {\n\toutline-offset: 2px !important;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container .monaco-text-button {\n\twidth: fit-content;\n\twidth: -moz-fit-content;\n\tpadding: 5px 10px;\n\tdisplay: inline-block;\t/* to enable ellipsis in text overflow */\n\tfont-size: 12px;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-buttons-container .monaco-dropdown-button {\n\tpadding: 5px\n}\n\n/** Notification: Progress */\n\n.monaco-workbench .notifications-list-container .progress-bit {\n\theight: 2px;\n\tbottom: 0;\n}\n";
+n(css$2,{});
+const NOTIFICATIONS_TOAST_BORDER = ( (registerColor('notificationToast.border', {
+    dark: null,
+    light: null,
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+},  (localize(
+    'notificationToastBorder',
+    "Notification toast border color. Notifications slide in from the bottom right of the window."
+)))));
+const NOTIFICATIONS_FOREGROUND = ( (registerColor('notifications.foreground', {
+    dark: editorWidgetForeground,
+    light: editorWidgetForeground,
+    hcDark: editorWidgetForeground,
+    hcLight: editorWidgetForeground
+},  (localize(
+    'notificationsForeground',
+    "Notifications foreground color. Notifications slide in from the bottom right of the window."
+)))));
+const NOTIFICATIONS_BACKGROUND = ( (registerColor('notifications.background', {
+    dark: editorWidgetBackground,
+    light: editorWidgetBackground,
+    hcDark: editorWidgetBackground,
+    hcLight: editorWidgetBackground
+},  (localize(
+    'notificationsBackground',
+    "Notifications background color. Notifications slide in from the bottom right of the window."
+)))));
+const NOTIFICATIONS_LINKS = ( (registerColor('notificationLink.foreground', {
+    dark: textLinkForeground,
+    light: textLinkForeground,
+    hcDark: textLinkForeground,
+    hcLight: textLinkForeground
+},  (localize(
+    'notificationsLink',
+    "Notification links foreground color. Notifications slide in from the bottom right of the window."
+)))));
+const NOTIFICATIONS_ERROR_ICON_FOREGROUND = ( (registerColor('notificationsErrorIcon.foreground', {
+    dark: editorErrorForeground,
+    light: editorErrorForeground,
+    hcDark: editorErrorForeground,
+    hcLight: editorErrorForeground
+},  (localize(
+    'notificationsErrorIconForeground',
+    "The color used for the icon of error notifications. Notifications slide in from the bottom right of the window."
+)))));
+const NOTIFICATIONS_WARNING_ICON_FOREGROUND = ( (registerColor('notificationsWarningIcon.foreground', {
+    dark: editorWarningForeground,
+    light: editorWarningForeground,
+    hcDark: editorWarningForeground,
+    hcLight: editorWarningForeground
+},  (localize(
+    'notificationsWarningIconForeground',
+    "The color used for the icon of warning notifications. Notifications slide in from the bottom right of the window."
+)))));
+const NOTIFICATIONS_INFO_ICON_FOREGROUND = ( (registerColor('notificationsInfoIcon.foreground', {
+    dark: editorInfoForeground,
+    light: editorInfoForeground,
+    hcDark: editorInfoForeground,
+    hcLight: editorInfoForeground
+},  (localize(
+    'notificationsInfoIconForeground',
+    "The color used for the icon of info notifications. Notifications slide in from the bottom right of the window."
+)))));
+const defaultOptions = {
+    buttonBackground: ( (Color.fromHex('#0E639C'))),
+    buttonHoverBackground: ( (Color.fromHex('#006BB3'))),
+    buttonSeparator: Color.white,
+    buttonForeground: Color.white
+};
+class Button extends Disposable {
+    constructor(container, options) {
+        super();
+        this._onDidClick = this._register(( (new Emitter())));
+        this.options = options || Object.create(null);
+        mixin(this.options, defaultOptions, false);
+        this.buttonForeground = this.options.buttonForeground;
+        this.buttonBackground = this.options.buttonBackground;
+        this.buttonHoverBackground = this.options.buttonHoverBackground;
+        this.buttonSecondaryForeground = this.options.buttonSecondaryForeground;
+        this.buttonSecondaryBackground = this.options.buttonSecondaryBackground;
+        this.buttonSecondaryHoverBackground = this.options.buttonSecondaryHoverBackground;
+        this.buttonBorder = this.options.buttonBorder;
+        this._element = document.createElement('a');
+        this._element.classList.add('monaco-button');
+        this._element.tabIndex = 0;
+        this._element.setAttribute('role', 'button');
+        container.appendChild(this._element);
+        this._register(Gesture.addTarget(this._element));
+        [EventType.CLICK, EventType$1.Tap].forEach(eventType => {
+            this._register(addDisposableListener(this._element, eventType, e => {
+                if (!this.enabled) {
+                    EventHelper.stop(e);
+                    return;
+                }
+                this._onDidClick.fire(e);
+            }));
+        });
+        this._register(addDisposableListener(this._element, EventType.KEY_DOWN, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            let eventHandled = false;
+            if (this.enabled && (event.equals(3 ) || event.equals(10 ))) {
+                this._onDidClick.fire(e);
+                eventHandled = true;
+            }
+            else if (event.equals(9 )) {
+                this._element.blur();
+                eventHandled = true;
+            }
+            if (eventHandled) {
+                EventHelper.stop(event, true);
+            }
+        }));
+        this._register(addDisposableListener(this._element, EventType.MOUSE_OVER, e => {
+            if (!this._element.classList.contains('disabled')) {
+                this.setHoverBackground();
+            }
+        }));
+        this._register(addDisposableListener(this._element, EventType.MOUSE_OUT, e => {
+            this.applyStyles();
+        }));
+        this.focusTracker = this._register(trackFocus(this._element));
+        this._register(this.focusTracker.onDidFocus(() => { if (this.enabled) {
+            this.setHoverBackground();
+        } }));
+        this._register(this.focusTracker.onDidBlur(() => { if (this.enabled) {
+            this.applyStyles();
+        } }));
+        this.applyStyles();
+    }
+    get onDidClick() { return this._onDidClick.event; }
+    setHoverBackground() {
+        let hoverBackground;
+        if (this.options.secondary) {
+            hoverBackground = this.buttonSecondaryHoverBackground ? ( (this.buttonSecondaryHoverBackground.toString())) : null;
+        }
+        else {
+            hoverBackground = this.buttonHoverBackground ? ( (this.buttonHoverBackground.toString())) : null;
+        }
+        if (hoverBackground) {
+            this._element.style.backgroundColor = hoverBackground;
+        }
+    }
+    style(styles) {
+        this.buttonForeground = styles.buttonForeground;
+        this.buttonBackground = styles.buttonBackground;
+        this.buttonHoverBackground = styles.buttonHoverBackground;
+        this.buttonSecondaryForeground = styles.buttonSecondaryForeground;
+        this.buttonSecondaryBackground = styles.buttonSecondaryBackground;
+        this.buttonSecondaryHoverBackground = styles.buttonSecondaryHoverBackground;
+        this.buttonBorder = styles.buttonBorder;
+        this.applyStyles();
+    }
+    applyStyles() {
+        if (this._element) {
+            let background, foreground;
+            if (this.options.secondary) {
+                foreground = this.buttonSecondaryForeground ? ( (this.buttonSecondaryForeground.toString())) : '';
+                background = this.buttonSecondaryBackground ? ( (this.buttonSecondaryBackground.toString())) : '';
+            }
+            else {
+                foreground = this.buttonForeground ? ( (this.buttonForeground.toString())) : '';
+                background = this.buttonBackground ? ( (this.buttonBackground.toString())) : '';
+            }
+            const border = this.buttonBorder ? ( (this.buttonBorder.toString())) : '';
+            this._element.style.color = foreground;
+            this._element.style.backgroundColor = background;
+            this._element.style.borderWidth = border ? '1px' : '';
+            this._element.style.borderStyle = border ? 'solid' : '';
+            this._element.style.borderColor = border;
+        }
+    }
+    get element() {
+        return this._element;
+    }
+    set label(value) {
+        this._element.classList.add('monaco-text-button');
+        if (this.options.supportIcons) {
+            reset(this._element, ...renderLabelWithIcons(value));
+        }
+        else {
+            this._element.textContent = value;
+        }
+        if (typeof this.options.title === 'string') {
+            this._element.title = this.options.title;
+        }
+        else if (this.options.title) {
+            this._element.title = value;
+        }
+    }
+    set icon(icon) {
+        this._element.classList.add(...CSSIcon.asClassNameArray(icon));
+    }
+    set enabled(value) {
+        if (value) {
+            this._element.classList.remove('disabled');
+            this._element.setAttribute('aria-disabled', String(false));
+            this._element.tabIndex = 0;
+        }
+        else {
+            this._element.classList.add('disabled');
+            this._element.setAttribute('aria-disabled', String(true));
+        }
+    }
+    get enabled() {
+        return !this._element.classList.contains('disabled');
+    }
+    focus() {
+        this._element.focus();
+    }
+    hasFocus() {
+        return this._element === document.activeElement;
+    }
+}
+class ButtonWithDropdown extends Disposable {
+    constructor(container, options) {
+        super();
+        this._onDidClick = this._register(( (new Emitter())));
+        this.onDidClick = this._onDidClick.event;
+        this.element = document.createElement('div');
+        this.element.classList.add('monaco-button-dropdown');
+        container.appendChild(this.element);
+        this.button = this._register(( (new Button(this.element, options))));
+        this._register(this.button.onDidClick(e => this._onDidClick.fire(e)));
+        this.action = this._register(( (new Action(
+            'primaryAction',
+            this.button.label,
+            undefined,
+            true,
+            async () => this._onDidClick.fire(undefined)
+        ))));
+        this.separatorContainer = document.createElement('div');
+        this.separatorContainer.classList.add('monaco-button-dropdown-separator');
+        this.separator = document.createElement('div');
+        this.separatorContainer.appendChild(this.separator);
+        this.element.appendChild(this.separatorContainer);
+        this.dropdownButton = this._register(( (new Button(this.element, { ...options, title: false, supportIcons: true }))));
+        this.dropdownButton.element.title = ( (localize("button dropdown more actions", 'More Actions...')));
+        this.dropdownButton.element.setAttribute('aria-haspopup', 'true');
+        this.dropdownButton.element.setAttribute('aria-expanded', 'false');
+        this.dropdownButton.element.classList.add('monaco-dropdown-button');
+        this.dropdownButton.icon = Codicon.dropDownButton;
+        this._register(this.dropdownButton.onDidClick(e => {
+            options.contextMenuProvider.showContextMenu({
+                getAnchor: () => this.dropdownButton.element,
+                getActions: () => options.addPrimaryActionToDropdown === false ? [...options.actions] : [this.action, ...options.actions],
+                actionRunner: options.actionRunner,
+                onHide: () => this.dropdownButton.element.setAttribute('aria-expanded', 'false')
+            });
+            this.dropdownButton.element.setAttribute('aria-expanded', 'true');
+        }));
+    }
+    set label(value) {
+        this.button.label = value;
+        this.action.label = value;
+    }
+    set icon(icon) {
+        this.button.icon = icon;
+    }
+    set enabled(enabled) {
+        this.button.enabled = enabled;
+        this.dropdownButton.enabled = enabled;
+        this.element.classList.toggle('disabled', !enabled);
+    }
+    get enabled() {
+        return this.button.enabled;
+    }
+    style(styles) {
+        this.button.style(styles);
+        this.dropdownButton.style(styles);
+        const border = styles.buttonBorder ? ( (styles.buttonBorder.toString())) : '';
+        this.separatorContainer.style.borderTopWidth = border ? '1px' : '';
+        this.separatorContainer.style.borderTopStyle = border ? 'solid' : '';
+        this.separatorContainer.style.borderTopColor = border;
+        this.separatorContainer.style.borderBottomWidth = border ? '1px' : '';
+        this.separatorContainer.style.borderBottomStyle = border ? 'solid' : '';
+        this.separatorContainer.style.borderBottomColor = border;
+        this.separatorContainer.style.backgroundColor = styles.buttonBackground?.toString() ?? '';
+        this.separator.style.backgroundColor = styles.buttonSeparator?.toString() ?? '';
+    }
+    focus() {
+        this.button.focus();
+    }
+    hasFocus() {
+        return this.button.hasFocus() || this.dropdownButton.hasFocus();
+    }
+}
+class ButtonWithDescription extends Button {
+    constructor(container, options) {
+        super(container, options);
+        this._element.classList.add('monaco-description-button');
+        this._labelElement = document.createElement('div');
+        this._labelElement.classList.add('monaco-button-label');
+        this._element.appendChild(this._labelElement);
+        this._descriptionElement = document.createElement('div');
+        this._descriptionElement.classList.add('monaco-button-description');
+        this._element.appendChild(this._descriptionElement);
+    }
+    set label(value) {
+        this._element.classList.add('monaco-text-button');
+        if (this.options.supportIcons) {
+            reset(this._labelElement, ...renderLabelWithIcons(value));
+        }
+        else {
+            this._labelElement.textContent = value;
+        }
+        if (typeof this.options.title === 'string') {
+            this._element.title = this.options.title;
+        }
+        else if (this.options.title) {
+            this._element.title = value;
+        }
+    }
+    set description(value) {
+        if (this.options.supportIcons) {
+            reset(this._descriptionElement, ...renderLabelWithIcons(value));
+        }
+        else {
+            this._descriptionElement.textContent = value;
+        }
+    }
+}
+class ButtonBar extends Disposable {
+    constructor(container) {
+        super();
+        this.container = container;
+        this._buttons = [];
+    }
+    get buttons() {
+        return this._buttons;
+    }
+    addButton(options) {
+        const button = this._register(( (new Button(this.container, options))));
+        this.pushButton(button);
+        return button;
+    }
+    addButtonWithDescription(options) {
+        const button = this._register(( (new ButtonWithDescription(this.container, options))));
+        this.pushButton(button);
+        return button;
+    }
+    addButtonWithDropdown(options) {
+        const button = this._register(( (new ButtonWithDropdown(this.container, options))));
+        this.pushButton(button);
+        return button;
+    }
+    pushButton(button) {
+        this._buttons.push(button);
+        const index = this._buttons.length - 1;
+        this._register(addDisposableListener(button.element, EventType.KEY_DOWN, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            let eventHandled = true;
+            let buttonIndexToFocus;
+            if (event.equals(15 )) {
+                buttonIndexToFocus = index > 0 ? index - 1 : this._buttons.length - 1;
+            }
+            else if (event.equals(17 )) {
+                buttonIndexToFocus = index === this._buttons.length - 1 ? 0 : index + 1;
+            }
+            else {
+                eventHandled = false;
+            }
+            if (eventHandled && typeof buttonIndexToFocus === 'number') {
+                this._buttons[buttonIndexToFocus].focus();
+                EventHelper.stop(e, true);
+            }
+        }));
+    }
+}
+class LinkedText {
+    constructor(nodes) {
+        this.nodes = nodes;
+    }
+    toString() {
+        return this.nodes.map(node => typeof node === 'string' ? node : node.label).join('');
+    }
+}
+const LINK_REGEX = /\[([^\]]+)\]\(((?:https?:\/\/|command:|file:)[^\)\s]+)(?: ("|')([^\3]+)(\3))?\)/gi;
+function parseLinkedText(text) {
+    const result = [];
+    let index = 0;
+    let match;
+    while (match = LINK_REGEX.exec(text)) {
+        if (match.index - index > 0) {
+            result.push(text.substring(index, match.index));
+        }
+        const [, label, href, , title] = match;
+        if (title) {
+            result.push({ label, href, title });
+        }
+        else {
+            result.push({ label, href });
+        }
+        index = match.index + match[0].length;
+    }
+    if (index < text.length) {
+        result.push(text.substring(index));
+    }
+    return (
+         (new LinkedText(result))
+    );
+}
+class NotificationHandle extends Disposable {
+    constructor(item, onClose) {
+        super();
+        this.item = item;
+        this.onClose = onClose;
+        this._onDidClose = this._register(( (new Emitter())));
+        this.onDidClose = this._onDidClose.event;
+        this._onDidChangeVisibility = this._register(( (new Emitter())));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.item.onDidChangeVisibility(visible => this._onDidChangeVisibility.fire(visible)));
+        Event.once(this.item.onDidClose)(() => {
+            this._onDidClose.fire();
+            this.dispose();
+        });
+    }
+    get progress() {
+        return this.item.progress;
+    }
+    updateSeverity(severity) {
+        this.item.updateSeverity(severity);
+    }
+    updateMessage(message) {
+        this.item.updateMessage(message);
+    }
+    updateActions(actions) {
+        this.item.updateActions(actions);
+    }
+    close() {
+        this.onClose(this.item);
+        this.dispose();
+    }
+}
+class NotificationsModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeNotification = this._register(( (new Emitter())));
+        this.onDidChangeNotification = this._onDidChangeNotification.event;
+        this._onDidChangeStatusMessage = this._register(( (new Emitter())));
+        this.onDidChangeStatusMessage = this._onDidChangeStatusMessage.event;
+        this._onDidChangeFilter = this._register(( (new Emitter())));
+        this.onDidChangeFilter = this._onDidChangeFilter.event;
+        this._notifications = [];
+        this.filter = NotificationsFilter.OFF;
+    }
+    get notifications() { return this._notifications; }
+    get statusMessage() { return this._statusMessage; }
+    setFilter(filter) {
+        this.filter = filter;
+        this._onDidChangeFilter.fire(filter);
+    }
+    addNotification(notification) {
+        const item = this.createViewItem(notification);
+        if (!item) {
+            return NotificationsModel.NO_OP_NOTIFICATION;
+        }
+        const duplicate = this.findNotification(item);
+        if (duplicate) {
+            duplicate.close();
+        }
+        this._notifications.splice(0, 0, item);
+        this._onDidChangeNotification.fire({ item, index: 0, kind: 0  });
+        return (
+             (new NotificationHandle(item, item => this.onClose(item)))
+        );
+    }
+    onClose(item) {
+        const liveItem = this.findNotification(item);
+        if (liveItem && liveItem !== item) {
+            liveItem.close();
+        }
+        else {
+            item.close();
+        }
+    }
+    findNotification(item) {
+        return this._notifications.find(notification => notification.equals(item));
+    }
+    createViewItem(notification) {
+        const item = NotificationViewItem.create(notification, this.filter);
+        if (!item) {
+            return undefined;
+        }
+        const fireNotificationChangeEvent = (kind, detail) => {
+            const index = this._notifications.indexOf(item);
+            if (index >= 0) {
+                this._onDidChangeNotification.fire({ item, index, kind, detail });
+            }
+        };
+        const itemExpansionChangeListener = item.onDidChangeExpansion(() => fireNotificationChangeEvent(2 ));
+        const itemContentChangeListener = item.onDidChangeContent(e => fireNotificationChangeEvent(1 , e.kind));
+        Event.once(item.onDidClose)(() => {
+            itemExpansionChangeListener.dispose();
+            itemContentChangeListener.dispose();
+            const index = this._notifications.indexOf(item);
+            if (index >= 0) {
+                this._notifications.splice(index, 1);
+                this._onDidChangeNotification.fire({ item, index, kind: 3  });
+            }
+        });
+        return item;
+    }
+    showStatusMessage(message, options) {
+        const item = StatusMessageViewItem.create(message, options);
+        if (!item) {
+            return Disposable.None;
+        }
+        this._statusMessage = item;
+        this._onDidChangeStatusMessage.fire({ kind: 0 , item });
+        return toDisposable(() => {
+            if (this._statusMessage === item) {
+                this._statusMessage = undefined;
+                this._onDidChangeStatusMessage.fire({ kind: 1 , item });
+            }
+        });
+    }
+}
+NotificationsModel.NO_OP_NOTIFICATION = ( (new NoOpNotification()));
+function isNotificationViewItem(obj) {
+    return obj instanceof NotificationViewItem;
+}
+class NotificationViewItemProgress extends Disposable {
+    constructor() {
+        super();
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this._state = Object.create(null);
+    }
+    get state() {
+        return this._state;
+    }
+    infinite() {
+        if (this._state.infinite) {
+            return;
+        }
+        this._state.infinite = true;
+        this._state.total = undefined;
+        this._state.worked = undefined;
+        this._state.done = undefined;
+        this._onDidChange.fire();
+    }
+    done() {
+        if (this._state.done) {
+            return;
+        }
+        this._state.done = true;
+        this._state.infinite = undefined;
+        this._state.total = undefined;
+        this._state.worked = undefined;
+        this._onDidChange.fire();
+    }
+    total(value) {
+        if (this._state.total === value) {
+            return;
+        }
+        this._state.total = value;
+        this._state.infinite = undefined;
+        this._state.done = undefined;
+        this._onDidChange.fire();
+    }
+    worked(value) {
+        if (typeof this._state.worked === 'number') {
+            this._state.worked += value;
+        }
+        else {
+            this._state.worked = value;
+        }
+        this._state.infinite = undefined;
+        this._state.done = undefined;
+        this._onDidChange.fire();
+    }
+}
+class NotificationViewItem extends Disposable {
+    constructor(id, _severity, _sticky, _silent, _message, _source, progress, actions) {
+        super();
+        this.id = id;
+        this._severity = _severity;
+        this._sticky = _sticky;
+        this._silent = _silent;
+        this._message = _message;
+        this._source = _source;
+        this._visible = false;
+        this._onDidChangeExpansion = this._register(( (new Emitter())));
+        this.onDidChangeExpansion = this._onDidChangeExpansion.event;
+        this._onDidClose = this._register(( (new Emitter())));
+        this.onDidClose = this._onDidClose.event;
+        this._onDidChangeContent = this._register(( (new Emitter())));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidChangeVisibility = this._register(( (new Emitter())));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        if (progress) {
+            this.setProgress(progress);
+        }
+        this.setActions(actions);
+    }
+    static create(notification, filter = NotificationsFilter.OFF) {
+        if (!notification || !notification.message || isCancellationError(notification.message)) {
+            return undefined;
+        }
+        let severity;
+        if (typeof notification.severity === 'number') {
+            severity = notification.severity;
+        }
+        else {
+            severity = Severity.Info;
+        }
+        const message = NotificationViewItem.parseNotificationMessage(notification.message);
+        if (!message) {
+            return undefined;
+        }
+        let actions;
+        if (notification.actions) {
+            actions = notification.actions;
+        }
+        else if (isErrorWithActions(notification.message)) {
+            actions = { primary: notification.message.actions };
+        }
+        return (
+             (new NotificationViewItem(
+                notification.id,
+                severity,
+                notification.sticky,
+                notification.silent || filter === NotificationsFilter.SILENT || (filter === NotificationsFilter.ERROR && notification.severity !== Severity.Error),
+                message,
+                notification.source,
+                notification.progress,
+                actions
+            ))
+        );
+    }
+    static parseNotificationMessage(input) {
+        let message;
+        if (input instanceof Error) {
+            message = toErrorMessage(input, false);
+        }
+        else if (typeof input === 'string') {
+            message = input;
+        }
+        if (!message) {
+            return undefined;
+        }
+        const raw = message;
+        if (message.length > NotificationViewItem.MAX_MESSAGE_LENGTH) {
+            message = `${message.substr(0, NotificationViewItem.MAX_MESSAGE_LENGTH)}...`;
+        }
+        message = message.replace(/(\r\n|\n|\r)/gm, ' ').trim();
+        const linkedText = parseLinkedText(message);
+        return { raw, linkedText, original: input };
+    }
+    setProgress(progress) {
+        if (progress.infinite) {
+            this.progress.infinite();
+        }
+        else if (progress.total) {
+            this.progress.total(progress.total);
+            if (progress.worked) {
+                this.progress.worked(progress.worked);
+            }
+        }
+    }
+    setActions(actions = { primary: [], secondary: [] }) {
+        this._actions = {
+            primary: Array.isArray(actions.primary) ? actions.primary : [],
+            secondary: Array.isArray(actions.secondary) ? actions.secondary : []
+        };
+        this._expanded = actions.primary && actions.primary.length > 0;
+    }
+    get canCollapse() {
+        return !this.hasActions;
+    }
+    get expanded() {
+        return !!this._expanded;
+    }
+    get severity() {
+        return this._severity;
+    }
+    get sticky() {
+        if (this._sticky) {
+            return true;
+        }
+        const hasActions = this.hasActions;
+        if ((hasActions && this._severity === Severity.Error) ||
+            (!hasActions && this._expanded) ||
+            (this._progress && !this._progress.state.done)
+        ) {
+            return true;
+        }
+        return false;
+    }
+    get silent() {
+        return !!this._silent;
+    }
+    get hasActions() {
+        if (!this._actions) {
+            return false;
+        }
+        if (!this._actions.primary) {
+            return false;
+        }
+        return this._actions.primary.length > 0;
+    }
+    get hasProgress() {
+        return !!this._progress;
+    }
+    get progress() {
+        if (!this._progress) {
+            this._progress = this._register(( (new NotificationViewItemProgress())));
+            this._register(this._progress.onDidChange(() => this._onDidChangeContent.fire({ kind: 3  })));
+        }
+        return this._progress;
+    }
+    get message() {
+        return this._message;
+    }
+    get source() {
+        return typeof this._source === 'string' ? this._source : (this._source ? this._source.label : undefined);
+    }
+    get sourceId() {
+        return (this._source && typeof this._source !== 'string' && 'id' in this._source) ? this._source.id : undefined;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get visible() {
+        return this._visible;
+    }
+    updateSeverity(severity) {
+        if (severity === this._severity) {
+            return;
+        }
+        this._severity = severity;
+        this._onDidChangeContent.fire({ kind: 0  });
+    }
+    updateMessage(input) {
+        const message = NotificationViewItem.parseNotificationMessage(input);
+        if (!message || message.raw === this._message.raw) {
+            return;
+        }
+        this._message = message;
+        this._onDidChangeContent.fire({ kind: 1  });
+    }
+    updateActions(actions) {
+        this.setActions(actions);
+        this._onDidChangeContent.fire({ kind: 2  });
+    }
+    updateVisibility(visible) {
+        if (this._visible !== visible) {
+            this._visible = visible;
+            this._onDidChangeVisibility.fire(visible);
+        }
+    }
+    expand() {
+        if (this._expanded || !this.canCollapse) {
+            return;
+        }
+        this._expanded = true;
+        this._onDidChangeExpansion.fire();
+    }
+    collapse(skipEvents) {
+        if (!this._expanded || !this.canCollapse) {
+            return;
+        }
+        this._expanded = false;
+        if (!skipEvents) {
+            this._onDidChangeExpansion.fire();
+        }
+    }
+    toggle() {
+        if (this._expanded) {
+            this.collapse();
+        }
+        else {
+            this.expand();
+        }
+    }
+    close() {
+        this._onDidClose.fire();
+        this.dispose();
+    }
+    equals(other) {
+        if (this.hasProgress || other.hasProgress) {
+            return false;
+        }
+        if (typeof this.id === 'string' || typeof other.id === 'string') {
+            return this.id === other.id;
+        }
+        if (typeof this._source === 'object') {
+            if (this._source.label !== other.source || this._source.id !== other.sourceId) {
+                return false;
+            }
+        }
+        else if (this._source !== other.source) {
+            return false;
+        }
+        if (this._message.raw !== other.message.raw) {
+            return false;
+        }
+        const primaryActions = (this._actions && this._actions.primary) || [];
+        const otherPrimaryActions = (other.actions && other.actions.primary) || [];
+        return equals(primaryActions, otherPrimaryActions, (action, otherAction) => (action.id + action.label) === (otherAction.id + otherAction.label));
+    }
+}
+NotificationViewItem.MAX_MESSAGE_LENGTH = 1000;
+class ChoiceAction extends Action {
+    constructor(id, choice) {
+        super(id, choice.label, undefined, true, async () => {
+            choice.run();
+            this._onDidRun.fire();
+        });
+        this._onDidRun = this._register(( (new Emitter())));
+        this.onDidRun = this._onDidRun.event;
+        this._keepOpen = !!choice.keepOpen;
+        this._menu = !choice.isSecondary && choice.menu ? choice.menu.map((c, index) => ( (new ChoiceAction(`${id}.${index}`, c)))) : undefined;
+    }
+    get menu() {
+        return this._menu;
+    }
+    get keepOpen() {
+        return this._keepOpen;
+    }
+}
+class StatusMessageViewItem {
+    static create(notification, options) {
+        if (!notification || isCancellationError(notification)) {
+            return undefined;
+        }
+        let message;
+        if (notification instanceof Error) {
+            message = toErrorMessage(notification, false);
+        }
+        else if (typeof notification === 'string') {
+            message = notification;
+        }
+        if (!message) {
+            return undefined;
+        }
+        return { message, options };
+    }
+}
+var css$1 = "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-toolbar-container .action-item,\n.monaco-workbench > .notifications-center > .notifications-center-header > .notifications-center-header-toolbar .action-item {\n\tmargin-right: 4px;\n}\n\n.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-toolbar-container .action-item:first-child,\n.monaco-workbench > .notifications-center > .notifications-center-header > .notifications-center-header-toolbar .action-item:first-child {\n\tmargin-left: 4px;\n}\n";
+n(css$1,{});
+function notificationToMetrics(message, source, silent) {
+    return {
+        id: ( (hash(( (message.toString()))).toString())),
+        silent,
+        source: source || 'core'
+    };
+}
+const MultipleEditorGroupsContext = ( (new RawContextKey(
+    'multipleEditorGroups',
+    false,
+     (localize('multipleEditorGroups', "Whether there are multiple editor groups opened"))
+)));
+MultipleEditorGroupsContext.toNegated();
+const NotificationFocusedContext = ( (new RawContextKey(
+    'notificationFocus',
+    true,
+     (localize('notificationFocus', "Whether a notification has keyboard focus"))
+)));
+const NotificationsCenterVisibleContext = ( (new RawContextKey(
+    'notificationCenterVisible',
+    false,
+     (localize('notificationCenterVisible', "Whether the notifications center is visible"))
+)));
+const NotificationsToastsVisibleContext = ( (new RawContextKey(
+    'notificationToastsVisible',
+    false,
+     (localize('notificationToastsVisible', "Whether a notification toast is visible"))
+)));
+let ResourceContextKey = class ResourceContextKey {
+    constructor(_contextKeyService, _fileService, _languageService, _modelService) {
+        this._contextKeyService = _contextKeyService;
+        this._fileService = _fileService;
+        this._languageService = _languageService;
+        this._modelService = _modelService;
+        this._disposables = ( (new DisposableStore()));
+        this._schemeKey = ResourceContextKey.Scheme.bindTo(this._contextKeyService);
+        this._filenameKey = ResourceContextKey.Filename.bindTo(this._contextKeyService);
+        this._dirnameKey = ResourceContextKey.Dirname.bindTo(this._contextKeyService);
+        this._pathKey = ResourceContextKey.Path.bindTo(this._contextKeyService);
+        this._langIdKey = ResourceContextKey.LangId.bindTo(this._contextKeyService);
+        this._resourceKey = ResourceContextKey.Resource.bindTo(this._contextKeyService);
+        this._extensionKey = ResourceContextKey.Extension.bindTo(this._contextKeyService);
+        this._hasResource = ResourceContextKey.HasResource.bindTo(this._contextKeyService);
+        this._isFileSystemResource = ResourceContextKey.IsFileSystemResource.bindTo(this._contextKeyService);
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(() => {
+            const resource = this.get();
+            this._isFileSystemResource.set(Boolean(resource && _fileService.hasProvider(resource)));
+        }));
+        this._disposables.add(_modelService.onModelAdded(model => {
+            if (isEqual(model.uri, this.get())) {
+                this._setLangId();
+            }
+        }));
+        this._disposables.add(_modelService.onModelLanguageChanged(e => {
+            if (isEqual(e.model.uri, this.get())) {
+                this._setLangId();
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    _setLangId() {
+        const value = this.get();
+        if (!value) {
+            this._langIdKey.set(null);
+            return;
+        }
+        const langId = this._modelService.getModel(value)?.getLanguageId() ?? this._languageService.guessLanguageIdByFilepathOrFirstLine(value);
+        this._langIdKey.set(langId);
+    }
+    set(value) {
+        value = value ?? undefined;
+        if (isEqual(this._value, value)) {
+            return;
+        }
+        this._value = value;
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.set(value ? ( (value.toString())) : null);
+            this._schemeKey.set(value ? value.scheme : null);
+            this._filenameKey.set(value ? basename(value) : null);
+            this._dirnameKey.set(value ? dirname(value).fsPath : null);
+            this._pathKey.set(value ? value.fsPath : null);
+            this._setLangId();
+            this._extensionKey.set(value ? extname(value) : null);
+            this._hasResource.set(Boolean(value));
+            this._isFileSystemResource.set(value ? this._fileService.hasProvider(value) : false);
+        });
+    }
+    reset() {
+        this._value = undefined;
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.reset();
+            this._schemeKey.reset();
+            this._filenameKey.reset();
+            this._dirnameKey.reset();
+            this._pathKey.reset();
+            this._langIdKey.reset();
+            this._extensionKey.reset();
+            this._hasResource.reset();
+            this._isFileSystemResource.reset();
+        });
+    }
+    get() {
+        return this._value;
+    }
+};
+ResourceContextKey.Scheme = ( (new RawContextKey(
+    'resourceScheme',
+    undefined,
+    { type: 'string', description: ( (localize('resourceScheme', "The scheme of the resource"))) }
+)));
+ResourceContextKey.Filename = ( (new RawContextKey(
+    'resourceFilename',
+    undefined,
+    { type: 'string', description: ( (localize('resourceFilename', "The file name of the resource"))) }
+)));
+ResourceContextKey.Dirname = ( (new RawContextKey(
+    'resourceDirname',
+    undefined,
+    { type: 'string', description: ( (localize('resourceDirname', "The folder name the resource is contained in"))) }
+)));
+ResourceContextKey.Path = ( (new RawContextKey(
+    'resourcePath',
+    undefined,
+    { type: 'string', description: ( (localize('resourcePath', "The full path of the resource"))) }
+)));
+ResourceContextKey.LangId = ( (new RawContextKey(
+    'resourceLangId',
+    undefined,
+    { type: 'string', description: ( (localize('resourceLangId', "The language identifier of the resource"))) }
+)));
+ResourceContextKey.Resource = ( (new RawContextKey(
+    'resource',
+    undefined,
+    { type: 'URI', description: ( (localize('resource', "The full value of the resource including scheme and path"))) }
+)));
+ResourceContextKey.Extension = ( (new RawContextKey(
+    'resourceExtname',
+    undefined,
+    { type: 'string', description: ( (localize('resourceExtname', "The extension name of the resource"))) }
+)));
+ResourceContextKey.HasResource = ( (new RawContextKey(
+    'resourceSet',
+    undefined,
+    { type: 'boolean', description: ( (localize('resourceSet', "Whether a resource is present or not"))) }
+)));
+ResourceContextKey.IsFileSystemResource = ( (new RawContextKey(
+    'isFileSystemResource',
+    undefined,
+    { type: 'boolean', description: ( (localize(
+        'isFileSystemResource',
+        "Whether the resource is backed by a file system provider"
+    ))) }
+)));
+ResourceContextKey = ( (__decorate([
+    ( (__param(0, IContextKeyService))),
+    ( (__param(1, IFileService))),
+    ( (__param(2, ILanguageService))),
+    ( (__param(3, IModelService)))
+], ResourceContextKey)));
+const SHOW_NOTIFICATIONS_CENTER = 'notifications.showList';
+const HIDE_NOTIFICATIONS_CENTER = 'notifications.hideList';
+const HIDE_NOTIFICATION_TOAST = 'notifications.hideToasts';
+const FOCUS_NOTIFICATION_TOAST = 'notifications.focusToasts';
+const FOCUS_NEXT_NOTIFICATION_TOAST = 'notifications.focusNextToast';
+const FOCUS_PREVIOUS_NOTIFICATION_TOAST = 'notifications.focusPreviousToast';
+const FOCUS_FIRST_NOTIFICATION_TOAST = 'notifications.focusFirstToast';
+const FOCUS_LAST_NOTIFICATION_TOAST = 'notifications.focusLastToast';
+const COLLAPSE_NOTIFICATION = 'notification.collapse';
+const EXPAND_NOTIFICATION = 'notification.expand';
+const TOGGLE_NOTIFICATION = 'notification.toggle';
+const CLEAR_NOTIFICATION = 'notification.clear';
+const CLEAR_ALL_NOTIFICATIONS = 'notifications.clearAll';
+const TOGGLE_DO_NOT_DISTURB_MODE = 'notifications.toggleDoNotDisturbMode';
+function registerNotificationCommands(center, toasts, model) {
+    function getNotificationFromContext(listService, context) {
+        if (isNotificationViewItem(context)) {
+            return context;
+        }
+        const list = listService.lastFocusedList;
+        if (list instanceof WorkbenchList) {
+            const focusedElement = list.getFocusedElements()[0];
+            if (isNotificationViewItem(focusedElement)) {
+                return focusedElement;
+            }
+        }
+        return undefined;
+    }
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: HIDE_NOTIFICATIONS_CENTER,
+        weight: 200  + 50,
+        when: NotificationsCenterVisibleContext,
+        primary: 9 ,
+        handler: accessor => {
+            const telemetryService = accessor.get(ITelemetryService);
+            for (const notification of model.notifications) {
+                if (notification.visible) {
+                    telemetryService.publicLog2('notification:hide', notificationToMetrics(notification.message.original, notification.sourceId, notification.silent));
+                }
+            }
+            center.hide();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: CLEAR_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 20 ,
+        mac: {
+            primary: 2048  | 1
+        },
+        handler: (accessor, args) => {
+            const notification = getNotificationFromContext(accessor.get(IListService), args);
+            if (notification && !notification.hasProgress) {
+                notification.close();
+            }
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: EXPAND_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 17 ,
+        handler: (accessor, args) => {
+            const notification = getNotificationFromContext(accessor.get(IListService), args);
+            if (notification) {
+                notification.expand();
+            }
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: COLLAPSE_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 15 ,
+        handler: (accessor, args) => {
+            const notification = getNotificationFromContext(accessor.get(IListService), args);
+            if (notification) {
+                notification.collapse();
+            }
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: TOGGLE_NOTIFICATION,
+        weight: 200 ,
+        when: NotificationFocusedContext,
+        primary: 10 ,
+        secondary: [3 ],
+        handler: accessor => {
+            const notification = getNotificationFromContext(accessor.get(IListService));
+            if (notification) {
+                notification.toggle();
+            }
+        }
+    });
+    KeybindingsRegistry.registerKeybindingRule({
+        id: HIDE_NOTIFICATION_TOAST,
+        weight: 200  - 50,
+        when: NotificationsToastsVisibleContext,
+        primary: 9
+    });
+    KeybindingsRegistry.registerKeybindingRule({
+        id: HIDE_NOTIFICATION_TOAST,
+        weight: 200  + 100,
+        when: ContextKeyExpr.and(NotificationsToastsVisibleContext, NotificationFocusedContext),
+        primary: 9
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_NEXT_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext),
+        primary: 18 ,
+        handler: (accessor) => {
+            toasts.focusNext();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_PREVIOUS_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext),
+        primary: 16 ,
+        handler: (accessor) => {
+            toasts.focusPrevious();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_FIRST_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext),
+        primary: 11 ,
+        secondary: [14 ],
+        handler: (accessor) => {
+            toasts.focusFirst();
+        }
+    });
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: FOCUS_LAST_NOTIFICATION_TOAST,
+        weight: 200 ,
+        when: ContextKeyExpr.and(NotificationFocusedContext, NotificationsToastsVisibleContext),
+        primary: 12 ,
+        secondary: [13 ],
+        handler: (accessor) => {
+            toasts.focusLast();
+        }
+    });
+    const category = { value: ( (localize('notifications', "Notifications"))), original: 'Notifications' };
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: SHOW_NOTIFICATIONS_CENTER, title: { value: ( (localize('showNotifications', "Show Notifications"))), original: 'Show Notifications' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: HIDE_NOTIFICATIONS_CENTER, title: { value: ( (localize('hideNotifications', "Hide Notifications"))), original: 'Hide Notifications' }, category }, when: NotificationsCenterVisibleContext });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: CLEAR_ALL_NOTIFICATIONS, title: { value: ( (localize('clearAllNotifications', "Clear All Notifications"))), original: 'Clear All Notifications' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: TOGGLE_DO_NOT_DISTURB_MODE, title: { value: ( (localize('toggleDoNotDisturbMode', "Toggle Do Not Disturb Mode"))), original: 'Toggle Do Not Disturb Mode' }, category } });
+    MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: { id: FOCUS_NOTIFICATION_TOAST, title: { value: ( (localize('focusNotificationToasts', "Focus Notification Toast"))), original: 'Focus Notification Toast' }, category }, when: NotificationsToastsVisibleContext });
+}
+const clearIcon = registerIcon('notifications-clear', Codicon.close, ( (localize('clearIcon', 'Icon for the clear action in notifications.'))));
+const clearAllIcon = registerIcon('notifications-clear-all', Codicon.clearAll, ( (localize('clearAllIcon', 'Icon for the clear all action in notifications.'))));
+const hideIcon = registerIcon('notifications-hide', Codicon.chevronDown, ( (localize('hideIcon', 'Icon for the hide action in notifications.'))));
+const expandIcon = registerIcon('notifications-expand', Codicon.chevronUp, ( (localize('expandIcon', 'Icon for the expand action in notifications.'))));
+const collapseIcon = registerIcon('notifications-collapse', Codicon.chevronDown, ( (localize('collapseIcon', 'Icon for the collapse action in notifications.'))));
+const configureIcon = registerIcon('notifications-configure', Codicon.gear, ( (localize('configureIcon', 'Icon for the configure action in notifications.'))));
+const doNotDisturbIcon = registerIcon('notifications-do-not-disturb', Codicon.bellSlash, ( (localize('doNotDisturbIcon', 'Icon for the mute all action in notifications.'))));
+let ClearNotificationAction = class ClearNotificationAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(clearIcon));
+        this.commandService = commandService;
+    }
+    async run(notification) {
+        this.commandService.executeCommand(CLEAR_NOTIFICATION, notification);
+    }
+};
+ClearNotificationAction.ID = CLEAR_NOTIFICATION;
+ClearNotificationAction.LABEL = ( (localize('clearNotification', "Clear Notification")));
+ClearNotificationAction = ( (__decorate([
+    ( (__param(2, ICommandService)))
+], ClearNotificationAction)));
+let ClearAllNotificationsAction = class ClearAllNotificationsAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(clearAllIcon));
+        this.commandService = commandService;
+    }
+    async run() {
+        this.commandService.executeCommand(CLEAR_ALL_NOTIFICATIONS);
+    }
+};
+ClearAllNotificationsAction.ID = CLEAR_ALL_NOTIFICATIONS;
+ClearAllNotificationsAction.LABEL = ( (localize('clearNotifications', "Clear All Notifications")));
+ClearAllNotificationsAction = ( (__decorate([
+    ( (__param(2, ICommandService)))
+], ClearAllNotificationsAction)));
+let ToggleDoNotDisturbAction = class ToggleDoNotDisturbAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(doNotDisturbIcon));
+        this.commandService = commandService;
+    }
+    async run() {
+        this.commandService.executeCommand(TOGGLE_DO_NOT_DISTURB_MODE);
+    }
+};
+ToggleDoNotDisturbAction.ID = TOGGLE_DO_NOT_DISTURB_MODE;
+ToggleDoNotDisturbAction.LABEL = ( (localize('toggleDoNotDisturbMode', "Toggle Do Not Disturb Mode")));
+ToggleDoNotDisturbAction = ( (__decorate([
+    ( (__param(2, ICommandService)))
+], ToggleDoNotDisturbAction)));
+let HideNotificationsCenterAction = class HideNotificationsCenterAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(hideIcon));
+        this.commandService = commandService;
+    }
+    async run() {
+        this.commandService.executeCommand(HIDE_NOTIFICATIONS_CENTER);
+    }
+};
+HideNotificationsCenterAction.ID = HIDE_NOTIFICATIONS_CENTER;
+HideNotificationsCenterAction.LABEL = ( (localize('hideNotificationsCenter', "Hide Notifications")));
+HideNotificationsCenterAction = ( (__decorate([
+    ( (__param(2, ICommandService)))
+], HideNotificationsCenterAction)));
+let ExpandNotificationAction = class ExpandNotificationAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(expandIcon));
+        this.commandService = commandService;
+    }
+    async run(notification) {
+        this.commandService.executeCommand(EXPAND_NOTIFICATION, notification);
+    }
+};
+ExpandNotificationAction.ID = EXPAND_NOTIFICATION;
+ExpandNotificationAction.LABEL = ( (localize('expandNotification', "Expand Notification")));
+ExpandNotificationAction = ( (__decorate([
+    ( (__param(2, ICommandService)))
+], ExpandNotificationAction)));
+let CollapseNotificationAction = class CollapseNotificationAction extends Action {
+    constructor(id, label, commandService) {
+        super(id, label, ThemeIcon.asClassName(collapseIcon));
+        this.commandService = commandService;
+    }
+    async run(notification) {
+        this.commandService.executeCommand(COLLAPSE_NOTIFICATION, notification);
+    }
+};
+CollapseNotificationAction.ID = COLLAPSE_NOTIFICATION;
+CollapseNotificationAction.LABEL = ( (localize('collapseNotification', "Collapse Notification")));
+CollapseNotificationAction = ( (__decorate([
+    ( (__param(2, ICommandService)))
+], CollapseNotificationAction)));
+class ConfigureNotificationAction extends Action {
+    constructor(id, label, configurationActions) {
+        super(id, label, ThemeIcon.asClassName(configureIcon));
+        this.configurationActions = configurationActions;
+    }
+}
+ConfigureNotificationAction.ID = 'workbench.action.configureNotification';
+ConfigureNotificationAction.LABEL = ( (localize('configureNotification', "Configure Notification")));
+let CopyNotificationMessageAction = class CopyNotificationMessageAction extends Action {
+    constructor(id, label, clipboardService) {
+        super(id, label);
+        this.clipboardService = clipboardService;
+    }
+    run(notification) {
+        return this.clipboardService.writeText(notification.message.raw);
+    }
+};
+CopyNotificationMessageAction.ID = 'workbench.action.copyNotificationMessage';
+CopyNotificationMessageAction.LABEL = ( (localize('copyNotification', "Copy Text")));
+CopyNotificationMessageAction = ( (__decorate([
+    ( (__param(2, IClipboardService)))
+], CopyNotificationMessageAction)));
+let NotificationActionRunner = class NotificationActionRunner extends ActionRunner {
+    constructor(telemetryService, notificationService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+    }
+    async runAction(action, context) {
+        this.telemetryService.publicLog2('workbenchActionExecuted', { id: action.id, from: 'message' });
+        if (isNotificationViewItem(context)) {
+            this.telemetryService.publicLog2('notification:actionExecuted', {
+                id: ( (hash(( (context.message.original.toString()))).toString())),
+                actionLabel: action.label,
+                source: context.sourceId || 'core',
+                silent: context.silent
+            });
+        }
+        try {
+            await super.runAction(action, context);
+        }
+        catch (error) {
+            this.notificationService.error(error);
+        }
+    }
+};
+NotificationActionRunner = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, INotificationService)))
+], NotificationActionRunner)));
+class NotificationsListDelegate {
+    constructor(container) {
+        this.offsetHelper = this.createOffsetHelper(container);
+    }
+    createOffsetHelper(container) {
+        const offsetHelper = document.createElement('div');
+        offsetHelper.classList.add('notification-offset-helper');
+        container.appendChild(offsetHelper);
+        return offsetHelper;
+    }
+    getHeight(notification) {
+        if (!notification.expanded) {
+            return NotificationsListDelegate.ROW_HEIGHT;
+        }
+        let expandedHeight = NotificationsListDelegate.ROW_HEIGHT;
+        const preferredMessageHeight = this.computePreferredHeight(notification);
+        const messageOverflows = NotificationsListDelegate.LINE_HEIGHT < preferredMessageHeight;
+        if (messageOverflows) {
+            const overflow = preferredMessageHeight - NotificationsListDelegate.LINE_HEIGHT;
+            expandedHeight += overflow;
+        }
+        if (notification.source || isNonEmptyArray(notification.actions && notification.actions.primary)) {
+            expandedHeight += NotificationsListDelegate.ROW_HEIGHT;
+        }
+        if (expandedHeight === NotificationsListDelegate.ROW_HEIGHT) {
+            notification.collapse(true );
+        }
+        return expandedHeight;
+    }
+    computePreferredHeight(notification) {
+        let actions = 1;
+        if (notification.canCollapse) {
+            actions++;
+        }
+        if (isNonEmptyArray(notification.actions && notification.actions.secondary)) {
+            actions++;
+        }
+        this.offsetHelper.style.width = `${450  - ((10  + 26  + (actions * (24 + 8))  - 4) )}px`;
+        const renderedMessage = NotificationMessageRenderer.render(notification.message);
+        this.offsetHelper.appendChild(renderedMessage);
+        const preferredHeight = Math.max(this.offsetHelper.offsetHeight, this.offsetHelper.scrollHeight);
+        clearNode(this.offsetHelper);
+        return preferredHeight;
+    }
+    getTemplateId(element) {
+        if (element instanceof NotificationViewItem) {
+            return NotificationRenderer.TEMPLATE_ID;
+        }
+        throw new Error('unknown element type: ' + element);
+    }
+}
+NotificationsListDelegate.ROW_HEIGHT = 42;
+NotificationsListDelegate.LINE_HEIGHT = 22;
+class NotificationMessageRenderer {
+    static render(message, actionHandler) {
+        const messageContainer = document.createElement('span');
+        for (const node of message.linkedText.nodes) {
+            if (typeof node === 'string') {
+                messageContainer.appendChild(document.createTextNode(node));
+            }
+            else {
+                let title = node.title;
+                if (!title && node.href.startsWith('command:')) {
+                    title = ( (localize(
+                        'executeCommand',
+                        "Click to execute command '{0}'",
+                        node.href.substr('command:'.length)
+                    )));
+                }
+                else if (!title) {
+                    title = node.href;
+                }
+                const anchor = $('a', { href: node.href, title: title, }, node.label);
+                if (actionHandler) {
+                    const onPointer = (e) => {
+                        EventHelper.stop(e, true);
+                        actionHandler.callback(node.href);
+                    };
+                    const onClick = actionHandler.toDispose.add(( (new DomEmitter(anchor, 'click')))).event;
+                    actionHandler.toDispose.add(Gesture.addTarget(anchor));
+                    const onTap = actionHandler.toDispose.add(( (new DomEmitter(anchor, EventType$1.Tap)))).event;
+                    Event.any(onClick, onTap)(onPointer, null, actionHandler.toDispose);
+                }
+                messageContainer.appendChild(anchor);
+            }
+        }
+        return messageContainer;
+    }
+}
+let NotificationRenderer = class NotificationRenderer {
+    constructor(actionRunner, themeService, contextMenuService, instantiationService) {
+        this.actionRunner = actionRunner;
+        this.themeService = themeService;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+    }
+    get templateId() {
+        return NotificationRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDispose = ( (new DisposableStore()));
+        data.container = document.createElement('div');
+        data.container.classList.add('notification-list-item');
+        data.mainRow = document.createElement('div');
+        data.mainRow.classList.add('notification-list-item-main-row');
+        data.icon = document.createElement('div');
+        data.icon.classList.add('notification-list-item-icon', 'codicon');
+        data.message = document.createElement('div');
+        data.message.classList.add('notification-list-item-message');
+        const toolbarContainer = document.createElement('div');
+        toolbarContainer.classList.add('notification-list-item-toolbar-container');
+        data.toolbar = ( (new ActionBar(toolbarContainer, {
+            ariaLabel: ( (localize('notificationActions', "Notification Actions"))),
+            actionViewItemProvider: action => {
+                if (action && action instanceof ConfigureNotificationAction) {
+                    const item = ( (new DropdownMenuActionViewItem(
+                        action,
+                        action.configurationActions,
+                        this.contextMenuService,
+                        { actionRunner: this.actionRunner, classNames: action.class }
+                    )));
+                    data.toDispose.add(item);
+                    return item;
+                }
+                return undefined;
+            },
+            actionRunner: this.actionRunner
+        })));
+        data.toDispose.add(data.toolbar);
+        data.detailsRow = document.createElement('div');
+        data.detailsRow.classList.add('notification-list-item-details-row');
+        data.source = document.createElement('div');
+        data.source.classList.add('notification-list-item-source');
+        data.buttonsContainer = document.createElement('div');
+        data.buttonsContainer.classList.add('notification-list-item-buttons-container');
+        container.appendChild(data.container);
+        data.container.appendChild(data.detailsRow);
+        data.detailsRow.appendChild(data.source);
+        data.detailsRow.appendChild(data.buttonsContainer);
+        data.container.appendChild(data.mainRow);
+        data.mainRow.appendChild(data.icon);
+        data.mainRow.appendChild(data.message);
+        data.mainRow.appendChild(toolbarContainer);
+        data.progress = ( (new ProgressBar(container)));
+        data.toDispose.add(attachProgressBarStyler(data.progress, this.themeService));
+        data.toDispose.add(data.progress);
+        data.renderer = this.instantiationService.createInstance(NotificationTemplateRenderer, data, this.actionRunner);
+        data.toDispose.add(data.renderer);
+        return data;
+    }
+    renderElement(notification, index, data) {
+        data.renderer.setInput(notification);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+NotificationRenderer.TEMPLATE_ID = 'notification';
+NotificationRenderer = ( (__decorate([
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IContextMenuService))),
+    ( (__param(3, IInstantiationService)))
+], NotificationRenderer)));
+let NotificationTemplateRenderer = class NotificationTemplateRenderer extends Disposable {
+    constructor(template, actionRunner, openerService, instantiationService, themeService, keybindingService, contextMenuService) {
+        super();
+        this.template = template;
+        this.actionRunner = actionRunner;
+        this.openerService = openerService;
+        this.instantiationService = instantiationService;
+        this.themeService = themeService;
+        this.keybindingService = keybindingService;
+        this.contextMenuService = contextMenuService;
+        this.inputDisposables = this._register(( (new DisposableStore())));
+        if (!NotificationTemplateRenderer.closeNotificationAction) {
+            NotificationTemplateRenderer.closeNotificationAction = instantiationService.createInstance(ClearNotificationAction, ClearNotificationAction.ID, ClearNotificationAction.LABEL);
+            NotificationTemplateRenderer.expandNotificationAction = instantiationService.createInstance(ExpandNotificationAction, ExpandNotificationAction.ID, ExpandNotificationAction.LABEL);
+            NotificationTemplateRenderer.collapseNotificationAction = instantiationService.createInstance(CollapseNotificationAction, CollapseNotificationAction.ID, CollapseNotificationAction.LABEL);
+        }
+    }
+    setInput(notification) {
+        this.inputDisposables.clear();
+        this.render(notification);
+    }
+    render(notification) {
+        this.template.container.classList.toggle('expanded', notification.expanded);
+        this.inputDisposables.add(addDisposableListener(this.template.container, EventType.MOUSE_UP, e => {
+            if (e.button === 1 ) {
+                EventHelper.stop(e, true);
+            }
+        }));
+        this.inputDisposables.add(addDisposableListener(this.template.container, EventType.AUXCLICK, e => {
+            if (!notification.hasProgress && e.button === 1 ) {
+                EventHelper.stop(e, true);
+                notification.close();
+            }
+        }));
+        this.renderSeverity(notification);
+        const messageOverflows = this.renderMessage(notification);
+        this.renderSecondaryActions(notification, messageOverflows);
+        this.renderSource(notification);
+        this.renderButtons(notification);
+        this.renderProgress(notification);
+        this.inputDisposables.add(notification.onDidChangeContent(event => {
+            switch (event.kind) {
+                case 0 :
+                    this.renderSeverity(notification);
+                    break;
+                case 3 :
+                    this.renderProgress(notification);
+                    break;
+                case 1 :
+                    this.renderMessage(notification);
+                    break;
+            }
+        }));
+    }
+    renderSeverity(notification) {
+        NotificationTemplateRenderer.SEVERITIES.forEach(severity => {
+            if (notification.severity !== severity) {
+                this.template.icon.classList.remove(...this.toSeverityIcon(severity).classNamesArray);
+            }
+        });
+        this.template.icon.classList.add(...this.toSeverityIcon(notification.severity).classNamesArray);
+    }
+    renderMessage(notification) {
+        clearNode(this.template.message);
+        this.template.message.appendChild(NotificationMessageRenderer.render(notification.message, {
+            callback: link => this.openerService.open(( (URI.parse(link))), { allowCommands: true }),
+            toDispose: this.inputDisposables
+        }));
+        const messageOverflows = notification.canCollapse && !notification.expanded && this.template.message.scrollWidth > this.template.message.clientWidth;
+        if (messageOverflows) {
+            this.template.message.title = this.template.message.textContent + '';
+        }
+        else {
+            this.template.message.removeAttribute('title');
+        }
+        const links = this.template.message.querySelectorAll('a');
+        for (let i = 0; i < links.length; i++) {
+            links.item(i).tabIndex = -1;
+        }
+        return messageOverflows;
+    }
+    renderSecondaryActions(notification, messageOverflows) {
+        const actions = [];
+        const secondaryActions = notification.actions ? notification.actions.secondary : undefined;
+        if (isNonEmptyArray(secondaryActions)) {
+            const configureNotificationAction = this.instantiationService.createInstance(ConfigureNotificationAction, ConfigureNotificationAction.ID, ConfigureNotificationAction.LABEL, secondaryActions);
+            actions.push(configureNotificationAction);
+            this.inputDisposables.add(configureNotificationAction);
+        }
+        let showExpandCollapseAction = false;
+        if (notification.canCollapse) {
+            if (notification.expanded) {
+                showExpandCollapseAction = true;
+            }
+            else if (notification.source) {
+                showExpandCollapseAction = true;
+            }
+            else if (messageOverflows) {
+                showExpandCollapseAction = true;
+            }
+        }
+        if (showExpandCollapseAction) {
+            actions.push(notification.expanded ? NotificationTemplateRenderer.collapseNotificationAction : NotificationTemplateRenderer.expandNotificationAction);
+        }
+        if (!notification.hasProgress) {
+            actions.push(NotificationTemplateRenderer.closeNotificationAction);
+        }
+        this.template.toolbar.clear();
+        this.template.toolbar.context = notification;
+        actions.forEach(action => this.template.toolbar.push(action, { icon: true, label: false, keybinding: this.getKeybindingLabel(action) }));
+    }
+    renderSource(notification) {
+        if (notification.expanded && notification.source) {
+            this.template.source.textContent = ( (localize('notificationSource', "Source: {0}", notification.source)));
+            this.template.source.title = notification.source;
+        }
+        else {
+            this.template.source.textContent = '';
+            this.template.source.removeAttribute('title');
+        }
+    }
+    renderButtons(notification) {
+        clearNode(this.template.buttonsContainer);
+        const primaryActions = notification.actions ? notification.actions.primary : undefined;
+        if (notification.expanded && isNonEmptyArray(primaryActions)) {
+            const that = this;
+            const actionRunner = new (class extends ActionRunner {
+                async runAction(action) {
+                    that.actionRunner.run(action, notification);
+                    if (!(action instanceof ChoiceAction) || !action.keepOpen) {
+                        notification.close();
+                    }
+                }
+            })();
+            const buttonToolbar = this.inputDisposables.add(( (new ButtonBar(this.template.buttonsContainer))));
+            for (let i = 0; i < primaryActions.length; i++) {
+                const action = primaryActions[i];
+                const options = {
+                    title: true,
+                    secondary: i > 0
+                };
+                const dropdownActions = action instanceof ChoiceAction ? action.menu : undefined;
+                const button = this.inputDisposables.add(dropdownActions ?
+                    buttonToolbar.addButtonWithDropdown({
+                        ...options,
+                        contextMenuProvider: this.contextMenuService,
+                        actions: dropdownActions,
+                        actionRunner
+                    }) :
+                    buttonToolbar.addButton(options));
+                button.label = action.label;
+                this.inputDisposables.add(button.onDidClick(e => {
+                    if (e) {
+                        EventHelper.stop(e, true);
+                    }
+                    actionRunner.run(action);
+                }));
+                this.inputDisposables.add(attachButtonStyler(button, this.themeService));
+            }
+        }
+    }
+    renderProgress(notification) {
+        if (!notification.hasProgress) {
+            this.template.progress.stop().hide();
+            return;
+        }
+        const state = notification.progress.state;
+        if (state.infinite) {
+            this.template.progress.infinite().show();
+        }
+        else if (typeof state.total === 'number' || typeof state.worked === 'number') {
+            if (typeof state.total === 'number' && !this.template.progress.hasTotal()) {
+                this.template.progress.total(state.total);
+            }
+            if (typeof state.worked === 'number') {
+                this.template.progress.setWorked(state.worked).show();
+            }
+        }
+        else {
+            this.template.progress.done().hide();
+        }
+    }
+    toSeverityIcon(severity) {
+        switch (severity) {
+            case Severity.Warning:
+                return Codicon.warning;
+            case Severity.Error:
+                return Codicon.error;
+        }
+        return Codicon.info;
+    }
+    getKeybindingLabel(action) {
+        const keybinding = this.keybindingService.lookupKeybinding(action.id);
+        return keybinding ? keybinding.getLabel() : null;
+    }
+};
+NotificationTemplateRenderer.SEVERITIES = [Severity.Info, Severity.Warning, Severity.Error];
+NotificationTemplateRenderer = ( (__decorate([
+    ( (__param(2, IOpenerService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IThemeService))),
+    ( (__param(5, IKeybindingService))),
+    ( (__param(6, IContextMenuService)))
+], NotificationTemplateRenderer)));
+let NotificationsList = class NotificationsList extends Themable {
+    constructor(container, options, instantiationService, themeService, contextMenuService) {
+        super(themeService);
+        this.container = container;
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.viewModel = [];
+    }
+    show(focus) {
+        if (this.isVisible) {
+            if (focus) {
+                const list = assertIsDefined(this.list);
+                list.domFocus();
+            }
+            return;
+        }
+        if (!this.list) {
+            this.createNotificationsList();
+        }
+        this.isVisible = true;
+        if (focus) {
+            const list = assertIsDefined(this.list);
+            list.domFocus();
+        }
+    }
+    createNotificationsList() {
+        this.listContainer = document.createElement('div');
+        this.listContainer.classList.add('notifications-list-container');
+        const actionRunner = this._register(this.instantiationService.createInstance(NotificationActionRunner));
+        const renderer = this.instantiationService.createInstance(NotificationRenderer, actionRunner);
+        const listDelegate = this.listDelegate = ( (new NotificationsListDelegate(this.listContainer)));
+        const options = this.options;
+        const list = this.list = this._register(this.instantiationService.createInstance(WorkbenchList, 'NotificationsList', this.listContainer, listDelegate, [renderer], {
+            ...options,
+            setRowLineHeight: false,
+            horizontalScrolling: false,
+            overrideStyles: {
+                listBackground: NOTIFICATIONS_BACKGROUND
+            },
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    if (!element.source) {
+                        return (
+                             (localize('notificationAriaLabel', "{0}, notification", element.message.raw))
+                        );
+                    }
+                    return (
+                         (localize(
+                            'notificationWithSourceAriaLabel',
+                            "{0}, source: {1}, notification",
+                            element.message.raw,
+                            element.source
+                        ))
+                    );
+                },
+                getWidgetAriaLabel() {
+                    return options.widgetAriaLabel ?? ( (localize('notificationsList', "Notifications List")));
+                },
+                getRole() {
+                    return 'dialog';
+                }
+            }
+        }));
+        const copyAction = this._register(this.instantiationService.createInstance(CopyNotificationMessageAction, CopyNotificationMessageAction.ID, CopyNotificationMessageAction.LABEL));
+        this._register((list.onContextMenu(e => {
+            if (!e.element) {
+                return;
+            }
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => e.anchor,
+                getActions: () => [copyAction],
+                getActionsContext: () => e.element,
+                actionRunner
+            });
+        })));
+        this._register((list.onMouseDblClick(event => event.element.toggle())));
+        const listFocusTracker = this._register(trackFocus(list.getHTMLElement()));
+        this._register(listFocusTracker.onDidBlur(() => {
+            if (document.hasFocus()) {
+                list.setFocus([]);
+            }
+        }));
+        NotificationFocusedContext.bindTo(list.contextKeyService);
+        this._register(list.onDidChangeSelection(e => {
+            if (e.indexes.length > 0) {
+                list.setSelection([]);
+            }
+        }));
+        this.container.appendChild(this.listContainer);
+        this.updateStyles();
+    }
+    updateNotificationsList(start, deleteCount, items = []) {
+        const [list, listContainer] = assertAllDefined(this.list, this.listContainer);
+        const listHasDOMFocus = isAncestor(document.activeElement, listContainer);
+        const focusedIndex = list.getFocus()[0];
+        const focusedItem = this.viewModel[focusedIndex];
+        let focusRelativeTop = null;
+        if (typeof focusedIndex === 'number') {
+            focusRelativeTop = list.getRelativeTop(focusedIndex);
+        }
+        this.viewModel.splice(start, deleteCount, ...items);
+        list.splice(start, deleteCount, items);
+        list.layout();
+        if (this.viewModel.length === 0) {
+            this.hide();
+        }
+        else if (typeof focusedIndex === 'number') {
+            let indexToFocus = 0;
+            if (focusedItem) {
+                let indexToFocusCandidate = this.viewModel.indexOf(focusedItem);
+                if (indexToFocusCandidate === -1) {
+                    indexToFocusCandidate = focusedIndex - 1;
+                }
+                if (indexToFocusCandidate < this.viewModel.length && indexToFocusCandidate >= 0) {
+                    indexToFocus = indexToFocusCandidate;
+                }
+            }
+            if (typeof focusRelativeTop === 'number') {
+                list.reveal(indexToFocus, focusRelativeTop);
+            }
+            list.setFocus([indexToFocus]);
+        }
+        if (this.isVisible && listHasDOMFocus) {
+            list.domFocus();
+        }
+    }
+    updateNotificationHeight(item) {
+        const index = this.viewModel.indexOf(item);
+        if (index === -1) {
+            return;
+        }
+        const [list, listDelegate] = assertAllDefined(this.list, this.listDelegate);
+        list.updateElementHeight(index, listDelegate.getHeight(item));
+        list.layout();
+    }
+    hide() {
+        if (!this.isVisible || !this.list) {
+            return;
+        }
+        this.isVisible = false;
+        this.list.splice(0, this.viewModel.length);
+        this.viewModel = [];
+    }
+    focusFirst() {
+        if (!this.isVisible || !this.list) {
+            return;
+        }
+        this.list.focusFirst();
+        this.list.domFocus();
+    }
+    hasFocus() {
+        if (!this.isVisible || !this.listContainer) {
+            return false;
+        }
+        return isAncestor(document.activeElement, this.listContainer);
+    }
+    updateStyles() {
+        if (this.listContainer) {
+            const foreground = this.getColor(NOTIFICATIONS_FOREGROUND);
+            this.listContainer.style.color = foreground ? foreground : '';
+            const background = this.getColor(NOTIFICATIONS_BACKGROUND);
+            this.listContainer.style.background = background ? background : '';
+            const outlineColor = this.getColor(contrastBorder);
+            this.listContainer.style.outlineColor = outlineColor ? outlineColor : '';
+        }
+    }
+    layout(width, maxHeight) {
+        if (this.listContainer && this.list) {
+            this.listContainer.style.width = `${width}px`;
+            if (typeof maxHeight === 'number') {
+                this.list.getHTMLElement().style.maxHeight = `${maxHeight}px`;
+            }
+            this.list.layout();
+        }
+    }
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+};
+NotificationsList = ( (__decorate([
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IContextMenuService)))
+], NotificationsList)));
+registerThemingParticipant((theme, collector) => {
+    const linkColor = theme.getColor(NOTIFICATIONS_LINKS);
+    if (linkColor) {
+        collector.addRule(`.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message a { color: ${linkColor}; }`);
+    }
+    const focusOutline = theme.getColor(focusBorder);
+    if (focusOutline) {
+        collector.addRule(`
+		.monaco-workbench .notifications-list-container .notification-list-item .notification-list-item-message a:focus {
+			outline-color: ${focusOutline};
+		}`);
+    }
+    const notificationErrorIconForegroundColor = theme.getColor(NOTIFICATIONS_ERROR_ICON_FOREGROUND);
+    if (notificationErrorIconForegroundColor) {
+        collector.addRule(`
+		.monaco-workbench .notifications-center ${Codicon.error.cssSelector},
+		.monaco-workbench .notifications-toasts ${Codicon.error.cssSelector} {
+			color: ${notificationErrorIconForegroundColor};
+		}`);
+    }
+    const notificationWarningIconForegroundColor = theme.getColor(NOTIFICATIONS_WARNING_ICON_FOREGROUND);
+    if (notificationWarningIconForegroundColor) {
+        collector.addRule(`
+		.monaco-workbench .notifications-center ${Codicon.warning.cssSelector},
+		.monaco-workbench .notifications-toasts ${Codicon.warning.cssSelector} {
+			color: ${notificationWarningIconForegroundColor};
+		}`);
+    }
+    const notificationInfoIconForegroundColor = theme.getColor(NOTIFICATIONS_INFO_ICON_FOREGROUND);
+    if (notificationInfoIconForegroundColor) {
+        collector.addRule(`
+		.monaco-workbench .notifications-center ${Codicon.info.cssSelector},
+		.monaco-workbench .notifications-toasts ${Codicon.info.cssSelector} {
+			color: ${notificationInfoIconForegroundColor};
+		}`);
+    }
+});
+var ToastVisibility;
+( ((function(ToastVisibility) {
+    ToastVisibility[ToastVisibility["HIDDEN_OR_VISIBLE"] = 0] = "HIDDEN_OR_VISIBLE";
+    ToastVisibility[ToastVisibility["HIDDEN"] = 1] = "HIDDEN";
+    ToastVisibility[ToastVisibility["VISIBLE"] = 2] = "VISIBLE";
+})(ToastVisibility || (ToastVisibility = {}))));
+let NotificationsToasts = class NotificationsToasts extends Themable {
+    constructor(container, model, instantiationService, layoutService, themeService, editorGroupService, contextKeyService, lifecycleService, hostService) {
+        super(themeService);
+        this.container = container;
+        this.model = model;
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.editorGroupService = editorGroupService;
+        this.contextKeyService = contextKeyService;
+        this.lifecycleService = lifecycleService;
+        this.hostService = hostService;
+        this._onDidChangeVisibility = this._register(( (new Emitter())));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._isVisible = false;
+        this.mapNotificationToToast = ( (new Map()));
+        this.mapNotificationToDisposable = ( (new Map()));
+        this.notificationsToastsVisibleContextKey = NotificationsToastsVisibleContext.bindTo(this.contextKeyService);
+        this.addedToastsIntervalCounter = ( (new IntervalCounter(NotificationsToasts.SPAM_PROTECTION.interval)));
+        this.registerListeners();
+    }
+    get isVisible() { return !!this._isVisible; }
+    registerListeners() {
+        this._register(this.layoutService.onDidLayout(dimension => this.layout(Dimension.lift(dimension))));
+        this.lifecycleService.when(3 ).then(() => {
+            this.model.notifications.forEach(notification => this.addToast(notification));
+            this._register(this.model.onDidChangeNotification(e => this.onDidChangeNotification(e)));
+        });
+        this._register(this.model.onDidChangeFilter(filter => {
+            if (filter === NotificationsFilter.SILENT || filter === NotificationsFilter.ERROR) {
+                this.hide();
+            }
+        }));
+    }
+    onDidChangeNotification(e) {
+        switch (e.kind) {
+            case 0 :
+                return this.addToast(e.item);
+            case 3 :
+                return this.removeToast(e.item);
+        }
+    }
+    addToast(item) {
+        if (this.isNotificationsCenterVisible) {
+            return;
+        }
+        if (item.silent) {
+            return;
+        }
+        if (this.addedToastsIntervalCounter.increment() > NotificationsToasts.SPAM_PROTECTION.limit) {
+            return;
+        }
+        const itemDisposables = ( (new DisposableStore()));
+        this.mapNotificationToDisposable.set(item, itemDisposables);
+        itemDisposables.add(scheduleAtNextAnimationFrame(() => this.doAddToast(item, itemDisposables)));
+    }
+    doAddToast(item, itemDisposables) {
+        let notificationsToastsContainer = this.notificationsToastsContainer;
+        if (!notificationsToastsContainer) {
+            notificationsToastsContainer = this.notificationsToastsContainer = document.createElement('div');
+            notificationsToastsContainer.classList.add('notifications-toasts');
+            this.container.appendChild(notificationsToastsContainer);
+        }
+        notificationsToastsContainer.classList.add('visible');
+        const notificationToastContainer = document.createElement('div');
+        notificationToastContainer.classList.add('notification-toast-container');
+        const firstToast = notificationsToastsContainer.firstChild;
+        if (firstToast) {
+            notificationsToastsContainer.insertBefore(notificationToastContainer, firstToast);
+        }
+        else {
+            notificationsToastsContainer.appendChild(notificationToastContainer);
+        }
+        const notificationToast = document.createElement('div');
+        notificationToast.classList.add('notification-toast');
+        notificationToastContainer.appendChild(notificationToast);
+        const notificationList = this.instantiationService.createInstance(NotificationsList, notificationToast, {
+            verticalScrollMode: 2 ,
+            widgetAriaLabel: (() => {
+                if (!item.source) {
+                    return (
+                         (localize('notificationAriaLabel', "{0}, notification", item.message.raw))
+                    );
+                }
+                return (
+                     (localize(
+                        'notificationWithSourceAriaLabel',
+                        "{0}, source: {1}, notification",
+                        item.message.raw,
+                        item.source
+                    ))
+                );
+            })()
+        });
+        itemDisposables.add(notificationList);
+        const toast = { item, list: notificationList, container: notificationToastContainer, toast: notificationToast };
+        this.mapNotificationToToast.set(item, toast);
+        itemDisposables.add(toDisposable(() => this.updateToastVisibility(toast, false)));
+        notificationList.show();
+        const maxDimensions = this.computeMaxDimensions();
+        this.layoutLists(maxDimensions.width);
+        notificationList.updateNotificationsList(0, 0, [item]);
+        this.layoutContainer(maxDimensions.height);
+        itemDisposables.add(item.onDidChangeExpansion(() => {
+            notificationList.updateNotificationsList(0, 1, [item]);
+        }));
+        itemDisposables.add(item.onDidChangeContent(e => {
+            switch (e.kind) {
+                case 2 :
+                    notificationList.updateNotificationsList(0, 1, [item]);
+                    break;
+                case 1 :
+                    if (item.expanded) {
+                        notificationList.updateNotificationHeight(item);
+                    }
+                    break;
+            }
+        }));
+        Event.once(item.onDidClose)(() => {
+            this.removeToast(item);
+        });
+        this.purgeNotification(item, notificationToastContainer, notificationList, itemDisposables);
+        this.updateStyles();
+        this.notificationsToastsVisibleContextKey.set(true);
+        notificationToast.classList.add('notification-fade-in');
+        itemDisposables.add(addDisposableListener(notificationToast, 'transitionend', () => {
+            notificationToast.classList.remove('notification-fade-in');
+            notificationToast.classList.add('notification-fade-in-done');
+        }));
+        item.updateVisibility(true);
+        if (!this._isVisible) {
+            this._isVisible = true;
+            this._onDidChangeVisibility.fire();
+        }
+    }
+    purgeNotification(item, notificationToastContainer, notificationList, disposables) {
+        let isMouseOverToast = false;
+        disposables.add(addDisposableListener(notificationToastContainer, EventType.MOUSE_OVER, () => isMouseOverToast = true));
+        disposables.add(addDisposableListener(notificationToastContainer, EventType.MOUSE_OUT, () => isMouseOverToast = false));
+        let purgeTimeoutHandle;
+        let listener;
+        const hideAfterTimeout = () => {
+            purgeTimeoutHandle = setTimeout(() => {
+                if (!this.hostService.hasFocus) {
+                    if (!listener) {
+                        listener = this.hostService.onDidChangeFocus(focus => {
+                            if (focus) {
+                                hideAfterTimeout();
+                            }
+                        });
+                        disposables.add(listener);
+                    }
+                }
+                else if (item.sticky ||
+                    notificationList.hasFocus() ||
+                    isMouseOverToast
+                ) {
+                    hideAfterTimeout();
+                }
+                else {
+                    this.removeToast(item);
+                }
+            }, NotificationsToasts.PURGE_TIMEOUT[item.severity]);
+        };
+        hideAfterTimeout();
+        disposables.add(toDisposable(() => clearTimeout(purgeTimeoutHandle)));
+    }
+    removeToast(item) {
+        let focusEditor = false;
+        const notificationToast = this.mapNotificationToToast.get(item);
+        if (notificationToast) {
+            const toastHasDOMFocus = isAncestor(document.activeElement, notificationToast.container);
+            if (toastHasDOMFocus) {
+                focusEditor = !(this.focusNext() || this.focusPrevious());
+            }
+            this.mapNotificationToToast.delete(item);
+        }
+        const notificationDisposables = this.mapNotificationToDisposable.get(item);
+        if (notificationDisposables) {
+            dispose(notificationDisposables);
+            this.mapNotificationToDisposable.delete(item);
+        }
+        if (this.mapNotificationToToast.size > 0) {
+            this.layout(this.workbenchDimensions);
+        }
+        else {
+            this.doHide();
+            if (focusEditor) {
+                this.editorGroupService.activeGroup.focus();
+            }
+        }
+    }
+    removeToasts() {
+        this.mapNotificationToToast.clear();
+        this.mapNotificationToDisposable.forEach(disposable => dispose(disposable));
+        this.mapNotificationToDisposable.clear();
+        this.doHide();
+    }
+    doHide() {
+        this.notificationsToastsContainer?.classList.remove('visible');
+        this.notificationsToastsVisibleContextKey.set(false);
+        if (this._isVisible) {
+            this._isVisible = false;
+            this._onDidChangeVisibility.fire();
+        }
+    }
+    hide() {
+        const focusEditor = this.notificationsToastsContainer ? isAncestor(document.activeElement, this.notificationsToastsContainer) : false;
+        this.removeToasts();
+        if (focusEditor) {
+            this.editorGroupService.activeGroup.focus();
+        }
+    }
+    focus() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        if (toasts.length > 0) {
+            toasts[0].list.focusFirst();
+            return true;
+        }
+        return false;
+    }
+    focusNext() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        for (let i = 0; i < toasts.length; i++) {
+            const toast = toasts[i];
+            if (toast.list.hasFocus()) {
+                const nextToast = toasts[i + 1];
+                if (nextToast) {
+                    nextToast.list.focusFirst();
+                    return true;
+                }
+                break;
+            }
+        }
+        return false;
+    }
+    focusPrevious() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        for (let i = 0; i < toasts.length; i++) {
+            const toast = toasts[i];
+            if (toast.list.hasFocus()) {
+                const previousToast = toasts[i - 1];
+                if (previousToast) {
+                    previousToast.list.focusFirst();
+                    return true;
+                }
+                break;
+            }
+        }
+        return false;
+    }
+    focusFirst() {
+        const toast = this.getToasts(ToastVisibility.VISIBLE)[0];
+        if (toast) {
+            toast.list.focusFirst();
+            return true;
+        }
+        return false;
+    }
+    focusLast() {
+        const toasts = this.getToasts(ToastVisibility.VISIBLE);
+        if (toasts.length > 0) {
+            toasts[toasts.length - 1].list.focusFirst();
+            return true;
+        }
+        return false;
+    }
+    update(isCenterVisible) {
+        if (this.isNotificationsCenterVisible !== isCenterVisible) {
+            this.isNotificationsCenterVisible = isCenterVisible;
+            if (this.isNotificationsCenterVisible) {
+                this.removeToasts();
+            }
+        }
+    }
+    updateStyles() {
+        this.mapNotificationToToast.forEach(({ toast }) => {
+            const backgroundColor = this.getColor(NOTIFICATIONS_BACKGROUND);
+            toast.style.background = backgroundColor ? backgroundColor : '';
+            const widgetShadowColor = this.getColor(widgetShadow);
+            toast.style.boxShadow = widgetShadowColor ? `0 0 8px 2px ${widgetShadowColor}` : '';
+            const borderColor = this.getColor(NOTIFICATIONS_TOAST_BORDER);
+            toast.style.border = borderColor ? `1px solid ${borderColor}` : '';
+        });
+    }
+    getToasts(state) {
+        const notificationToasts = [];
+        this.mapNotificationToToast.forEach(toast => {
+            switch (state) {
+                case ToastVisibility.HIDDEN_OR_VISIBLE:
+                    notificationToasts.push(toast);
+                    break;
+                case ToastVisibility.HIDDEN:
+                    if (!this.isToastInDOM(toast)) {
+                        notificationToasts.push(toast);
+                    }
+                    break;
+                case ToastVisibility.VISIBLE:
+                    if (this.isToastInDOM(toast)) {
+                        notificationToasts.push(toast);
+                    }
+                    break;
+            }
+        });
+        return notificationToasts.reverse();
+    }
+    layout(dimension) {
+        this.workbenchDimensions = dimension;
+        const maxDimensions = this.computeMaxDimensions();
+        if (maxDimensions.height) {
+            this.layoutContainer(maxDimensions.height);
+        }
+        this.layoutLists(maxDimensions.width);
+    }
+    computeMaxDimensions() {
+        const maxWidth = NotificationsToasts.MAX_WIDTH;
+        let availableWidth = maxWidth;
+        let availableHeight;
+        if (this.workbenchDimensions) {
+            availableWidth = this.workbenchDimensions.width;
+            availableWidth -= (2 * 8);
+            availableHeight = this.workbenchDimensions.height;
+            if (this.layoutService.isVisible("workbench.parts.statusbar" )) {
+                availableHeight -= 22;
+            }
+            if (this.layoutService.isVisible("workbench.parts.titlebar" )) {
+                availableHeight -= 22;
+            }
+            availableHeight -= (2 * 12);
+        }
+        availableHeight = typeof availableHeight === 'number'
+            ? Math.round(availableHeight * 0.618)
+            : 0;
+        return (
+             (new Dimension(Math.min(maxWidth, availableWidth), availableHeight))
+        );
+    }
+    layoutLists(width) {
+        this.mapNotificationToToast.forEach(({ list }) => list.layout(width));
+    }
+    layoutContainer(heightToGive) {
+        let visibleToasts = 0;
+        for (const toast of this.getToasts(ToastVisibility.HIDDEN_OR_VISIBLE)) {
+            toast.container.style.opacity = '0';
+            this.updateToastVisibility(toast, true);
+            heightToGive -= toast.container.offsetHeight;
+            let makeVisible = false;
+            if (visibleToasts === NotificationsToasts.MAX_NOTIFICATIONS) {
+                makeVisible = false;
+            }
+            else if (heightToGive >= 0) {
+                makeVisible = true;
+            }
+            this.updateToastVisibility(toast, makeVisible);
+            toast.container.style.opacity = '';
+            if (makeVisible) {
+                visibleToasts++;
+            }
+        }
+    }
+    updateToastVisibility(toast, visible) {
+        if (this.isToastInDOM(toast) === visible) {
+            return;
+        }
+        const notificationsToastsContainer = assertIsDefined(this.notificationsToastsContainer);
+        if (visible) {
+            notificationsToastsContainer.appendChild(toast.container);
+        }
+        else {
+            notificationsToastsContainer.removeChild(toast.container);
+        }
+        toast.item.updateVisibility(visible);
+    }
+    isToastInDOM(toast) {
+        return !!toast.container.parentElement;
+    }
+};
+NotificationsToasts.MAX_WIDTH = 450;
+NotificationsToasts.MAX_NOTIFICATIONS = 3;
+NotificationsToasts.PURGE_TIMEOUT = {
+    [Severity.Info]: 15000,
+    [Severity.Warning]: 18000,
+    [Severity.Error]: 20000
+};
+NotificationsToasts.SPAM_PROTECTION = {
+    interval: 800,
+    limit: NotificationsToasts.MAX_NOTIFICATIONS
+};
+NotificationsToasts = ( (__decorate([
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IWorkbenchLayoutService))),
+    ( (__param(4, IThemeService))),
+    ( (__param(5, IEditorGroupsService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, ILifecycleService))),
+    ( (__param(8, IHostService)))
+], NotificationsToasts)));
+let NotificationService = class NotificationService extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.model = this._register(( (new NotificationsModel())));
+        this._onDidAddNotification = this._register(( (new Emitter())));
+        this.onDidAddNotification = this._onDidAddNotification.event;
+        this._onDidRemoveNotification = this._register(( (new Emitter())));
+        this.onDidRemoveNotification = this._onDidRemoveNotification.event;
+        this._onDidChangeDoNotDisturbMode = this._register(( (new Emitter())));
+        this.onDidChangeDoNotDisturbMode = this._onDidChangeDoNotDisturbMode.event;
+        this._doNotDisturbMode = this.storageService.getBoolean(NotificationService.DND_SETTINGS_KEY, -1 , false);
+        this.updateDoNotDisturbFilters();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.model.onDidChangeNotification(e => {
+            switch (e.kind) {
+                case 0 :
+                case 3 : {
+                    const notification = {
+                        message: e.item.message.original,
+                        severity: e.item.severity,
+                        source: typeof e.item.sourceId === 'string' && typeof e.item.source === 'string' ? { id: e.item.sourceId, label: e.item.source } : e.item.source,
+                        silent: e.item.silent
+                    };
+                    if (e.kind === 0 ) {
+                        this._onDidAddNotification.fire(notification);
+                    }
+                    if (e.kind === 3 ) {
+                        this._onDidRemoveNotification.fire(notification);
+                    }
+                    break;
+                }
+            }
+        }));
+    }
+    get doNotDisturbMode() {
+        return this._doNotDisturbMode;
+    }
+    set doNotDisturbMode(enabled) {
+        if (this._doNotDisturbMode === enabled) {
+            return;
+        }
+        this.storageService.store(NotificationService.DND_SETTINGS_KEY, enabled, -1 , 1 );
+        this._doNotDisturbMode = enabled;
+        this.updateDoNotDisturbFilters();
+        this._onDidChangeDoNotDisturbMode.fire();
+    }
+    updateDoNotDisturbFilters() {
+        let filter;
+        if (this._doNotDisturbMode) {
+            filter = NotificationsFilter.ERROR;
+        }
+        else {
+            filter = NotificationsFilter.OFF;
+        }
+        this.model.setFilter(filter);
+    }
+    info(message) {
+        if (Array.isArray(message)) {
+            message.forEach(m => this.info(m));
+            return;
+        }
+        this.model.addNotification({ severity: Severity.Info, message });
+    }
+    warn(message) {
+        if (Array.isArray(message)) {
+            message.forEach(m => this.warn(m));
+            return;
+        }
+        this.model.addNotification({ severity: Severity.Warning, message });
+    }
+    error(message) {
+        if (Array.isArray(message)) {
+            message.forEach(m => this.error(m));
+            return;
+        }
+        this.model.addNotification({ severity: Severity.Error, message });
+    }
+    notify(notification) {
+        const toDispose = ( (new DisposableStore()));
+        if (notification.neverShowAgain) {
+            const scope = this.toStorageScope(notification.neverShowAgain);
+            const id = notification.neverShowAgain.id;
+            if (this.storageService.getBoolean(id, scope)) {
+                return (
+                     (new NoOpNotification())
+                );
+            }
+            const neverShowAgainAction = toDispose.add(( (new Action(
+                'workbench.notification.neverShowAgain',
+                 (localize('neverShowAgain', "Don't Show Again")),
+                undefined,
+                true,
+                async () => {
+                    handle.close();
+                    this.storageService.store(id, true, scope, 0 );
+                }
+            ))));
+            const actions = {
+                primary: notification.actions?.primary || [],
+                secondary: notification.actions?.secondary || []
+            };
+            if (!notification.neverShowAgain.isSecondary) {
+                actions.primary = [neverShowAgainAction, ...actions.primary];
+            }
+            else {
+                actions.secondary = [...actions.secondary, neverShowAgainAction];
+            }
+            notification.actions = actions;
+        }
+        const handle = this.model.addNotification(notification);
+        Event.once(handle.onDidClose)(() => toDispose.dispose());
+        return handle;
+    }
+    toStorageScope(options) {
+        switch (options.scope) {
+            case NeverShowAgainScope.APPLICATION:
+                return -1 ;
+            case NeverShowAgainScope.PROFILE:
+                return 0 ;
+            case NeverShowAgainScope.WORKSPACE:
+                return 1 ;
+            default:
+                return -1 ;
+        }
+    }
+    prompt(severity, message, choices, options) {
+        const toDispose = ( (new DisposableStore()));
+        if (options?.neverShowAgain) {
+            const scope = this.toStorageScope(options.neverShowAgain);
+            const id = options.neverShowAgain.id;
+            if (this.storageService.getBoolean(id, scope)) {
+                return (
+                     (new NoOpNotification())
+                );
+            }
+            const neverShowAgainChoice = {
+                label: ( (localize('neverShowAgain', "Don't Show Again"))),
+                run: () => this.storageService.store(id, true, scope, 0 ),
+                isSecondary: options.neverShowAgain.isSecondary
+            };
+            if (!options.neverShowAgain.isSecondary) {
+                choices = [neverShowAgainChoice, ...choices];
+            }
+            else {
+                choices = [...choices, neverShowAgainChoice];
+            }
+        }
+        let choiceClicked = false;
+        const primaryActions = [];
+        const secondaryActions = [];
+        choices.forEach((choice, index) => {
+            const action = ( (new ChoiceAction(`workbench.dialog.choice.${index}`, choice)));
+            if (!choice.isSecondary) {
+                primaryActions.push(action);
+            }
+            else {
+                secondaryActions.push(action);
+            }
+            toDispose.add(action.onDidRun(() => {
+                choiceClicked = true;
+                if (!choice.keepOpen) {
+                    handle.close();
+                }
+            }));
+            toDispose.add(action);
+        });
+        const actions = { primary: primaryActions, secondary: secondaryActions };
+        const handle = this.notify({ severity, message, actions, sticky: options?.sticky, silent: options?.silent });
+        Event.once(handle.onDidClose)(() => {
+            toDispose.dispose();
+            if (options && typeof options.onCancel === 'function' && !choiceClicked) {
+                options.onCancel();
+            }
+        });
+        return handle;
+    }
+    status(message, options) {
+        return this.model.showStatusMessage(message, options);
+    }
+};
+NotificationService.DND_SETTINGS_KEY = 'notifications.doNotDisturbMode';
+NotificationService = ( (__decorate([
+    ( (__param(0, IStorageService)))
+], NotificationService)));
+function mnemonicButtonLabel(label, forceDisableMnemonics) {
+    if (isMacintosh || forceDisableMnemonics) {
+        return label.replace(/\(&&\w\)|&&/g, '');
+    }
+    if (isWindows) {
+        return label.replace(/&&|&/g, m => m === '&' ? '&&' : '&');
+    }
+    return label.replace(/&&/g, '_');
+}
+var css = "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/** Dialog: Modal Block */\n.monaco-dialog-modal-block {\n\tposition: fixed;\n\theight: 100%;\n\twidth: 100%;\n\tleft:0;\n\ttop:0;\n\tz-index: 2600;\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n}\n\n.monaco-dialog-modal-block.dimmed {\n\tbackground: rgba(0, 0, 0, 0.3);\n}\n\n/** Dialog: Container */\n.monaco-dialog-box {\n\tdisplay: flex;\n\tflex-direction: column-reverse;\n\twidth: min-content;\n\tmin-width: 500px;\n\tmax-width: 90vw;\n\tmin-height: 75px;\n\tpadding: 10px;\n\ttransform: translate3d(0px, 0px, 0px);\n}\n\n/** Dialog: Title Actions Row */\n.monaco-dialog-box .dialog-toolbar-row {\n\theight: 22px;\n\tpadding-bottom: 4px;\n}\n\n.monaco-dialog-box .dialog-toolbar-row .actions-container {\n\tjustify-content: flex-end;\n}\n\n/** Dialog: Message Row */\n.monaco-dialog-box .dialog-message-row {\n\tdisplay: flex;\n\tflex-grow: 1;\n\talign-items: center;\n\tpadding: 0 10px;\n}\n\n.monaco-dialog-box .dialog-message-row > .dialog-icon.codicon {\n\tflex: 0 0 48px;\n\theight: 48px;\n\talign-self: baseline;\n\tfont-size: 48px;\n}\n\n/** Dialog: Message Container */\n.monaco-dialog-box .dialog-message-row .dialog-message-container {\n\tdisplay: flex;\n\tflex-direction: column;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tpadding-left: 24px;\n\tuser-select: text;\n\t-webkit-user-select: text;\n\t-ms-user-select: text;\n\tword-wrap: break-word; /* never overflow long words, but break to next line */\n\twhite-space: normal;\n}\n\n/** Dialog: Message */\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message {\n\tline-height: 22px;\n\tfont-size: 18px;\n\tflex: 1; /* let the message always grow */\n\twhite-space: normal;\n\tword-wrap: break-word; /* never overflow long words, but break to next line */\n\tmin-height: 48px; /* matches icon height */\n\tmargin-bottom: 8px;\n\tdisplay: flex;\n\talign-items: center;\n}\n\n/** Dialog: Details */\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-detail {\n\tline-height: 22px;\n\tflex: 1; /* let the message always grow */\n}\n\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message a:focus {\n\toutline-width: 1px;\n\toutline-style: solid;\n}\n\n/** Dialog: Checkbox */\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-checkbox-row {\n\tpadding: 15px 0px 0px;\n\tdisplay: flex;\n}\n\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-checkbox-row .dialog-checkbox-message {\n\tcursor: pointer;\n\tuser-select: none;\n\t-webkit-user-select: none;\n\t-ms-user-select: none;\n}\n\n/** Dialog: Input */\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-input {\n\tpadding: 15px 0px 0px;\n\tdisplay: flex;\n}\n\n.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-input .monaco-inputbox {\n\tflex: 1;\n}\n\n/** Dialog: File Path */\n.monaco-dialog-box code {\n\tfont-family: var(--monaco-monospace-font);\n}\n\n/** Dialog: Buttons Row */\n.monaco-dialog-box > .dialog-buttons-row {\n\tdisplay: flex;\n\talign-items: center;\n\tpadding-right: 1px;\n\toverflow: hidden; /* buttons row should never overflow */\n}\n\n.monaco-dialog-box > .dialog-buttons-row {\n\tdisplay: flex;\n\twhite-space: nowrap;\n\tpadding: 20px 10px 10px;\n}\n\n/** Dialog: Buttons */\n.monaco-dialog-box > .dialog-buttons-row > .dialog-buttons {\n\tdisplay: flex;\n\twidth: 100%;\n\tjustify-content: flex-end;\n\toverflow: hidden;\n\tmargin-left: 67px; /* for long buttons, force align with text */\n}\n\n.monaco-dialog-box > .dialog-buttons-row > .dialog-buttons > .monaco-button {\n\twidth: fit-content;\n\twidth: -moz-fit-content;\n\tpadding: 5px 10px;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tmargin: 4px 5px; /* allows button focus outline to be visible */\n\toutline-offset: 2px !important;\n}\n";
+n(css,{});
+class Dialog extends Disposable {
+    constructor(container, message, buttons, options) {
+        super();
+        this.container = container;
+        this.message = message;
+        this.options = options;
+        this.modalElement = this.container.appendChild($(`.monaco-dialog-modal-block.dimmed`));
+        this.shadowElement = this.modalElement.appendChild($('.dialog-shadow'));
+        this.element = this.shadowElement.appendChild($('.monaco-dialog-box'));
+        this.element.setAttribute('role', 'dialog');
+        this.element.tabIndex = -1;
+        hide(this.element);
+        if (Array.isArray(buttons) && buttons.length > 0) {
+            this.buttons = buttons;
+        }
+        else if (!this.options.disableDefaultAction) {
+            this.buttons = [( (localize('ok', "OK")))];
+        }
+        else {
+            this.buttons = [];
+        }
+        const buttonsRowElement = this.element.appendChild($('.dialog-buttons-row'));
+        this.buttonsContainer = buttonsRowElement.appendChild($('.dialog-buttons'));
+        const messageRowElement = this.element.appendChild($('.dialog-message-row'));
+        this.iconElement = messageRowElement.appendChild($('#monaco-dialog-icon.dialog-icon'));
+        this.iconElement.setAttribute('aria-label', this.getIconAriaLabel());
+        this.messageContainer = messageRowElement.appendChild($('.dialog-message-container'));
+        if (this.options.detail || this.options.renderBody) {
+            const messageElement = this.messageContainer.appendChild($('.dialog-message'));
+            const messageTextElement = messageElement.appendChild($('#monaco-dialog-message-text.dialog-message-text'));
+            messageTextElement.innerText = this.message;
+        }
+        this.messageDetailElement = this.messageContainer.appendChild($('#monaco-dialog-message-detail.dialog-message-detail'));
+        if (this.options.detail || !this.options.renderBody) {
+            this.messageDetailElement.innerText = this.options.detail ? this.options.detail : message;
+        }
+        else {
+            this.messageDetailElement.style.display = 'none';
+        }
+        if (this.options.renderBody) {
+            const customBody = this.messageContainer.appendChild($('#monaco-dialog-message-body.dialog-message-body'));
+            this.options.renderBody(customBody);
+            for (const el of this.messageContainer.querySelectorAll('a')) {
+                el.tabIndex = 0;
+            }
+        }
+        if (this.options.inputs) {
+            this.inputs = this.options.inputs.map(input => {
+                const inputRowElement = this.messageContainer.appendChild($('.dialog-message-input'));
+                const inputBox = this._register(( (new InputBox(inputRowElement, undefined, {
+                    placeholder: input.placeholder,
+                    type: input.type ?? 'text',
+                }))));
+                if (input.value) {
+                    inputBox.value = input.value;
+                }
+                return inputBox;
+            });
+        }
+        else {
+            this.inputs = [];
+        }
+        if (this.options.checkboxLabel) {
+            const checkboxRowElement = this.messageContainer.appendChild($('.dialog-checkbox-row'));
+            const checkbox = this.checkbox = this._register(( (new Checkbox(this.options.checkboxLabel, !!this.options.checkboxChecked))));
+            checkboxRowElement.appendChild(checkbox.domNode);
+            const checkboxMessageElement = checkboxRowElement.appendChild($('.dialog-checkbox-message'));
+            checkboxMessageElement.innerText = this.options.checkboxLabel;
+            this._register(addDisposableListener(checkboxMessageElement, EventType.CLICK, () => checkbox.checked = !checkbox.checked));
+        }
+        const toolbarRowElement = this.element.appendChild($('.dialog-toolbar-row'));
+        this.toolbarContainer = toolbarRowElement.appendChild($('.dialog-toolbar'));
+    }
+    getIconAriaLabel() {
+        const typeLabel = ( (localize('dialogInfoMessage', 'Info')));
+        return typeLabel;
+    }
+    updateMessage(message) {
+        this.messageDetailElement.innerText = message;
+    }
+    async show() {
+        this.focusToReturn = document.activeElement;
+        return (
+             (new Promise((resolve) => {
+                clearNode(this.buttonsContainer);
+                const buttonBar = this.buttonBar = this._register(( (new ButtonBar(this.buttonsContainer))));
+                const buttonMap = this.rearrangeButtons(this.buttons, this.options.cancelId);
+                buttonMap.forEach((entry, index) => {
+                    const primary = buttonMap[index].index === 0;
+                    const button = this.options.buttonDetails ? this._register(buttonBar.addButtonWithDescription({ title: true, secondary: !primary })) : this._register(buttonBar.addButton({ title: true, secondary: !primary }));
+                    button.label = mnemonicButtonLabel(buttonMap[index].label, true);
+                    if (button instanceof ButtonWithDescription) {
+                        button.description = this.options.buttonDetails[buttonMap[index].index];
+                    }
+                    this._register(button.onDidClick(e => {
+                        if (e) {
+                            EventHelper.stop(e);
+                        }
+                        resolve({
+                            button: buttonMap[index].index,
+                            checkboxChecked: this.checkbox ? this.checkbox.checked : undefined,
+                            values: this.inputs.length > 0 ? this.inputs.map(input => input.value) : undefined
+                        });
+                    }));
+                });
+                this._register(addDisposableListener(window, 'keydown', e => {
+                    const evt = ( (new StandardKeyboardEvent(e)));
+                    if (evt.equals(512 )) {
+                        evt.preventDefault();
+                    }
+                    if (evt.equals(3 )) {
+                        if (this.inputs.some(input => input.hasFocus())) {
+                            EventHelper.stop(e);
+                            resolve({
+                                button: buttonMap.find(button => button.index !== this.options.cancelId)?.index ?? 0,
+                                checkboxChecked: this.checkbox ? this.checkbox.checked : undefined,
+                                values: this.inputs.length > 0 ? this.inputs.map(input => input.value) : undefined
+                            });
+                        }
+                        return;
+                    }
+                    if (evt.equals(10 )) {
+                        return;
+                    }
+                    let eventHandled = false;
+                    if (evt.equals(2 ) || evt.equals(17 ) || evt.equals(1024  | 2 ) || evt.equals(15 )) {
+                        const focusableElements = [];
+                        let focusedIndex = -1;
+                        if (this.messageContainer) {
+                            const links = this.messageContainer.querySelectorAll('a');
+                            for (const link of links) {
+                                focusableElements.push(link);
+                                if (link === document.activeElement) {
+                                    focusedIndex = focusableElements.length - 1;
+                                }
+                            }
+                        }
+                        for (const input of this.inputs) {
+                            focusableElements.push(input);
+                            if (input.hasFocus()) {
+                                focusedIndex = focusableElements.length - 1;
+                            }
+                        }
+                        if (this.checkbox) {
+                            focusableElements.push(this.checkbox);
+                            if (this.checkbox.hasFocus()) {
+                                focusedIndex = focusableElements.length - 1;
+                            }
+                        }
+                        if (this.buttonBar) {
+                            for (const button of this.buttonBar.buttons) {
+                                focusableElements.push(button);
+                                if (button.hasFocus()) {
+                                    focusedIndex = focusableElements.length - 1;
+                                }
+                            }
+                        }
+                        if (evt.equals(2 ) || evt.equals(17 )) {
+                            if (focusedIndex === -1) {
+                                focusedIndex = 0;
+                            }
+                            const newFocusedIndex = (focusedIndex + 1) % focusableElements.length;
+                            focusableElements[newFocusedIndex].focus();
+                        }
+                        else {
+                            if (focusedIndex === -1) {
+                                focusedIndex = focusableElements.length;
+                            }
+                            let newFocusedIndex = focusedIndex - 1;
+                            if (newFocusedIndex === -1) {
+                                newFocusedIndex = focusableElements.length - 1;
+                            }
+                            focusableElements[newFocusedIndex].focus();
+                        }
+                        eventHandled = true;
+                    }
+                    if (eventHandled) {
+                        EventHelper.stop(e, true);
+                    }
+                    else if (this.options.keyEventProcessor) {
+                        this.options.keyEventProcessor(evt);
+                    }
+                }, true));
+                this._register(addDisposableListener(window, 'keyup', e => {
+                    EventHelper.stop(e, true);
+                    const evt = ( (new StandardKeyboardEvent(e)));
+                    if (!this.options.disableCloseAction && evt.equals(9 )) {
+                        resolve({
+                            button: this.options.cancelId || 0,
+                            checkboxChecked: this.checkbox ? this.checkbox.checked : undefined
+                        });
+                    }
+                }, true));
+                this._register(addDisposableListener(this.element, 'focusout', e => {
+                    if (!!e.relatedTarget && !!this.element) {
+                        if (!isAncestor(e.relatedTarget, this.element)) {
+                            this.focusToReturn = e.relatedTarget;
+                            if (e.target) {
+                                e.target.focus();
+                                EventHelper.stop(e, true);
+                            }
+                        }
+                    }
+                }, false));
+                const spinModifierClassName = 'codicon-modifier-spin';
+                this.iconElement.classList.remove(...Codicon.dialogError.classNamesArray, ...Codicon.dialogWarning.classNamesArray, ...Codicon.dialogInfo.classNamesArray, ...Codicon.loading.classNamesArray, spinModifierClassName);
+                if (this.options.icon) {
+                    this.iconElement.classList.add(...this.options.icon.classNamesArray);
+                }
+                else {
+                    switch (this.options.type) {
+                        case 'error':
+                            this.iconElement.classList.add(...Codicon.dialogError.classNamesArray);
+                            break;
+                        case 'warning':
+                            this.iconElement.classList.add(...Codicon.dialogWarning.classNamesArray);
+                            break;
+                        case 'pending':
+                            this.iconElement.classList.add(...Codicon.loading.classNamesArray, spinModifierClassName);
+                            break;
+                        case 'none':
+                        case 'info':
+                        case 'question':
+                        default:
+                            this.iconElement.classList.add(...Codicon.dialogInfo.classNamesArray);
+                            break;
+                    }
+                }
+                if (!this.options.disableCloseAction) {
+                    const actionBar = this._register(( (new ActionBar(this.toolbarContainer, {}))));
+                    const action = this._register(( (new Action(
+                        'dialog.close',
+                         (localize('dialogClose', "Close Dialog")),
+                        Codicon.dialogClose.classNames,
+                        true,
+                        async () => {
+                            resolve({
+                                button: this.options.cancelId || 0,
+                                checkboxChecked: this.checkbox ? this.checkbox.checked : undefined
+                            });
+                        }
+                    ))));
+                    actionBar.push(action, { icon: true, label: false, });
+                }
+                this.applyStyles();
+                this.element.setAttribute('aria-modal', 'true');
+                this.element.setAttribute('aria-labelledby', 'monaco-dialog-icon monaco-dialog-message-text');
+                this.element.setAttribute('aria-describedby', 'monaco-dialog-icon monaco-dialog-message-text monaco-dialog-message-detail monaco-dialog-message-body');
+                show(this.element);
+                if (this.inputs.length > 0) {
+                    this.inputs[0].focus();
+                    this.inputs[0].select();
+                }
+                else {
+                    buttonMap.forEach((value, index) => {
+                        if (value.index === 0) {
+                            buttonBar.buttons[index].focus();
+                        }
+                    });
+                }
+            }))
+        );
+    }
+    applyStyles() {
+        if (this.styles) {
+            const style = this.styles;
+            const fgColor = style.dialogForeground;
+            const bgColor = style.dialogBackground;
+            const shadowColor = style.dialogShadow ? `0 0px 8px ${style.dialogShadow}` : '';
+            const border = style.dialogBorder ? `1px solid ${style.dialogBorder}` : '';
+            const linkFgColor = style.textLinkForeground;
+            this.shadowElement.style.boxShadow = shadowColor;
+            this.element.style.color = fgColor?.toString() ?? '';
+            this.element.style.backgroundColor = bgColor?.toString() ?? '';
+            this.element.style.border = border;
+            this.buttonBar?.buttons.forEach(button => button.style(style));
+            this.checkbox?.style(style);
+            if (fgColor && bgColor) {
+                const messageDetailColor = ( (fgColor.transparent(.9)));
+                this.messageDetailElement.style.color = ( (messageDetailColor.makeOpaque(bgColor).toString()));
+            }
+            if (linkFgColor) {
+                for (const el of this.messageContainer.getElementsByTagName('a')) {
+                    el.style.color = ( (linkFgColor.toString()));
+                }
+            }
+            let color;
+            switch (this.options.type) {
+                case 'error':
+                    color = style.errorIconForeground;
+                    break;
+                case 'warning':
+                    color = style.warningIconForeground;
+                    break;
+                default:
+                    color = style.infoIconForeground;
+                    break;
+            }
+            if (color) {
+                this.iconElement.style.color = ( (color.toString()));
+            }
+            for (const input of this.inputs) {
+                input.style(style);
+            }
+        }
+    }
+    style(style) {
+        this.styles = style;
+        this.applyStyles();
+    }
+    dispose() {
+        super.dispose();
+        if (this.modalElement) {
+            this.modalElement.remove();
+            this.modalElement = undefined;
+        }
+        if (this.focusToReturn && isAncestor(this.focusToReturn, document.body)) {
+            this.focusToReturn.focus();
+            this.focusToReturn = undefined;
+        }
+    }
+    rearrangeButtons(buttons, cancelId) {
+        const buttonMap = [];
+        if (buttons.length === 0) {
+            return buttonMap;
+        }
+        buttons.forEach((button, index) => {
+            buttonMap.push({ label: button, index });
+        });
+        if (isMacintosh || isLinux) {
+            if (cancelId !== undefined && cancelId < buttons.length) {
+                const cancelButton = buttonMap.splice(cancelId, 1)[0];
+                buttonMap.reverse();
+                buttonMap.splice(buttonMap.length - 1, 0, cancelButton);
+            }
+        }
+        return buttonMap;
+    }
+}
+const minute = 60;
+const hour = minute * 60;
+const day = hour * 24;
+const week = day * 7;
+const month = day * 30;
+const year = day * 365;
+function fromNow(date, appendAgoLabel, useFullTimeWords) {
+    if (typeof date !== 'number') {
+        date = date.getTime();
+    }
+    const seconds = Math.round((( (new Date())).getTime() - date) / 1000);
+    if (seconds < -30) {
+        return (
+             (localize(
+                'date.fromNow.in',
+                'in {0}',
+                fromNow(( (new Date())).getTime() + seconds * 1000, false)
+            ))
+        );
+    }
+    if (seconds < 30) {
+        return (
+             (localize('date.fromNow.now', 'now'))
+        );
+    }
+    let value;
+    if (seconds < minute) {
+        value = seconds;
+        if (appendAgoLabel) {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.seconds.singular.ago.fullWord', '{0} second ago', value)))
+                    : ( (localize('date.fromNow.seconds.singular.ago', '{0} sec ago', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.seconds.plural.ago.fullWord', '{0} seconds ago', value)))
+                    : ( (localize('date.fromNow.seconds.plural.ago', '{0} secs ago', value)));
+            }
+        }
+        else {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.seconds.singular.fullWord', '{0} second', value)))
+                    : ( (localize('date.fromNow.seconds.singular', '{0} sec', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.seconds.plural.fullWord', '{0} seconds', value)))
+                    : ( (localize('date.fromNow.seconds.plural', '{0} secs', value)));
+            }
+        }
+    }
+    if (seconds < hour) {
+        value = Math.floor(seconds / minute);
+        if (appendAgoLabel) {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.minutes.singular.ago.fullWord', '{0} minute ago', value)))
+                    : ( (localize('date.fromNow.minutes.singular.ago', '{0} min ago', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.minutes.plural.ago.fullWord', '{0} minutes ago', value)))
+                    : ( (localize('date.fromNow.minutes.plural.ago', '{0} mins ago', value)));
+            }
+        }
+        else {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.minutes.singular.fullWord', '{0} minute', value)))
+                    : ( (localize('date.fromNow.minutes.singular', '{0} min', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.minutes.plural.fullWord', '{0} minutes', value)))
+                    : ( (localize('date.fromNow.minutes.plural', '{0} mins', value)));
+            }
+        }
+    }
+    if (seconds < day) {
+        value = Math.floor(seconds / hour);
+        if (appendAgoLabel) {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.hours.singular.ago.fullWord', '{0} hour ago', value)))
+                    : ( (localize('date.fromNow.hours.singular.ago', '{0} hr ago', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.hours.plural.ago.fullWord', '{0} hours ago', value)))
+                    : ( (localize('date.fromNow.hours.plural.ago', '{0} hrs ago', value)));
+            }
+        }
+        else {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.hours.singular.fullWord', '{0} hour', value)))
+                    : ( (localize('date.fromNow.hours.singular', '{0} hr', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.hours.plural.fullWord', '{0} hours', value)))
+                    : ( (localize('date.fromNow.hours.plural', '{0} hrs', value)));
+            }
+        }
+    }
+    if (seconds < week) {
+        value = Math.floor(seconds / day);
+        if (appendAgoLabel) {
+            return value === 1
+                ? ( (localize('date.fromNow.days.singular.ago', '{0} day ago', value)))
+                : ( (localize('date.fromNow.days.plural.ago', '{0} days ago', value)));
+        }
+        else {
+            return value === 1
+                ? ( (localize('date.fromNow.days.singular', '{0} day', value)))
+                : ( (localize('date.fromNow.days.plural', '{0} days', value)));
+        }
+    }
+    if (seconds < month) {
+        value = Math.floor(seconds / week);
+        if (appendAgoLabel) {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.weeks.singular.ago.fullWord', '{0} week ago', value)))
+                    : ( (localize('date.fromNow.weeks.singular.ago', '{0} wk ago', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.weeks.plural.ago.fullWord', '{0} weeks ago', value)))
+                    : ( (localize('date.fromNow.weeks.plural.ago', '{0} wks ago', value)));
+            }
+        }
+        else {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.weeks.singular.fullWord', '{0} week', value)))
+                    : ( (localize('date.fromNow.weeks.singular', '{0} wk', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.weeks.plural.fullWord', '{0} weeks', value)))
+                    : ( (localize('date.fromNow.weeks.plural', '{0} wks', value)));
+            }
+        }
+    }
+    if (seconds < year) {
+        value = Math.floor(seconds / month);
+        if (appendAgoLabel) {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.months.singular.ago.fullWord', '{0} month ago', value)))
+                    : ( (localize('date.fromNow.months.singular.ago', '{0} mo ago', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.months.plural.ago.fullWord', '{0} months ago', value)))
+                    : ( (localize('date.fromNow.months.plural.ago', '{0} mos ago', value)));
+            }
+        }
+        else {
+            if (value === 1) {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.months.singular.fullWord', '{0} month', value)))
+                    : ( (localize('date.fromNow.months.singular', '{0} mo', value)));
+            }
+            else {
+                return useFullTimeWords
+                    ? ( (localize('date.fromNow.months.plural.fullWord', '{0} months', value)))
+                    : ( (localize('date.fromNow.months.plural', '{0} mos', value)));
+            }
+        }
+    }
+    value = Math.floor(seconds / year);
+    if (appendAgoLabel) {
+        if (value === 1) {
+            return useFullTimeWords
+                ? ( (localize('date.fromNow.years.singular.ago.fullWord', '{0} year ago', value)))
+                : ( (localize('date.fromNow.years.singular.ago', '{0} yr ago', value)));
+        }
+        else {
+            return useFullTimeWords
+                ? ( (localize('date.fromNow.years.plural.ago.fullWord', '{0} years ago', value)))
+                : ( (localize('date.fromNow.years.plural.ago', '{0} yrs ago', value)));
+        }
+    }
+    else {
+        if (value === 1) {
+            return useFullTimeWords
+                ? ( (localize('date.fromNow.years.singular.fullWord', '{0} year', value)))
+                : ( (localize('date.fromNow.years.singular', '{0} yr', value)));
+        }
+        else {
+            return useFullTimeWords
+                ? ( (localize('date.fromNow.years.plural.fullWord', '{0} years', value)))
+                : ( (localize('date.fromNow.years.plural', '{0} yrs', value)));
+        }
+    }
+}
+let BrowserDialogHandler = class BrowserDialogHandler {
+    constructor(logService, layoutService, themeService, keybindingService, instantiationService, productService, clipboardService) {
+        this.logService = logService;
+        this.layoutService = layoutService;
+        this.themeService = themeService;
+        this.keybindingService = keybindingService;
+        this.instantiationService = instantiationService;
+        this.productService = productService;
+        this.clipboardService = clipboardService;
+        this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+    }
+    async confirm(confirmation) {
+        this.logService.trace('DialogService#confirm', confirmation.message);
+        const buttons = [];
+        if (confirmation.primaryButton) {
+            buttons.push(confirmation.primaryButton);
+        }
+        else {
+            buttons.push(( (localize({ key: 'yesButton', comment: ['&& denotes a mnemonic'] }, "&&Yes"))));
+        }
+        if (confirmation.secondaryButton) {
+            buttons.push(confirmation.secondaryButton);
+        }
+        else if (typeof confirmation.secondaryButton === 'undefined') {
+            buttons.push(( (localize('cancelButton', "Cancel"))));
+        }
+        const result = await this.doShow(confirmation.type, confirmation.message, buttons, confirmation.detail, 1, confirmation.checkbox);
+        return { confirmed: result.button === 0, checkboxChecked: result.checkboxChecked };
+    }
+    getDialogType(severity) {
+        return (severity === Severity$1.Info) ? 'question' : (severity === Severity$1.Error) ? 'error' : (severity === Severity$1.Warning) ? 'warning' : 'none';
+    }
+    async show(severity, message, buttons, options) {
+        this.logService.trace('DialogService#show', message);
+        const result = await this.doShow(this.getDialogType(severity), message, buttons, options?.detail, options?.cancelId, options?.checkbox, undefined, typeof options?.custom === 'object' ? options.custom : undefined);
+        return {
+            choice: result.button,
+            checkboxChecked: result.checkboxChecked
+        };
+    }
+    async doShow(type, message, buttons, detail, cancelId, checkbox, inputs, customOptions) {
+        const dialogDisposables = ( (new DisposableStore()));
+        const renderBody = customOptions ? (parent) => {
+            parent.classList.add(...(customOptions.classes || []));
+            customOptions.markdownDetails?.forEach(markdownDetail => {
+                const result = this.markdownRenderer.render(markdownDetail.markdown);
+                parent.appendChild(result.element);
+                result.element.classList.add(...(markdownDetail.classes || []));
+                dialogDisposables.add(result);
+            });
+        } : undefined;
+        const dialog = ( (new Dialog(this.layoutService.container, message, buttons, {
+            detail,
+            cancelId,
+            type,
+            keyEventProcessor: (event) => {
+                const resolved = this.keybindingService.softDispatch(event, this.layoutService.container);
+                if (resolved?.commandId) {
+                    if (BrowserDialogHandler.ALLOWABLE_COMMANDS.indexOf(resolved.commandId) === -1) {
+                        EventHelper.stop(event, true);
+                    }
+                }
+            },
+            renderBody,
+            icon: customOptions?.icon,
+            disableCloseAction: customOptions?.disableCloseAction,
+            buttonDetails: customOptions?.buttonDetails,
+            checkboxLabel: checkbox?.label,
+            checkboxChecked: checkbox?.checked,
+            inputs
+        })));
+        dialogDisposables.add(dialog);
+        dialogDisposables.add(attachDialogStyler(dialog, this.themeService));
+        const result = await dialog.show();
+        dialogDisposables.dispose();
+        return result;
+    }
+    async input(severity, message, buttons, inputs, options) {
+        this.logService.trace('DialogService#input', message);
+        const result = await this.doShow(this.getDialogType(severity), message, buttons, options?.detail, options?.cancelId, options?.checkbox, inputs);
+        return {
+            choice: result.button,
+            checkboxChecked: result.checkboxChecked,
+            values: result.values
+        };
+    }
+    async about() {
+        const detailString = (useAgo) => {
+            return (
+                 (localize(
+                    'aboutDetail',
+                    "Version: {0}\nCommit: {1}\nDate: {2}\nBrowser: {3}",
+                    this.productService.version || 'Unknown',
+                    this.productService.commit || 'Unknown',
+                    this.productService.date ? `${this.productService.date}${useAgo ? ' (' + fromNow(( new Date(this.productService.date)), true) + ')' : ''}` : 'Unknown',
+                    navigator.userAgent
+                ))
+            );
+        };
+        const detail = detailString(true);
+        const detailToCopy = detailString(false);
+        const { choice } = await this.show(Severity$1.Info, this.productService.nameLong, [( (localize('copy', "Copy"))), ( (localize('ok', "OK")))], { detail, cancelId: 1 });
+        if (choice === 0) {
+            this.clipboardService.writeText(detailToCopy);
+        }
+    }
+};
+BrowserDialogHandler.ALLOWABLE_COMMANDS = [
+    'copy',
+    'cut',
+    'editor.action.selectAll',
+    'editor.action.clipboardCopyAction',
+    'editor.action.clipboardCutAction',
+    'editor.action.clipboardPasteAction'
+];
+BrowserDialogHandler = ( (__decorate([
+    ( (__param(0, ILogService))),
+    ( (__param(1, ILayoutService))),
+    ( (__param(2, IThemeService))),
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IProductService))),
+    ( (__param(6, IClipboardService)))
+], BrowserDialogHandler)));
+let DialogHandlerContribution = class DialogHandlerContribution extends Disposable {
+    constructor(dialogService, logService, layoutService, themeService, keybindingService, instantiationService, productService, clipboardService) {
+        super();
+        this.dialogService = dialogService;
+        this.impl = ( (new BrowserDialogHandler(
+            logService,
+            layoutService,
+            themeService,
+            keybindingService,
+            instantiationService,
+            productService,
+            clipboardService
+        )));
+        this.model = this.dialogService.model;
+        this._register(this.model.onWillShowDialog(() => {
+            if (!this.currentDialog) {
+                this.processDialogs();
+            }
+        }));
+        this.processDialogs();
+    }
+    async processDialogs() {
+        while (this.model.dialogs.length) {
+            this.currentDialog = this.model.dialogs[0];
+            let result = undefined;
+            if (this.currentDialog.args.confirmArgs) {
+                const args = this.currentDialog.args.confirmArgs;
+                result = await this.impl.confirm(args.confirmation);
+            }
+            else if (this.currentDialog.args.inputArgs) {
+                const args = this.currentDialog.args.inputArgs;
+                result = await this.impl.input(args.severity, args.message, args.buttons, args.inputs, args.options);
+            }
+            else if (this.currentDialog.args.showArgs) {
+                const args = this.currentDialog.args.showArgs;
+                result = await this.impl.show(args.severity, args.message, args.buttons, args.options);
+            }
+            else {
+                await this.impl.about();
+            }
+            this.currentDialog.close(result);
+            this.currentDialog = undefined;
+        }
+    }
+};
+DialogHandlerContribution = ( (__decorate([
+    ( (__param(0, IDialogService))),
+    ( (__param(1, ILogService))),
+    ( (__param(2, ILayoutService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IProductService))),
+    ( (__param(7, IClipboardService)))
+], DialogHandlerContribution)));
+class DialogsModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.dialogs = [];
+        this._onWillShowDialog = this._register(( (new Emitter())));
+        this.onWillShowDialog = this._onWillShowDialog.event;
+        this._onDidShowDialog = this._register(( (new Emitter())));
+        this.onDidShowDialog = this._onDidShowDialog.event;
+    }
+    show(dialog) {
+        const promise = ( (new DeferredPromise()));
+        const item = {
+            args: dialog,
+            close: result => {
+                this.dialogs.splice(0, 1);
+                promise.complete(result);
+                this._onDidShowDialog.fire();
+            }
+        };
+        this.dialogs.push(item);
+        this._onWillShowDialog.fire();
+        return {
+            item,
+            result: promise.p
+        };
+    }
+}
+let DialogService = class DialogService extends Disposable {
+    constructor(environmentService, logService) {
+        super();
+        this.environmentService = environmentService;
+        this.logService = logService;
+        this.model = this._register(( (new DialogsModel())));
+        this.onWillShowDialog = this.model.onWillShowDialog;
+        this.onDidShowDialog = this.model.onDidShowDialog;
+    }
+    skipDialogs() {
+        if (this.environmentService.isExtensionDevelopment && this.environmentService.extensionTestsLocationURI) {
+            return true;
+        }
+        return !!this.environmentService.enableSmokeTestDriver;
+    }
+    async confirm(confirmation) {
+        if (this.skipDialogs()) {
+            this.logService.trace('DialogService: refused to show confirmation dialog in tests.');
+            return { confirmed: true };
+        }
+        const handle = this.model.show({ confirmArgs: { confirmation } });
+        return await handle.result;
+    }
+    async show(severity, message, buttons, options) {
+        if (this.skipDialogs()) {
+            throw new Error('DialogService: refused to show dialog in tests.');
+        }
+        const handle = this.model.show({ showArgs: { severity, message, buttons, options } });
+        return await handle.result;
+    }
+    async input(severity, message, buttons, inputs, options) {
+        if (this.skipDialogs()) {
+            throw new Error('DialogService: refused to show input dialog in tests.');
+        }
+        const handle = this.model.show({ inputArgs: { severity, message, buttons, inputs, options } });
+        return await handle.result;
+    }
+    async about() {
+        if (this.skipDialogs()) {
+            throw new Error('DialogService: refused to show about dialog in tests.');
+        }
+        const handle = this.model.show({});
+        await handle.result;
+    }
+};
+DialogService = ( (__decorate([
+    ( (__param(0, IWorkbenchEnvironmentService))),
+    ( (__param(1, ILogService)))
+], DialogService)));
+class LayoutService {
+    constructor(container) {
+        this.container = container;
+        this.offset = { top: 0, quickPickTop: 0 };
+        this._onDidLayout = new Emitter();
+        this.onDidLayout = this._onDidLayout.event;
+        window.addEventListener('resize', () => this.layout());
+        this.layout();
+    }
+    isVisible() {
+        return false;
+    }
+    get dimension() { return this._dimension; }
+    layout() {
+        this._dimension = getClientArea(window.document.body);
+        this._onDidLayout.fire(this._dimension);
+    }
+    get hasContainer() {
+        return true;
+    }
+    focus() {
+        StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor()?.focus();
+    }
+}
+function getServiceOverride$1(container = document.body) {
+    return {
+        [( ILayoutService.toString())]: new SyncDescriptor(LayoutService, [container]),
+        [( IWorkbenchLayoutService.toString())]: new SyncDescriptor(LayoutService, [container])
+    };
+}
+function initialize(instantiationService) {
+    const container = StandaloneServices.get(ILayoutService).container;
+    container.classList.add('monaco-workbench');
+    const model = instantiationService.invokeFunction((accessor) => accessor.get(INotificationService)).model;
+    const notificationsToasts = instantiationService.createInstance(NotificationsToasts, container, model);
+    notificationsToasts.layout(getClientArea(container));
+    const notificationsCenter = {
+        isVisible: false,
+        show: unsupported,
+        hide: unsupported,
+        clearAll: function () {
+            for (const notification of [...model.notifications] ) {
+                if (!notification.hasProgress) {
+                    notification.close();
+                }
+            }
+        }
+    };
+    registerNotificationCommands(notificationsCenter, notificationsToasts, model);
+    instantiationService.createInstance(DialogHandlerContribution);
+}
+function getServiceOverride(container) {
+    onServicesInitialized(initialize);
+    return {
+        [( IDialogService.toString())]: new SyncDescriptor(DialogService),
+        [( INotificationService.toString())]: new SyncDescriptor(NotificationService),
+        ...getServiceOverride$1(container)
+    };
+}
+export { getServiceOverride as default };