monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/inputBox.js

@@ -0,0 +1,510 @@
+import { append, $ as $$1, getTotalHeight, isActiveElement, getTotalWidth } from '../../dom.js';
+import { asCssValueWithDefault } from '../../cssValue.js';
+import { DomEmitter } from '../../event.js';
+import { renderFormattedText, renderText } from '../../formattedTextRenderer.js';
+import { ActionBar } from '../actionbar/actionbar.js';
+import { status, alert } from '../aria/aria.js';
+import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
+import { ScrollableElement } from '../scrollbar/scrollableElement.js';
+import { Widget } from '../widget.js';
+import { Emitter, Event } from '../../../common/event.js';
+import { HistoryNavigator } from '../../../common/history.js';
+import { equals } from '../../../common/objects.js';
+import './inputBox.css';
+import { localize } from '../../../../nls.js';
+import { MutableDisposable } from '../../../common/lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const $ = $$1;
+class InputBox extends Widget {
+    get onDidChange() { return this._onDidChange.event; }
+    get onDidHeightChange() { return this._onDidHeightChange.event; }
+    constructor(container, contextViewProvider, options) {
+        super();
+        this.state = 'idle';
+        this.maxHeight = Number.POSITIVE_INFINITY;
+        this.hover = this._register(new MutableDisposable());
+        this._onDidChange = this._register(new Emitter());
+        this._onDidHeightChange = this._register(new Emitter());
+        this.contextViewProvider = contextViewProvider;
+        this.options = options;
+        this.message = null;
+        this.placeholder = this.options.placeholder || '';
+        this.tooltip = this.options.tooltip ?? (this.placeholder || '');
+        this.ariaLabel = this.options.ariaLabel || '';
+        if (this.options.validationOptions) {
+            this.validation = this.options.validationOptions.validation;
+        }
+        this.element = append(container, $('.monaco-inputbox.idle'));
+        const tagName = this.options.flexibleHeight ? 'textarea' : 'input';
+        const wrapper = append(this.element, $('.ibwrapper'));
+        this.input = append(wrapper, $(tagName + '.input.empty'));
+        this.input.setAttribute('autocorrect', 'off');
+        this.input.setAttribute('autocapitalize', 'off');
+        this.input.setAttribute('spellcheck', 'false');
+        this.onfocus(this.input, () => this.element.classList.add('synthetic-focus'));
+        this.onblur(this.input, () => this.element.classList.remove('synthetic-focus'));
+        if (this.options.flexibleHeight) {
+            this.maxHeight = typeof this.options.flexibleMaxHeight === 'number' ? this.options.flexibleMaxHeight : Number.POSITIVE_INFINITY;
+            this.mirror = append(wrapper, $('div.mirror'));
+            this.mirror.innerText = '\u00a0';
+            this.scrollableElement = new ScrollableElement(this.element, { vertical: 1 /* ScrollbarVisibility.Auto */ });
+            if (this.options.flexibleWidth) {
+                this.input.setAttribute('wrap', 'off');
+                this.mirror.style.whiteSpace = 'pre';
+                this.mirror.style.wordWrap = 'initial';
+            }
+            append(container, this.scrollableElement.getDomNode());
+            this._register(this.scrollableElement);
+            // from ScrollableElement to DOM
+            this._register(this.scrollableElement.onScroll(e => this.input.scrollTop = e.scrollTop));
+            const onSelectionChange = this._register(new DomEmitter(container.ownerDocument, 'selectionchange'));
+            const onAnchoredSelectionChange = Event.filter(onSelectionChange.event, () => {
+                const selection = container.ownerDocument.getSelection();
+                return selection?.anchorNode === wrapper;
+            });
+            // from DOM to ScrollableElement
+            this._register(onAnchoredSelectionChange(this.updateScrollDimensions, this));
+            this._register(this.onDidHeightChange(this.updateScrollDimensions, this));
+        }
+        else {
+            this.input.type = this.options.type || 'text';
+            this.input.setAttribute('wrap', 'off');
+        }
+        if (this.ariaLabel) {
+            this.input.setAttribute('aria-label', this.ariaLabel);
+        }
+        if (this.placeholder && !this.options.showPlaceholderOnFocus) {
+            this.setPlaceHolder(this.placeholder);
+        }
+        if (this.tooltip) {
+            this.setTooltip(this.tooltip);
+        }
+        this.oninput(this.input, () => this.onValueChange());
+        this.onblur(this.input, () => this.onBlur());
+        this.onfocus(this.input, () => this.onFocus());
+        this._register(this.ignoreGesture(this.input));
+        setTimeout(() => this.updateMirror(), 0);
+        // Support actions
+        if (this.options.actions) {
+            this.actionbar = this._register(new ActionBar(this.element));
+            this.actionbar.push(this.options.actions, { icon: true, label: false });
+        }
+        this.applyStyles();
+    }
+    onBlur() {
+        this._hideMessage();
+        if (this.options.showPlaceholderOnFocus) {
+            this.input.setAttribute('placeholder', '');
+        }
+    }
+    onFocus() {
+        this._showMessage();
+        if (this.options.showPlaceholderOnFocus) {
+            this.input.setAttribute('placeholder', this.placeholder || '');
+        }
+    }
+    setPlaceHolder(placeHolder) {
+        this.placeholder = placeHolder;
+        this.input.setAttribute('placeholder', placeHolder);
+    }
+    setTooltip(tooltip) {
+        this.tooltip = tooltip;
+        if (!this.hover.value) {
+            this.hover.value = this._register(getBaseLayerHoverDelegate().setupDelayedHoverAtMouse(this.input, () => ({
+                content: this.tooltip,
+                appearance: {
+                    compact: true,
+                }
+            })));
+        }
+    }
+    get inputElement() {
+        return this.input;
+    }
+    get value() {
+        return this.input.value;
+    }
+    set value(newValue) {
+        if (this.input.value !== newValue) {
+            this.input.value = newValue;
+            this.onValueChange();
+        }
+    }
+    get height() {
+        return typeof this.cachedHeight === 'number' ? this.cachedHeight : getTotalHeight(this.element);
+    }
+    focus() {
+        this.input.focus();
+    }
+    blur() {
+        this.input.blur();
+    }
+    hasFocus() {
+        return isActiveElement(this.input);
+    }
+    select(range = null) {
+        this.input.select();
+        if (range) {
+            this.input.setSelectionRange(range.start, range.end);
+            if (range.end === this.input.value.length) {
+                this.input.scrollLeft = this.input.scrollWidth;
+            }
+        }
+    }
+    isSelectionAtEnd() {
+        return this.input.selectionEnd === this.input.value.length && this.input.selectionStart === this.input.selectionEnd;
+    }
+    getSelection() {
+        const selectionStart = this.input.selectionStart;
+        if (selectionStart === null) {
+            return null;
+        }
+        const selectionEnd = this.input.selectionEnd ?? selectionStart;
+        return {
+            start: selectionStart,
+            end: selectionEnd,
+        };
+    }
+    enable() {
+        this.input.removeAttribute('disabled');
+    }
+    disable() {
+        this.blur();
+        this.input.disabled = true;
+        this._hideMessage();
+    }
+    set paddingRight(paddingRight) {
+        // Set width to avoid hint text overlapping buttons
+        this.input.style.width = `calc(100% - ${paddingRight}px)`;
+        if (this.mirror) {
+            this.mirror.style.paddingRight = paddingRight + 'px';
+        }
+    }
+    updateScrollDimensions() {
+        if (typeof this.cachedContentHeight !== 'number' || typeof this.cachedHeight !== 'number' || !this.scrollableElement) {
+            return;
+        }
+        const scrollHeight = this.cachedContentHeight;
+        const height = this.cachedHeight;
+        const scrollTop = this.input.scrollTop;
+        this.scrollableElement.setScrollDimensions({ scrollHeight, height });
+        this.scrollableElement.setScrollPosition({ scrollTop });
+    }
+    showMessage(message, force) {
+        if (this.state === 'open' && equals(this.message, message)) {
+            // Already showing
+            return;
+        }
+        this.message = message;
+        this.element.classList.remove('idle');
+        this.element.classList.remove('info');
+        this.element.classList.remove('warning');
+        this.element.classList.remove('error');
+        this.element.classList.add(this.classForType(message.type));
+        const styles = this.stylesForType(this.message.type);
+        this.element.style.border = `1px solid ${asCssValueWithDefault(styles.border, 'transparent')}`;
+        if (this.message.content && (this.hasFocus() || force)) {
+            this._showMessage();
+        }
+    }
+    hideMessage() {
+        this.message = null;
+        this.element.classList.remove('info');
+        this.element.classList.remove('warning');
+        this.element.classList.remove('error');
+        this.element.classList.add('idle');
+        this._hideMessage();
+        this.applyStyles();
+    }
+    validate() {
+        let errorMsg = null;
+        if (this.validation) {
+            errorMsg = this.validation(this.value);
+            if (errorMsg) {
+                this.inputElement.setAttribute('aria-invalid', 'true');
+                this.showMessage(errorMsg);
+            }
+            else if (this.inputElement.hasAttribute('aria-invalid')) {
+                this.inputElement.removeAttribute('aria-invalid');
+                this.hideMessage();
+            }
+        }
+        return errorMsg?.type;
+    }
+    stylesForType(type) {
+        const styles = this.options.inputBoxStyles;
+        switch (type) {
+            case 1 /* MessageType.INFO */: return { border: styles.inputValidationInfoBorder, background: styles.inputValidationInfoBackground, foreground: styles.inputValidationInfoForeground };
+            case 2 /* MessageType.WARNING */: return { border: styles.inputValidationWarningBorder, background: styles.inputValidationWarningBackground, foreground: styles.inputValidationWarningForeground };
+            default: return { border: styles.inputValidationErrorBorder, background: styles.inputValidationErrorBackground, foreground: styles.inputValidationErrorForeground };
+        }
+    }
+    classForType(type) {
+        switch (type) {
+            case 1 /* MessageType.INFO */: return 'info';
+            case 2 /* MessageType.WARNING */: return 'warning';
+            default: return 'error';
+        }
+    }
+    _showMessage() {
+        if (!this.contextViewProvider || !this.message) {
+            return;
+        }
+        let div;
+        const layout = () => div.style.width = getTotalWidth(this.element) + 'px';
+        this.contextViewProvider.showContextView({
+            getAnchor: () => this.element,
+            anchorAlignment: 1 /* AnchorAlignment.RIGHT */,
+            render: (container) => {
+                if (!this.message) {
+                    return null;
+                }
+                div = append(container, $('.monaco-inputbox-container'));
+                layout();
+                const spanElement = $('span.monaco-inputbox-message');
+                if (this.message.formatContent) {
+                    renderFormattedText(this.message.content, undefined, spanElement);
+                }
+                else {
+                    renderText(this.message.content, undefined, spanElement);
+                }
+                spanElement.classList.add(this.classForType(this.message.type));
+                const styles = this.stylesForType(this.message.type);
+                spanElement.style.backgroundColor = styles.background ?? '';
+                spanElement.style.color = styles.foreground ?? '';
+                spanElement.style.border = styles.border ? `1px solid ${styles.border}` : '';
+                append(div, spanElement);
+                return null;
+            },
+            onHide: () => {
+                this.state = 'closed';
+            },
+            layout: layout
+        });
+        // ARIA Support
+        let alertText;
+        if (this.message.type === 3 /* MessageType.ERROR */) {
+            alertText = localize(9, "Error: {0}", this.message.content);
+        }
+        else if (this.message.type === 2 /* MessageType.WARNING */) {
+            alertText = localize(10, "Warning: {0}", this.message.content);
+        }
+        else {
+            alertText = localize(11, "Info: {0}", this.message.content);
+        }
+        alert(alertText);
+        this.state = 'open';
+    }
+    _hideMessage() {
+        if (!this.contextViewProvider) {
+            return;
+        }
+        if (this.state === 'open') {
+            this.contextViewProvider.hideContextView();
+        }
+        this.state = 'idle';
+    }
+    onValueChange() {
+        this._onDidChange.fire(this.value);
+        this.validate();
+        this.updateMirror();
+        this.input.classList.toggle('empty', !this.value);
+        if (this.state === 'open' && this.contextViewProvider) {
+            this.contextViewProvider.layout();
+        }
+    }
+    updateMirror() {
+        if (!this.mirror) {
+            return;
+        }
+        const value = this.value;
+        const lastCharCode = value.charCodeAt(value.length - 1);
+        const suffix = lastCharCode === 10 ? ' ' : '';
+        const mirrorTextContent = (value + suffix)
+            .replace(/\u000c/g, ''); // Don't measure with the form feed character, which messes up sizing
+        if (mirrorTextContent) {
+            this.mirror.textContent = value + suffix;
+        }
+        else {
+            this.mirror.innerText = '\u00a0';
+        }
+        this.layout();
+    }
+    applyStyles() {
+        const styles = this.options.inputBoxStyles;
+        const background = styles.inputBackground ?? '';
+        const foreground = styles.inputForeground ?? '';
+        const border = styles.inputBorder ?? '';
+        this.element.style.backgroundColor = background;
+        this.element.style.color = foreground;
+        this.input.style.backgroundColor = 'inherit';
+        this.input.style.color = foreground;
+        // there's always a border, even if the color is not set.
+        this.element.style.border = `1px solid ${asCssValueWithDefault(border, 'transparent')}`;
+    }
+    layout() {
+        if (!this.mirror) {
+            return;
+        }
+        const previousHeight = this.cachedContentHeight;
+        this.cachedContentHeight = getTotalHeight(this.mirror);
+        if (previousHeight !== this.cachedContentHeight) {
+            this.cachedHeight = Math.min(this.cachedContentHeight, this.maxHeight);
+            this.input.style.height = this.cachedHeight + 'px';
+            this._onDidHeightChange.fire(this.cachedContentHeight);
+        }
+    }
+    insertAtCursor(text) {
+        const inputElement = this.inputElement;
+        const start = inputElement.selectionStart;
+        const end = inputElement.selectionEnd;
+        const content = inputElement.value;
+        if (start !== null && end !== null) {
+            this.value = content.substr(0, start) + text + content.substr(end);
+            inputElement.setSelectionRange(start + 1, start + 1);
+            this.layout();
+        }
+    }
+    dispose() {
+        this._hideMessage();
+        this.message = null;
+        this.actionbar?.dispose();
+        super.dispose();
+    }
+}
+class HistoryInputBox extends InputBox {
+    constructor(container, contextViewProvider, options) {
+        const NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_NO_PARENS = localize(12, ' or {0} for history', `\u21C5`);
+
+
+
+        const NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_IN_PARENS = localize(13, ' ({0} for history)', `\u21C5`);
+
+
+
+        super(container, contextViewProvider, options);
+        this._onDidFocus = this._register(new Emitter());
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(new Emitter());
+        this.onDidBlur = this._onDidBlur.event;
+        this.history = this._register(new HistoryNavigator(options.history, 100));
+        // Function to append the history suffix to the placeholder if necessary
+        const addSuffix = () => {
+            if (options.showHistoryHint && options.showHistoryHint() && !this.placeholder.endsWith(NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_NO_PARENS) && !this.placeholder.endsWith(NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_IN_PARENS) && this.history.getHistory().length) {
+                const suffix = this.placeholder.endsWith(')') ? NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_NO_PARENS : NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_IN_PARENS;
+                const suffixedPlaceholder = this.placeholder + suffix;
+                if (options.showPlaceholderOnFocus && !isActiveElement(this.input)) {
+                    this.placeholder = suffixedPlaceholder;
+                }
+                else {
+                    this.setPlaceHolder(suffixedPlaceholder);
+                }
+            }
+        };
+        // Spot the change to the textarea class attribute which occurs when it changes between non-empty and empty,
+        // and add the history suffix to the placeholder if not yet present
+        this.observer = new MutationObserver((mutationList, observer) => {
+            mutationList.forEach((mutation) => {
+                if (!mutation.target.textContent) {
+                    addSuffix();
+                }
+            });
+        });
+        this.observer.observe(this.input, { attributeFilter: ['class'] });
+        this.onfocus(this.input, () => addSuffix());
+        this.onblur(this.input, () => {
+            const resetPlaceholder = (historyHint) => {
+                if (!this.placeholder.endsWith(historyHint)) {
+                    return false;
+                }
+                else {
+                    const revertedPlaceholder = this.placeholder.slice(0, this.placeholder.length - historyHint.length);
+                    if (options.showPlaceholderOnFocus) {
+                        this.placeholder = revertedPlaceholder;
+                    }
+                    else {
+                        this.setPlaceHolder(revertedPlaceholder);
+                    }
+                    return true;
+                }
+            };
+            if (!resetPlaceholder(NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_IN_PARENS)) {
+                resetPlaceholder(NLS_PLACEHOLDER_HISTORY_HINT_SUFFIX_NO_PARENS);
+            }
+        });
+    }
+    dispose() {
+        super.dispose();
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = undefined;
+        }
+    }
+    addToHistory(always) {
+        if (this.value && (always || this.value !== this.getCurrentValue())) {
+            this.history.add(this.value);
+        }
+    }
+    isAtLastInHistory() {
+        return this.history.isLast();
+    }
+    isNowhereInHistory() {
+        return this.history.isNowhere();
+    }
+    showNextValue() {
+        if (!this.history.has(this.value)) {
+            this.addToHistory();
+        }
+        let next = this.getNextValue();
+        if (next) {
+            next = next === this.value ? this.getNextValue() : next;
+        }
+        this.value = next ?? '';
+        status(this.value ? this.value : localize(14, "Cleared Input"));
+    }
+    showPreviousValue() {
+        if (!this.history.has(this.value)) {
+            this.addToHistory();
+        }
+        let previous = this.getPreviousValue();
+        if (previous) {
+            previous = previous === this.value ? this.getPreviousValue() : previous;
+        }
+        if (previous) {
+            this.value = previous;
+            status(this.value);
+        }
+    }
+    setPlaceHolder(placeHolder) {
+        super.setPlaceHolder(placeHolder);
+        this.setTooltip(placeHolder);
+    }
+    onBlur() {
+        super.onBlur();
+        this._onDidBlur.fire();
+    }
+    onFocus() {
+        super.onFocus();
+        this._onDidFocus.fire();
+    }
+    getCurrentValue() {
+        let currentValue = this.history.current();
+        if (!currentValue) {
+            currentValue = this.history.last();
+            this.history.next();
+        }
+        return currentValue;
+    }
+    getPreviousValue() {
+        return this.history.previous() || this.history.first();
+    }
+    getNextValue() {
+        return this.history.next();
+    }
+}
+
+export { HistoryInputBox, InputBox };

