monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/findDecorations.js

@@ -0,0 +1,311 @@
+import { Range } from '../../../common/core/range.js';
+import { OverviewRulerLane } from '../../../common/model.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { overviewRulerFindMatchForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import { minimapFindMatch } from '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class FindDecorations {
+    constructor(editor) {
+        this._editor = editor;
+        this._decorations = [];
+        this._overviewRulerApproximateDecorations = [];
+        this._findScopeDecorationIds = [];
+        this._rangeHighlightDecorationId = null;
+        this._highlightedDecorationId = null;
+        this._startPosition = this._editor.getPosition();
+    }
+    dispose() {
+        this._editor.removeDecorations(this._allDecorations());
+        this._decorations = [];
+        this._overviewRulerApproximateDecorations = [];
+        this._findScopeDecorationIds = [];
+        this._rangeHighlightDecorationId = null;
+        this._highlightedDecorationId = null;
+    }
+    reset() {
+        this._decorations = [];
+        this._overviewRulerApproximateDecorations = [];
+        this._findScopeDecorationIds = [];
+        this._rangeHighlightDecorationId = null;
+        this._highlightedDecorationId = null;
+    }
+    getCount() {
+        return this._decorations.length;
+    }
+    /** @deprecated use getFindScopes to support multiple selections */
+    getFindScope() {
+        if (this._findScopeDecorationIds[0]) {
+            return this._editor.getModel().getDecorationRange(this._findScopeDecorationIds[0]);
+        }
+        return null;
+    }
+    getFindScopes() {
+        if (this._findScopeDecorationIds.length) {
+            const scopes = this._findScopeDecorationIds.map(findScopeDecorationId => this._editor.getModel().getDecorationRange(findScopeDecorationId)).filter(element => !!element);
+            if (scopes.length) {
+                return scopes;
+            }
+        }
+        return null;
+    }
+    getStartPosition() {
+        return this._startPosition;
+    }
+    setStartPosition(newStartPosition) {
+        this._startPosition = newStartPosition;
+        this.setCurrentFindMatch(null);
+    }
+    _getDecorationIndex(decorationId) {
+        const index = this._decorations.indexOf(decorationId);
+        if (index >= 0) {
+            return index + 1;
+        }
+        return 1;
+    }
+    getDecorationRangeAt(index) {
+        const decorationId = index < this._decorations.length ? this._decorations[index] : null;
+        if (decorationId) {
+            return this._editor.getModel().getDecorationRange(decorationId);
+        }
+        return null;
+    }
+    getCurrentMatchesPosition(desiredRange) {
+        const candidates = this._editor.getModel().getDecorationsInRange(desiredRange);
+        for (const candidate of candidates) {
+            const candidateOpts = candidate.options;
+            if (candidateOpts === FindDecorations._FIND_MATCH_DECORATION || candidateOpts === FindDecorations._CURRENT_FIND_MATCH_DECORATION) {
+                return this._getDecorationIndex(candidate.id);
+            }
+        }
+        // We don't know the current match position, so returns zero to show '?' in find widget
+        return 0;
+    }
+    setCurrentFindMatch(nextMatch) {
+        let newCurrentDecorationId = null;
+        let matchPosition = 0;
+        if (nextMatch) {
+            for (let i = 0, len = this._decorations.length; i < len; i++) {
+                const range = this._editor.getModel().getDecorationRange(this._decorations[i]);
+                if (nextMatch.equalsRange(range)) {
+                    newCurrentDecorationId = this._decorations[i];
+                    matchPosition = (i + 1);
+                    break;
+                }
+            }
+        }
+        if (this._highlightedDecorationId !== null || newCurrentDecorationId !== null) {
+            this._editor.changeDecorations((changeAccessor) => {
+                if (this._highlightedDecorationId !== null) {
+                    changeAccessor.changeDecorationOptions(this._highlightedDecorationId, FindDecorations._FIND_MATCH_DECORATION);
+                    this._highlightedDecorationId = null;
+                }
+                if (newCurrentDecorationId !== null) {
+                    this._highlightedDecorationId = newCurrentDecorationId;
+                    changeAccessor.changeDecorationOptions(this._highlightedDecorationId, FindDecorations._CURRENT_FIND_MATCH_DECORATION);
+                }
+                if (this._rangeHighlightDecorationId !== null) {
+                    changeAccessor.removeDecoration(this._rangeHighlightDecorationId);
+                    this._rangeHighlightDecorationId = null;
+                }
+                if (newCurrentDecorationId !== null) {
+                    let rng = this._editor.getModel().getDecorationRange(newCurrentDecorationId);
+                    if (rng.startLineNumber !== rng.endLineNumber && rng.endColumn === 1) {
+                        const lineBeforeEnd = rng.endLineNumber - 1;
+                        const lineBeforeEndMaxColumn = this._editor.getModel().getLineMaxColumn(lineBeforeEnd);
+                        rng = new Range(rng.startLineNumber, rng.startColumn, lineBeforeEnd, lineBeforeEndMaxColumn);
+                    }
+                    this._rangeHighlightDecorationId = changeAccessor.addDecoration(rng, FindDecorations._RANGE_HIGHLIGHT_DECORATION);
+                }
+            });
+        }
+        return matchPosition;
+    }
+    set(findMatches, findScopes) {
+        this._editor.changeDecorations((accessor) => {
+            let findMatchesOptions = FindDecorations._FIND_MATCH_DECORATION;
+            const newOverviewRulerApproximateDecorations = [];
+            if (findMatches.length > 1000) {
+                // we go into a mode where the overview ruler gets "approximate" decorations
+                // the reason is that the overview ruler paints all the decorations in the file and we don't want to cause freezes
+                findMatchesOptions = FindDecorations._FIND_MATCH_NO_OVERVIEW_DECORATION;
+                // approximate a distance in lines where matches should be merged
+                const lineCount = this._editor.getModel().getLineCount();
+                const height = this._editor.getLayoutInfo().height;
+                const approxPixelsPerLine = height / lineCount;
+                const mergeLinesDelta = Math.max(2, Math.ceil(3 / approxPixelsPerLine));
+                // merge decorations as much as possible
+                let prevStartLineNumber = findMatches[0].range.startLineNumber;
+                let prevEndLineNumber = findMatches[0].range.endLineNumber;
+                for (let i = 1, len = findMatches.length; i < len; i++) {
+                    const range = findMatches[i].range;
+                    if (prevEndLineNumber + mergeLinesDelta >= range.startLineNumber) {
+                        if (range.endLineNumber > prevEndLineNumber) {
+                            prevEndLineNumber = range.endLineNumber;
+                        }
+                    }
+                    else {
+                        newOverviewRulerApproximateDecorations.push({
+                            range: new Range(prevStartLineNumber, 1, prevEndLineNumber, 1),
+                            options: FindDecorations._FIND_MATCH_ONLY_OVERVIEW_DECORATION
+                        });
+                        prevStartLineNumber = range.startLineNumber;
+                        prevEndLineNumber = range.endLineNumber;
+                    }
+                }
+                newOverviewRulerApproximateDecorations.push({
+                    range: new Range(prevStartLineNumber, 1, prevEndLineNumber, 1),
+                    options: FindDecorations._FIND_MATCH_ONLY_OVERVIEW_DECORATION
+                });
+            }
+            // Find matches
+            const newFindMatchesDecorations = new Array(findMatches.length);
+            for (let i = 0, len = findMatches.length; i < len; i++) {
+                newFindMatchesDecorations[i] = {
+                    range: findMatches[i].range,
+                    options: findMatchesOptions
+                };
+            }
+            this._decorations = accessor.deltaDecorations(this._decorations, newFindMatchesDecorations);
+            // Overview ruler approximate decorations
+            this._overviewRulerApproximateDecorations = accessor.deltaDecorations(this._overviewRulerApproximateDecorations, newOverviewRulerApproximateDecorations);
+            // Range highlight
+            if (this._rangeHighlightDecorationId) {
+                accessor.removeDecoration(this._rangeHighlightDecorationId);
+                this._rangeHighlightDecorationId = null;
+            }
+            // Find scope
+            if (this._findScopeDecorationIds.length) {
+                this._findScopeDecorationIds.forEach(findScopeDecorationId => accessor.removeDecoration(findScopeDecorationId));
+                this._findScopeDecorationIds = [];
+            }
+            if (findScopes?.length) {
+                this._findScopeDecorationIds = findScopes.map(findScope => accessor.addDecoration(findScope, FindDecorations._FIND_SCOPE_DECORATION));
+            }
+        });
+    }
+    matchBeforePosition(position) {
+        if (this._decorations.length === 0) {
+            return null;
+        }
+        for (let i = this._decorations.length - 1; i >= 0; i--) {
+            const decorationId = this._decorations[i];
+            const r = this._editor.getModel().getDecorationRange(decorationId);
+            if (!r || r.endLineNumber > position.lineNumber) {
+                continue;
+            }
+            if (r.endLineNumber < position.lineNumber) {
+                return r;
+            }
+            if (r.endColumn > position.column) {
+                continue;
+            }
+            return r;
+        }
+        return this._editor.getModel().getDecorationRange(this._decorations[this._decorations.length - 1]);
+    }
+    matchAfterPosition(position) {
+        if (this._decorations.length === 0) {
+            return null;
+        }
+        for (let i = 0, len = this._decorations.length; i < len; i++) {
+            const decorationId = this._decorations[i];
+            const r = this._editor.getModel().getDecorationRange(decorationId);
+            if (!r || r.startLineNumber < position.lineNumber) {
+                continue;
+            }
+            if (r.startLineNumber > position.lineNumber) {
+                return r;
+            }
+            if (r.startColumn < position.column) {
+                continue;
+            }
+            return r;
+        }
+        return this._editor.getModel().getDecorationRange(this._decorations[0]);
+    }
+    _allDecorations() {
+        let result = [];
+        result = result.concat(this._decorations);
+        result = result.concat(this._overviewRulerApproximateDecorations);
+        if (this._findScopeDecorationIds.length) {
+            result.push(...this._findScopeDecorationIds);
+        }
+        if (this._rangeHighlightDecorationId) {
+            result.push(this._rangeHighlightDecorationId);
+        }
+        return result;
+    }
+    static { this._CURRENT_FIND_MATCH_DECORATION = ModelDecorationOptions.register({
+        description: 'current-find-match',
+        stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+        zIndex: 13,
+        className: 'currentFindMatch',
+        inlineClassName: 'currentFindMatchInline',
+        showIfCollapsed: true,
+        overviewRuler: {
+            color: themeColorFromId(overviewRulerFindMatchForeground),
+            position: OverviewRulerLane.Center
+        },
+        minimap: {
+            color: themeColorFromId(minimapFindMatch),
+            position: 1 /* MinimapPosition.Inline */
+        }
+    }); }
+    static { this._FIND_MATCH_DECORATION = ModelDecorationOptions.register({
+        description: 'find-match',
+        stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+        zIndex: 10,
+        className: 'findMatch',
+        inlineClassName: 'findMatchInline',
+        showIfCollapsed: true,
+        overviewRuler: {
+            color: themeColorFromId(overviewRulerFindMatchForeground),
+            position: OverviewRulerLane.Center
+        },
+        minimap: {
+            color: themeColorFromId(minimapFindMatch),
+            position: 1 /* MinimapPosition.Inline */
+        }
+    }); }
+    static { this._FIND_MATCH_NO_OVERVIEW_DECORATION = ModelDecorationOptions.register({
+        description: 'find-match-no-overview',
+        stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+        className: 'findMatch',
+        showIfCollapsed: true
+    }); }
+    static { this._FIND_MATCH_ONLY_OVERVIEW_DECORATION = ModelDecorationOptions.register({
+        description: 'find-match-only-overview',
+        stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+        overviewRuler: {
+            color: themeColorFromId(overviewRulerFindMatchForeground),
+            position: OverviewRulerLane.Center
+        }
+    }); }
+    static { this._RANGE_HIGHLIGHT_DECORATION = ModelDecorationOptions.register({
+        description: 'find-range-highlight',
+        stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+        className: 'rangeHighlight',
+        isWholeLine: true
+    }); }
+    static { this._FIND_SCOPE_DECORATION = ModelDecorationOptions.register({
+        description: 'find-scope',
+        className: 'findScope',
+        isWholeLine: true
+    }); }
+}
+
+export { FindDecorations };

