@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/base/browser/ui/contextview/contextview.js

@@ -0,0 +1,271 @@
+import { BrowserFeatures } from '../../canIUse.js';
+import { $, hide, addStandardDisposableListener, clearNode, show, getDomNodePagePosition, getDomNodeZoomLevel, getTotalWidth, getTotalHeight, getActiveWindow, getWindow, isAncestor } from '../../dom.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../common/lifecycle.js';
+import { isIOS } from '../../../common/platform.js';
+import { Range } from '../../../common/range.js';
+import './contextview.css.js';
+function isAnchor(obj) {
+    const anchor = obj;
+    return !!anchor && typeof anchor.x === 'number' && typeof anchor.y === 'number';
+}
+var LayoutAnchorMode;
+( (function(LayoutAnchorMode) {
+    LayoutAnchorMode[LayoutAnchorMode["AVOID"] = 0] = "AVOID";
+    LayoutAnchorMode[LayoutAnchorMode["ALIGN"] = 1] = "ALIGN";
+})(LayoutAnchorMode || (LayoutAnchorMode = {})));
+function layout(viewportSize, viewSize, anchor) {
+    const layoutAfterAnchorBoundary = anchor.mode === LayoutAnchorMode.ALIGN ? anchor.offset : anchor.offset + anchor.size;
+    const layoutBeforeAnchorBoundary = anchor.mode === LayoutAnchorMode.ALIGN ? anchor.offset + anchor.size : anchor.offset;
+    if (anchor.position === 0 ) {
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary) {
+            return layoutAfterAnchorBoundary;
+        }
+        if (viewSize <= layoutBeforeAnchorBoundary) {
+            return layoutBeforeAnchorBoundary - viewSize;
+        }
+        return Math.max(viewportSize - viewSize, 0);
+    }
+    else {
+        if (viewSize <= layoutBeforeAnchorBoundary) {
+            return layoutBeforeAnchorBoundary - viewSize;
+        }
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary) {
+            return layoutAfterAnchorBoundary;
+        }
+        return 0;
+    }
+}
+class ContextView extends Disposable {
+    static { this.BUBBLE_UP_EVENTS = ['click', 'keydown', 'focus', 'blur']; }
+    static { this.BUBBLE_DOWN_EVENTS = ['click']; }
+    constructor(container, domPosition) {
+        super();
+        this.container = null;
+        this.useFixedPosition = false;
+        this.useShadowDOM = false;
+        this.delegate = null;
+        this.toDisposeOnClean = Disposable.None;
+        this.toDisposeOnSetContainer = Disposable.None;
+        this.shadowRoot = null;
+        this.shadowRootHostElement = null;
+        this.view = $('.context-view');
+        hide(this.view);
+        this.setContainer(container, domPosition);
+        this._register(toDisposable(() => this.setContainer(null, 1 )));
+    }
+    setContainer(container, domPosition) {
+        this.useFixedPosition = domPosition !== 1 ;
+        const usedShadowDOM = this.useShadowDOM;
+        this.useShadowDOM = domPosition === 3 ;
+        if (container === this.container && usedShadowDOM !== this.useShadowDOM) {
+            return;
+        }
+        if (this.container) {
+            this.toDisposeOnSetContainer.dispose();
+            if (this.shadowRoot) {
+                this.shadowRoot.removeChild(this.view);
+                this.shadowRoot = null;
+                this.shadowRootHostElement?.remove();
+                this.shadowRootHostElement = null;
+            }
+            else {
+                this.container.removeChild(this.view);
+            }
+            this.container = null;
+        }
+        if (container) {
+            this.container = container;
+            if (this.useShadowDOM) {
+                this.shadowRootHostElement = $('.shadow-root-host');
+                this.container.appendChild(this.shadowRootHostElement);
+                this.shadowRoot = this.shadowRootHostElement.attachShadow({ mode: 'open' });
+                const style = document.createElement('style');
+                style.textContent = SHADOW_ROOT_CSS;
+                this.shadowRoot.appendChild(style);
+                this.shadowRoot.appendChild(this.view);
+                this.shadowRoot.appendChild($('slot'));
+            }
+            else {
+                this.container.appendChild(this.view);
+            }
+            const toDisposeOnSetContainer = ( new DisposableStore());
+            ContextView.BUBBLE_UP_EVENTS.forEach(event => {
+                toDisposeOnSetContainer.add(addStandardDisposableListener(this.container, event, e => {
+                    this.onDOMEvent(e, false);
+                }));
+            });
+            ContextView.BUBBLE_DOWN_EVENTS.forEach(event => {
+                toDisposeOnSetContainer.add(addStandardDisposableListener(this.container, event, e => {
+                    this.onDOMEvent(e, true);
+                }, true));
+            });
+            this.toDisposeOnSetContainer = toDisposeOnSetContainer;
+        }
+    }
+    show(delegate) {
+        if (this.isVisible()) {
+            this.hide();
+        }
+        clearNode(this.view);
+        this.view.className = 'context-view';
+        this.view.style.top = '0px';
+        this.view.style.left = '0px';
+        this.view.style.zIndex = '2575';
+        this.view.style.position = this.useFixedPosition ? 'fixed' : 'absolute';
+        show(this.view);
+        this.toDisposeOnClean = delegate.render(this.view) || Disposable.None;
+        this.delegate = delegate;
+        this.doLayout();
+        this.delegate.focus?.();
+    }
+    getViewElement() {
+        return this.view;
+    }
+    layout() {
+        if (!this.isVisible()) {
+            return;
+        }
+        if (this.delegate.canRelayout === false && !(isIOS && BrowserFeatures.pointerEvents)) {
+            this.hide();
+            return;
+        }
+        if (this.delegate.layout) {
+            this.delegate.layout();
+        }
+        this.doLayout();
+    }
+    doLayout() {
+        if (!this.isVisible()) {
+            return;
+        }
+        const anchor = this.delegate.getAnchor();
+        let around;
+        if (anchor instanceof HTMLElement) {
+            const elementPosition = getDomNodePagePosition(anchor);
+            const zoom = getDomNodeZoomLevel(anchor);
+            around = {
+                top: elementPosition.top * zoom,
+                left: elementPosition.left * zoom,
+                width: elementPosition.width * zoom,
+                height: elementPosition.height * zoom
+            };
+        }
+        else if (isAnchor(anchor)) {
+            around = {
+                top: anchor.y,
+                left: anchor.x,
+                width: anchor.width || 1,
+                height: anchor.height || 2
+            };
+        }
+        else {
+            around = {
+                top: anchor.posy,
+                left: anchor.posx,
+                width: 2,
+                height: 2
+            };
+        }
+        const viewSizeWidth = getTotalWidth(this.view);
+        const viewSizeHeight = getTotalHeight(this.view);
+        const anchorPosition = this.delegate.anchorPosition || 0 ;
+        const anchorAlignment = this.delegate.anchorAlignment || 0 ;
+        const anchorAxisAlignment = this.delegate.anchorAxisAlignment || 0 ;
+        let top;
+        let left;
+        const activeWindow = getActiveWindow();
+        if (anchorAxisAlignment === 0 ) {
+            const verticalAnchor = { offset: around.top - activeWindow.pageYOffset, size: around.height, position: anchorPosition === 0  ? 0  : 1  };
+            const horizontalAnchor = { offset: around.left, size: around.width, position: anchorAlignment === 0  ? 0  : 1 , mode: LayoutAnchorMode.ALIGN };
+            top = layout(activeWindow.innerHeight, viewSizeHeight, verticalAnchor) + activeWindow.pageYOffset;
+            if (Range.intersects({ start: top, end: top + viewSizeHeight }, { start: verticalAnchor.offset, end: verticalAnchor.offset + verticalAnchor.size })) {
+                horizontalAnchor.mode = LayoutAnchorMode.AVOID;
+            }
+            left = layout(activeWindow.innerWidth, viewSizeWidth, horizontalAnchor);
+        }
+        else {
+            const horizontalAnchor = { offset: around.left, size: around.width, position: anchorAlignment === 0  ? 0  : 1  };
+            const verticalAnchor = { offset: around.top, size: around.height, position: anchorPosition === 0  ? 0  : 1 , mode: LayoutAnchorMode.ALIGN };
+            left = layout(activeWindow.innerWidth, viewSizeWidth, horizontalAnchor);
+            if (Range.intersects({ start: left, end: left + viewSizeWidth }, { start: horizontalAnchor.offset, end: horizontalAnchor.offset + horizontalAnchor.size })) {
+                verticalAnchor.mode = LayoutAnchorMode.AVOID;
+            }
+            top = layout(activeWindow.innerHeight, viewSizeHeight, verticalAnchor) + activeWindow.pageYOffset;
+        }
+        this.view.classList.remove('top', 'bottom', 'left', 'right');
+        this.view.classList.add(anchorPosition === 0  ? 'bottom' : 'top');
+        this.view.classList.add(anchorAlignment === 0  ? 'left' : 'right');
+        this.view.classList.toggle('fixed', this.useFixedPosition);
+        const containerPosition = getDomNodePagePosition(this.container);
+        this.view.style.top = `${top - (this.useFixedPosition ? getDomNodePagePosition(this.view).top : containerPosition.top)}px`;
+        this.view.style.left = `${left - (this.useFixedPosition ? getDomNodePagePosition(this.view).left : containerPosition.left)}px`;
+        this.view.style.width = 'initial';
+    }
+    hide(data) {
+        const delegate = this.delegate;
+        this.delegate = null;
+        if (delegate?.onHide) {
+            delegate.onHide(data);
+        }
+        this.toDisposeOnClean.dispose();
+        hide(this.view);
+    }
+    isVisible() {
+        return !!this.delegate;
+    }
+    onDOMEvent(e, onCapture) {
+        if (this.delegate) {
+            if (this.delegate.onDOMEvent) {
+                this.delegate.onDOMEvent(e, getWindow(e).document.activeElement);
+            }
+            else if (onCapture && !isAncestor(e.target, this.container)) {
+                this.hide();
+            }
+        }
+    }
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+}
+const SHADOW_ROOT_CSS =  `
+	:host {
+		all: initial; /* 1st rule so subsequent properties are reset. */
+	}
+
+	.codicon[class*='codicon-'] {
+		font: normal normal normal 16px/1 codicon;
+		display: inline-block;
+		text-decoration: none;
+		text-rendering: auto;
+		text-align: center;
+		-webkit-font-smoothing: antialiased;
+		-moz-osx-font-smoothing: grayscale;
+		user-select: none;
+		-webkit-user-select: none;
+		-ms-user-select: none;
+	}
+
+	:host {
+		font-family: -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", system-ui, "Ubuntu", "Droid Sans", sans-serif;
+	}
+
+	:host-context(.mac) { font-family: -apple-system, BlinkMacSystemFont, sans-serif; }
+	:host-context(.mac:lang(zh-Hans)) { font-family: -apple-system, BlinkMacSystemFont, "PingFang SC", "Hiragino Sans GB", sans-serif; }
+	:host-context(.mac:lang(zh-Hant)) { font-family: -apple-system, BlinkMacSystemFont, "PingFang TC", sans-serif; }
+	:host-context(.mac:lang(ja)) { font-family: -apple-system, BlinkMacSystemFont, "Hiragino Kaku Gothic Pro", sans-serif; }
+	:host-context(.mac:lang(ko)) { font-family: -apple-system, BlinkMacSystemFont, "Nanum Gothic", "Apple SD Gothic Neo", "AppleGothic", sans-serif; }
+
+	:host-context(.windows) { font-family: "Segoe WPC", "Segoe UI", sans-serif; }
+	:host-context(.windows:lang(zh-Hans)) { font-family: "Segoe WPC", "Segoe UI", "Microsoft YaHei", sans-serif; }
+	:host-context(.windows:lang(zh-Hant)) { font-family: "Segoe WPC", "Segoe UI", "Microsoft Jhenghei", sans-serif; }
+	:host-context(.windows:lang(ja)) { font-family: "Segoe WPC", "Segoe UI", "Yu Gothic UI", "Meiryo UI", sans-serif; }
+	:host-context(.windows:lang(ko)) { font-family: "Segoe WPC", "Segoe UI", "Malgun Gothic", "Dotom", sans-serif; }
+
+	:host-context(.linux) { font-family: system-ui, "Ubuntu", "Droid Sans", sans-serif; }
+	:host-context(.linux:lang(zh-Hans)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans SC", "Source Han Sans CN", "Source Han Sans", sans-serif; }
+	:host-context(.linux:lang(zh-Hant)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans TC", "Source Han Sans TW", "Source Han Sans", sans-serif; }
+	:host-context(.linux:lang(ja)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans J", "Source Han Sans JP", "Source Han Sans", sans-serif; }
+	:host-context(.linux:lang(ko)) { font-family: system-ui, "Ubuntu", "Droid Sans", "Source Han Sans K", "Source Han Sans JR", "Source Han Sans", "UnDotum", "FBaekmuk Gulim", sans-serif; }
+`;
+export { ContextView, LayoutAnchorMode, isAnchor, layout };

