@codingame/monaco-vscode-search-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/search/browser/searchWidget.js

@@ -0,0 +1,674 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $, trackFocus } from 'vscode/vscode/vs/base/browser/dom';
+import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { InputBox } from 'vscode/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { Widget } from 'vscode/vscode/vs/base/browser/ui/widget';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { Delayer } from 'vscode/vscode/vs/base/common/async';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { CONTEXT_FIND_WIDGET_NOT_VISIBLE } from 'vscode/vscode/vs/editor/contrib/find/browser/findModel';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextViewService, IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { KeybindingsRegistry } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { ContextScopedReplaceInput } from 'vscode/vscode/vs/platform/history/browser/contextScopedHistoryWidget';
+import { appendKeyBindingLabel, isSearchViewFocused, getSearchView } from 'vscode/vscode/vs/workbench/contrib/search/browser/searchActionsBase';
+import { SearchContext } from 'vscode/vscode/vs/workbench/contrib/search/common/constants';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
+import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
+import { Toggle } from 'vscode/vscode/vs/base/browser/ui/toggle/toggle';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
+import { searchReplaceAllIcon, searchHideReplaceIcon, searchShowContextIcon, searchShowReplaceIcon } from './searchIcons.js';
+import { ToggleSearchEditorContextLinesCommandId } from 'vscode/vscode/vs/workbench/contrib/searchEditor/browser/constants';
+import { showHistoryKeybindingHint } from 'vscode/vscode/vs/platform/history/browser/historyWidgetKeybindingHint';
+import { defaultToggleStyles, defaultInputBoxStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { NotebookFindFilters } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/contrib/find/findFilters';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { SearchFindInput } from './searchFindInput.js';
+import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+var SearchWidget_1;
+const SingleLineInputHeight = 26;
+class ReplaceAllAction extends Action {
+    static { this.ID = 'search.action.replaceAll'; }
+    constructor(_searchWidget) {
+        super(ReplaceAllAction.ID, '', ThemeIcon.asClassName(searchReplaceAllIcon), false);
+        this._searchWidget = _searchWidget;
+    }
+    set searchWidget(searchWidget) {
+        this._searchWidget = searchWidget;
+    }
+    run() {
+        if (this._searchWidget) {
+            return this._searchWidget.triggerReplaceAll();
+        }
+        return Promise.resolve(null);
+    }
+}
+const ctrlKeyMod = ((isMacintosh ? 256  : 2048) );
+function stopPropagationForMultiLineUpwards(event, value, textarea) {
+    const isMultiline = !!value.match(/\n/);
+    if (textarea && (isMultiline || textarea.clientHeight > SingleLineInputHeight) && textarea.selectionStart > 0) {
+        event.stopPropagation();
+        return;
+    }
+}
+function stopPropagationForMultiLineDownwards(event, value, textarea) {
+    const isMultiline = !!value.match(/\n/);
+    if (textarea && (isMultiline || textarea.clientHeight > SingleLineInputHeight) && textarea.selectionEnd < textarea.value.length) {
+        event.stopPropagation();
+        return;
+    }
+}
+let SearchWidget = class SearchWidget extends Widget {
+    static { SearchWidget_1 = this; }
+    static { this.INPUT_MAX_HEIGHT = 134; }
+    static { this.REPLACE_ALL_DISABLED_LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/search/browser/searchWidget',
+        'search.action.replaceAll.disabled.label',
+        "Replace All (Submit Search to Enable)"
+    )); }
+    static { this.REPLACE_ALL_ENABLED_LABEL = (keyBindingService2) => {
+        const kb = keyBindingService2.lookupKeybinding(ReplaceAllAction.ID);
+        return appendKeyBindingLabel(( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchWidget',
+            'search.action.replaceAll.enabled.label',
+            "Replace All"
+        )), kb);
+    }; }
+    constructor(container, options, contextViewService, contextKeyService, keybindingService, clipboardServce, configurationService, accessibilityService, contextMenuService, instantiationService, editorService) {
+        super();
+        this.contextViewService = contextViewService;
+        this.contextKeyService = contextKeyService;
+        this.keybindingService = keybindingService;
+        this.clipboardServce = clipboardServce;
+        this.configurationService = configurationService;
+        this.accessibilityService = accessibilityService;
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.ignoreGlobalFindBufferOnNextFocus = false;
+        this.previousGlobalFindBufferValue = null;
+        this._onSearchSubmit = this._register(( new Emitter()));
+        this.onSearchSubmit = this._onSearchSubmit.event;
+        this._onSearchCancel = this._register(( new Emitter()));
+        this.onSearchCancel = this._onSearchCancel.event;
+        this._onReplaceToggled = this._register(( new Emitter()));
+        this.onReplaceToggled = this._onReplaceToggled.event;
+        this._onReplaceStateChange = this._register(( new Emitter()));
+        this.onReplaceStateChange = this._onReplaceStateChange.event;
+        this._onPreserveCaseChange = this._register(( new Emitter()));
+        this.onPreserveCaseChange = this._onPreserveCaseChange.event;
+        this._onReplaceValueChanged = this._register(( new Emitter()));
+        this.onReplaceValueChanged = this._onReplaceValueChanged.event;
+        this._onReplaceAll = this._register(( new Emitter()));
+        this.onReplaceAll = this._onReplaceAll.event;
+        this._onBlur = this._register(( new Emitter()));
+        this.onBlur = this._onBlur.event;
+        this._onDidHeightChange = this._register(( new Emitter()));
+        this.onDidHeightChange = this._onDidHeightChange.event;
+        this._onDidToggleContext = ( new Emitter());
+        this.onDidToggleContext = this._onDidToggleContext.event;
+        this.replaceActive = SearchContext.ReplaceActiveKey.bindTo(this.contextKeyService);
+        this.searchInputBoxFocused = SearchContext.SearchInputBoxFocusedKey.bindTo(this.contextKeyService);
+        this.replaceInputBoxFocused = SearchContext.ReplaceInputBoxFocusedKey.bindTo(this.contextKeyService);
+        const notebookOptions = options.notebookOptions ??
+            {
+                isInNotebookMarkdownInput: true,
+                isInNotebookMarkdownPreview: true,
+                isInNotebookCellInput: true,
+                isInNotebookCellOutput: true
+            };
+        this._notebookFilters = this._register(( new NotebookFindFilters(
+            notebookOptions.isInNotebookMarkdownInput,
+            notebookOptions.isInNotebookMarkdownPreview,
+            notebookOptions.isInNotebookCellInput,
+            notebookOptions.isInNotebookCellOutput
+        )));
+        this._register(this._notebookFilters.onDidChange(() => {
+            if (this.searchInput) {
+                this.searchInput.updateStyles();
+            }
+        }));
+        this._register(this.editorService.onDidEditorsChange((e) => {
+            if (this.searchInput &&
+                e.event.editor instanceof NotebookEditorInput &&
+                ((e.event.kind === 4  || e.event.kind === 5) )) {
+                this.searchInput.filterVisible = this._hasNotebookOpen();
+            }
+        }));
+        this._replaceHistoryDelayer = ( new Delayer(500));
+        this._toggleReplaceButtonListener = this._register(( new MutableDisposable()));
+        this.render(container, options);
+        this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor.accessibilitySupport')) {
+                this.updateAccessibilitySupport();
+            }
+        });
+        this.accessibilityService.onDidChangeScreenReaderOptimized(() => this.updateAccessibilitySupport());
+        this.updateAccessibilitySupport();
+    }
+    _hasNotebookOpen() {
+        const editors = this.editorService.editors;
+        return ( editors.some(editor => editor instanceof NotebookEditorInput));
+    }
+    getNotebookFilters() {
+        return this._notebookFilters;
+    }
+    focus(select = true, focusReplace = false, suppressGlobalSearchBuffer = false) {
+        this.ignoreGlobalFindBufferOnNextFocus = suppressGlobalSearchBuffer;
+        if (focusReplace && this.isReplaceShown()) {
+            if (this.replaceInput) {
+                this.replaceInput.focus();
+                if (select) {
+                    this.replaceInput.select();
+                }
+            }
+        }
+        else {
+            if (this.searchInput) {
+                this.searchInput.focus();
+                if (select) {
+                    this.searchInput.select();
+                }
+            }
+        }
+    }
+    setWidth(width) {
+        this.searchInput?.inputBox.layout();
+        if (this.replaceInput) {
+            this.replaceInput.width = width - 28;
+            this.replaceInput.inputBox.layout();
+        }
+    }
+    clear() {
+        this.searchInput?.clear();
+        this.replaceInput?.setValue('');
+        this.setReplaceAllActionState(false);
+    }
+    isReplaceShown() {
+        return this.replaceContainer ? !this.replaceContainer.classList.contains('disabled') : false;
+    }
+    isReplaceActive() {
+        return !!this.replaceActive.get();
+    }
+    getReplaceValue() {
+        return this.replaceInput?.getValue() ?? '';
+    }
+    toggleReplace(show) {
+        if (show === undefined || show !== this.isReplaceShown()) {
+            this.onToggleReplaceButton();
+        }
+    }
+    getSearchHistory() {
+        return this.searchInput?.inputBox.getHistory() ?? [];
+    }
+    getReplaceHistory() {
+        return this.replaceInput?.inputBox.getHistory() ?? [];
+    }
+    prependSearchHistory(history) {
+        this.searchInput?.inputBox.prependHistory(history);
+    }
+    prependReplaceHistory(history) {
+        this.replaceInput?.inputBox.prependHistory(history);
+    }
+    clearHistory() {
+        this.searchInput?.inputBox.clearHistory();
+        this.replaceInput?.inputBox.clearHistory();
+    }
+    showNextSearchTerm() {
+        this.searchInput?.inputBox.showNextValue();
+    }
+    showPreviousSearchTerm() {
+        this.searchInput?.inputBox.showPreviousValue();
+    }
+    showNextReplaceTerm() {
+        this.replaceInput?.inputBox.showNextValue();
+    }
+    showPreviousReplaceTerm() {
+        this.replaceInput?.inputBox.showPreviousValue();
+    }
+    searchInputHasFocus() {
+        return !!this.searchInputBoxFocused.get();
+    }
+    replaceInputHasFocus() {
+        return !!this.replaceInput?.inputBox.hasFocus();
+    }
+    focusReplaceAllAction() {
+        this.replaceActionBar?.focus(true);
+    }
+    focusRegexAction() {
+        this.searchInput?.focusOnRegex();
+    }
+    render(container, options) {
+        this.domNode = append(container, $('.search-widget'));
+        this.domNode.style.position = 'relative';
+        if (!options._hideReplaceToggle) {
+            this.renderToggleReplaceButton(this.domNode);
+        }
+        this.renderSearchInput(this.domNode, options);
+        this.renderReplaceInput(this.domNode, options);
+    }
+    updateAccessibilitySupport() {
+        this.searchInput?.setFocusInputOnOptionClick(!this.accessibilityService.isScreenReaderOptimized());
+    }
+    renderToggleReplaceButton(parent) {
+        const opts = {
+            buttonBackground: undefined,
+            buttonBorder: undefined,
+            buttonForeground: undefined,
+            buttonHoverBackground: undefined,
+            buttonSecondaryBackground: undefined,
+            buttonSecondaryForeground: undefined,
+            buttonSecondaryHoverBackground: undefined,
+            buttonSeparator: undefined,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchWidget',
+                'search.replace.toggle.button.title',
+                "Toggle Replace"
+            )),
+            hoverDelegate: getDefaultHoverDelegate('element'),
+        };
+        this.toggleReplaceButton = this._register(( new Button(parent, opts)));
+        this.toggleReplaceButton.element.setAttribute('aria-expanded', 'false');
+        this.toggleReplaceButton.element.classList.add('toggle-replace-button');
+        this.toggleReplaceButton.icon = searchHideReplaceIcon;
+        this._toggleReplaceButtonListener.value = this.toggleReplaceButton.onDidClick(() => this.onToggleReplaceButton());
+    }
+    renderSearchInput(parent, options) {
+        const inputOptions = {
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchWidget',
+                'label.Search',
+                'Search: Type Search Term and press Enter to search'
+            )),
+            validation: (value) => this.validateSearchInput(value),
+            placeholder: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchWidget',
+                'search.placeHolder',
+                "Search"
+            )),
+            appendCaseSensitiveLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding("toggleSearchCaseSensitive" )),
+            appendWholeWordsLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding("toggleSearchWholeWord" )),
+            appendRegexLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding("toggleSearchRegex" )),
+            history: options.searchHistory,
+            showHistoryHint: () => showHistoryKeybindingHint(this.keybindingService),
+            flexibleHeight: true,
+            flexibleMaxHeight: SearchWidget_1.INPUT_MAX_HEIGHT,
+            showCommonFindToggles: true,
+            inputBoxStyles: options.inputBoxStyles,
+            toggleStyles: options.toggleStyles
+        };
+        const searchInputContainer = append(parent, $('.search-container.input-box'));
+        this.searchInput = this._register(( new SearchFindInput(
+            searchInputContainer,
+            this.contextViewService,
+            inputOptions,
+            this.contextKeyService,
+            this.contextMenuService,
+            this.instantiationService,
+            this._notebookFilters,
+            options.initialAIButtonVisibility ?? false,
+            this._hasNotebookOpen()
+        )));
+        this.searchInput.onKeyDown((keyboardEvent) => this.onSearchInputKeyDown(keyboardEvent));
+        this.searchInput.setValue(options.value || '');
+        this.searchInput.setRegex(!!options.isRegex);
+        this.searchInput.setCaseSensitive(!!options.isCaseSensitive);
+        this.searchInput.setWholeWords(!!options.isWholeWords);
+        this._register(this.searchInput.onCaseSensitiveKeyDown((keyboardEvent) => this.onCaseSensitiveKeyDown(keyboardEvent)));
+        this._register(this.searchInput.onRegexKeyDown((keyboardEvent) => this.onRegexKeyDown(keyboardEvent)));
+        this._register(this.searchInput.inputBox.onDidChange(() => this.onSearchInputChanged()));
+        this._register(this.searchInput.inputBox.onDidHeightChange(() => this._onDidHeightChange.fire()));
+        this._register(this.onReplaceValueChanged(() => {
+            this._replaceHistoryDelayer.trigger(() => this.replaceInput?.inputBox.addToHistory());
+        }));
+        this.searchInputFocusTracker = this._register(trackFocus(this.searchInput.inputBox.inputElement));
+        this._register(this.searchInputFocusTracker.onDidFocus(async () => {
+            this.searchInputBoxFocused.set(true);
+            const useGlobalFindBuffer = this.searchConfiguration.globalFindClipboard;
+            if (!this.ignoreGlobalFindBufferOnNextFocus && useGlobalFindBuffer) {
+                const globalBufferText = await this.clipboardServce.readFindText();
+                if (globalBufferText && this.previousGlobalFindBufferValue !== globalBufferText) {
+                    this.searchInput?.inputBox.addToHistory();
+                    this.searchInput?.setValue(globalBufferText);
+                    this.searchInput?.select();
+                }
+                this.previousGlobalFindBufferValue = globalBufferText;
+            }
+            this.ignoreGlobalFindBufferOnNextFocus = false;
+        }));
+        this._register(this.searchInputFocusTracker.onDidBlur(() => this.searchInputBoxFocused.set(false)));
+        this.showContextToggle = ( new Toggle({
+            isChecked: false,
+            title: appendKeyBindingLabel(( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchWidget',
+                'showContext',
+                "Toggle Context Lines"
+            )), this.keybindingService.lookupKeybinding(ToggleSearchEditorContextLinesCommandId)),
+            icon: searchShowContextIcon,
+            hoverDelegate: getDefaultHoverDelegate('element'),
+            ...defaultToggleStyles
+        }));
+        this._register(this.showContextToggle.onChange(() => this.onContextLinesChanged()));
+        if (options.showContextToggle) {
+            this.contextLinesInput = ( new InputBox(
+                searchInputContainer,
+                this.contextViewService,
+                { type: 'number', inputBoxStyles: defaultInputBoxStyles }
+            ));
+            this.contextLinesInput.element.classList.add('context-lines-input');
+            this.contextLinesInput.value = '' + (this.configurationService.getValue('search').searchEditor.defaultNumberOfContextLines ?? 1);
+            this._register(this.contextLinesInput.onDidChange((value) => {
+                if (value !== '0') {
+                    this.showContextToggle.checked = true;
+                }
+                this.onContextLinesChanged();
+            }));
+            append(searchInputContainer, this.showContextToggle.domNode);
+        }
+    }
+    onContextLinesChanged() {
+        this._onDidToggleContext.fire();
+        if (this.contextLinesInput.value.includes('-')) {
+            this.contextLinesInput.value = '0';
+        }
+        this._onDidToggleContext.fire();
+    }
+    setContextLines(lines) {
+        if (!this.contextLinesInput) {
+            return;
+        }
+        if (lines === 0) {
+            this.showContextToggle.checked = false;
+        }
+        else {
+            this.showContextToggle.checked = true;
+            this.contextLinesInput.value = '' + lines;
+        }
+    }
+    renderReplaceInput(parent, options) {
+        this.replaceContainer = append(parent, $('.replace-container.disabled'));
+        const replaceBox = append(this.replaceContainer, $('.replace-input'));
+        this.replaceInput = this._register(( new ContextScopedReplaceInput(replaceBox, this.contextViewService, {
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchWidget',
+                'label.Replace',
+                'Replace: Type replace term and press Enter to preview'
+            )),
+            placeholder: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchWidget',
+                'search.replace.placeHolder',
+                "Replace"
+            )),
+            appendPreserveCaseLabel: appendKeyBindingLabel('', this.keybindingService.lookupKeybinding("toggleSearchPreserveCase" )),
+            history: options.replaceHistory,
+            showHistoryHint: () => showHistoryKeybindingHint(this.keybindingService),
+            flexibleHeight: true,
+            flexibleMaxHeight: SearchWidget_1.INPUT_MAX_HEIGHT,
+            inputBoxStyles: options.inputBoxStyles,
+            toggleStyles: options.toggleStyles
+        }, this.contextKeyService, true)));
+        this._register(this.replaceInput.onDidOptionChange(viaKeyboard => {
+            if (!viaKeyboard) {
+                if (this.replaceInput) {
+                    this._onPreserveCaseChange.fire(this.replaceInput.getPreserveCase());
+                }
+            }
+        }));
+        this.replaceInput.onKeyDown((keyboardEvent) => this.onReplaceInputKeyDown(keyboardEvent));
+        this.replaceInput.setValue(options.replaceValue || '');
+        this._register(this.replaceInput.inputBox.onDidChange(() => this._onReplaceValueChanged.fire()));
+        this._register(this.replaceInput.inputBox.onDidHeightChange(() => this._onDidHeightChange.fire()));
+        this.replaceAllAction = ( new ReplaceAllAction(this));
+        this.replaceAllAction.label = SearchWidget_1.REPLACE_ALL_DISABLED_LABEL;
+        this.replaceActionBar = this._register(( new ActionBar(this.replaceContainer)));
+        this.replaceActionBar.push([this.replaceAllAction], { icon: true, label: false });
+        this.onkeydown(this.replaceActionBar.domNode, (keyboardEvent) => this.onReplaceActionbarKeyDown(keyboardEvent));
+        this.replaceInputFocusTracker = this._register(trackFocus(this.replaceInput.inputBox.inputElement));
+        this._register(this.replaceInputFocusTracker.onDidFocus(() => this.replaceInputBoxFocused.set(true)));
+        this._register(this.replaceInputFocusTracker.onDidBlur(() => this.replaceInputBoxFocused.set(false)));
+        this._register(this.replaceInput.onPreserveCaseKeyDown((keyboardEvent) => this.onPreserveCaseKeyDown(keyboardEvent)));
+    }
+    triggerReplaceAll() {
+        this._onReplaceAll.fire();
+        return Promise.resolve(null);
+    }
+    onToggleReplaceButton() {
+        this.replaceContainer?.classList.toggle('disabled');
+        if (this.isReplaceShown()) {
+            this.toggleReplaceButton?.element.classList.remove(...ThemeIcon.asClassNameArray(searchHideReplaceIcon));
+            this.toggleReplaceButton?.element.classList.add(...ThemeIcon.asClassNameArray(searchShowReplaceIcon));
+        }
+        else {
+            this.toggleReplaceButton?.element.classList.remove(...ThemeIcon.asClassNameArray(searchShowReplaceIcon));
+            this.toggleReplaceButton?.element.classList.add(...ThemeIcon.asClassNameArray(searchHideReplaceIcon));
+        }
+        this.toggleReplaceButton?.element.setAttribute('aria-expanded', this.isReplaceShown() ? 'true' : 'false');
+        this.updateReplaceActiveState();
+        this._onReplaceToggled.fire();
+    }
+    setValue(value) {
+        this.searchInput?.setValue(value);
+    }
+    setReplaceAllActionState(enabled) {
+        if (this.replaceAllAction && (this.replaceAllAction.enabled !== enabled)) {
+            this.replaceAllAction.enabled = enabled;
+            this.replaceAllAction.label = enabled ? SearchWidget_1.REPLACE_ALL_ENABLED_LABEL(this.keybindingService) : SearchWidget_1.REPLACE_ALL_DISABLED_LABEL;
+            this.updateReplaceActiveState();
+        }
+    }
+    updateReplaceActiveState() {
+        const currentState = this.isReplaceActive();
+        const newState = this.isReplaceShown() && !!this.replaceAllAction?.enabled;
+        if (currentState !== newState) {
+            this.replaceActive.set(newState);
+            this._onReplaceStateChange.fire(newState);
+            this.replaceInput?.inputBox.layout();
+        }
+    }
+    validateSearchInput(value) {
+        if (value.length === 0) {
+            return null;
+        }
+        if (!(this.searchInput?.getRegex())) {
+            return null;
+        }
+        return null;
+    }
+    onSearchInputChanged() {
+        this.searchInput?.clearMessage();
+        this.setReplaceAllActionState(false);
+        if (this.searchConfiguration.searchOnType) {
+            const delayMultiplierFromAISearch = (this.searchInput && this.searchInput.isAIEnabled) ? 5 : 1;
+            if (this.searchInput?.getRegex()) {
+                try {
+                    const regex = ( new RegExp(this.searchInput.getValue(), 'ug'));
+                    const matchienessHeuristic = `
+								~!@#$%^&*()_+
+								\`1234567890-=
+								qwertyuiop[]\\
+								QWERTYUIOP{}|
+								asdfghjkl;'
+								ASDFGHJKL:"
+								zxcvbnm,./
+								ZXCVBNM<>? `.match(regex)?.length ?? 0;
+                    const delayMultiplier = matchienessHeuristic < 50 ? 1 :
+                        matchienessHeuristic < 100 ? 5 :
+                            10;
+                    this.submitSearch(true, this.searchConfiguration.searchOnTypeDebouncePeriod * delayMultiplier * delayMultiplierFromAISearch);
+                }
+                catch {
+                }
+            }
+            else {
+                this.submitSearch(true, this.searchConfiguration.searchOnTypeDebouncePeriod * delayMultiplierFromAISearch);
+            }
+        }
+    }
+    onSearchInputKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(ctrlKeyMod | 3 )) {
+            this.searchInput?.inputBox.insertAtCursor('\n');
+            keyboardEvent.preventDefault();
+        }
+        if (keyboardEvent.equals(3 )) {
+            this.searchInput?.onSearchSubmit();
+            this.submitSearch();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(9 )) {
+            this._onSearchCancel.fire({ focus: true });
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(2 )) {
+            if (this.isReplaceShown()) {
+                this.replaceInput?.focus();
+            }
+            else {
+                this.searchInput?.focusOnCaseSensitive();
+            }
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(16 )) {
+            stopPropagationForMultiLineUpwards(keyboardEvent, this.searchInput?.getValue() ?? '', this.searchInput?.domNode.querySelector('textarea') ?? null);
+        }
+        else if (keyboardEvent.equals(18 )) {
+            stopPropagationForMultiLineDownwards(keyboardEvent, this.searchInput?.getValue() ?? '', this.searchInput?.domNode.querySelector('textarea') ?? null);
+        }
+    }
+    onCaseSensitiveKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(1024  | 2 )) {
+            if (this.isReplaceShown()) {
+                this.replaceInput?.focus();
+                keyboardEvent.preventDefault();
+            }
+        }
+    }
+    onRegexKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(2 )) {
+            if (this.isReplaceShown()) {
+                this.replaceInput?.focusOnPreserve();
+                keyboardEvent.preventDefault();
+            }
+        }
+    }
+    onPreserveCaseKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(2 )) {
+            if (this.isReplaceActive()) {
+                this.focusReplaceAllAction();
+            }
+            else {
+                this._onBlur.fire();
+            }
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(1024  | 2 )) {
+            this.focusRegexAction();
+            keyboardEvent.preventDefault();
+        }
+    }
+    onReplaceInputKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(ctrlKeyMod | 3 )) {
+            this.replaceInput?.inputBox.insertAtCursor('\n');
+            keyboardEvent.preventDefault();
+        }
+        if (keyboardEvent.equals(3 )) {
+            this.submitSearch();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(2 )) {
+            this.searchInput?.focusOnCaseSensitive();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(1024  | 2 )) {
+            this.searchInput?.focus();
+            keyboardEvent.preventDefault();
+        }
+        else if (keyboardEvent.equals(16 )) {
+            stopPropagationForMultiLineUpwards(keyboardEvent, this.replaceInput?.getValue() ?? '', this.replaceInput?.domNode.querySelector('textarea') ?? null);
+        }
+        else if (keyboardEvent.equals(18 )) {
+            stopPropagationForMultiLineDownwards(keyboardEvent, this.replaceInput?.getValue() ?? '', this.replaceInput?.domNode.querySelector('textarea') ?? null);
+        }
+    }
+    onReplaceActionbarKeyDown(keyboardEvent) {
+        if (keyboardEvent.equals(1024  | 2 )) {
+            this.focusRegexAction();
+            keyboardEvent.preventDefault();
+        }
+    }
+    async submitSearch(triggeredOnType = false, delay = 0) {
+        this.searchInput?.validate();
+        if (!this.searchInput?.inputBox.isInputValid()) {
+            return;
+        }
+        const value = this.searchInput.getValue();
+        const useGlobalFindBuffer = this.searchConfiguration.globalFindClipboard;
+        if (value && useGlobalFindBuffer) {
+            await this.clipboardServce.writeFindText(value);
+        }
+        this._onSearchSubmit.fire({ triggeredOnType, delay });
+    }
+    getContextLines() {
+        return this.showContextToggle.checked ? +this.contextLinesInput.value : 0;
+    }
+    modifyContextLines(increase) {
+        const current = +this.contextLinesInput.value;
+        const modified = current + (increase ? 1 : -1);
+        this.showContextToggle.checked = modified !== 0;
+        this.contextLinesInput.value = '' + modified;
+    }
+    toggleContextLines() {
+        this.showContextToggle.checked = !this.showContextToggle.checked;
+        this.onContextLinesChanged();
+    }
+    dispose() {
+        this.setReplaceAllActionState(false);
+        super.dispose();
+    }
+    get searchConfiguration() {
+        return this.configurationService.getValue('search');
+    }
+};
+SearchWidget = SearchWidget_1 = ( __decorate([
+    ( __param(2, IContextViewService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IClipboardService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IAccessibilityService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, IEditorService))
+], SearchWidget));
+function registerContributions() {
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: ReplaceAllAction.ID,
+        weight: 200 ,
+        when: ( ContextKeyExpr.and(
+            SearchContext.SearchViewVisibleKey,
+            SearchContext.ReplaceActiveKey,
+            CONTEXT_FIND_WIDGET_NOT_VISIBLE
+        )),
+        primary: 512  | 2048  | 3 ,
+        handler: accessor => {
+            const viewsService = accessor.get(IViewsService);
+            if (isSearchViewFocused(viewsService)) {
+                const searchView = getSearchView(viewsService);
+                if (searchView) {
+                    ( new ReplaceAllAction(searchView.searchAndReplaceWidget)).run();
+                }
+            }
+        }
+    });
+}
+
+export { SearchWidget, registerContributions };