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

package/vscode/src/vs/editor/contrib/find/browser/findWidget.js

@@ -0,0 +1,1238 @@
+import { trackFocus, getTotalWidth, getDomNodePagePosition, getTopLeftOffset, getComputedStyle } from '../../../../base/browser/dom.js';
+import { alert } from '../../../../base/browser/ui/aria/aria.js';
+import { Toggle } from '../../../../base/browser/ui/toggle/toggle.js';
+import { Sash } from '../../../../base/browser/ui/sash/sash.js';
+import { Widget } from '../../../../base/browser/ui/widget.js';
+import { Delayer } from '../../../../base/common/async.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { isWindows, isNative, isLinux, isMacintosh } from '../../../../base/common/platform.js';
+import { format } from '../../../../base/common/strings.js';
+import './findWidget.css.js';
+import { Range } from '../../../common/core/range.js';
+import { CONTEXT_FIND_INPUT_FOCUSED, CONTEXT_REPLACE_INPUT_FOCUSED, MATCHES_LIMIT, FIND_IDS } from './findModel.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ContextScopedFindInput, ContextScopedReplaceInput } from '../../../../platform/history/browser/contextScopedHistoryWidget.js';
+import { showHistoryKeybindingHint } from '../../../../platform/history/browser/historyWidgetKeybindingHint.js';
+import { asCssVariable, inputActiveOptionBackground, inputActiveOptionBorder, inputActiveOptionForeground, editorFindMatchHighlight, editorFindMatch, editorFindRangeHighlight, editorWidgetBackground, widgetShadow, widgetBorder, editorFindMatchHighlightBorder, editorFindMatchBorder, editorFindRangeHighlightBorder, contrastBorder, editorWidgetForeground, errorForeground, editorWidgetResizeBorder, editorWidgetBorder, toolbarHoverBackground, focusBorder } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerIcon, widgetClose } from '../../../../platform/theme/common/iconRegistry.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { isHighContrast } from '../../../../platform/theme/common/theme.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import { defaultInputBoxStyles, defaultToggleStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+const findSelectionIcon = registerIcon('find-selection', Codicon.selection, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findSelectionIcon',
+    'Icon for \'Find in Selection\' in the editor find widget.'
+)));
+const findCollapsedIcon = registerIcon('find-collapsed', Codicon.chevronRight, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findCollapsedIcon',
+    'Icon to indicate that the editor find widget is collapsed.'
+)));
+const findExpandedIcon = registerIcon('find-expanded', Codicon.chevronDown, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findExpandedIcon',
+    'Icon to indicate that the editor find widget is expanded.'
+)));
+const findReplaceIcon = registerIcon('find-replace', Codicon.replace, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findReplaceIcon',
+    'Icon for \'Replace\' in the editor find widget.'
+)));
+const findReplaceAllIcon = registerIcon('find-replace-all', Codicon.replaceAll, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findReplaceAllIcon',
+    'Icon for \'Replace All\' in the editor find widget.'
+)));
+const findPreviousMatchIcon = registerIcon('find-previous-match', Codicon.arrowUp, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findPreviousMatchIcon',
+    'Icon for \'Find Previous\' in the editor find widget.'
+)));
+const findNextMatchIcon = registerIcon('find-next-match', Codicon.arrowDown, ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'findNextMatchIcon',
+    'Icon for \'Find Next\' in the editor find widget.'
+)));
+const NLS_FIND_DIALOG_LABEL = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.findDialog',
+    "Find / Replace"
+));
+const NLS_FIND_INPUT_LABEL = ( localizeWithPath('vs/editor/contrib/find/browser/findWidget', 'label.find', "Find"));
+const NLS_FIND_INPUT_PLACEHOLDER = ( localizeWithPath('vs/editor/contrib/find/browser/findWidget', 'placeholder.find', "Find"));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.previousMatchButton',
+    "Previous Match"
+));
+const NLS_NEXT_MATCH_BTN_LABEL = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.nextMatchButton',
+    "Next Match"
+));
+const NLS_TOGGLE_SELECTION_FIND_TITLE = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.toggleSelectionFind',
+    "Find in Selection"
+));
+const NLS_CLOSE_BTN_LABEL = ( localizeWithPath('vs/editor/contrib/find/browser/findWidget', 'label.closeButton', "Close"));
+const NLS_REPLACE_INPUT_LABEL = ( localizeWithPath('vs/editor/contrib/find/browser/findWidget', 'label.replace', "Replace"));
+const NLS_REPLACE_INPUT_PLACEHOLDER = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'placeholder.replace',
+    "Replace"
+));
+const NLS_REPLACE_BTN_LABEL = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.replaceButton',
+    "Replace"
+));
+const NLS_REPLACE_ALL_BTN_LABEL = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.replaceAllButton',
+    "Replace All"
+));
+const NLS_TOGGLE_REPLACE_MODE_BTN_LABEL = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.toggleReplaceButton',
+    "Toggle Replace"
+));
+const NLS_MATCHES_COUNT_LIMIT_TITLE = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'title.matchesCountLimit',
+    "Only the first {0} results are highlighted, but all find operations work on the entire text.",
+    MATCHES_LIMIT
+));
+const NLS_MATCHES_LOCATION = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.matchesLocation',
+    "{0} of {1}"
+));
+const NLS_NO_RESULTS = ( localizeWithPath(
+    'vs/editor/contrib/find/browser/findWidget',
+    'label.noResults',
+    "No results"
+));
+const FIND_WIDGET_INITIAL_WIDTH = 419;
+const PART_WIDTH = 275;
+const FIND_INPUT_AREA_WIDTH = PART_WIDTH - 54;
+let MAX_MATCHES_COUNT_WIDTH = 69;
+const FIND_INPUT_AREA_HEIGHT = 33;
+const ctrlEnterReplaceAllWarningPromptedKey = 'ctrlEnterReplaceAll.windows.donotask';
+const ctrlKeyMod = ((isMacintosh ? 256  : 2048) );
+class FindWidgetViewZone {
+    constructor(afterLineNumber) {
+        this.afterLineNumber = afterLineNumber;
+        this.heightInPx = FIND_INPUT_AREA_HEIGHT;
+        this.suppressMouseDown = false;
+        this.domNode = document.createElement('div');
+        this.domNode.className = 'dock-find-viewzone';
+    }
+}
+function stopPropagationForMultiLineUpwards(event, value, textarea) {
+    const isMultiline = !!value.match(/\n/);
+    if (textarea && isMultiline && textarea.selectionStart > 0) {
+        event.stopPropagation();
+        return;
+    }
+}
+function stopPropagationForMultiLineDownwards(event, value, textarea) {
+    const isMultiline = !!value.match(/\n/);
+    if (textarea && isMultiline && textarea.selectionEnd < textarea.value.length) {
+        event.stopPropagation();
+        return;
+    }
+}
+class FindWidget extends Widget {
+    static { this.ID = 'editor.contrib.findWidget'; }
+    constructor(codeEditor, controller, state, contextViewProvider, keybindingService, contextKeyService, themeService, storageService, notificationService) {
+        super();
+        this._cachedHeight = null;
+        this._revealTimeouts = [];
+        this._codeEditor = codeEditor;
+        this._controller = controller;
+        this._state = state;
+        this._contextViewProvider = contextViewProvider;
+        this._keybindingService = keybindingService;
+        this._contextKeyService = contextKeyService;
+        this._storageService = storageService;
+        this._notificationService = notificationService;
+        this._ctrlEnterReplaceAllWarningPrompted = !!storageService.getBoolean(ctrlEnterReplaceAllWarningPromptedKey, 0 );
+        this._isVisible = false;
+        this._isReplaceVisible = false;
+        this._ignoreChangeEvent = false;
+        this._updateHistoryDelayer = ( new Delayer(500));
+        this._register(toDisposable(() => this._updateHistoryDelayer.cancel()));
+        this._register(this._state.onFindReplaceStateChange((e) => this._onStateChanged(e)));
+        this._buildDomNode();
+        this._updateButtons();
+        this._tryUpdateWidgetWidth();
+        this._findInput.inputBox.layout();
+        this._register(this._codeEditor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(90 )) {
+                if (this._codeEditor.getOption(90 )) {
+                    this._state.change({ isReplaceRevealed: false }, false);
+                }
+                this._updateButtons();
+            }
+            if (e.hasChanged(143 )) {
+                this._tryUpdateWidgetWidth();
+            }
+            if (e.hasChanged(2 )) {
+                this.updateAccessibilitySupport();
+            }
+            if (e.hasChanged(41 )) {
+                const supportLoop = this._codeEditor.getOption(41 ).loop;
+                this._state.change({ loop: supportLoop }, false);
+                const addExtraSpaceOnTop = this._codeEditor.getOption(41 ).addExtraSpaceOnTop;
+                if (addExtraSpaceOnTop && !this._viewZone) {
+                    this._viewZone = ( new FindWidgetViewZone(0));
+                    this._showViewZone();
+                }
+                if (!addExtraSpaceOnTop && this._viewZone) {
+                    this._removeViewZone();
+                }
+            }
+        }));
+        this.updateAccessibilitySupport();
+        this._register(this._codeEditor.onDidChangeCursorSelection(() => {
+            if (this._isVisible) {
+                this._updateToggleSelectionFindButton();
+            }
+        }));
+        this._register(this._codeEditor.onDidFocusEditorWidget(async () => {
+            if (this._isVisible) {
+                const globalBufferTerm = await this._controller.getGlobalBufferTerm();
+                if (globalBufferTerm && globalBufferTerm !== this._state.searchString) {
+                    this._state.change({ searchString: globalBufferTerm }, false);
+                    this._findInput.select();
+                }
+            }
+        }));
+        this._findInputFocused = CONTEXT_FIND_INPUT_FOCUSED.bindTo(contextKeyService);
+        this._findFocusTracker = this._register(trackFocus(this._findInput.inputBox.inputElement));
+        this._register(this._findFocusTracker.onDidFocus(() => {
+            this._findInputFocused.set(true);
+            this._updateSearchScope();
+        }));
+        this._register(this._findFocusTracker.onDidBlur(() => {
+            this._findInputFocused.set(false);
+        }));
+        this._replaceInputFocused = CONTEXT_REPLACE_INPUT_FOCUSED.bindTo(contextKeyService);
+        this._replaceFocusTracker = this._register(trackFocus(this._replaceInput.inputBox.inputElement));
+        this._register(this._replaceFocusTracker.onDidFocus(() => {
+            this._replaceInputFocused.set(true);
+            this._updateSearchScope();
+        }));
+        this._register(this._replaceFocusTracker.onDidBlur(() => {
+            this._replaceInputFocused.set(false);
+        }));
+        this._codeEditor.addOverlayWidget(this);
+        if (this._codeEditor.getOption(41 ).addExtraSpaceOnTop) {
+            this._viewZone = ( new FindWidgetViewZone(0));
+        }
+        this._register(this._codeEditor.onDidChangeModel(() => {
+            if (!this._isVisible) {
+                return;
+            }
+            this._viewZoneId = undefined;
+        }));
+        this._register(this._codeEditor.onDidScrollChange((e) => {
+            if (e.scrollTopChanged) {
+                this._layoutViewZone();
+                return;
+            }
+            setTimeout(() => {
+                this._layoutViewZone();
+            }, 0);
+        }));
+    }
+    getId() {
+        return FindWidget.ID;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        if (this._isVisible) {
+            return {
+                preference: 0
+            };
+        }
+        return null;
+    }
+    _onStateChanged(e) {
+        if (e.searchString) {
+            try {
+                this._ignoreChangeEvent = true;
+                this._findInput.setValue(this._state.searchString);
+            }
+            finally {
+                this._ignoreChangeEvent = false;
+            }
+            this._updateButtons();
+        }
+        if (e.replaceString) {
+            this._replaceInput.inputBox.value = this._state.replaceString;
+        }
+        if (e.isRevealed) {
+            if (this._state.isRevealed) {
+                this._reveal();
+            }
+            else {
+                this._hide(true);
+            }
+        }
+        if (e.isReplaceRevealed) {
+            if (this._state.isReplaceRevealed) {
+                if (!this._codeEditor.getOption(90 ) && !this._isReplaceVisible) {
+                    this._isReplaceVisible = true;
+                    this._replaceInput.width = getTotalWidth(this._findInput.domNode);
+                    this._updateButtons();
+                    this._replaceInput.inputBox.layout();
+                }
+            }
+            else {
+                if (this._isReplaceVisible) {
+                    this._isReplaceVisible = false;
+                    this._updateButtons();
+                }
+            }
+        }
+        if ((e.isRevealed || e.isReplaceRevealed) && (this._state.isRevealed || this._state.isReplaceRevealed)) {
+            if (this._tryUpdateHeight()) {
+                this._showViewZone();
+            }
+        }
+        if (e.isRegex) {
+            this._findInput.setRegex(this._state.isRegex);
+        }
+        if (e.wholeWord) {
+            this._findInput.setWholeWords(this._state.wholeWord);
+        }
+        if (e.matchCase) {
+            this._findInput.setCaseSensitive(this._state.matchCase);
+        }
+        if (e.preserveCase) {
+            this._replaceInput.setPreserveCase(this._state.preserveCase);
+        }
+        if (e.searchScope) {
+            if (this._state.searchScope) {
+                this._toggleSelectionFind.checked = true;
+            }
+            else {
+                this._toggleSelectionFind.checked = false;
+            }
+            this._updateToggleSelectionFindButton();
+        }
+        if (e.searchString || e.matchesCount || e.matchesPosition) {
+            const showRedOutline = (this._state.searchString.length > 0 && this._state.matchesCount === 0);
+            this._domNode.classList.toggle('no-results', showRedOutline);
+            this._updateMatchesCount();
+            this._updateButtons();
+        }
+        if (e.searchString || e.currentMatch) {
+            this._layoutViewZone();
+        }
+        if (e.updateHistory) {
+            this._delayedUpdateHistory();
+        }
+        if (e.loop) {
+            this._updateButtons();
+        }
+    }
+    _delayedUpdateHistory() {
+        this._updateHistoryDelayer.trigger(this._updateHistory.bind(this)).then(undefined, onUnexpectedError);
+    }
+    _updateHistory() {
+        if (this._state.searchString) {
+            this._findInput.inputBox.addToHistory();
+        }
+        if (this._state.replaceString) {
+            this._replaceInput.inputBox.addToHistory();
+        }
+    }
+    _updateMatchesCount() {
+        this._matchesCount.style.minWidth = MAX_MATCHES_COUNT_WIDTH + 'px';
+        if (this._state.matchesCount >= MATCHES_LIMIT) {
+            this._matchesCount.title = NLS_MATCHES_COUNT_LIMIT_TITLE;
+        }
+        else {
+            this._matchesCount.title = '';
+        }
+        if (this._matchesCount.firstChild) {
+            this._matchesCount.removeChild(this._matchesCount.firstChild);
+        }
+        let label;
+        if (this._state.matchesCount > 0) {
+            let matchesCount = String(this._state.matchesCount);
+            if (this._state.matchesCount >= MATCHES_LIMIT) {
+                matchesCount += '+';
+            }
+            let matchesPosition = String(this._state.matchesPosition);
+            if (matchesPosition === '0') {
+                matchesPosition = '?';
+            }
+            label = format(NLS_MATCHES_LOCATION, matchesPosition, matchesCount);
+        }
+        else {
+            label = NLS_NO_RESULTS;
+        }
+        this._matchesCount.appendChild(document.createTextNode(label));
+        alert(this._getAriaLabel(label, this._state.currentMatch, this._state.searchString));
+        MAX_MATCHES_COUNT_WIDTH = Math.max(MAX_MATCHES_COUNT_WIDTH, this._matchesCount.clientWidth);
+    }
+    _getAriaLabel(label, currentMatch, searchString) {
+        if (label === NLS_NO_RESULTS) {
+            return searchString === ''
+                ? ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findWidget',
+                'ariaSearchNoResultEmpty',
+                "{0} found",
+                label
+            ))
+                : ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findWidget',
+                'ariaSearchNoResult',
+                "{0} found for '{1}'",
+                label,
+                searchString
+            ));
+        }
+        if (currentMatch) {
+            const ariaLabel = ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findWidget',
+                'ariaSearchNoResultWithLineNum',
+                "{0} found for '{1}', at {2}",
+                label,
+                searchString,
+                currentMatch.startLineNumber + ':' + currentMatch.startColumn
+            ));
+            const model = this._codeEditor.getModel();
+            if (model && (currentMatch.startLineNumber <= model.getLineCount()) && (currentMatch.startLineNumber >= 1)) {
+                const lineContent = model.getLineContent(currentMatch.startLineNumber);
+                return `${lineContent}, ${ariaLabel}`;
+            }
+            return ariaLabel;
+        }
+        return ( localizeWithPath(
+            'vs/editor/contrib/find/browser/findWidget',
+            'ariaSearchNoResultWithLineNumNoCurrentMatch',
+            "{0} found for '{1}'",
+            label,
+            searchString
+        ));
+    }
+    _updateToggleSelectionFindButton() {
+        const selection = this._codeEditor.getSelection();
+        const isSelection = selection ? (selection.startLineNumber !== selection.endLineNumber || selection.startColumn !== selection.endColumn) : false;
+        const isChecked = this._toggleSelectionFind.checked;
+        if (this._isVisible && (isChecked || isSelection)) {
+            this._toggleSelectionFind.enable();
+        }
+        else {
+            this._toggleSelectionFind.disable();
+        }
+    }
+    _updateButtons() {
+        this._findInput.setEnabled(this._isVisible);
+        this._replaceInput.setEnabled(this._isVisible && this._isReplaceVisible);
+        this._updateToggleSelectionFindButton();
+        this._closeBtn.setEnabled(this._isVisible);
+        const findInputIsNonEmpty = (this._state.searchString.length > 0);
+        const matchesCount = this._state.matchesCount ? true : false;
+        this._prevBtn.setEnabled(this._isVisible && findInputIsNonEmpty && matchesCount && this._state.canNavigateBack());
+        this._nextBtn.setEnabled(this._isVisible && findInputIsNonEmpty && matchesCount && this._state.canNavigateForward());
+        this._replaceBtn.setEnabled(this._isVisible && this._isReplaceVisible && findInputIsNonEmpty);
+        this._replaceAllBtn.setEnabled(this._isVisible && this._isReplaceVisible && findInputIsNonEmpty);
+        this._domNode.classList.toggle('replaceToggled', this._isReplaceVisible);
+        this._toggleReplaceBtn.setExpanded(this._isReplaceVisible);
+        const canReplace = !this._codeEditor.getOption(90 );
+        this._toggleReplaceBtn.setEnabled(this._isVisible && canReplace);
+    }
+    _reveal() {
+        this._revealTimeouts.forEach(e => {
+            clearTimeout(e);
+        });
+        this._revealTimeouts = [];
+        if (!this._isVisible) {
+            this._isVisible = true;
+            const selection = this._codeEditor.getSelection();
+            switch (this._codeEditor.getOption(41 ).autoFindInSelection) {
+                case 'always':
+                    this._toggleSelectionFind.checked = true;
+                    break;
+                case 'never':
+                    this._toggleSelectionFind.checked = false;
+                    break;
+                case 'multiline': {
+                    const isSelectionMultipleLine = !!selection && selection.startLineNumber !== selection.endLineNumber;
+                    this._toggleSelectionFind.checked = isSelectionMultipleLine;
+                    break;
+                }
+            }
+            this._tryUpdateWidgetWidth();
+            this._updateButtons();
+            this._revealTimeouts.push(setTimeout(() => {
+                this._domNode.classList.add('visible');
+                this._domNode.setAttribute('aria-hidden', 'false');
+            }, 0));
+            this._revealTimeouts.push(setTimeout(() => {
+                this._findInput.validate();
+            }, 200));
+            this._codeEditor.layoutOverlayWidget(this);
+            let adjustEditorScrollTop = true;
+            if (this._codeEditor.getOption(41 ).seedSearchStringFromSelection && selection) {
+                const domNode = this._codeEditor.getDomNode();
+                if (domNode) {
+                    const editorCoords = getDomNodePagePosition(domNode);
+                    const startCoords = this._codeEditor.getScrolledVisiblePosition(selection.getStartPosition());
+                    const startLeft = editorCoords.left + (startCoords ? startCoords.left : 0);
+                    const startTop = startCoords ? startCoords.top : 0;
+                    if (this._viewZone && startTop < this._viewZone.heightInPx) {
+                        if (selection.endLineNumber > selection.startLineNumber) {
+                            adjustEditorScrollTop = false;
+                        }
+                        const leftOfFindWidget = getTopLeftOffset(this._domNode).left;
+                        if (startLeft > leftOfFindWidget) {
+                            adjustEditorScrollTop = false;
+                        }
+                        const endCoords = this._codeEditor.getScrolledVisiblePosition(selection.getEndPosition());
+                        const endLeft = editorCoords.left + (endCoords ? endCoords.left : 0);
+                        if (endLeft > leftOfFindWidget) {
+                            adjustEditorScrollTop = false;
+                        }
+                    }
+                }
+            }
+            this._showViewZone(adjustEditorScrollTop);
+        }
+    }
+    _hide(focusTheEditor) {
+        this._revealTimeouts.forEach(e => {
+            clearTimeout(e);
+        });
+        this._revealTimeouts = [];
+        if (this._isVisible) {
+            this._isVisible = false;
+            this._updateButtons();
+            this._domNode.classList.remove('visible');
+            this._domNode.setAttribute('aria-hidden', 'true');
+            this._findInput.clearMessage();
+            if (focusTheEditor) {
+                this._codeEditor.focus();
+            }
+            this._codeEditor.layoutOverlayWidget(this);
+            this._removeViewZone();
+        }
+    }
+    _layoutViewZone(targetScrollTop) {
+        const addExtraSpaceOnTop = this._codeEditor.getOption(41 ).addExtraSpaceOnTop;
+        if (!addExtraSpaceOnTop) {
+            this._removeViewZone();
+            return;
+        }
+        if (!this._isVisible) {
+            return;
+        }
+        const viewZone = this._viewZone;
+        if (this._viewZoneId !== undefined || !viewZone) {
+            return;
+        }
+        this._codeEditor.changeViewZones((accessor) => {
+            viewZone.heightInPx = this._getHeight();
+            this._viewZoneId = accessor.addZone(viewZone);
+            this._codeEditor.setScrollTop(targetScrollTop || this._codeEditor.getScrollTop() + viewZone.heightInPx);
+        });
+    }
+    _showViewZone(adjustScroll = true) {
+        if (!this._isVisible) {
+            return;
+        }
+        const addExtraSpaceOnTop = this._codeEditor.getOption(41 ).addExtraSpaceOnTop;
+        if (!addExtraSpaceOnTop) {
+            return;
+        }
+        if (this._viewZone === undefined) {
+            this._viewZone = ( new FindWidgetViewZone(0));
+        }
+        const viewZone = this._viewZone;
+        this._codeEditor.changeViewZones((accessor) => {
+            if (this._viewZoneId !== undefined) {
+                const newHeight = this._getHeight();
+                if (newHeight === viewZone.heightInPx) {
+                    return;
+                }
+                const scrollAdjustment = newHeight - viewZone.heightInPx;
+                viewZone.heightInPx = newHeight;
+                accessor.layoutZone(this._viewZoneId);
+                if (adjustScroll) {
+                    this._codeEditor.setScrollTop(this._codeEditor.getScrollTop() + scrollAdjustment);
+                }
+                return;
+            }
+            else {
+                let scrollAdjustment = this._getHeight();
+                scrollAdjustment -= this._codeEditor.getOption(83 ).top;
+                if (scrollAdjustment <= 0) {
+                    return;
+                }
+                viewZone.heightInPx = scrollAdjustment;
+                this._viewZoneId = accessor.addZone(viewZone);
+                if (adjustScroll) {
+                    this._codeEditor.setScrollTop(this._codeEditor.getScrollTop() + scrollAdjustment);
+                }
+            }
+        });
+    }
+    _removeViewZone() {
+        this._codeEditor.changeViewZones((accessor) => {
+            if (this._viewZoneId !== undefined) {
+                accessor.removeZone(this._viewZoneId);
+                this._viewZoneId = undefined;
+                if (this._viewZone) {
+                    this._codeEditor.setScrollTop(this._codeEditor.getScrollTop() - this._viewZone.heightInPx);
+                    this._viewZone = undefined;
+                }
+            }
+        });
+    }
+    _tryUpdateWidgetWidth() {
+        if (!this._isVisible) {
+            return;
+        }
+        if (!this._domNode.isConnected) {
+            return;
+        }
+        const layoutInfo = this._codeEditor.getLayoutInfo();
+        const editorContentWidth = layoutInfo.contentWidth;
+        if (editorContentWidth <= 0) {
+            this._domNode.classList.add('hiddenEditor');
+            return;
+        }
+        else if (this._domNode.classList.contains('hiddenEditor')) {
+            this._domNode.classList.remove('hiddenEditor');
+        }
+        const editorWidth = layoutInfo.width;
+        const minimapWidth = layoutInfo.minimap.minimapWidth;
+        let collapsedFindWidget = false;
+        let reducedFindWidget = false;
+        let narrowFindWidget = false;
+        if (this._resized) {
+            const widgetWidth = getTotalWidth(this._domNode);
+            if (widgetWidth > FIND_WIDGET_INITIAL_WIDTH) {
+                this._domNode.style.maxWidth = `${editorWidth - 28 - minimapWidth - 15}px`;
+                this._replaceInput.width = getTotalWidth(this._findInput.domNode);
+                return;
+            }
+        }
+        if (FIND_WIDGET_INITIAL_WIDTH + 28 + minimapWidth >= editorWidth) {
+            reducedFindWidget = true;
+        }
+        if (FIND_WIDGET_INITIAL_WIDTH + 28 + minimapWidth - MAX_MATCHES_COUNT_WIDTH >= editorWidth) {
+            narrowFindWidget = true;
+        }
+        if (FIND_WIDGET_INITIAL_WIDTH + 28 + minimapWidth - MAX_MATCHES_COUNT_WIDTH >= editorWidth + 50) {
+            collapsedFindWidget = true;
+        }
+        this._domNode.classList.toggle('collapsed-find-widget', collapsedFindWidget);
+        this._domNode.classList.toggle('narrow-find-widget', narrowFindWidget);
+        this._domNode.classList.toggle('reduced-find-widget', reducedFindWidget);
+        if (!narrowFindWidget && !collapsedFindWidget) {
+            this._domNode.style.maxWidth = `${editorWidth - 28 - minimapWidth - 15}px`;
+        }
+        this._findInput.layout({ collapsedFindWidget, narrowFindWidget, reducedFindWidget });
+        if (this._resized) {
+            const findInputWidth = this._findInput.inputBox.element.clientWidth;
+            if (findInputWidth > 0) {
+                this._replaceInput.width = findInputWidth;
+            }
+        }
+        else if (this._isReplaceVisible) {
+            this._replaceInput.width = getTotalWidth(this._findInput.domNode);
+        }
+    }
+    _getHeight() {
+        let totalheight = 0;
+        totalheight += 4;
+        totalheight += this._findInput.inputBox.height + 2 ;
+        if (this._isReplaceVisible) {
+            totalheight += 4;
+            totalheight += this._replaceInput.inputBox.height + 2 ;
+        }
+        totalheight += 4;
+        return totalheight;
+    }
+    _tryUpdateHeight() {
+        const totalHeight = this._getHeight();
+        if (this._cachedHeight !== null && this._cachedHeight === totalHeight) {
+            return false;
+        }
+        this._cachedHeight = totalHeight;
+        this._domNode.style.height = `${totalHeight}px`;
+        return true;
+    }
+    focusFindInput() {
+        this._findInput.select();
+        this._findInput.focus();
+    }
+    focusReplaceInput() {
+        this._replaceInput.select();
+        this._replaceInput.focus();
+    }
+    highlightFindOptions() {
+        this._findInput.highlightFindOptions();
+    }
+    _updateSearchScope() {
+        if (!this._codeEditor.hasModel()) {
+            return;
+        }
+        if (this._toggleSelectionFind.checked) {
+            const selections = this._codeEditor.getSelections();
+            ( selections.map(selection => {
+                if (selection.endColumn === 1 && selection.endLineNumber > selection.startLineNumber) {
+                    selection = selection.setEndPosition(selection.endLineNumber - 1, this._codeEditor.getModel().getLineMaxColumn(selection.endLineNumber - 1));
+                }
+                const currentMatch = this._state.currentMatch;
+                if (selection.startLineNumber !== selection.endLineNumber) {
+                    if (!Range.equalsRange(selection, currentMatch)) {
+                        return selection;
+                    }
+                }
+                return null;
+            })).filter(element => !!element);
+            if (selections.length) {
+                this._state.change({ searchScope: selections }, true);
+            }
+        }
+    }
+    _onFindInputMouseDown(e) {
+        if (e.middleButton) {
+            e.stopPropagation();
+        }
+    }
+    _onFindInputKeyDown(e) {
+        if (e.equals(ctrlKeyMod | 3 )) {
+            if (this._keybindingService.dispatchEvent(e, e.target)) {
+                e.preventDefault();
+                return;
+            }
+            else {
+                this._findInput.inputBox.insertAtCursor('\n');
+                e.preventDefault();
+                return;
+            }
+        }
+        if (e.equals(2 )) {
+            if (this._isReplaceVisible) {
+                this._replaceInput.focus();
+            }
+            else {
+                this._findInput.focusOnCaseSensitive();
+            }
+            e.preventDefault();
+            return;
+        }
+        if (e.equals(2048  | 18 )) {
+            this._codeEditor.focus();
+            e.preventDefault();
+            return;
+        }
+        if (e.equals(16 )) {
+            return stopPropagationForMultiLineUpwards(e, this._findInput.getValue(), this._findInput.domNode.querySelector('textarea'));
+        }
+        if (e.equals(18 )) {
+            return stopPropagationForMultiLineDownwards(e, this._findInput.getValue(), this._findInput.domNode.querySelector('textarea'));
+        }
+    }
+    _onReplaceInputKeyDown(e) {
+        if (e.equals(ctrlKeyMod | 3 )) {
+            if (this._keybindingService.dispatchEvent(e, e.target)) {
+                e.preventDefault();
+                return;
+            }
+            else {
+                if (isWindows && isNative && !this._ctrlEnterReplaceAllWarningPrompted) {
+                    this._notificationService.info(( localizeWithPath(
+                        'vs/editor/contrib/find/browser/findWidget',
+                        'ctrlEnter.keybindingChanged',
+                        'Ctrl+Enter now inserts line break instead of replacing all. You can modify the keybinding for editor.action.replaceAll to override this behavior.'
+                    )));
+                    this._ctrlEnterReplaceAllWarningPrompted = true;
+                    this._storageService.store(ctrlEnterReplaceAllWarningPromptedKey, true, 0 , 0 );
+                }
+                this._replaceInput.inputBox.insertAtCursor('\n');
+                e.preventDefault();
+                return;
+            }
+        }
+        if (e.equals(2 )) {
+            this._findInput.focusOnCaseSensitive();
+            e.preventDefault();
+            return;
+        }
+        if (e.equals(1024  | 2 )) {
+            this._findInput.focus();
+            e.preventDefault();
+            return;
+        }
+        if (e.equals(2048  | 18 )) {
+            this._codeEditor.focus();
+            e.preventDefault();
+            return;
+        }
+        if (e.equals(16 )) {
+            return stopPropagationForMultiLineUpwards(e, this._replaceInput.inputBox.value, this._replaceInput.inputBox.element.querySelector('textarea'));
+        }
+        if (e.equals(18 )) {
+            return stopPropagationForMultiLineDownwards(e, this._replaceInput.inputBox.value, this._replaceInput.inputBox.element.querySelector('textarea'));
+        }
+    }
+    getVerticalSashLeft(_sash) {
+        return 0;
+    }
+    _keybindingLabelFor(actionId) {
+        const kb = this._keybindingService.lookupKeybinding(actionId);
+        if (!kb) {
+            return '';
+        }
+        return ` (${kb.getLabel()})`;
+    }
+    _buildDomNode() {
+        const flexibleHeight = true;
+        const flexibleWidth = true;
+        this._findInput = this._register(( new ContextScopedFindInput(null, this._contextViewProvider, {
+            width: FIND_INPUT_AREA_WIDTH,
+            label: NLS_FIND_INPUT_LABEL,
+            placeholder: NLS_FIND_INPUT_PLACEHOLDER,
+            appendCaseSensitiveLabel: this._keybindingLabelFor(FIND_IDS.ToggleCaseSensitiveCommand),
+            appendWholeWordsLabel: this._keybindingLabelFor(FIND_IDS.ToggleWholeWordCommand),
+            appendRegexLabel: this._keybindingLabelFor(FIND_IDS.ToggleRegexCommand),
+            validation: (value) => {
+                if (value.length === 0 || !this._findInput.getRegex()) {
+                    return null;
+                }
+                try {
+                    return null;
+                }
+                catch (e) {
+                    return { content: e.message };
+                }
+            },
+            flexibleHeight,
+            flexibleWidth,
+            flexibleMaxHeight: 118,
+            showCommonFindToggles: true,
+            showHistoryHint: () => showHistoryKeybindingHint(this._keybindingService),
+            inputBoxStyles: defaultInputBoxStyles,
+            toggleStyles: defaultToggleStyles
+        }, this._contextKeyService)));
+        this._findInput.setRegex(!!this._state.isRegex);
+        this._findInput.setCaseSensitive(!!this._state.matchCase);
+        this._findInput.setWholeWords(!!this._state.wholeWord);
+        this._register(this._findInput.onKeyDown((e) => this._onFindInputKeyDown(e)));
+        this._register(this._findInput.inputBox.onDidChange(() => {
+            if (this._ignoreChangeEvent) {
+                return;
+            }
+            this._state.change({ searchString: this._findInput.getValue() }, true);
+        }));
+        this._register(this._findInput.onDidOptionChange(() => {
+            this._state.change({
+                isRegex: this._findInput.getRegex(),
+                wholeWord: this._findInput.getWholeWords(),
+                matchCase: this._findInput.getCaseSensitive()
+            }, true);
+        }));
+        this._register(this._findInput.onCaseSensitiveKeyDown((e) => {
+            if (e.equals(1024  | 2 )) {
+                if (this._isReplaceVisible) {
+                    this._replaceInput.focus();
+                    e.preventDefault();
+                }
+            }
+        }));
+        this._register(this._findInput.onRegexKeyDown((e) => {
+            if (e.equals(2 )) {
+                if (this._isReplaceVisible) {
+                    this._replaceInput.focusOnPreserve();
+                    e.preventDefault();
+                }
+            }
+        }));
+        this._register(this._findInput.inputBox.onDidHeightChange((e) => {
+            if (this._tryUpdateHeight()) {
+                this._showViewZone();
+            }
+        }));
+        if (isLinux) {
+            this._register(this._findInput.onMouseDown((e) => this._onFindInputMouseDown(e)));
+        }
+        this._matchesCount = document.createElement('div');
+        this._matchesCount.className = 'matchesCount';
+        this._updateMatchesCount();
+        this._prevBtn = this._register(( new SimpleButton({
+            label: NLS_PREVIOUS_MATCH_BTN_LABEL + this._keybindingLabelFor(FIND_IDS.PreviousMatchFindAction),
+            icon: findPreviousMatchIcon,
+            onTrigger: () => {
+                assertIsDefined(this._codeEditor.getAction(FIND_IDS.PreviousMatchFindAction)).run().then(undefined, onUnexpectedError);
+            }
+        })));
+        this._nextBtn = this._register(( new SimpleButton({
+            label: NLS_NEXT_MATCH_BTN_LABEL + this._keybindingLabelFor(FIND_IDS.NextMatchFindAction),
+            icon: findNextMatchIcon,
+            onTrigger: () => {
+                assertIsDefined(this._codeEditor.getAction(FIND_IDS.NextMatchFindAction)).run().then(undefined, onUnexpectedError);
+            }
+        })));
+        const findPart = document.createElement('div');
+        findPart.className = 'find-part';
+        findPart.appendChild(this._findInput.domNode);
+        const actionsContainer = document.createElement('div');
+        actionsContainer.className = 'find-actions';
+        findPart.appendChild(actionsContainer);
+        actionsContainer.appendChild(this._matchesCount);
+        actionsContainer.appendChild(this._prevBtn.domNode);
+        actionsContainer.appendChild(this._nextBtn.domNode);
+        this._toggleSelectionFind = this._register(( new Toggle({
+            icon: findSelectionIcon,
+            title: NLS_TOGGLE_SELECTION_FIND_TITLE + this._keybindingLabelFor(FIND_IDS.ToggleSearchScopeCommand),
+            isChecked: false,
+            inputActiveOptionBackground: asCssVariable(inputActiveOptionBackground),
+            inputActiveOptionBorder: asCssVariable(inputActiveOptionBorder),
+            inputActiveOptionForeground: asCssVariable(inputActiveOptionForeground),
+        })));
+        this._register(this._toggleSelectionFind.onChange(() => {
+            if (this._toggleSelectionFind.checked) {
+                if (this._codeEditor.hasModel()) {
+                    let selections = this._codeEditor.getSelections();
+                    selections = ( selections.map(selection => {
+                        if (selection.endColumn === 1 && selection.endLineNumber > selection.startLineNumber) {
+                            selection = selection.setEndPosition(selection.endLineNumber - 1, this._codeEditor.getModel().getLineMaxColumn(selection.endLineNumber - 1));
+                        }
+                        if (!selection.isEmpty()) {
+                            return selection;
+                        }
+                        return null;
+                    })).filter((element) => !!element);
+                    if (selections.length) {
+                        this._state.change({ searchScope: selections }, true);
+                    }
+                }
+            }
+            else {
+                this._state.change({ searchScope: null }, true);
+            }
+        }));
+        actionsContainer.appendChild(this._toggleSelectionFind.domNode);
+        this._closeBtn = this._register(( new SimpleButton({
+            label: NLS_CLOSE_BTN_LABEL + this._keybindingLabelFor(FIND_IDS.CloseFindWidgetCommand),
+            icon: widgetClose,
+            onTrigger: () => {
+                this._state.change({ isRevealed: false, searchScope: null }, false);
+            },
+            onKeyDown: (e) => {
+                if (e.equals(2 )) {
+                    if (this._isReplaceVisible) {
+                        if (this._replaceBtn.isEnabled()) {
+                            this._replaceBtn.focus();
+                        }
+                        else {
+                            this._codeEditor.focus();
+                        }
+                        e.preventDefault();
+                    }
+                }
+            }
+        })));
+        this._replaceInput = this._register(( new ContextScopedReplaceInput(null, undefined, {
+            label: NLS_REPLACE_INPUT_LABEL,
+            placeholder: NLS_REPLACE_INPUT_PLACEHOLDER,
+            appendPreserveCaseLabel: this._keybindingLabelFor(FIND_IDS.TogglePreserveCaseCommand),
+            history: [],
+            flexibleHeight,
+            flexibleWidth,
+            flexibleMaxHeight: 118,
+            showHistoryHint: () => showHistoryKeybindingHint(this._keybindingService),
+            inputBoxStyles: defaultInputBoxStyles,
+            toggleStyles: defaultToggleStyles
+        }, this._contextKeyService, true)));
+        this._replaceInput.setPreserveCase(!!this._state.preserveCase);
+        this._register(this._replaceInput.onKeyDown((e) => this._onReplaceInputKeyDown(e)));
+        this._register(this._replaceInput.inputBox.onDidChange(() => {
+            this._state.change({ replaceString: this._replaceInput.inputBox.value }, false);
+        }));
+        this._register(this._replaceInput.inputBox.onDidHeightChange((e) => {
+            if (this._isReplaceVisible && this._tryUpdateHeight()) {
+                this._showViewZone();
+            }
+        }));
+        this._register(this._replaceInput.onDidOptionChange(() => {
+            this._state.change({
+                preserveCase: this._replaceInput.getPreserveCase()
+            }, true);
+        }));
+        this._register(this._replaceInput.onPreserveCaseKeyDown((e) => {
+            if (e.equals(2 )) {
+                if (this._prevBtn.isEnabled()) {
+                    this._prevBtn.focus();
+                }
+                else if (this._nextBtn.isEnabled()) {
+                    this._nextBtn.focus();
+                }
+                else if (this._toggleSelectionFind.enabled) {
+                    this._toggleSelectionFind.focus();
+                }
+                else if (this._closeBtn.isEnabled()) {
+                    this._closeBtn.focus();
+                }
+                e.preventDefault();
+            }
+        }));
+        this._replaceBtn = this._register(( new SimpleButton({
+            label: NLS_REPLACE_BTN_LABEL + this._keybindingLabelFor(FIND_IDS.ReplaceOneAction),
+            icon: findReplaceIcon,
+            onTrigger: () => {
+                this._controller.replace();
+            },
+            onKeyDown: (e) => {
+                if (e.equals(1024  | 2 )) {
+                    this._closeBtn.focus();
+                    e.preventDefault();
+                }
+            }
+        })));
+        this._replaceAllBtn = this._register(( new SimpleButton({
+            label: NLS_REPLACE_ALL_BTN_LABEL + this._keybindingLabelFor(FIND_IDS.ReplaceAllAction),
+            icon: findReplaceAllIcon,
+            onTrigger: () => {
+                this._controller.replaceAll();
+            }
+        })));
+        const replacePart = document.createElement('div');
+        replacePart.className = 'replace-part';
+        replacePart.appendChild(this._replaceInput.domNode);
+        const replaceActionsContainer = document.createElement('div');
+        replaceActionsContainer.className = 'replace-actions';
+        replacePart.appendChild(replaceActionsContainer);
+        replaceActionsContainer.appendChild(this._replaceBtn.domNode);
+        replaceActionsContainer.appendChild(this._replaceAllBtn.domNode);
+        this._toggleReplaceBtn = this._register(( new SimpleButton({
+            label: NLS_TOGGLE_REPLACE_MODE_BTN_LABEL,
+            className: 'codicon toggle left',
+            onTrigger: () => {
+                this._state.change({ isReplaceRevealed: !this._isReplaceVisible }, false);
+                if (this._isReplaceVisible) {
+                    this._replaceInput.width = getTotalWidth(this._findInput.domNode);
+                    this._replaceInput.inputBox.layout();
+                }
+                this._showViewZone();
+            }
+        })));
+        this._toggleReplaceBtn.setExpanded(this._isReplaceVisible);
+        this._domNode = document.createElement('div');
+        this._domNode.className = 'editor-widget find-widget';
+        this._domNode.setAttribute('aria-hidden', 'true');
+        this._domNode.ariaLabel = NLS_FIND_DIALOG_LABEL;
+        this._domNode.role = 'dialog';
+        this._domNode.style.width = `${FIND_WIDGET_INITIAL_WIDTH}px`;
+        this._domNode.appendChild(this._toggleReplaceBtn.domNode);
+        this._domNode.appendChild(findPart);
+        this._domNode.appendChild(this._closeBtn.domNode);
+        this._domNode.appendChild(replacePart);
+        this._resizeSash = ( new Sash(
+            this._domNode,
+            this,
+            { orientation: 0 , size: 2 }
+        ));
+        this._resized = false;
+        let originalWidth = FIND_WIDGET_INITIAL_WIDTH;
+        this._register(this._resizeSash.onDidStart(() => {
+            originalWidth = getTotalWidth(this._domNode);
+        }));
+        this._register(this._resizeSash.onDidChange((evt) => {
+            this._resized = true;
+            const width = originalWidth + evt.startX - evt.currentX;
+            if (width < FIND_WIDGET_INITIAL_WIDTH) {
+                return;
+            }
+            const maxWidth = parseFloat(getComputedStyle(this._domNode).maxWidth) || 0;
+            if (width > maxWidth) {
+                return;
+            }
+            this._domNode.style.width = `${width}px`;
+            if (this._isReplaceVisible) {
+                this._replaceInput.width = getTotalWidth(this._findInput.domNode);
+            }
+            this._findInput.inputBox.layout();
+            this._tryUpdateHeight();
+        }));
+        this._register(this._resizeSash.onDidReset(() => {
+            const currentWidth = getTotalWidth(this._domNode);
+            if (currentWidth < FIND_WIDGET_INITIAL_WIDTH) {
+                return;
+            }
+            let width = FIND_WIDGET_INITIAL_WIDTH;
+            if (!this._resized || currentWidth === FIND_WIDGET_INITIAL_WIDTH) {
+                const layoutInfo = this._codeEditor.getLayoutInfo();
+                width = layoutInfo.width - 28 - layoutInfo.minimap.minimapWidth - 15;
+                this._resized = true;
+            }
+            this._domNode.style.width = `${width}px`;
+            if (this._isReplaceVisible) {
+                this._replaceInput.width = getTotalWidth(this._findInput.domNode);
+            }
+            this._findInput.inputBox.layout();
+        }));
+    }
+    updateAccessibilitySupport() {
+        const value = this._codeEditor.getOption(2 );
+        this._findInput.setFocusInputOnOptionClick(value !== 2 );
+    }
+    getViewState() {
+        let widgetViewZoneVisible = false;
+        if (this._viewZone && this._viewZoneId) {
+            widgetViewZoneVisible = this._viewZone.heightInPx > this._codeEditor.getScrollTop();
+        }
+        return {
+            widgetViewZoneVisible,
+            scrollTop: this._codeEditor.getScrollTop()
+        };
+    }
+    setViewState(state) {
+        if (!state) {
+            return;
+        }
+        if (state.widgetViewZoneVisible) {
+            this._layoutViewZone(state.scrollTop);
+        }
+    }
+}
+class SimpleButton extends Widget {
+    constructor(opts) {
+        super();
+        this._opts = opts;
+        let className = 'button';
+        if (this._opts.className) {
+            className = className + ' ' + this._opts.className;
+        }
+        if (this._opts.icon) {
+            className = className + ' ' + ThemeIcon.asClassName(this._opts.icon);
+        }
+        this._domNode = document.createElement('div');
+        this._domNode.title = this._opts.label;
+        this._domNode.tabIndex = 0;
+        this._domNode.className = className;
+        this._domNode.setAttribute('role', 'button');
+        this._domNode.setAttribute('aria-label', this._opts.label);
+        this.onclick(this._domNode, (e) => {
+            this._opts.onTrigger();
+            e.preventDefault();
+        });
+        this.onkeydown(this._domNode, (e) => {
+            if (e.equals(10 ) || e.equals(3 )) {
+                this._opts.onTrigger();
+                e.preventDefault();
+                return;
+            }
+            this._opts.onKeyDown?.(e);
+        });
+    }
+    get domNode() {
+        return this._domNode;
+    }
+    isEnabled() {
+        return (this._domNode.tabIndex >= 0);
+    }
+    focus() {
+        this._domNode.focus();
+    }
+    setEnabled(enabled) {
+        this._domNode.classList.toggle('disabled', !enabled);
+        this._domNode.setAttribute('aria-disabled', String(!enabled));
+        this._domNode.tabIndex = enabled ? 0 : -1;
+    }
+    setExpanded(expanded) {
+        this._domNode.setAttribute('aria-expanded', String(!!expanded));
+        if (expanded) {
+            this._domNode.classList.remove(...ThemeIcon.asClassNameArray(findCollapsedIcon));
+            this._domNode.classList.add(...ThemeIcon.asClassNameArray(findExpandedIcon));
+        }
+        else {
+            this._domNode.classList.remove(...ThemeIcon.asClassNameArray(findExpandedIcon));
+            this._domNode.classList.add(...ThemeIcon.asClassNameArray(findCollapsedIcon));
+        }
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const addBackgroundColorRule = (selector, color) => {
+        if (color) {
+            collector.addRule(`.monaco-editor ${selector} { background-color: ${color}; }`);
+        }
+    };
+    addBackgroundColorRule('.findMatch', theme.getColor(editorFindMatchHighlight));
+    addBackgroundColorRule('.currentFindMatch', theme.getColor(editorFindMatch));
+    addBackgroundColorRule('.findScope', theme.getColor(editorFindRangeHighlight));
+    const widgetBackground = theme.getColor(editorWidgetBackground);
+    addBackgroundColorRule('.find-widget', widgetBackground);
+    const widgetShadowColor = theme.getColor(widgetShadow);
+    if (widgetShadowColor) {
+        collector.addRule(`.monaco-editor .find-widget { box-shadow: 0 0 8px 2px ${widgetShadowColor}; }`);
+    }
+    const widgetBorderColor = theme.getColor(widgetBorder);
+    if (widgetBorderColor) {
+        collector.addRule(`.monaco-editor .find-widget { border-left: 1px solid ${widgetBorderColor}; border-right: 1px solid ${widgetBorderColor}; border-bottom: 1px solid ${widgetBorderColor}; }`);
+    }
+    const findMatchHighlightBorder = theme.getColor(editorFindMatchHighlightBorder);
+    if (findMatchHighlightBorder) {
+        collector.addRule(`.monaco-editor .findMatch { border: 1px ${isHighContrast(theme.type) ? 'dotted' : 'solid'} ${findMatchHighlightBorder}; box-sizing: border-box; }`);
+    }
+    const findMatchBorder = theme.getColor(editorFindMatchBorder);
+    if (findMatchBorder) {
+        collector.addRule(`.monaco-editor .currentFindMatch { border: 2px solid ${findMatchBorder}; padding: 1px; box-sizing: border-box; }`);
+    }
+    const findRangeHighlightBorder = theme.getColor(editorFindRangeHighlightBorder);
+    if (findRangeHighlightBorder) {
+        collector.addRule(`.monaco-editor .findScope { border: 1px ${isHighContrast(theme.type) ? 'dashed' : 'solid'} ${findRangeHighlightBorder}; }`);
+    }
+    const hcBorder = theme.getColor(contrastBorder);
+    if (hcBorder) {
+        collector.addRule(`.monaco-editor .find-widget { border: 1px solid ${hcBorder}; }`);
+    }
+    const foreground = theme.getColor(editorWidgetForeground);
+    if (foreground) {
+        collector.addRule(`.monaco-editor .find-widget { color: ${foreground}; }`);
+    }
+    const error = theme.getColor(errorForeground);
+    if (error) {
+        collector.addRule(`.monaco-editor .find-widget.no-results .matchesCount { color: ${error}; }`);
+    }
+    const resizeBorderBackground = theme.getColor(editorWidgetResizeBorder);
+    if (resizeBorderBackground) {
+        collector.addRule(`.monaco-editor .find-widget .monaco-sash { background-color: ${resizeBorderBackground}; }`);
+    }
+    else {
+        const border = theme.getColor(editorWidgetBorder);
+        if (border) {
+            collector.addRule(`.monaco-editor .find-widget .monaco-sash { background-color: ${border}; }`);
+        }
+    }
+    const toolbarHoverBackgroundColor = theme.getColor(toolbarHoverBackground);
+    if (toolbarHoverBackgroundColor) {
+        collector.addRule(`
+		.monaco-editor .find-widget .button:not(.disabled):hover,
+		.monaco-editor .find-widget .codicon-find-selection:hover {
+			background-color: ${toolbarHoverBackgroundColor} !important;
+		}
+	`);
+    }
+    const focusOutline = theme.getColor(focusBorder);
+    if (focusOutline) {
+        collector.addRule(`.monaco-editor .find-widget .monaco-inputbox.synthetic-focus { outline-color: ${focusOutline}; }`);
+    }
+});
+export { FindWidget, FindWidgetViewZone, NLS_MATCHES_LOCATION, NLS_NO_RESULTS, SimpleButton, findNextMatchIcon, findPreviousMatchIcon, findReplaceAllIcon, findReplaceIcon };