package/vscode/src/vs/base/browser/ui/countBadge/countBadge.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-count-badge{border-radius:11px;box-sizing:border-box;display:inline-block;font-size:11px;font-weight:400;line-height:11px;min-height:18px;min-width:18px;padding:3px 6px;text-align:center}.monaco-count-badge.long{border-radius:2px;line-height:normal;min-height:auto;padding:2px 3px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/base/browser/ui/countBadge/countBadge.js

@@ -0,0 +1,36 @@
+import { append, $ } from '../../dom.js';
+import { format } from '../../../common/strings.js';
+import './countBadge.css.js';
+class CountBadge {
+    constructor(container, options, styles) {
+        this.options = options;
+        this.styles = styles;
+        this.count = 0;
+        this.element = append(container, $('.monaco-count-badge'));
+        this.countFormat = this.options.countFormat || '{0}';
+        this.titleFormat = this.options.titleFormat || '';
+        this.setCount(this.options.count || 0);
+    }
+    setCount(count) {
+        this.count = count;
+        this.render();
+    }
+    setCountFormat(countFormat) {
+        this.countFormat = countFormat;
+        this.render();
+    }
+    setTitleFormat(titleFormat) {
+        this.titleFormat = titleFormat;
+        this.render();
+    }
+    render() {
+        this.element.textContent = format(this.countFormat, this.count);
+        this.element.title = format(this.titleFormat, this.count);
+        this.element.style.backgroundColor = this.styles.badgeBackground ?? '';
+        this.element.style.color = this.styles.badgeForeground ?? '';
+        if (this.styles.badgeBorder) {
+            this.element.style.border = `1px solid ${this.styles.badgeBorder}`;
+        }
+    }
+}
+export { CountBadge };

package/vscode/src/vs/base/browser/ui/dialog/dialog.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-dialog-modal-block{align-items:center;display:flex;height:100%;justify-content:center;left:0;position:fixed;top:0;width:100%;z-index:2600}.monaco-dialog-modal-block.dimmed{background:rgba(0,0,0,.3)}.monaco-dialog-box{display:flex;flex-direction:column-reverse;max-width:90vw;min-height:75px;min-width:500px;padding:10px;transform:translateZ(0);width:min-content}.monaco-dialog-box .dialog-toolbar-row{height:22px;padding-bottom:4px}.monaco-dialog-box .dialog-toolbar-row .actions-container{justify-content:flex-end}.monaco-dialog-box .dialog-message-row{align-items:center;display:flex;flex-grow:1;padding:0 10px}.monaco-dialog-box .dialog-message-row>.dialog-icon.codicon{align-self:baseline;flex:0 0 48px;font-size:48px;height:48px}.monaco-dialog-box .dialog-message-row .dialog-message-container{word-wrap:break-word;display:flex;flex-direction:column;overflow:hidden;padding-left:24px;text-overflow:ellipsis;user-select:text;-webkit-user-select:text;white-space:normal}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message{word-wrap:break-word;align-items:center;display:flex;flex:1;font-size:18px;line-height:22px;margin-bottom:8px;min-height:48px;white-space:normal}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-detail{flex:1;line-height:22px}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message a:focus{outline-style:solid;outline-width:1px}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-checkbox-row{display:flex;padding:15px 0 0}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-checkbox-row .dialog-checkbox-message{cursor:pointer;user-select:none;-webkit-user-select:none}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-input{display:flex;padding:15px 0 0}.monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-input .monaco-inputbox{flex:1}.monaco-dialog-box code{font-family:var(--monaco-monospace-font)}.monaco-dialog-box>.dialog-buttons-row{align-items:center;display:flex;overflow:hidden;padding-right:1px;padding:20px 10px 10px;white-space:nowrap}.monaco-dialog-box>.dialog-buttons-row>.dialog-buttons{display:flex;justify-content:flex-end;margin-left:67px;overflow:hidden;width:100%}.monaco-dialog-box>.dialog-buttons-row>.dialog-buttons>.monaco-button{margin:4px 5px;outline-offset:2px!important;overflow:hidden;padding:5px 10px;text-overflow:ellipsis;width:fit-content}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/base/browser/ui/dialog/dialog.js

@@ -0,0 +1,355 @@
+import { $, hide, addDisposableListener, EventType, clearNode, EventHelper, getWindow, isAncestor, show, isActiveElement } from '../../dom.js';
+import { StandardKeyboardEvent } from '../../keyboardEvent.js';
+import { ActionBar } from '../actionbar/actionbar.js';
+import { ButtonBar, ButtonWithDescription } from '../button/button.js';
+import { Checkbox } from '../toggle/toggle.js';
+import { InputBox } from '../inputbox/inputBox.js';
+import { Action } from '../../../common/actions.js';
+import { Codicon } from '../../../common/codicons.js';
+import { ThemeIcon } from '../../../common/themables.js';
+import { mnemonicButtonLabel } from '../../../common/labels.js';
+import { Disposable } from '../../../common/lifecycle.js';
+import { isMacintosh, isLinux, isWindows } from '../../../common/platform.js';
+import './dialog.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+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);
+        this.buttonStyles = options.buttonStyles;
+        if (Array.isArray(buttons) && buttons.length > 0) {
+            this.buttons = buttons;
+        }
+        else if (!this.options.disableDefaultAction) {
+            this.buttons = [( localizeWithPath('vs/base/browser/ui/dialog/dialog', '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',
+                    inputBoxStyles: options.inputBoxStyles
+                })));
+                if (input.value) {
+                    inputBox.value = input.value;
+                }
+                return inputBox;
+            }));
+        }
+        else {
+            this.inputs = [];
+        }
+        if (this.options.checkboxLabel) {
+            const checkboxRowElement = this.messageContainer.appendChild($('.dialog-checkbox-row'));
+            const checkbox = this.checkbox = this._register(( new Checkbox(
+                this.options.checkboxLabel,
+                !!this.options.checkboxChecked,
+                options.checkboxStyles
+            )));
+            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'));
+        this.applyStyles();
+    }
+    getIconAriaLabel() {
+        let typeLabel = ( localizeWithPath('vs/base/browser/ui/dialog/dialog', 'dialogInfoMessage', 'Info'));
+        switch (this.options.type) {
+            case 'error':
+                typeLabel = ( localizeWithPath('vs/base/browser/ui/dialog/dialog', 'dialogErrorMessage', 'Error'));
+                break;
+            case 'warning':
+                typeLabel = ( localizeWithPath('vs/base/browser/ui/dialog/dialog', 'dialogWarningMessage', 'Warning'));
+                break;
+            case 'pending':
+                typeLabel = ( localizeWithPath('vs/base/browser/ui/dialog/dialog', 'dialogPendingMessage', 'In Progress'));
+                break;
+        }
+        return typeLabel;
+    }
+    updateMessage(message) {
+        this.messageDetailElement.innerText = message;
+    }
+    async show() {
+        this.focusToReturn = this.container.ownerDocument.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.buttonStyles })) : this._register(buttonBar.addButton({ title: true, secondary: !primary, ...this.buttonStyles }));
+                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
+                    });
+                }));
+            });
+            const window = getWindow(this.container);
+            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 (isActiveElement(link)) {
+                                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(...ThemeIcon.asClassNameArray(Codicon.dialogError), ...ThemeIcon.asClassNameArray(Codicon.dialogWarning), ...ThemeIcon.asClassNameArray(Codicon.dialogInfo), ...ThemeIcon.asClassNameArray(Codicon.loading), spinModifierClassName);
+            if (this.options.icon) {
+                this.iconElement.classList.add(...ThemeIcon.asClassNameArray(this.options.icon));
+            }
+            else {
+                switch (this.options.type) {
+                    case 'error':
+                        this.iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.dialogError));
+                        break;
+                    case 'warning':
+                        this.iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.dialogWarning));
+                        break;
+                    case 'pending':
+                        this.iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.loading), spinModifierClassName);
+                        break;
+                    case 'none':
+                        this.iconElement.classList.add('no-codicon');
+                        break;
+                    case 'info':
+                    case 'question':
+                    default:
+                        this.iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.dialogInfo));
+                        break;
+                }
+            }
+            if (!this.options.disableCloseAction) {
+                const actionBar = this._register(( new ActionBar(this.toolbarContainer, {})));
+                const action = this._register(( new Action('dialog.close', ( localizeWithPath('vs/base/browser/ui/dialog/dialog', 'dialogClose', "Close Dialog")), ThemeIcon.asClassName(Codicon.dialogClose), 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() {
+        const style = this.options.dialogStyles;
+        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 ?? '';
+        this.element.style.backgroundColor = bgColor ?? '';
+        this.element.style.border = border;
+        if (linkFgColor) {
+            for (const el of this.messageContainer.getElementsByTagName('a')) {
+                el.style.color = linkFgColor;
+            }
+        }
+        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;
+        }
+    }
+    dispose() {
+        super.dispose();
+        if (this.modalElement) {
+            this.modalElement.remove();
+            this.modalElement = undefined;
+        }
+        if (this.focusToReturn && isAncestor(this.focusToReturn, this.container.ownerDocument.body)) {
+            this.focusToReturn.focus();
+            this.focusToReturn = undefined;
+        }
+    }
+    rearrangeButtons(buttons, cancelId) {
+        const buttonMap = ( buttons.map((label, index) => ({ label, index })));
+        if (buttons.length < 2) {
+            return buttonMap;
+        }
+        if (isMacintosh || isLinux) {
+            if (typeof cancelId === 'number' && buttonMap[cancelId]) {
+                const cancelButton = buttonMap.splice(cancelId, 1)[0];
+                buttonMap.splice(1, 0, cancelButton);
+            }
+            buttonMap.reverse();
+        }
+        else if (isWindows) {
+            if (typeof cancelId === 'number' && buttonMap[cancelId]) {
+                const cancelButton = buttonMap.splice(cancelId, 1)[0];
+                buttonMap.push(cancelButton);
+            }
+        }
+        return buttonMap;
+    }
+}
+export { Dialog };