package/dist/workers/inputColors.js

@@ -0,0 +1,66 @@
+import { localize } from '../../../../nls.js';
+import { Color, RGBA } from '../../../../base/common/color.js';
+import { registerColor, transparent, darken, lighten } from '../colorUtils.js';
+import { foreground, contrastBorder, focusBorder, iconForeground } from './baseColors.js';
+import { editorWidgetBackground } from './editorColors.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// ----- input
+const inputBackground = registerColor('input.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, localize(1893, "Input box background."));
+const inputForeground = registerColor('input.foreground', foreground, localize(1894, "Input box foreground."));
+const inputBorder = registerColor('input.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1895, "Input box border."));
+const inputActiveOptionBorder = registerColor('inputOption.activeBorder', { dark: '#007ACC', light: '#007ACC', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1896, "Border color of activated options in input fields."));
+const inputActiveOptionHoverBackground = registerColor('inputOption.hoverBackground', { dark: '#5a5d5e80', light: '#b8b8b850', hcDark: null, hcLight: null }, localize(1897, "Background color of activated options in input fields."));
+const inputActiveOptionBackground = registerColor('inputOption.activeBackground', { dark: transparent(focusBorder, 0.4), light: transparent(focusBorder, 0.2), hcDark: Color.transparent, hcLight: Color.transparent }, localize(1898, "Background hover color of options in input fields."));
+const inputActiveOptionForeground = registerColor('inputOption.activeForeground', { dark: Color.white, light: Color.black, hcDark: foreground, hcLight: foreground }, localize(1899, "Foreground color of activated options in input fields."));
+registerColor('input.placeholderForeground', { light: transparent(foreground, 0.5), dark: transparent(foreground, 0.5), hcDark: transparent(foreground, 0.7), hcLight: transparent(foreground, 0.7) }, localize(1900, "Input box foreground color for placeholder text."));
+// ----- input validation
+const inputValidationInfoBackground = registerColor('inputValidation.infoBackground', { dark: '#063B49', light: '#D6ECF2', hcDark: Color.black, hcLight: Color.white }, localize(1901, "Input validation background color for information severity."));
+const inputValidationInfoForeground = registerColor('inputValidation.infoForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1902, "Input validation foreground color for information severity."));
+const inputValidationInfoBorder = registerColor('inputValidation.infoBorder', { dark: '#007acc', light: '#007acc', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1903, "Input validation border color for information severity."));
+const inputValidationWarningBackground = registerColor('inputValidation.warningBackground', { dark: '#352A05', light: '#F6F5D2', hcDark: Color.black, hcLight: Color.white }, localize(1904, "Input validation background color for warning severity."));
+const inputValidationWarningForeground = registerColor('inputValidation.warningForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1905, "Input validation foreground color for warning severity."));
+const inputValidationWarningBorder = registerColor('inputValidation.warningBorder', { dark: '#B89500', light: '#B89500', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1906, "Input validation border color for warning severity."));
+const inputValidationErrorBackground = registerColor('inputValidation.errorBackground', { dark: '#5A1D1D', light: '#F2DEDE', hcDark: Color.black, hcLight: Color.white }, localize(1907, "Input validation background color for error severity."));
+const inputValidationErrorForeground = registerColor('inputValidation.errorForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1908, "Input validation foreground color for error severity."));
+const inputValidationErrorBorder = registerColor('inputValidation.errorBorder', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1909, "Input validation border color for error severity."));
+// ----- select
+const selectBackground = registerColor('dropdown.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, localize(1910, "Dropdown background."));
+const selectListBackground = registerColor('dropdown.listBackground', { dark: null, light: null, hcDark: Color.black, hcLight: Color.white }, localize(1911, "Dropdown list background."));
+const selectForeground = registerColor('dropdown.foreground', { dark: '#F0F0F0', light: foreground, hcDark: Color.white, hcLight: foreground }, localize(1912, "Dropdown foreground."));
+const selectBorder = registerColor('dropdown.border', { dark: selectBackground, light: '#CECECE', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1913, "Dropdown border."));
+// ------ button
+const buttonForeground = registerColor('button.foreground', Color.white, localize(1914, "Button foreground color."));
+const buttonSeparator = registerColor('button.separator', transparent(buttonForeground, .4), localize(1915, "Button separator color."));
+const buttonBackground = registerColor('button.background', { dark: '#0E639C', light: '#007ACC', hcDark: Color.black, hcLight: '#0F4A85' }, localize(1916, "Button background color."));
+const buttonHoverBackground = registerColor('button.hoverBackground', { dark: lighten(buttonBackground, 0.2), light: darken(buttonBackground, 0.2), hcDark: buttonBackground, hcLight: buttonBackground }, localize(1917, "Button background color when hovering."));
+const buttonBorder = registerColor('button.border', contrastBorder, localize(1918, "Button border color."));
+const buttonSecondaryForeground = registerColor('button.secondaryForeground', { dark: Color.white, light: Color.white, hcDark: Color.white, hcLight: foreground }, localize(1919, "Secondary button foreground color."));
+const buttonSecondaryBackground = registerColor('button.secondaryBackground', { dark: '#3A3D41', light: '#5F6A79', hcDark: null, hcLight: Color.white }, localize(1920, "Secondary button background color."));
+const buttonSecondaryHoverBackground = registerColor('button.secondaryHoverBackground', { dark: lighten(buttonSecondaryBackground, 0.2), light: darken(buttonSecondaryBackground, 0.2), hcDark: null, hcLight: null }, localize(1921, "Secondary button background color when hovering."));
+// ------ radio
+const radioActiveForeground = registerColor('radio.activeForeground', inputActiveOptionForeground, localize(1922, "Foreground color of active radio option."));
+const radioActiveBackground = registerColor('radio.activeBackground', inputActiveOptionBackground, localize(1923, "Background color of active radio option."));
+const radioActiveBorder = registerColor('radio.activeBorder', inputActiveOptionBorder, localize(1924, "Border color of the active radio option."));
+const radioInactiveForeground = registerColor('radio.inactiveForeground', null, localize(1925, "Foreground color of inactive radio option."));
+const radioInactiveBackground = registerColor('radio.inactiveBackground', null, localize(1926, "Background color of inactive radio option."));
+const radioInactiveBorder = registerColor('radio.inactiveBorder', { light: transparent(radioActiveForeground, .2), dark: transparent(radioActiveForeground, .2), hcDark: transparent(radioActiveForeground, .4), hcLight: transparent(radioActiveForeground, .2) }, localize(1927, "Border color of the inactive radio option."));
+const radioInactiveHoverBackground = registerColor('radio.inactiveHoverBackground', inputActiveOptionHoverBackground, localize(1928, "Background color of inactive active radio option when hovering."));
+// ------ checkbox
+const checkboxBackground = registerColor('checkbox.background', selectBackground, localize(1929, "Background color of checkbox widget."));
+registerColor('checkbox.selectBackground', editorWidgetBackground, localize(1930, "Background color of checkbox widget when the element it's in is selected."));
+const checkboxForeground = registerColor('checkbox.foreground', selectForeground, localize(1931, "Foreground color of checkbox widget."));
+const checkboxBorder = registerColor('checkbox.border', selectBorder, localize(1932, "Border color of checkbox widget."));
+registerColor('checkbox.selectBorder', iconForeground, localize(1933, "Border color of checkbox widget when the element it's in is selected."));
+const checkboxDisabledBackground = registerColor('checkbox.disabled.background', { op: 7 /* ColorTransformType.Mix */, color: checkboxBackground, with: checkboxForeground, ratio: 0.33 }, localize(1934, "Background of a disabled checkbox."));
+const checkboxDisabledForeground = registerColor('checkbox.disabled.foreground', { op: 7 /* ColorTransformType.Mix */, color: checkboxForeground, with: checkboxBackground, ratio: 0.33 }, localize(1935, "Foreground of a disabled checkbox."));
+// ------ keybinding label
+const keybindingLabelBackground = registerColor('keybindingLabel.background', { dark: new Color(new RGBA(128, 128, 128, 0.17)), light: new Color(new RGBA(221, 221, 221, 0.4)), hcDark: Color.transparent, hcLight: Color.transparent }, localize(1936, "Keybinding label background color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelForeground = registerColor('keybindingLabel.foreground', { dark: Color.fromHex('#CCCCCC'), light: Color.fromHex('#555555'), hcDark: Color.white, hcLight: foreground }, localize(1937, "Keybinding label foreground color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelBorder = registerColor('keybindingLabel.border', { dark: new Color(new RGBA(51, 51, 51, 0.6)), light: new Color(new RGBA(204, 204, 204, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: contrastBorder }, localize(1938, "Keybinding label border color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelBottomBorder = registerColor('keybindingLabel.bottomBorder', { dark: new Color(new RGBA(68, 68, 68, 0.6)), light: new Color(new RGBA(187, 187, 187, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: foreground }, localize(1939, "Keybinding label border bottom color. The keybinding label is used to represent a keyboard shortcut."));
+
+export { buttonBackground, buttonBorder, buttonForeground, buttonHoverBackground, buttonSecondaryBackground, buttonSecondaryForeground, buttonSecondaryHoverBackground, buttonSeparator, checkboxBackground, checkboxBorder, checkboxDisabledBackground, checkboxDisabledForeground, checkboxForeground, inputActiveOptionBackground, inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionHoverBackground, inputBackground, inputBorder, inputForeground, inputValidationErrorBackground, inputValidationErrorBorder, inputValidationErrorForeground, inputValidationInfoBackground, inputValidationInfoBorder, inputValidationInfoForeground, inputValidationWarningBackground, inputValidationWarningBorder, inputValidationWarningForeground, keybindingLabelBackground, keybindingLabelBorder, keybindingLabelBottomBorder, keybindingLabelForeground, radioActiveBackground, radioActiveBorder, radioActiveForeground, radioInactiveBackground, radioInactiveBorder, radioInactiveForeground, radioInactiveHoverBackground, selectBackground, selectBorder, selectForeground, selectListBackground };

package/dist/workers/inputMode.js

@@ -0,0 +1,22 @@
+import { Emitter } from '../../base/common/event.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class InputModeImpl {
+    constructor() {
+        this._inputMode = 'insert';
+        this._onDidChangeInputMode = new Emitter();
+        this.onDidChangeInputMode = this._onDidChangeInputMode.event;
+    }
+    getInputMode() {
+        return this._inputMode;
+    }
+}
+/**
+ * Controls the type mode, whether insert or overtype
+ */
+const InputMode = new InputModeImpl();
+
+export { InputMode };

package/dist/workers/insertFinalNewLine.js

@@ -0,0 +1,32 @@
+import { EditorAction, registerEditorAction } from '../../../browser/editorExtensions.js';
+import { InsertFinalNewLineCommand } from './insertFinalNewLineCommand.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { localize2 } from '../../../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class InsertFinalNewLineAction extends EditorAction {
+    static { this.ID = 'editor.action.insertFinalNewLine'; }
+    constructor() {
+        super({
+            id: InsertFinalNewLineAction.ID,
+            label: localize2(1242, "Insert Final New Line"),
+            precondition: EditorContextKeys.writable
+        });
+    }
+    run(_accessor, editor, args) {
+        const selection = editor.getSelection();
+        if (selection === null) {
+            return;
+        }
+        const command = new InsertFinalNewLineCommand(selection);
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, [command]);
+        editor.pushUndoStop();
+    }
+}
+registerEditorAction(InsertFinalNewLineAction);
+
+export { InsertFinalNewLineAction };