@umbraco-cms/backoffice 15.3.1 → 15.4.0-rc2

package/dist-cms/monaco-editor/vs/base/browser/ui/dropdown/dropdown.js

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { $, addDisposableListener, append, EventHelper, EventType, isMouseEvent } from '../../dom.js';
+import { StandardKeyboardEvent } from '../../keyboardEvent.js';
+import { EventType as GestureEventType, Gesture } from '../../touch.js';
+import { ActionRunner } from '../../../common/actions.js';
+import { Emitter } from '../../../common/event.js';
+import './dropdown.css';
+class BaseDropdown extends ActionRunner {
+    constructor(container, options) {
+        super();
+        this._onDidChangeVisibility = this._register(new Emitter());
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._element = append(container, $('.monaco-dropdown'));
+        this._label = append(this._element, $('.dropdown-label'));
+        let labelRenderer = options.labelRenderer;
+        if (!labelRenderer) {
+            labelRenderer = (container) => {
+                container.textContent = options.label || '';
+                return null;
+            };
+        }
+        for (const event of [EventType.CLICK, EventType.MOUSE_DOWN, GestureEventType.Tap]) {
+            this._register(addDisposableListener(this.element, event, e => EventHelper.stop(e, true))); // prevent default click behaviour to trigger
+        }
+        for (const event of [EventType.MOUSE_DOWN, GestureEventType.Tap]) {
+            this._register(addDisposableListener(this._label, event, e => {
+                if (isMouseEvent(e) && (e.detail > 1 || e.button !== 0)) {
+                    // prevent right click trigger to allow separate context menu (https://github.com/microsoft/vscode/issues/151064)
+                    // prevent multiple clicks to open multiple context menus (https://github.com/microsoft/vscode/issues/41363)
+                    return;
+                }
+                if (this.visible) {
+                    this.hide();
+                }
+                else {
+                    this.show();
+                }
+            }));
+        }
+        this._register(addDisposableListener(this._label, EventType.KEY_UP, e => {
+            const event = new StandardKeyboardEvent(e);
+            if (event.equals(3 /* KeyCode.Enter */) || event.equals(10 /* KeyCode.Space */)) {
+                EventHelper.stop(e, true); // https://github.com/microsoft/vscode/issues/57997
+                if (this.visible) {
+                    this.hide();
+                }
+                else {
+                    this.show();
+                }
+            }
+        }));
+        const cleanupFn = labelRenderer(this._label);
+        if (cleanupFn) {
+            this._register(cleanupFn);
+        }
+        this._register(Gesture.addTarget(this._label));
+    }
+    get element() {
+        return this._element;
+    }
+    show() {
+        if (!this.visible) {
+            this.visible = true;
+            this._onDidChangeVisibility.fire(true);
+        }
+    }
+    hide() {
+        if (this.visible) {
+            this.visible = false;
+            this._onDidChangeVisibility.fire(false);
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.hide();
+        if (this.boxContainer) {
+            this.boxContainer.remove();
+            this.boxContainer = undefined;
+        }
+        if (this.contents) {
+            this.contents.remove();
+            this.contents = undefined;
+        }
+        if (this._label) {
+            this._label.remove();
+            this._label = undefined;
+        }
+    }
+}
+export class DropdownMenu extends BaseDropdown {
+    constructor(container, _options) {
+        super(container, _options);
+        this._options = _options;
+        this._actions = [];
+        this.actions = _options.actions || [];
+    }
+    set menuOptions(options) {
+        this._menuOptions = options;
+    }
+    get menuOptions() {
+        return this._menuOptions;
+    }
+    get actions() {
+        if (this._options.actionProvider) {
+            return this._options.actionProvider.getActions();
+        }
+        return this._actions;
+    }
+    set actions(actions) {
+        this._actions = actions;
+    }
+    show() {
+        super.show();
+        this.element.classList.add('active');
+        this._options.contextMenuProvider.showContextMenu({
+            getAnchor: () => this.element,
+            getActions: () => this.actions,
+            getActionsContext: () => this.menuOptions ? this.menuOptions.context : null,
+            getActionViewItem: (action, options) => this.menuOptions && this.menuOptions.actionViewItemProvider ? this.menuOptions.actionViewItemProvider(action, options) : undefined,
+            getKeyBinding: action => this.menuOptions && this.menuOptions.getKeyBinding ? this.menuOptions.getKeyBinding(action) : undefined,
+            getMenuClassName: () => this._options.menuClassName || '',
+            onHide: () => this.onHide(),
+            actionRunner: this.menuOptions ? this.menuOptions.actionRunner : undefined,
+            anchorAlignment: this.menuOptions ? this.menuOptions.anchorAlignment : 0 /* AnchorAlignment.LEFT */,
+            domForShadowRoot: this._options.menuAsChild ? this.element : undefined,
+            skipTelemetry: this._options.skipTelemetry
+        });
+    }
+    hide() {
+        super.hide();
+    }
+    onHide() {
+        this.hide();
+        this.element.classList.remove('active');
+    }
+}

package/dist-cms/monaco-editor/vs/base/browser/ui/dropdown/dropdownActionViewItem.js

@@ -0,0 +1,107 @@
+import { $, append } from '../../dom.js';
+import { BaseActionViewItem } from '../actionbar/actionViewItems.js';
+import { DropdownMenu } from './dropdown.js';
+import { Emitter } from '../../../common/event.js';
+import './dropdown.css';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
+import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
+export class DropdownMenuActionViewItem extends BaseActionViewItem {
+    constructor(action, menuActionsOrProvider, contextMenuProvider, options = Object.create(null)) {
+        super(null, action, options);
+        this.actionItem = null;
+        this._onDidChangeVisibility = this._register(new Emitter());
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this.menuActionsOrProvider = menuActionsOrProvider;
+        this.contextMenuProvider = contextMenuProvider;
+        this.options = options;
+        if (this.options.actionRunner) {
+            this.actionRunner = this.options.actionRunner;
+        }
+    }
+    render(container) {
+        this.actionItem = container;
+        const labelRenderer = (el) => {
+            this.element = append(el, $('a.action-label'));
+            let classNames = [];
+            if (typeof this.options.classNames === 'string') {
+                classNames = this.options.classNames.split(/\s+/g).filter(s => !!s);
+            }
+            else if (this.options.classNames) {
+                classNames = this.options.classNames;
+            }
+            // todo@aeschli: remove codicon, should come through `this.options.classNames`
+            if (!classNames.find(c => c === 'icon')) {
+                classNames.push('codicon');
+            }
+            this.element.classList.add(...classNames);
+            this.element.setAttribute('role', 'button');
+            this.element.setAttribute('aria-haspopup', 'true');
+            this.element.setAttribute('aria-expanded', 'false');
+            if (this._action.label) {
+                this._register(getBaseLayerHoverDelegate().setupManagedHover(this.options.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.element, this._action.label));
+            }
+            this.element.ariaLabel = this._action.label || '';
+            return null;
+        };
+        const isActionsArray = Array.isArray(this.menuActionsOrProvider);
+        const options = {
+            contextMenuProvider: this.contextMenuProvider,
+            labelRenderer: labelRenderer,
+            menuAsChild: this.options.menuAsChild,
+            actions: isActionsArray ? this.menuActionsOrProvider : undefined,
+            actionProvider: isActionsArray ? undefined : this.menuActionsOrProvider,
+            skipTelemetry: this.options.skipTelemetry
+        };
+        this.dropdownMenu = this._register(new DropdownMenu(container, options));
+        this._register(this.dropdownMenu.onDidChangeVisibility(visible => {
+            this.element?.setAttribute('aria-expanded', `${visible}`);
+            this._onDidChangeVisibility.fire(visible);
+        }));
+        this.dropdownMenu.menuOptions = {
+            actionViewItemProvider: this.options.actionViewItemProvider,
+            actionRunner: this.actionRunner,
+            getKeyBinding: this.options.keybindingProvider,
+            context: this._context
+        };
+        if (this.options.anchorAlignmentProvider) {
+            const that = this;
+            this.dropdownMenu.menuOptions = {
+                ...this.dropdownMenu.menuOptions,
+                get anchorAlignment() {
+                    return that.options.anchorAlignmentProvider();
+                }
+            };
+        }
+        this.updateTooltip();
+        this.updateEnabled();
+    }
+    getTooltip() {
+        let title = null;
+        if (this.action.tooltip) {
+            title = this.action.tooltip;
+        }
+        else if (this.action.label) {
+            title = this.action.label;
+        }
+        return title ?? undefined;
+    }
+    setActionContext(newContext) {
+        super.setActionContext(newContext);
+        if (this.dropdownMenu) {
+            if (this.dropdownMenu.menuOptions) {
+                this.dropdownMenu.menuOptions.context = newContext;
+            }
+            else {
+                this.dropdownMenu.menuOptions = { context: newContext };
+            }
+        }
+    }
+    show() {
+        this.dropdownMenu?.show();
+    }
+    updateEnabled() {
+        const disabled = !this.action.enabled;
+        this.actionItem?.classList.toggle('disabled', disabled);
+        this.element?.classList.toggle('disabled', disabled);
+    }
+}

package/dist-cms/monaco-editor/vs/base/browser/ui/findinput/findInput.css

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/* ---------- Find input ---------- */
+
+.monaco-findInput {
+	position: relative;
+}
+
+.monaco-findInput .monaco-inputbox {
+	font-size: 13px;
+	width: 100%;
+}
+
+.monaco-findInput > .controls {
+	position: absolute;
+	top: 3px;
+	right: 2px;
+}
+
+.vs .monaco-findInput.disabled {
+	background-color: #E1E1E1;
+}
+
+/* Theming */
+.vs-dark .monaco-findInput.disabled {
+	background-color: #333;
+}
+
+/* Highlighting */
+.monaco-findInput.highlight-0 .controls,
+.hc-light .monaco-findInput.highlight-0 .controls {
+	animation: monaco-findInput-highlight-0 100ms linear 0s;
+}
+
+.monaco-findInput.highlight-1 .controls,
+.hc-light .monaco-findInput.highlight-1 .controls {
+	animation: monaco-findInput-highlight-1 100ms linear 0s;
+}
+
+.hc-black .monaco-findInput.highlight-0 .controls,
+.vs-dark  .monaco-findInput.highlight-0 .controls {
+	animation: monaco-findInput-highlight-dark-0 100ms linear 0s;
+}
+
+.hc-black .monaco-findInput.highlight-1 .controls,
+.vs-dark  .monaco-findInput.highlight-1 .controls {
+	animation: monaco-findInput-highlight-dark-1 100ms linear 0s;
+}
+
+@keyframes monaco-findInput-highlight-0 {
+	0% { background: rgba(253, 255, 0, 0.8); }
+	100% { background: transparent; }
+}
+@keyframes monaco-findInput-highlight-1 {
+	0% { background: rgba(253, 255, 0, 0.8); }
+	/* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/
+	99% { background: transparent; }
+}
+
+@keyframes monaco-findInput-highlight-dark-0 {
+	0% { background: rgba(255, 255, 255, 0.44); }
+	100% { background: transparent; }
+}
+@keyframes monaco-findInput-highlight-dark-1 {
+	0% { background: rgba(255, 255, 255, 0.44); }
+	/* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/
+	99% { background: transparent; }
+}

package/dist-cms/monaco-editor/vs/base/browser/ui/findinput/findInput.js

@@ -0,0 +1,293 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as dom from '../../dom.js';
+import { CaseSensitiveToggle, RegexToggle, WholeWordsToggle } from './findInputToggles.js';
+import { HistoryInputBox } from '../inputbox/inputBox.js';
+import { Widget } from '../widget.js';
+import { Emitter } from '../../../common/event.js';
+import './findInput.css';
+import * as nls from '../../../../nls.js';
+import { DisposableStore, MutableDisposable } from '../../../common/lifecycle.js';
+import { createInstantHoverDelegate } from '../hover/hoverDelegateFactory.js';
+const NLS_DEFAULT_LABEL = nls.localize('defaultLabel', "input");
+export class FindInput extends Widget {
+    constructor(parent, contextViewProvider, options) {
+        super();
+        this.fixFocusOnOptionClickEnabled = true;
+        this.imeSessionInProgress = false;
+        this.additionalTogglesDisposables = this._register(new MutableDisposable());
+        this.additionalToggles = [];
+        this._onDidOptionChange = this._register(new Emitter());
+        this.onDidOptionChange = this._onDidOptionChange.event;
+        this._onKeyDown = this._register(new Emitter());
+        this.onKeyDown = this._onKeyDown.event;
+        this._onMouseDown = this._register(new Emitter());
+        this.onMouseDown = this._onMouseDown.event;
+        this._onInput = this._register(new Emitter());
+        this._onKeyUp = this._register(new Emitter());
+        this._onCaseSensitiveKeyDown = this._register(new Emitter());
+        this.onCaseSensitiveKeyDown = this._onCaseSensitiveKeyDown.event;
+        this._onRegexKeyDown = this._register(new Emitter());
+        this.onRegexKeyDown = this._onRegexKeyDown.event;
+        this._lastHighlightFindOptions = 0;
+        this.placeholder = options.placeholder || '';
+        this.validation = options.validation;
+        this.label = options.label || NLS_DEFAULT_LABEL;
+        this.showCommonFindToggles = !!options.showCommonFindToggles;
+        const appendCaseSensitiveLabel = options.appendCaseSensitiveLabel || '';
+        const appendWholeWordsLabel = options.appendWholeWordsLabel || '';
+        const appendRegexLabel = options.appendRegexLabel || '';
+        const history = options.history || [];
+        const flexibleHeight = !!options.flexibleHeight;
+        const flexibleWidth = !!options.flexibleWidth;
+        const flexibleMaxHeight = options.flexibleMaxHeight;
+        this.domNode = document.createElement('div');
+        this.domNode.classList.add('monaco-findInput');
+        this.inputBox = this._register(new HistoryInputBox(this.domNode, contextViewProvider, {
+            placeholder: this.placeholder || '',
+            ariaLabel: this.label || '',
+            validationOptions: {
+                validation: this.validation
+            },
+            history,
+            showHistoryHint: options.showHistoryHint,
+            flexibleHeight,
+            flexibleWidth,
+            flexibleMaxHeight,
+            inputBoxStyles: options.inputBoxStyles,
+        }));
+        const hoverDelegate = this._register(createInstantHoverDelegate());
+        if (this.showCommonFindToggles) {
+            this.regex = this._register(new RegexToggle({
+                appendTitle: appendRegexLabel,
+                isChecked: false,
+                hoverDelegate,
+                ...options.toggleStyles
+            }));
+            this._register(this.regex.onChange(viaKeyboard => {
+                this._onDidOptionChange.fire(viaKeyboard);
+                if (!viaKeyboard && this.fixFocusOnOptionClickEnabled) {
+                    this.inputBox.focus();
+                }
+                this.validate();
+            }));
+            this._register(this.regex.onKeyDown(e => {
+                this._onRegexKeyDown.fire(e);
+            }));
+            this.wholeWords = this._register(new WholeWordsToggle({
+                appendTitle: appendWholeWordsLabel,
+                isChecked: false,
+                hoverDelegate,
+                ...options.toggleStyles
+            }));
+            this._register(this.wholeWords.onChange(viaKeyboard => {
+                this._onDidOptionChange.fire(viaKeyboard);
+                if (!viaKeyboard && this.fixFocusOnOptionClickEnabled) {
+                    this.inputBox.focus();
+                }
+                this.validate();
+            }));
+            this.caseSensitive = this._register(new CaseSensitiveToggle({
+                appendTitle: appendCaseSensitiveLabel,
+                isChecked: false,
+                hoverDelegate,
+                ...options.toggleStyles
+            }));
+            this._register(this.caseSensitive.onChange(viaKeyboard => {
+                this._onDidOptionChange.fire(viaKeyboard);
+                if (!viaKeyboard && this.fixFocusOnOptionClickEnabled) {
+                    this.inputBox.focus();
+                }
+                this.validate();
+            }));
+            this._register(this.caseSensitive.onKeyDown(e => {
+                this._onCaseSensitiveKeyDown.fire(e);
+            }));
+            // Arrow-Key support to navigate between options
+            const indexes = [this.caseSensitive.domNode, this.wholeWords.domNode, this.regex.domNode];
+            this.onkeydown(this.domNode, (event) => {
+                if (event.equals(15 /* KeyCode.LeftArrow */) || event.equals(17 /* KeyCode.RightArrow */) || event.equals(9 /* KeyCode.Escape */)) {
+                    const index = indexes.indexOf(this.domNode.ownerDocument.activeElement);
+                    if (index >= 0) {
+                        let newIndex = -1;
+                        if (event.equals(17 /* KeyCode.RightArrow */)) {
+                            newIndex = (index + 1) % indexes.length;
+                        }
+                        else if (event.equals(15 /* KeyCode.LeftArrow */)) {
+                            if (index === 0) {
+                                newIndex = indexes.length - 1;
+                            }
+                            else {
+                                newIndex = index - 1;
+                            }
+                        }
+                        if (event.equals(9 /* KeyCode.Escape */)) {
+                            indexes[index].blur();
+                            this.inputBox.focus();
+                        }
+                        else if (newIndex >= 0) {
+                            indexes[newIndex].focus();
+                        }
+                        dom.EventHelper.stop(event, true);
+                    }
+                }
+            });
+        }
+        this.controls = document.createElement('div');
+        this.controls.className = 'controls';
+        this.controls.style.display = this.showCommonFindToggles ? '' : 'none';
+        if (this.caseSensitive) {
+            this.controls.append(this.caseSensitive.domNode);
+        }
+        if (this.wholeWords) {
+            this.controls.appendChild(this.wholeWords.domNode);
+        }
+        if (this.regex) {
+            this.controls.appendChild(this.regex.domNode);
+        }
+        this.setAdditionalToggles(options?.additionalToggles);
+        if (this.controls) {
+            this.domNode.appendChild(this.controls);
+        }
+        parent?.appendChild(this.domNode);
+        this._register(dom.addDisposableListener(this.inputBox.inputElement, 'compositionstart', (e) => {
+            this.imeSessionInProgress = true;
+        }));
+        this._register(dom.addDisposableListener(this.inputBox.inputElement, 'compositionend', (e) => {
+            this.imeSessionInProgress = false;
+            this._onInput.fire();
+        }));
+        this.onkeydown(this.inputBox.inputElement, (e) => this._onKeyDown.fire(e));
+        this.onkeyup(this.inputBox.inputElement, (e) => this._onKeyUp.fire(e));
+        this.oninput(this.inputBox.inputElement, (e) => this._onInput.fire());
+        this.onmousedown(this.inputBox.inputElement, (e) => this._onMouseDown.fire(e));
+    }
+    get onDidChange() {
+        return this.inputBox.onDidChange;
+    }
+    layout(style) {
+        this.inputBox.layout();
+        this.updateInputBoxPadding(style.collapsedFindWidget);
+    }
+    enable() {
+        this.domNode.classList.remove('disabled');
+        this.inputBox.enable();
+        this.regex?.enable();
+        this.wholeWords?.enable();
+        this.caseSensitive?.enable();
+        for (const toggle of this.additionalToggles) {
+            toggle.enable();
+        }
+    }
+    disable() {
+        this.domNode.classList.add('disabled');
+        this.inputBox.disable();
+        this.regex?.disable();
+        this.wholeWords?.disable();
+        this.caseSensitive?.disable();
+        for (const toggle of this.additionalToggles) {
+            toggle.disable();
+        }
+    }
+    setFocusInputOnOptionClick(value) {
+        this.fixFocusOnOptionClickEnabled = value;
+    }
+    setEnabled(enabled) {
+        if (enabled) {
+            this.enable();
+        }
+        else {
+            this.disable();
+        }
+    }
+    setAdditionalToggles(toggles) {
+        for (const currentToggle of this.additionalToggles) {
+            currentToggle.domNode.remove();
+        }
+        this.additionalToggles = [];
+        this.additionalTogglesDisposables.value = new DisposableStore();
+        for (const toggle of toggles ?? []) {
+            this.additionalTogglesDisposables.value.add(toggle);
+            this.controls.appendChild(toggle.domNode);
+            this.additionalTogglesDisposables.value.add(toggle.onChange(viaKeyboard => {
+                this._onDidOptionChange.fire(viaKeyboard);
+                if (!viaKeyboard && this.fixFocusOnOptionClickEnabled) {
+                    this.inputBox.focus();
+                }
+            }));
+            this.additionalToggles.push(toggle);
+        }
+        if (this.additionalToggles.length > 0) {
+            this.controls.style.display = '';
+        }
+        this.updateInputBoxPadding();
+    }
+    updateInputBoxPadding(controlsHidden = false) {
+        if (controlsHidden) {
+            this.inputBox.paddingRight = 0;
+        }
+        else {
+            this.inputBox.paddingRight =
+                ((this.caseSensitive?.width() ?? 0) + (this.wholeWords?.width() ?? 0) + (this.regex?.width() ?? 0))
+                    + this.additionalToggles.reduce((r, t) => r + t.width(), 0);
+        }
+    }
+    getValue() {
+        return this.inputBox.value;
+    }
+    setValue(value) {
+        if (this.inputBox.value !== value) {
+            this.inputBox.value = value;
+        }
+    }
+    select() {
+        this.inputBox.select();
+    }
+    focus() {
+        this.inputBox.focus();
+    }
+    getCaseSensitive() {
+        return this.caseSensitive?.checked ?? false;
+    }
+    setCaseSensitive(value) {
+        if (this.caseSensitive) {
+            this.caseSensitive.checked = value;
+        }
+    }
+    getWholeWords() {
+        return this.wholeWords?.checked ?? false;
+    }
+    setWholeWords(value) {
+        if (this.wholeWords) {
+            this.wholeWords.checked = value;
+        }
+    }
+    getRegex() {
+        return this.regex?.checked ?? false;
+    }
+    setRegex(value) {
+        if (this.regex) {
+            this.regex.checked = value;
+            this.validate();
+        }
+    }
+    focusOnCaseSensitive() {
+        this.caseSensitive?.focus();
+    }
+    highlightFindOptions() {
+        this.domNode.classList.remove('highlight-' + (this._lastHighlightFindOptions));
+        this._lastHighlightFindOptions = 1 - this._lastHighlightFindOptions;
+        this.domNode.classList.add('highlight-' + (this._lastHighlightFindOptions));
+    }
+    validate() {
+        this.inputBox.validate();
+    }
+    showMessage(message) {
+        this.inputBox.showMessage(message);
+    }
+    clearMessage() {
+        this.inputBox.hideMessage();
+    }
+}

package/dist-cms/monaco-editor/vs/base/browser/ui/findinput/findInputToggles.js

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
+import { Toggle } from '../toggle/toggle.js';
+import { Codicon } from '../../../common/codicons.js';
+import * as nls from '../../../../nls.js';
+const NLS_CASE_SENSITIVE_TOGGLE_LABEL = nls.localize('caseDescription', "Match Case");
+const NLS_WHOLE_WORD_TOGGLE_LABEL = nls.localize('wordsDescription', "Match Whole Word");
+const NLS_REGEX_TOGGLE_LABEL = nls.localize('regexDescription', "Use Regular Expression");
+export class CaseSensitiveToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.caseSensitive,
+            title: NLS_CASE_SENSITIVE_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverDelegate: opts.hoverDelegate ?? getDefaultHoverDelegate('element'),
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+export class WholeWordsToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.wholeWord,
+            title: NLS_WHOLE_WORD_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverDelegate: opts.hoverDelegate ?? getDefaultHoverDelegate('element'),
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+export class RegexToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.regex,
+            title: NLS_REGEX_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverDelegate: opts.hoverDelegate ?? getDefaultHoverDelegate('element'),
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}