package/dist/workers/findInput.js

@@ -0,0 +1,294 @@
+import { EventHelper, addDisposableListener } from '../../dom.js';
+import { RegexToggle, WholeWordsToggle, CaseSensitiveToggle } from './findInputToggles.js';
+import { HistoryInputBox } from '../inputbox/inputBox.js';
+import { Widget } from '../widget.js';
+import { Emitter } from '../../../common/event.js';
+import './findInput.css';
+import { localize } from '../../../../nls.js';
+import { MutableDisposable, DisposableStore } 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 NLS_DEFAULT_LABEL = localize(1, "input");
+class FindInput extends Widget {
+    get onDidOptionChange() { return this._onDidOptionChange.event; }
+    get onKeyDown() { return this._onKeyDown.event; }
+    get onMouseDown() { return this._onMouseDown.event; }
+    get onCaseSensitiveKeyDown() { return this._onCaseSensitiveKeyDown.event; }
+    get onRegexKeyDown() { return this._onRegexKeyDown.event; }
+    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._onKeyDown = this._register(new Emitter());
+        this._onMouseDown = this._register(new Emitter());
+        this._onInput = this._register(new Emitter());
+        this._onKeyUp = this._register(new Emitter());
+        this._onCaseSensitiveKeyDown = this._register(new Emitter());
+        this._onRegexKeyDown = this._register(new Emitter());
+        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 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
+            },
+            showHistoryHint: options.showHistoryHint,
+            flexibleHeight,
+            flexibleWidth,
+            flexibleMaxHeight,
+            inputBoxStyles: options.inputBoxStyles,
+            history: options.history
+        }));
+        if (this.showCommonFindToggles) {
+            const hoverLifecycleOptions = options?.hoverLifecycleOptions || { groupId: 'find-input' };
+            this.regex = this._register(new RegexToggle({
+                appendTitle: appendRegexLabel,
+                isChecked: false,
+                hoverLifecycleOptions,
+                ...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,
+                hoverLifecycleOptions,
+                ...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,
+                hoverLifecycleOptions,
+                ...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();
+                        }
+                        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(addDisposableListener(this.inputBox.inputElement, 'compositionstart', (e) => {
+            this.imeSessionInProgress = true;
+        }));
+        this._register(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();
+    }
+}
+
+export { FindInput };

package/dist/workers/findInputToggles.js

@@ -0,0 +1,52 @@
+import { Toggle } from '../toggle/toggle.js';
+import { Codicon } from '../../../common/codicons.js';
+import { localize } 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.
+ *--------------------------------------------------------------------------------------------*/
+const NLS_CASE_SENSITIVE_TOGGLE_LABEL = localize(2, "Match Case");
+const NLS_WHOLE_WORD_TOGGLE_LABEL = localize(3, "Match Whole Word");
+const NLS_REGEX_TOGGLE_LABEL = localize(4, "Use Regular Expression");
+class CaseSensitiveToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.caseSensitive,
+            title: NLS_CASE_SENSITIVE_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverLifecycleOptions: opts.hoverLifecycleOptions,
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+class WholeWordsToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.wholeWord,
+            title: NLS_WHOLE_WORD_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverLifecycleOptions: opts.hoverLifecycleOptions,
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+class RegexToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.regex,
+            title: NLS_REGEX_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverLifecycleOptions: opts.hoverLifecycleOptions,
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+
+export { CaseSensitiveToggle, RegexToggle, WholeWordsToggle };