@codingame/monaco-vscode-api 1.67.8 → 1.67.11

package/dist/messages.js

@@ -0,0 +1,4298 @@
+import { E as Emitter, N as NotificationsFilter, a as assertAllDefined, I as ILifecycleService, b as NeverShowAgainScope, u as unsupported } from './missing-services-71e80bea.js';
+import { b as __decorate, d as __param, f as IFileService, w as refineServiceDecorator, n as IEditorGroupsService, s as IHostService, p as IProductService } from './services-fb7952fb.js';
+import { editorWidgetBackground, editorWidgetForeground, widgetShadow, contrastBorder, buttonForeground, buttonBackground, buttonSecondaryBackground, buttonSecondaryForeground, buttonSecondaryHoverBackground, buttonHoverBackground, buttonBorder, simpleCheckboxBorder, simpleCheckboxBackground, simpleCheckboxForeground, problemsErrorIconForeground, problemsWarningIconForeground, problemsInfoIconForeground, inputBackground, inputForeground, inputBorder, textLinkForeground, progressBarBackground, resolveColorValue, registerColor, editorBackground, transparent, treeIndentGuidesStroke, focusBorder, listActiveSelectionBackground, darken, listActiveSelectionForeground, editorInfoForeground, errorForeground, editorWarningForeground, activeContrastBorder, lighten, editorErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.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 { CommandsRegistry, 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 { IListService, WorkbenchList } 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 { CSSIcon, Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { ThemeIcon, IThemeService, Themable, registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { addDisposableListener, EventType, EventHelper, trackFocus, reset, clearNode, $, isAncestor, Dimension, scheduleAtNextAnimationFrame, hide, show, getClientArea } 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 { 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 { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { I as IntervalCounter } from './async-9ffe4d42.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, isWindows, isLinux } 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 { 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 'monaco-editor/esm/vs/base/common/buffer.js';
+import 'monaco-editor/esm/vs/editor/common/services/languageService.js';
+import 'monaco-editor/esm/vs/editor/common/services/languagesRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/languages.js';
+import 'monaco-editor/esm/vs/base/parts/quickinput/browser/quickInput.js';
+import 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
+import 'monaco-editor/esm/vs/platform/label/common/label.js';
+import 'monaco-editor/esm/vs/editor/editor.api.js';
+import 'monaco-editor/esm/vs/base/common/network.js';
+import 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+import 'monaco-editor/esm/vs/base/common/strings.js';
+import 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import 'monaco-editor/esm/vs/base/common/path.js';
+import 'monaco-editor/esm/vs/base/common/linkedList.js';
+import 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import 'monaco-editor/esm/vs/base/common/cancellation.js';
+import 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.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}}
+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 > .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,{});
+function computeStyles(theme, styleMap) {
+    const styles = Object.create(null);
+    for (let 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,
+        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,
+    buttonBackground: buttonBackground,
+    buttonSecondaryBackground: buttonSecondaryBackground,
+    buttonSecondaryForeground: buttonSecondaryForeground,
+    buttonSecondaryHoverBackground: buttonSecondaryHoverBackground,
+    buttonHoverBackground: buttonHoverBackground,
+    buttonBorder: buttonBorder,
+    checkboxBorder: simpleCheckboxBorder,
+    checkboxBackground: simpleCheckboxBackground,
+    checkboxForeground: simpleCheckboxForeground,
+    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);
+}
+const TAB_ACTIVE_BACKGROUND = registerColor('tab.activeBackground', {
+    dark: editorBackground,
+    light: editorBackground,
+    hc: editorBackground
+},  localize(
+    'tabActiveBackground',
+    "Active tab background color in an active group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedActiveBackground', {
+    dark: TAB_ACTIVE_BACKGROUND,
+    light: TAB_ACTIVE_BACKGROUND,
+    hc: TAB_ACTIVE_BACKGROUND
+},  localize(
+    'tabUnfocusedActiveBackground',
+    "Active tab background color in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_INACTIVE_BACKGROUND = registerColor('tab.inactiveBackground', {
+    dark: '#2D2D2D',
+    light: '#ECECEC',
+    hc: null
+},  localize(
+    'tabInactiveBackground',
+    "Inactive tab background color in an active group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedInactiveBackground', {
+    dark: TAB_INACTIVE_BACKGROUND,
+    light: TAB_INACTIVE_BACKGROUND,
+    hc: TAB_INACTIVE_BACKGROUND
+},  localize(
+    'tabUnfocusedInactiveBackground',
+    "Inactive tab background color in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_ACTIVE_FOREGROUND = registerColor('tab.activeForeground', {
+    dark: Color.white,
+    light: '#333333',
+    hc: Color.white
+},  localize(
+    'tabActiveForeground',
+    "Active tab foreground color in an active group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_INACTIVE_FOREGROUND = registerColor('tab.inactiveForeground', {
+    dark: transparent(TAB_ACTIVE_FOREGROUND, 0.5),
+    light: transparent(TAB_ACTIVE_FOREGROUND, 0.7),
+    hc: Color.white
+},  localize(
+    'tabInactiveForeground',
+    "Inactive tab foreground color in an active group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedActiveForeground', {
+    dark: transparent(TAB_ACTIVE_FOREGROUND, 0.5),
+    light: transparent(TAB_ACTIVE_FOREGROUND, 0.7),
+    hc: Color.white
+},  localize(
+    'tabUnfocusedActiveForeground',
+    "Active tab foreground color in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedInactiveForeground', {
+    dark: transparent(TAB_INACTIVE_FOREGROUND, 0.5),
+    light: transparent(TAB_INACTIVE_FOREGROUND, 0.5),
+    hc: Color.white
+},  localize(
+    'tabUnfocusedInactiveForeground',
+    "Inactive tab foreground color in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_HOVER_BACKGROUND = registerColor('tab.hoverBackground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'tabHoverBackground',
+    "Tab background color when hovering. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedHoverBackground', {
+    dark: transparent(TAB_HOVER_BACKGROUND, 0.5),
+    light: transparent(TAB_HOVER_BACKGROUND, 0.7),
+    hc: null
+},  localize(
+    'tabUnfocusedHoverBackground',
+    "Tab background color in an unfocused group when hovering. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_HOVER_FOREGROUND = registerColor('tab.hoverForeground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'tabHoverForeground',
+    "Tab foreground color when hovering. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedHoverForeground', {
+    dark: transparent(TAB_HOVER_FOREGROUND, 0.5),
+    light: transparent(TAB_HOVER_FOREGROUND, 0.5),
+    hc: null
+},  localize(
+    'tabUnfocusedHoverForeground',
+    "Tab foreground color in an unfocused group when hovering. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.border', {
+    dark: '#252526',
+    light: '#F3F3F3',
+    hc: contrastBorder
+},  localize(
+    'tabBorder',
+    "Border to separate tabs from each other. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.lastPinnedBorder', {
+    dark: treeIndentGuidesStroke,
+    light: treeIndentGuidesStroke,
+    hc: contrastBorder
+},  localize(
+    'lastPinnedTabBorder',
+    "Border to separate pinned tabs from other tabs. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_ACTIVE_BORDER = registerColor('tab.activeBorder', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'tabActiveBorder',
+    "Border on the bottom of an active tab. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedActiveBorder', {
+    dark: transparent(TAB_ACTIVE_BORDER, 0.5),
+    light: transparent(TAB_ACTIVE_BORDER, 0.7),
+    hc: null
+},  localize(
+    'tabActiveUnfocusedBorder',
+    "Border on the bottom of an active tab in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_ACTIVE_BORDER_TOP = registerColor('tab.activeBorderTop', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'tabActiveBorderTop',
+    "Border to the top of an active tab. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedActiveBorderTop', {
+    dark: transparent(TAB_ACTIVE_BORDER_TOP, 0.5),
+    light: transparent(TAB_ACTIVE_BORDER_TOP, 0.7),
+    hc: null
+},  localize(
+    'tabActiveUnfocusedBorderTop',
+    "Border to the top of an active tab in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_HOVER_BORDER = registerColor('tab.hoverBorder', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'tabHoverBorder',
+    "Border to highlight tabs when hovering. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedHoverBorder', {
+    dark: transparent(TAB_HOVER_BORDER, 0.5),
+    light: transparent(TAB_HOVER_BORDER, 0.7),
+    hc: null
+},  localize(
+    'tabUnfocusedHoverBorder',
+    "Border to highlight tabs in an unfocused group when hovering. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_ACTIVE_MODIFIED_BORDER = registerColor('tab.activeModifiedBorder', {
+    dark: '#3399CC',
+    light: '#33AAEE',
+    hc: null
+},  localize(
+    'tabActiveModifiedBorder',
+    "Border on the top of modified active tabs in an active group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+const TAB_INACTIVE_MODIFIED_BORDER = registerColor('tab.inactiveModifiedBorder', {
+    dark: transparent(TAB_ACTIVE_MODIFIED_BORDER, 0.5),
+    light: transparent(TAB_ACTIVE_MODIFIED_BORDER, 0.5),
+    hc: Color.white
+},  localize(
+    'tabInactiveModifiedBorder',
+    "Border on the top of modified inactive tabs in an active group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedActiveModifiedBorder', {
+    dark: transparent(TAB_ACTIVE_MODIFIED_BORDER, 0.5),
+    light: transparent(TAB_ACTIVE_MODIFIED_BORDER, 0.7),
+    hc: Color.white
+},  localize(
+    'unfocusedActiveModifiedBorder',
+    "Border on the top of modified active tabs in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('tab.unfocusedInactiveModifiedBorder', {
+    dark: transparent(TAB_INACTIVE_MODIFIED_BORDER, 0.5),
+    light: transparent(TAB_INACTIVE_MODIFIED_BORDER, 0.5),
+    hc: Color.white
+},  localize(
+    'unfocusedINactiveModifiedBorder',
+    "Border on the top of modified inactive tabs in an unfocused group. Tabs are the containers for editors in the editor area. Multiple tabs can be opened in one editor group. There can be multiple editor groups."
+));
+registerColor('editorPane.background', {
+    dark: editorBackground,
+    light: editorBackground,
+    hc: editorBackground
+},  localize(
+    'editorPaneBackground',
+    "Background color of the editor pane visible on the left and right side of the centered editor layout."
+));
+registerColor('editorGroup.emptyBackground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'editorGroupEmptyBackground',
+    "Background color of an empty editor group. Editor groups are the containers of editors."
+));
+registerColor('editorGroup.focusedEmptyBorder', {
+    dark: null,
+    light: null,
+    hc: focusBorder
+},  localize(
+    'editorGroupFocusedEmptyBorder',
+    "Border color of an empty editor group that is focused. Editor groups are the containers of editors."
+));
+registerColor('editorGroupHeader.tabsBackground', {
+    dark: '#252526',
+    light: '#F3F3F3',
+    hc: null
+},  localize(
+    'tabsContainerBackground',
+    "Background color of the editor group title header when tabs are enabled. Editor groups are the containers of editors."
+));
+registerColor('editorGroupHeader.tabsBorder', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'tabsContainerBorder',
+    "Border color of the editor group title header when tabs are enabled. Editor groups are the containers of editors."
+));
+registerColor('editorGroupHeader.noTabsBackground', {
+    dark: editorBackground,
+    light: editorBackground,
+    hc: editorBackground
+},  localize(
+    'editorGroupHeaderBackground',
+    "Background color of the editor group title header when tabs are disabled (`\"workbench.editor.showTabs\": false`). Editor groups are the containers of editors."
+));
+registerColor('editorGroupHeader.border', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'editorTitleContainerBorder',
+    "Border color of the editor group title header. Editor groups are the containers of editors."
+));
+const EDITOR_GROUP_BORDER = registerColor('editorGroup.border', {
+    dark: '#444444',
+    light: '#E7E7E7',
+    hc: contrastBorder
+},  localize(
+    'editorGroupBorder',
+    "Color to separate multiple editor groups from each other. Editor groups are the containers of editors."
+));
+const EDITOR_DRAG_AND_DROP_BACKGROUND = registerColor('editorGroup.dropBackground', {
+    dark: Color.fromHex('#53595D').transparent(0.5),
+    light: Color.fromHex('#2677CB').transparent(0.18),
+    hc: null
+},  localize(
+    'editorDragAndDropBackground',
+    "Background color when dragging editors around. The color should have transparency so that the editor contents can still shine through."
+));
+registerColor('sideBySideEditor.horizontalBorder', {
+    dark: EDITOR_GROUP_BORDER,
+    light: EDITOR_GROUP_BORDER,
+    hc: EDITOR_GROUP_BORDER
+},  localize(
+    'sideBySideEditor.horizontalBorder',
+    "Color to separate two editors from each other when shown side by side in an editor group from top to bottom."
+));
+registerColor('sideBySideEditor.verticalBorder', {
+    dark: EDITOR_GROUP_BORDER,
+    light: EDITOR_GROUP_BORDER,
+    hc: EDITOR_GROUP_BORDER
+},  localize(
+    'sideBySideEditor.verticalBorder',
+    "Color to separate two editors from each other when shown side by side in an editor group from left to right."
+));
+registerColor('panel.background', {
+    dark: editorBackground,
+    light: editorBackground,
+    hc: editorBackground
+},  localize(
+    'panelBackground',
+    "Panel background color. Panels are shown below the editor area and contain views like output and integrated terminal."
+));
+const PANEL_BORDER = registerColor('panel.border', {
+    dark: Color.fromHex('#808080').transparent(0.35),
+    light: Color.fromHex('#808080').transparent(0.35),
+    hc: contrastBorder
+},  localize(
+    'panelBorder',
+    "Panel border color to separate the panel from the editor. Panels are shown below the editor area and contain views like output and integrated terminal."
+));
+const PANEL_ACTIVE_TITLE_FOREGROUND = registerColor('panelTitle.activeForeground', {
+    dark: '#E7E7E7',
+    light: '#424242',
+    hc: Color.white
+},  localize(
+    'panelActiveTitleForeground',
+    "Title color for the active panel. Panels are shown below the editor area and contain views like output and integrated terminal."
+));
+registerColor('panelTitle.inactiveForeground', {
+    dark: transparent(PANEL_ACTIVE_TITLE_FOREGROUND, 0.6),
+    light: transparent(PANEL_ACTIVE_TITLE_FOREGROUND, 0.75),
+    hc: Color.white
+},  localize(
+    'panelInactiveTitleForeground',
+    "Title color for the inactive panel. Panels are shown below the editor area and contain views like output and integrated terminal."
+));
+registerColor('panelTitle.activeBorder', {
+    dark: PANEL_ACTIVE_TITLE_FOREGROUND,
+    light: PANEL_ACTIVE_TITLE_FOREGROUND,
+    hc: contrastBorder
+},  localize(
+    'panelActiveTitleBorder',
+    "Border color for the active panel title. Panels are shown below the editor area and contain views like output and integrated terminal."
+));
+registerColor('panelInput.border', {
+    dark: null,
+    light: Color.fromHex('#ddd'),
+    hc: null
+},  localize('panelInputBorder', "Input box border for inputs in the panel."));
+registerColor('panel.dropBorder', {
+    dark: PANEL_ACTIVE_TITLE_FOREGROUND,
+    light: PANEL_ACTIVE_TITLE_FOREGROUND,
+    hc: PANEL_ACTIVE_TITLE_FOREGROUND,
+},  localize(
+    'panelDragAndDropBorder',
+    "Drag and drop feedback color for the panel titles. Panels are shown below the editor area and contain views like output and integrated terminal."
+));
+registerColor('panelSection.dropBackground', {
+    dark: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    light: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    hc: EDITOR_DRAG_AND_DROP_BACKGROUND,
+},  localize(
+    'panelSectionDragAndDropBackground',
+    "Drag and drop feedback color for the panel sections. The color should have transparency so that the panel sections can still shine through. Panels are shown below the editor area and contain views like output and integrated terminal. Panel sections are views nested within the panels."
+));
+registerColor('panelSectionHeader.background', {
+    dark: Color.fromHex('#808080').transparent(0.2),
+    light: Color.fromHex('#808080').transparent(0.2),
+    hc: null
+},  localize(
+    'panelSectionHeaderBackground',
+    "Panel section header background color. Panels are shown below the editor area and contain views like output and integrated terminal. Panel sections are views nested within the panels."
+));
+registerColor('panelSectionHeader.foreground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'panelSectionHeaderForeground',
+    "Panel section header foreground color. Panels are shown below the editor area and contain views like output and integrated terminal. Panel sections are views nested within the panels."
+));
+registerColor('panelSectionHeader.border', {
+    dark: contrastBorder,
+    light: contrastBorder,
+    hc: contrastBorder
+},  localize(
+    'panelSectionHeaderBorder',
+    "Panel section header border color used when multiple views are stacked vertically in the panel. Panels are shown below the editor area and contain views like output and integrated terminal. Panel sections are views nested within the panels."
+));
+registerColor('panelSection.border', {
+    dark: PANEL_BORDER,
+    light: PANEL_BORDER,
+    hc: PANEL_BORDER
+},  localize(
+    'panelSectionBorder',
+    "Panel section border color used when multiple views are stacked horizontally in the panel. Panels are shown below the editor area and contain views like output and integrated terminal. Panel sections are views nested within the panels."
+));
+registerColor('banner.background', {
+    dark: listActiveSelectionBackground,
+    light: darken(listActiveSelectionBackground, 0.3),
+    hc: listActiveSelectionBackground
+},  localize(
+    'banner.background',
+    "Banner background color. The banner is shown under the title bar of the window."
+));
+registerColor('banner.foreground', {
+    dark: listActiveSelectionForeground,
+    light: listActiveSelectionForeground,
+    hc: listActiveSelectionForeground
+},  localize(
+    'banner.foreground',
+    "Banner foreground color. The banner is shown under the title bar of the window."
+));
+registerColor('banner.iconForeground', {
+    dark: editorInfoForeground,
+    light: editorInfoForeground,
+    hc: editorInfoForeground
+},  localize(
+    'banner.iconForeground',
+    "Banner icon color. The banner is shown under the title bar of the window."
+));
+const STATUS_BAR_FOREGROUND = registerColor('statusBar.foreground', {
+    dark: '#FFFFFF',
+    light: '#FFFFFF',
+    hc: '#FFFFFF'
+},  localize(
+    'statusBarForeground',
+    "Status bar foreground color when a workspace or folder is opened. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBar.noFolderForeground', {
+    dark: STATUS_BAR_FOREGROUND,
+    light: STATUS_BAR_FOREGROUND,
+    hc: STATUS_BAR_FOREGROUND
+},  localize(
+    'statusBarNoFolderForeground',
+    "Status bar foreground color when no folder is opened. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBar.background', {
+    dark: '#007ACC',
+    light: '#007ACC',
+    hc: null
+},  localize(
+    'statusBarBackground',
+    "Status bar background color when a workspace or folder is opened. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBar.noFolderBackground', {
+    dark: '#68217A',
+    light: '#68217A',
+    hc: null
+},  localize(
+    'statusBarNoFolderBackground',
+    "Status bar background color when no folder is opened. The status bar is shown in the bottom of the window."
+));
+const STATUS_BAR_BORDER = registerColor('statusBar.border', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'statusBarBorder',
+    "Status bar border color separating to the sidebar and editor. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBar.focusBorder', {
+    dark: STATUS_BAR_FOREGROUND,
+    light: STATUS_BAR_FOREGROUND,
+    hc: null,
+},  localize(
+    'statusBarFocusBorder',
+    "Status bar border color when focused on keyboard navigation. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBar.noFolderBorder', {
+    dark: STATUS_BAR_BORDER,
+    light: STATUS_BAR_BORDER,
+    hc: STATUS_BAR_BORDER
+},  localize(
+    'statusBarNoFolderBorder',
+    "Status bar border color separating to the sidebar and editor when no folder is opened. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.activeBackground', {
+    dark: Color.white.transparent(0.18),
+    light: Color.white.transparent(0.18),
+    hc: Color.white.transparent(0.18)
+},  localize(
+    'statusBarItemActiveBackground',
+    "Status bar item background color when clicking. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.focusBorder', {
+    dark: STATUS_BAR_FOREGROUND,
+    light: STATUS_BAR_FOREGROUND,
+    hc: null,
+},  localize(
+    'statusBarItemFocusBorder',
+    "Status bar item border color when focused on keyboard navigation. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.hoverBackground', {
+    dark: Color.white.transparent(0.12),
+    light: Color.white.transparent(0.12),
+    hc: Color.white.transparent(0.12)
+},  localize(
+    'statusBarItemHoverBackground',
+    "Status bar item background color when hovering. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.compactHoverBackground', {
+    dark: Color.white.transparent(0.20),
+    light: Color.white.transparent(0.20),
+    hc: Color.white.transparent(0.20)
+},  localize(
+    'statusBarItemCompactHoverBackground',
+    "Status bar item background color when hovering an item that contains two hovers. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.prominentForeground', {
+    dark: STATUS_BAR_FOREGROUND,
+    light: STATUS_BAR_FOREGROUND,
+    hc: STATUS_BAR_FOREGROUND
+},  localize(
+    'statusBarProminentItemForeground',
+    "Status bar prominent items foreground color. Prominent items stand out from other status bar entries to indicate importance. Change mode `Toggle Tab Key Moves Focus` from command palette to see an example. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.prominentBackground', {
+    dark: Color.black.transparent(0.5),
+    light: Color.black.transparent(0.5),
+    hc: Color.black.transparent(0.5),
+},  localize(
+    'statusBarProminentItemBackground',
+    "Status bar prominent items background color. Prominent items stand out from other status bar entries to indicate importance. Change mode `Toggle Tab Key Moves Focus` from command palette to see an example. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.prominentHoverBackground', {
+    dark: Color.black.transparent(0.3),
+    light: Color.black.transparent(0.3),
+    hc: Color.black.transparent(0.3),
+},  localize(
+    'statusBarProminentItemHoverBackground',
+    "Status bar prominent items background color when hovering. Prominent items stand out from other status bar entries to indicate importance. Change mode `Toggle Tab Key Moves Focus` from command palette to see an example. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.errorBackground', {
+    dark: darken(errorForeground, .4),
+    light: darken(errorForeground, .4),
+    hc: null,
+},  localize(
+    'statusBarErrorItemBackground',
+    "Status bar error items background color. Error items stand out from other status bar entries to indicate error conditions. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.errorForeground', {
+    dark: Color.white,
+    light: Color.white,
+    hc: Color.white,
+},  localize(
+    'statusBarErrorItemForeground',
+    "Status bar error items foreground color. Error items stand out from other status bar entries to indicate error conditions. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.warningBackground', {
+    dark: darken(editorWarningForeground, .4),
+    light: darken(editorWarningForeground, .4),
+    hc: null,
+},  localize(
+    'statusBarWarningItemBackground',
+    "Status bar warning items background color. Warning items stand out from other status bar entries to indicate warning conditions. The status bar is shown in the bottom of the window."
+));
+registerColor('statusBarItem.warningForeground', {
+    dark: Color.white,
+    light: Color.white,
+    hc: Color.white,
+},  localize(
+    'statusBarWarningItemForeground',
+    "Status bar warning items foreground color. Warning items stand out from other status bar entries to indicate warning conditions. The status bar is shown in the bottom of the window."
+));
+registerColor('activityBar.background', {
+    dark: '#333333',
+    light: '#2C2C2C',
+    hc: '#000000'
+},  localize(
+    'activityBarBackground',
+    "Activity bar background color. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+const ACTIVITY_BAR_FOREGROUND = registerColor('activityBar.foreground', {
+    dark: Color.white,
+    light: Color.white,
+    hc: Color.white
+},  localize(
+    'activityBarForeground',
+    "Activity bar item foreground color when it is active. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('activityBar.inactiveForeground', {
+    dark: transparent(ACTIVITY_BAR_FOREGROUND, 0.4),
+    light: transparent(ACTIVITY_BAR_FOREGROUND, 0.4),
+    hc: Color.white
+},  localize(
+    'activityBarInActiveForeground',
+    "Activity bar item foreground color when it is inactive. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('activityBar.border', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'activityBarBorder',
+    "Activity bar border color separating to the side bar. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('activityBar.activeBorder', {
+    dark: ACTIVITY_BAR_FOREGROUND,
+    light: ACTIVITY_BAR_FOREGROUND,
+    hc: null
+},  localize(
+    'activityBarActiveBorder',
+    "Activity bar border color for the active item. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('activityBar.activeFocusBorder', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'activityBarActiveFocusBorder',
+    "Activity bar focus border color for the active item. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('activityBar.activeBackground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'activityBarActiveBackground',
+    "Activity bar background color for the active item. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('activityBar.dropBorder', {
+    dark: ACTIVITY_BAR_FOREGROUND,
+    light: ACTIVITY_BAR_FOREGROUND,
+    hc: ACTIVITY_BAR_FOREGROUND,
+},  localize(
+    'activityBarDragAndDropBorder',
+    "Drag and drop feedback color for the activity bar items. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+const ACTIVITY_BAR_BADGE_BACKGROUND = registerColor('activityBarBadge.background', {
+    dark: '#007ACC',
+    light: '#007ACC',
+    hc: '#000000'
+},  localize(
+    'activityBarBadgeBackground',
+    "Activity notification badge background color. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+const ACTIVITY_BAR_BADGE_FOREGROUND = registerColor('activityBarBadge.foreground', {
+    dark: Color.white,
+    light: Color.white,
+    hc: Color.white
+},  localize(
+    'activityBarBadgeForeground',
+    "Activity notification badge foreground color. The activity bar is showing on the far left or right and allows to switch between views of the side bar."
+));
+registerColor('statusBarItem.remoteBackground', {
+    dark: ACTIVITY_BAR_BADGE_BACKGROUND,
+    light: ACTIVITY_BAR_BADGE_BACKGROUND,
+    hc: ACTIVITY_BAR_BADGE_BACKGROUND
+},  localize(
+    'statusBarItemHostBackground',
+    "Background color for the remote indicator on the status bar."
+));
+registerColor('statusBarItem.remoteForeground', {
+    dark: ACTIVITY_BAR_BADGE_FOREGROUND,
+    light: ACTIVITY_BAR_BADGE_FOREGROUND,
+    hc: ACTIVITY_BAR_BADGE_FOREGROUND
+},  localize(
+    'statusBarItemHostForeground',
+    "Foreground color for the remote indicator on the status bar."
+));
+registerColor('extensionBadge.remoteBackground', {
+    dark: ACTIVITY_BAR_BADGE_BACKGROUND,
+    light: ACTIVITY_BAR_BADGE_BACKGROUND,
+    hc: ACTIVITY_BAR_BADGE_BACKGROUND
+},  localize(
+    'extensionBadge.remoteBackground',
+    "Background color for the remote badge in the extensions view."
+));
+registerColor('extensionBadge.remoteForeground', {
+    dark: ACTIVITY_BAR_BADGE_FOREGROUND,
+    light: ACTIVITY_BAR_BADGE_FOREGROUND,
+    hc: ACTIVITY_BAR_BADGE_FOREGROUND
+},  localize(
+    'extensionBadge.remoteForeground',
+    "Foreground color for the remote badge in the extensions view."
+));
+registerColor('sideBar.background', {
+    dark: '#252526',
+    light: '#F3F3F3',
+    hc: '#000000'
+},  localize(
+    'sideBarBackground',
+    "Side bar background color. The side bar is the container for views like explorer and search."
+));
+const SIDE_BAR_FOREGROUND = registerColor('sideBar.foreground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'sideBarForeground',
+    "Side bar foreground color. The side bar is the container for views like explorer and search."
+));
+registerColor('sideBar.border', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'sideBarBorder',
+    "Side bar border color on the side separating to the editor. The side bar is the container for views like explorer and search."
+));
+registerColor('sideBarTitle.foreground', {
+    dark: SIDE_BAR_FOREGROUND,
+    light: SIDE_BAR_FOREGROUND,
+    hc: SIDE_BAR_FOREGROUND
+},  localize(
+    'sideBarTitleForeground',
+    "Side bar title foreground color. The side bar is the container for views like explorer and search."
+));
+registerColor('sideBar.dropBackground', {
+    dark: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    light: EDITOR_DRAG_AND_DROP_BACKGROUND,
+    hc: EDITOR_DRAG_AND_DROP_BACKGROUND,
+},  localize(
+    'sideBarDragAndDropBackground',
+    "Drag and drop feedback color for the side bar sections. The color should have transparency so that the side bar sections can still shine through. The side bar is the container for views like explorer and search. Side bar sections are views nested within the side bar."
+));
+registerColor('sideBarSectionHeader.background', {
+    dark: Color.fromHex('#808080').transparent(0.2),
+    light: Color.fromHex('#808080').transparent(0.2),
+    hc: null
+},  localize(
+    'sideBarSectionHeaderBackground',
+    "Side bar section header background color. The side bar is the container for views like explorer and search. Side bar sections are views nested within the side bar."
+));
+registerColor('sideBarSectionHeader.foreground', {
+    dark: SIDE_BAR_FOREGROUND,
+    light: SIDE_BAR_FOREGROUND,
+    hc: SIDE_BAR_FOREGROUND
+},  localize(
+    'sideBarSectionHeaderForeground',
+    "Side bar section header foreground color. The side bar is the container for views like explorer and search. Side bar sections are views nested within the side bar."
+));
+registerColor('sideBarSectionHeader.border', {
+    dark: contrastBorder,
+    light: contrastBorder,
+    hc: contrastBorder
+},  localize(
+    'sideBarSectionHeaderBorder',
+    "Side bar section header border color. The side bar is the container for views like explorer and search. Side bar sections are views nested within the side bar."
+));
+const TITLE_BAR_ACTIVE_FOREGROUND = registerColor('titleBar.activeForeground', {
+    dark: '#CCCCCC',
+    light: '#333333',
+    hc: '#FFFFFF'
+},  localize(
+    'titleBarActiveForeground',
+    "Title bar foreground when the window is active."
+));
+registerColor('titleBar.inactiveForeground', {
+    dark: transparent(TITLE_BAR_ACTIVE_FOREGROUND, 0.6),
+    light: transparent(TITLE_BAR_ACTIVE_FOREGROUND, 0.6),
+    hc: null
+},  localize(
+    'titleBarInactiveForeground',
+    "Title bar foreground when the window is inactive."
+));
+const TITLE_BAR_ACTIVE_BACKGROUND = registerColor('titleBar.activeBackground', {
+    dark: '#3C3C3C',
+    light: '#DDDDDD',
+    hc: '#000000'
+},  localize(
+    'titleBarActiveBackground',
+    "Title bar background when the window is active."
+));
+registerColor('titleBar.inactiveBackground', {
+    dark: transparent(TITLE_BAR_ACTIVE_BACKGROUND, 0.6),
+    light: transparent(TITLE_BAR_ACTIVE_BACKGROUND, 0.6),
+    hc: null
+},  localize(
+    'titleBarInactiveBackground',
+    "Title bar background when the window is inactive."
+));
+registerColor('titleBar.border', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize('titleBarBorder', "Title bar border color."));
+registerColor('menubar.selectionForeground', {
+    dark: TITLE_BAR_ACTIVE_FOREGROUND,
+    light: TITLE_BAR_ACTIVE_FOREGROUND,
+    hc: TITLE_BAR_ACTIVE_FOREGROUND
+},  localize(
+    'menubarSelectionForeground',
+    "Foreground color of the selected menu item in the menubar."
+));
+registerColor('menubar.selectionBackground', {
+    dark: transparent(Color.white, 0.1),
+    light: transparent(Color.black, 0.1),
+    hc: null
+},  localize(
+    'menubarSelectionBackground',
+    "Background color of the selected menu item in the menubar."
+));
+registerColor('menubar.selectionBorder', {
+    dark: null,
+    light: null,
+    hc: activeContrastBorder
+},  localize(
+    'menubarSelectionBorder',
+    "Border color of the selected menu item in the menubar."
+));
+registerColor('notificationCenter.border', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'notificationCenterBorder',
+    "Notifications center border color. Notifications slide in from the bottom right of the window."
+));
+const NOTIFICATIONS_TOAST_BORDER = registerColor('notificationToast.border', {
+    dark: null,
+    light: null,
+    hc: 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,
+    hc: 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,
+    hc: 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,
+    hc: textLinkForeground
+},  localize(
+    'notificationsLink',
+    "Notification links foreground color. Notifications slide in from the bottom right of the window."
+));
+registerColor('notificationCenterHeader.foreground', {
+    dark: null,
+    light: null,
+    hc: null
+},  localize(
+    'notificationCenterHeaderForeground',
+    "Notifications center header foreground color. Notifications slide in from the bottom right of the window."
+));
+const NOTIFICATIONS_CENTER_HEADER_BACKGROUND = registerColor('notificationCenterHeader.background', {
+    dark: lighten(NOTIFICATIONS_BACKGROUND, 0.3),
+    light: darken(NOTIFICATIONS_BACKGROUND, 0.05),
+    hc: NOTIFICATIONS_BACKGROUND
+},  localize(
+    'notificationCenterHeaderBackground',
+    "Notifications center header background color. Notifications slide in from the bottom right of the window."
+));
+registerColor('notifications.border', {
+    dark: NOTIFICATIONS_CENTER_HEADER_BACKGROUND,
+    light: NOTIFICATIONS_CENTER_HEADER_BACKGROUND,
+    hc: NOTIFICATIONS_CENTER_HEADER_BACKGROUND
+},  localize(
+    'notificationsBorder',
+    "Notifications border color separating from other notifications in the notifications center. Notifications slide in from the bottom right of the window."
+));
+const NOTIFICATIONS_ERROR_ICON_FOREGROUND = registerColor('notificationsErrorIcon.foreground', {
+    dark: editorErrorForeground,
+    light: editorErrorForeground,
+    hc: 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,
+    hc: 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,
+    hc: editorInfoForeground
+},  localize(
+    'notificationsInfoIconForeground',
+    "The color used for the icon of info notifications. Notifications slide in from the bottom right of the window."
+));
+registerColor('window.activeBorder', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'windowActiveBorder',
+    "The color used for the border of the window when it is active. Only supported in the desktop client when using the custom title bar."
+));
+registerColor('window.inactiveBorder', {
+    dark: null,
+    light: null,
+    hc: contrastBorder
+},  localize(
+    'windowInactiveBorder',
+    "The color used for the border of the window when it is inactive. Only supported in the desktop client when using the custom title bar."
+));
+const defaultOptions = {
+    buttonBackground: Color.fromHex('#0E639C'),
+    buttonHoverBackground: Color.fromHex('#006BB3'),
+    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(() => this.setHoverBackground()));
+        this._register(this.focusTracker.onDidBlur(() => 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.dropdownButton = this._register( new Button(this.element, { ...options, title: false, supportIcons: true }));
+        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: () => [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;
+    }
+    get enabled() {
+        return this.button.enabled;
+    }
+    style(styles) {
+        this.button.style(styles);
+        this.dropdownButton.style(styles);
+    }
+    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._labelElement.tabIndex = -1;
+        this._element.appendChild(this._labelElement);
+        this._descriptionElement = document.createElement('div');
+        this._descriptionElement.classList.add('monaco-button-description');
+        this._descriptionElement.tabIndex = -1;
+        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) {
+        if (isEqual(this.get(), value ?? undefined)) {
+            return;
+        }
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.set(value);
+            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._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._resourceKey.get() ?? undefined;
+    }
+};
+ResourceContextKey.Scheme =  new RawContextKey('resourceScheme', undefined, { type: 'string', description:  localize('resourceScheme', "The scheme of the rsource") });
+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';
+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;
+    }
+     CommandsRegistry.registerCommand(SHOW_NOTIFICATIONS_CENTER, () => {
+        toasts.hide();
+        center.show();
+    });
+    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: 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.'));
+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 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 (const action of primaryActions) {
+                const buttonOptions = { title: true,  };
+                const dropdownActions = action instanceof ChoiceAction ? action.menu : undefined;
+                const button = this.inputDisposables.add(dropdownActions
+                    ? buttonToolbar.addButtonWithDropdown({
+                        ...buttonOptions,
+                        contextMenuProvider: this.contextMenuService,
+                        actions: dropdownActions,
+                        actionRunner
+                    })
+                    : buttonToolbar.addButton(buttonOptions));
+                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) {
+        const errorCodiconSelector = Codicon.error.cssSelector;
+        collector.addRule(`
+		.monaco-workbench .notifications-center ${errorCodiconSelector},
+		.monaco-workbench .notifications-toasts ${errorCodiconSelector} {
+			color: ${notificationErrorIconForegroundColor};
+		}`);
+    }
+    const notificationWarningIconForegroundColor = theme.getColor(NOTIFICATIONS_WARNING_ICON_FOREGROUND);
+    if (notificationWarningIconForegroundColor) {
+        const warningCodiconSelector = Codicon.warning.cssSelector;
+        collector.addRule(`
+		.monaco-workbench .notifications-center ${warningCodiconSelector},
+		.monaco-workbench .notifications-toasts ${warningCodiconSelector} {
+			color: ${notificationWarningIconForegroundColor};
+		}`);
+    }
+    const notificationInfoIconForegroundColor = theme.getColor(NOTIFICATIONS_INFO_ICON_FOREGROUND);
+    if (notificationInfoIconForegroundColor) {
+        const infoCodiconSelector = Codicon.info.cssSelector;
+        collector.addRule(`
+		.monaco-workbench .notifications-center ${infoCodiconSelector},
+		.monaco-workbench .notifications-toasts ${infoCodiconSelector} {
+			color: ${notificationInfoIconForegroundColor};
+		}`);
+    }
+});
+const IWorkbenchLayoutService = refineServiceDecorator(ILayoutService);
+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() {
+        if (this.notificationsToastsContainer) {
+            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() {
+        let 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.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;
+                }
+            }
+        }));
+    }
+    setFilter(filter) {
+        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();
+        let handle;
+        if (notification.neverShowAgain) {
+            const scope = notification.neverShowAgain.scope === NeverShowAgainScope.WORKSPACE ? 1  : 0 ;
+            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;
+        }
+        handle = this.model.addNotification(notification);
+        Event.once(handle.onDidClose)(() => toDispose.dispose());
+        return handle;
+    }
+    prompt(severity, message, choices, options) {
+        const toDispose =  new DisposableStore();
+        if (options?.neverShowAgain) {
+            const scope = options.neverShowAgain.scope === NeverShowAgainScope.WORKSPACE ? 1  : 0 ;
+            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;
+        let handle;
+        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 };
+        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 =  __decorate([
+     __param(0, IStorageService)
+], NotificationService);
+const defaultOpts = {
+    inputActiveOptionBorder: Color.fromHex('#007ACC00'),
+    inputActiveOptionForeground: Color.fromHex('#FFFFFF'),
+    inputActiveOptionBackground: Color.fromHex('#0E639C50')
+};
+class Checkbox 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-checkbox'];
+        if (this._opts.icon) {
+            classes.push(...CSSIcon.asClassNameArray(this._opts.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();
+                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();
+    }
+    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 SimpleCheckbox extends Widget {
+    constructor(title, isChecked) {
+        super();
+        this.title = title;
+        this.isChecked = isChecked;
+        this.checkbox =  new Checkbox(
+            { title: this.title, isChecked: this.isChecked, icon: Codicon.check, actionClassName: 'monaco-simple-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 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 SimpleCheckbox(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() {
+        let 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;
+            if (this.buttonBar) {
+                this.buttonBar.buttons.forEach(button => button.style(style));
+            }
+            if (this.checkbox) {
+                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
+        };
+    }
+}
+class DialogService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.model = this._register( new DialogsModel());
+        this.onWillShowDialog = this.model.onWillShowDialog;
+        this.onDidShowDialog = this.model.onDidShowDialog;
+    }
+    async confirm(confirmation) {
+        const handle = this.model.show({ confirmArgs: { confirmation } });
+        return await handle.result;
+    }
+    async show(severity, message, buttons, options) {
+        const handle = this.model.show({ showArgs: { severity, message, buttons, options } });
+        return await handle.result;
+    }
+    async input(severity, message, buttons, inputs, options) {
+        const handle = this.model.show({ inputArgs: { severity, message, buttons, inputs, options } });
+        return await handle.result;
+    }
+    async about() {
+        const handle = this.model.show({});
+        await handle.result;
+    }
+}
+class LayoutService {
+    constructor(container, _codeEditorService) {
+        this.container = container;
+        this._codeEditorService = _codeEditorService;
+        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() {
+        this._codeEditorService.getFocusedCodeEditor()?.focus();
+    }
+}
+function register(container) {
+    container.classList.add('monaco-workbench');
+    const model = StandaloneServices.get(INotificationService).model;
+    const instantiationService = StandaloneServices.get(IInstantiationService);
+    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);
+    StandaloneServices.get(IInstantiationService).createInstance(DialogHandlerContribution);
+}
+function getServiceOverride(container) {
+    setTimeout(() => register(container));
+    return {
+        [IDialogService.toString()]: new SyncDescriptor(DialogService),
+        [INotificationService.toString()]: new SyncDescriptor(NotificationService),
+        [ILayoutService.toString()]: new SyncDescriptor(LayoutService, [container])
+    };
+}
+export { getServiceOverride as default };