@codingame/monaco-vscode-api 23.2.2 → 24.1.0

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

@@ -0,0 +1,2292 @@
+
+import { registerCss } from '../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $ as $$1, hide, append, addDisposableListener, EventType, EventHelper, clearNode, show, getActiveWindow, getTotalHeight, Dimension, isAncestorOfActiveElement } from '../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { MessageType } from '../../../../base/browser/ui/inputbox/inputBox.js';
+import { ObjectTreeElementCollapseState } from '../../../../base/browser/ui/tree/tree.js';
+import { Delayer, RunOnceScheduler, Throttler } from '../../../../base/common/async.js';
+import { isCancellationError, onUnexpectedError } from '../../../../base/common/errors.js';
+import { Event } from '../../../../base/common/event.js';
+import { KeyCode, KeyMod as KeyMod$1 } from '../../../../base/common/keyCodes.js';
+import { DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { Schemas } from '../../../../base/common/network.js';
+import * as searchview from './media/searchview.css';
+import { isCodeEditor, getCodeEditor, isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.service.js';
+import { EmbeddedCodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { Selection } from '../../../../editor/common/core/selection.js';
+import { CommonFindController } from '../../../../editor/contrib/find/browser/findController.js';
+import { MultiCursorSelectionController } from '../../../../editor/contrib/multicursor/browser/multicursor.js';
+import { localize } from '../../../../nls.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IContextViewService, IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { FileChangeType } from '../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { WorkbenchCompressibleAsyncDataTree, getSelectionKeyboardEvent } from '../../../../platform/list/browser/listService.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { withSelection } from '../../../../platform/opener/common/opener.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { defaultInputBoxStyles, defaultToggleStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { WorkbenchState } from '../../../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { OpenFolderAction } from '../../../browser/actions/workspaceActions.js';
+import { ResourceListDnDHandler } from '../../../browser/dnd.js';
+import { ResourceLabels } from '../../../browser/labels.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { Memento } from '../../../common/memento.js';
+import { IViewDescriptorService } from '../../../common/views.service.js';
+import { NotebookEditor } from '../../notebook/browser/notebookEditor.js';
+import { IncludePatternInputWidget, ExcludePatternInputWidget } from './patternInputWidget.js';
+import { appendKeyBindingLabel } from './searchActionsBase.js';
+import { searchDetailsIcon } from './searchIcons.js';
+import { renderSearchMessage } from './searchMessage.js';
+import { SearchAccessibilityProvider, SearchDelegate, FolderMatchRenderer, FileMatchRenderer, TextSearchResultRenderer, MatchRenderer } from './searchResultsView.js';
+import { SearchWidget } from './searchWidget.js';
+import { SearchContext, SearchCommandIds } from '../common/constants.js';
+import { IReplaceService } from './replace.service.js';
+import { SearchStateKey, SearchUIState, getOutOfWorkspaceEditorResources } from '../common/search.js';
+import { SearchHistoryService } from '../common/searchHistoryService.js';
+import { ISearchHistoryService } from '../common/searchHistoryService.service.js';
+import { createEditorFromSearchResult } from '../../searchEditor/browser/searchEditorActions.js';
+import { SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.service.js';
+import { QueryBuilder } from '../../../services/search/common/queryBuilder.js';
+import { SearchSortOrder, ViewMode, SemanticSearchBehavior, SearchCompletionExitCode, isAIKeyword } from '../../../services/search/common/search.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.service.js';
+import { INotebookService } from '../../notebook/common/notebookService.service.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { AccessibilitySignal } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
+import { ISearchViewModelWorkbenchService } from './searchTreeModel/searchViewModelWorkbenchService.service.js';
+import { SearchModelLocation, isSearchTreeMatch, isSearchTreeFolderMatch, isTextSearchHeading, isSearchTreeFolderMatchWorkspaceRoot, isSearchTreeFolderMatchNoRoot, isSearchTreeFileMatch, isSearchTreeFolderMatchWithResource, isSearchHeader, isSearchResult } from './searchTreeModel/searchTreeCommon.js';
+import { isIMatchInNotebook } from './notebookSearch/notebookSearchModelBase.js';
+import { searchMatchComparer } from './searchCompare.js';
+import { AIFolderMatchWorkspaceRootImpl } from './AISearch/aiSearchModel.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { forcedExpandRecursively } from './searchActionsTopBar.js';
+import { TextSearchCompleteMessageType } from '../../../services/search/common/searchExtTypes.js';
+
+var SearchView_1;
+registerCss(searchview);
+const $ = $$1;
+var SearchViewPosition;
+(function (SearchViewPosition) {
+    SearchViewPosition[SearchViewPosition["SideBar"] = 0] = "SideBar";
+    SearchViewPosition[SearchViewPosition["Panel"] = 1] = "Panel";
+})(SearchViewPosition || (SearchViewPosition = {}));
+const SEARCH_CANCELLED_MESSAGE = ( localize(10819, "Search was canceled before any results could be found - "));
+const DEBOUNCE_DELAY = 75;
+let SearchView = class SearchView extends ViewPane {
+    static { SearchView_1 = this; }
+    static { this.ACTIONS_RIGHT_CLASS_NAME = 'actions-right'; }
+    constructor(options, fileService, editorService, codeEditorService, progressService, notificationService, dialogService, commandService, contextViewService, instantiationService, viewDescriptorService, configurationService, contextService, searchViewModelWorkbenchService, contextKeyService, replaceService, textFileService, preferencesService, themeService, searchHistoryService, contextMenuService, accessibilityService, keybindingService, storageService, openerService, hoverService, notebookService, logService, accessibilitySignalService, telemetryService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+        this.fileService = fileService;
+        this.editorService = editorService;
+        this.codeEditorService = codeEditorService;
+        this.progressService = progressService;
+        this.notificationService = notificationService;
+        this.dialogService = dialogService;
+        this.commandService = commandService;
+        this.contextViewService = contextViewService;
+        this.contextService = contextService;
+        this.searchViewModelWorkbenchService = searchViewModelWorkbenchService;
+        this.replaceService = replaceService;
+        this.textFileService = textFileService;
+        this.preferencesService = preferencesService;
+        this.searchHistoryService = searchHistoryService;
+        this.accessibilityService = accessibilityService;
+        this.storageService = storageService;
+        this.notebookService = notebookService;
+        this.logService = logService;
+        this.accessibilitySignalService = accessibilitySignalService;
+        this.telemetryService = telemetryService;
+        this.isDisposed = false;
+        this.lastFocusState = 'input';
+        this.messageDisposables = ( new DisposableStore());
+        this.currentSearchQ = Promise.resolve();
+        this.pauseSearching = false;
+        this._visibleMatches = 0;
+        this._cachedKeywords = [];
+        this.container = $$1('.search-view');
+        this.viewletVisible = SearchContext.SearchViewVisibleKey.bindTo(this.contextKeyService);
+        this.firstMatchFocused = SearchContext.FirstMatchFocusKey.bindTo(this.contextKeyService);
+        this.fileMatchOrMatchFocused = SearchContext.FileMatchOrMatchFocusKey.bindTo(this.contextKeyService);
+        this.fileMatchOrFolderMatchFocus = SearchContext.FileMatchOrFolderMatchFocusKey.bindTo(this.contextKeyService);
+        this.fileMatchOrFolderMatchWithResourceFocus = SearchContext.FileMatchOrFolderMatchWithResourceFocusKey.bindTo(this.contextKeyService);
+        this.fileMatchFocused = SearchContext.FileFocusKey.bindTo(this.contextKeyService);
+        this.folderMatchFocused = SearchContext.FolderFocusKey.bindTo(this.contextKeyService);
+        this.folderMatchWithResourceFocused = SearchContext.ResourceFolderFocusKey.bindTo(this.contextKeyService);
+        this.searchResultHeaderFocused = SearchContext.SearchResultHeaderFocused.bindTo(this.contextKeyService);
+        this.hasSearchResultsKey = SearchContext.HasSearchResults.bindTo(this.contextKeyService);
+        this.matchFocused = SearchContext.MatchFocusKey.bindTo(this.contextKeyService);
+        this.searchStateKey = SearchStateKey.bindTo(this.contextKeyService);
+        this.hasSearchPatternKey = SearchContext.ViewHasSearchPatternKey.bindTo(this.contextKeyService);
+        this.hasReplacePatternKey = SearchContext.ViewHasReplacePatternKey.bindTo(this.contextKeyService);
+        this.hasFilePatternKey = SearchContext.ViewHasFilePatternKey.bindTo(this.contextKeyService);
+        this.hasSomeCollapsibleResultKey = SearchContext.ViewHasSomeCollapsibleKey.bindTo(this.contextKeyService);
+        this.treeViewKey = SearchContext.InTreeViewKey.bindTo(this.contextKeyService);
+        this.refreshTreeController = this._register(this.instantiationService.createInstance(RefreshTreeController, this, () => this.searchConfig));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            const keys = ( SearchContext.hasAIResultProvider.keys());
+            if (e.affectsSome(( new Set(keys)))) {
+                this.refreshHasAISetting();
+            }
+        }));
+        this.contextKeyService = this._register(this.contextKeyService.createScoped(this.container));
+        SearchContext.SearchViewFocusedKey.bindTo(this.contextKeyService).set(true);
+        this.inputBoxFocused = SearchContext.InputBoxFocusedKey.bindTo(this.contextKeyService);
+        this.inputPatternIncludesFocused = SearchContext.PatternIncludesFocusedKey.bindTo(this.contextKeyService);
+        this.inputPatternExclusionsFocused = SearchContext.PatternExcludesFocusedKey.bindTo(this.contextKeyService);
+        this.isEditableItem = SearchContext.IsEditableItemKey.bindTo(this.contextKeyService);
+        this.instantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService]))));
+        this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration('search.sortOrder')) {
+                if (this.searchConfig.sortOrder === SearchSortOrder.Modified) {
+                    this.removeFileStats();
+                }
+                await this.refreshTreeController.queue();
+            }
+        }));
+        this.viewModel = this.searchViewModelWorkbenchService.searchModel;
+        this.queryBuilder = this.instantiationService.createInstance(QueryBuilder);
+        this.memento = ( new Memento(this.id, storageService));
+        this.viewletState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
+        this._register(this.fileService.onDidFilesChange(e => this.onFilesChanged(e)));
+        this._register(this.textFileService.untitled.onWillDispose(model => this.onUntitledDidDispose(model.resource)));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.onDidChangeWorkbenchState()));
+        this._register(this.searchHistoryService.onDidClearHistory(() => this.clearHistory()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+        this.delayedRefresh = this._register(( new Delayer(250)));
+        this.addToSearchHistoryDelayer = this._register(( new Delayer(2000)));
+        this.toggleCollapseStateDelayer = this._register(( new Delayer(100)));
+        this.triggerQueryDelayer = this._register(( new Delayer(0)));
+        this.treeAccessibilityProvider = this.instantiationService.createInstance(SearchAccessibilityProvider, this);
+        this.isTreeLayoutViewVisible = this.viewletState.view?.treeLayout ?? (this.searchConfig.defaultViewMode === ViewMode.Tree);
+        this._refreshResultsScheduler = this._register(( new RunOnceScheduler(this._updateResults.bind(this), 80)));
+        this._register(this.storageService.onWillSaveState(() => {
+            this._saveSearchHistoryService();
+        }));
+        this._register(this.storageService.onDidChangeValue(StorageScope.WORKSPACE, SearchHistoryService.SEARCH_HISTORY_KEY, this._store)(() => {
+            const restoredHistory = this.searchHistoryService.load();
+            if (restoredHistory.include) {
+                this.inputPatternIncludes.prependHistory(restoredHistory.include);
+            }
+            if (restoredHistory.exclude) {
+                this.inputPatternExcludes.prependHistory(restoredHistory.exclude);
+            }
+            if (restoredHistory.search) {
+                this.searchWidget.prependSearchHistory(restoredHistory.search);
+            }
+            if (restoredHistory.replace) {
+                this.searchWidget.prependReplaceHistory(restoredHistory.replace);
+            }
+        }));
+        this.changedWhileHidden = this.hasSearchResults();
+    }
+    get cachedResults() {
+        return this._cachedResults;
+    }
+    async queueRefreshTree() {
+        return this.refreshTreeController.queue();
+    }
+    get isTreeLayoutViewVisible() {
+        return this.treeViewKey.get() ?? false;
+    }
+    set isTreeLayoutViewVisible(visible) {
+        this.treeViewKey.set(visible);
+    }
+    async setTreeView(visible) {
+        if (visible === this.isTreeLayoutViewVisible) {
+            return;
+        }
+        this.isTreeLayoutViewVisible = visible;
+        this.updateIndentStyles(this.themeService.getFileIconTheme());
+        return this.refreshTreeController.queue();
+    }
+    get state() {
+        return this.searchStateKey.get() ?? SearchUIState.Idle;
+    }
+    set state(v) {
+        this.searchStateKey.set(v);
+    }
+    getContainer() {
+        return this.container;
+    }
+    get searchResult() {
+        return this.viewModel && this.viewModel.searchResult;
+    }
+    get model() {
+        return this.viewModel;
+    }
+    async refreshHasAISetting() {
+        const shouldShowAI = this.shouldShowAIResults();
+        if (!this.tree || !this.tree.hasNode(this.searchResult)) {
+            return;
+        }
+        if (shouldShowAI && !this.tree.hasNode(this.searchResult.aiTextSearchResult)) {
+            if (this.model.searchResult.getCachedSearchComplete(false)) {
+                return this.refreshAndUpdateCount();
+            }
+        }
+        else if (!shouldShowAI && this.tree.hasNode(this.searchResult.aiTextSearchResult)) {
+            return this.refreshAndUpdateCount();
+        }
+    }
+    onDidChangeWorkbenchState() {
+        if (this.contextService.getWorkbenchState() !== WorkbenchState.EMPTY && this.searchWithoutFolderMessageElement) {
+            hide(this.searchWithoutFolderMessageElement);
+        }
+    }
+    refreshInputs() {
+        this.pauseSearching = true;
+        this.searchWidget.setValue(this.viewModel.searchResult.query?.contentPattern.pattern ?? '');
+        this.searchWidget.setReplaceAllActionState(false);
+        this.searchWidget.toggleReplace(true);
+        this.inputPatternIncludes.setOnlySearchInOpenEditors(this.viewModel.searchResult.query?.onlyOpenEditors || false);
+        this.inputPatternExcludes.setUseExcludesAndIgnoreFiles(!this.viewModel.searchResult.query?.userDisabledExcludesAndIgnoreFiles || true);
+        this.searchIncludePattern.setValue('');
+        this.searchExcludePattern.setValue('');
+        this.pauseSearching = false;
+    }
+    async replaceSearchModel(searchModel, asyncResults) {
+        let progressComplete;
+        this.progressService.withProgress({ location: this.getProgressLocation(), delay: 0 }, _progress => {
+            return ( new Promise(resolve => progressComplete = resolve));
+        });
+        const slowTimer = setTimeout(() => {
+            this.state = SearchUIState.SlowSearch;
+        }, 2000);
+        this._refreshResultsScheduler.schedule();
+        searchModel.location = SearchModelLocation.PANEL;
+        searchModel.replaceActive = this.viewModel.isReplaceActive();
+        searchModel.replaceString = this.searchWidget.getReplaceValue();
+        this._onSearchResultChangedDisposable?.dispose();
+        this._onSearchResultChangedDisposable = this._register(searchModel.onSearchResultChanged(async (event) => this.onSearchResultsChanged(event)));
+        this.searchViewModelWorkbenchService.searchModel = searchModel;
+        this.viewModel = searchModel;
+        this.tree.setInput(this.viewModel.searchResult);
+        await this.onSearchResultsChanged();
+        this.refreshInputs();
+        asyncResults.then((complete) => {
+            clearTimeout(slowTimer);
+            return this.onSearchComplete(progressComplete, undefined, undefined, complete);
+        }, (e) => {
+            clearTimeout(slowTimer);
+            return this.onSearchError(e, progressComplete, undefined, undefined);
+        });
+        await this.expandIfSingularResult();
+    }
+    renderBody(parent) {
+        super.renderBody(parent);
+        this.container = append(parent, $$1('.search-view'));
+        this.searchWidgetsContainerElement = append(this.container, $('.search-widgets-container'));
+        this.createSearchWidget(this.searchWidgetsContainerElement);
+        const history = this.searchHistoryService.load();
+        const filePatterns = this.viewletState.query?.filePatterns || '';
+        const patternExclusions = this.viewletState.query?.folderExclusions || '';
+        const patternExclusionsHistory = history.exclude || [];
+        const patternIncludes = this.viewletState.query?.folderIncludes || '';
+        const patternIncludesHistory = history.include || [];
+        const onlyOpenEditors = this.viewletState.query?.onlyOpenEditors || false;
+        const queryDetailsExpanded = this.viewletState.query?.queryDetailsExpanded || '';
+        const useExcludesAndIgnoreFiles = typeof this.viewletState.query?.useExcludesAndIgnoreFiles === 'boolean' ?
+            this.viewletState.query.useExcludesAndIgnoreFiles : true;
+        this.queryDetails = append(this.searchWidgetsContainerElement, $('.query-details'));
+        const toggleQueryDetailsLabel = ( localize(10820, "Toggle Search Details"));
+        this.toggleQueryDetailsButton = append(this.queryDetails, $('.more' + ThemeIcon.asCSSSelector(searchDetailsIcon), { tabindex: 0, role: 'button', 'aria-label': toggleQueryDetailsLabel }));
+        this._register(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), this.toggleQueryDetailsButton, toggleQueryDetailsLabel));
+        this._register(addDisposableListener(this.toggleQueryDetailsButton, EventType.CLICK, e => {
+            EventHelper.stop(e);
+            this.toggleQueryDetails(!this.accessibilityService.isScreenReaderOptimized());
+        }));
+        this._register(addDisposableListener(this.toggleQueryDetailsButton, EventType.KEY_UP, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(e);
+                this.toggleQueryDetails(false);
+            }
+        }));
+        this._register(addDisposableListener(this.toggleQueryDetailsButton, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyMod$1.Shift | KeyCode.Tab)) {
+                if (this.searchWidget.isReplaceActive()) {
+                    this.searchWidget.focusReplaceAllAction();
+                }
+                else {
+                    this.searchWidget.isReplaceShown() ? this.searchWidget.replaceInput?.focusOnPreserve() : this.searchWidget.focusRegexAction();
+                }
+                EventHelper.stop(e);
+            }
+        }));
+        const folderIncludesList = append(this.queryDetails, $('.file-types.includes'));
+        const filesToIncludeTitle = ( localize(10821, "files to include"));
+        append(folderIncludesList, $('h4', undefined, filesToIncludeTitle));
+        this.inputPatternIncludes = this._register(this.instantiationService.createInstance(IncludePatternInputWidget, folderIncludesList, this.contextViewService, {
+            ariaLabel: filesToIncludeTitle,
+            placeholder: ( localize(10822, "e.g. *.ts, src/**/include")),
+            showPlaceholderOnFocus: true,
+            history: patternIncludesHistory,
+            inputBoxStyles: defaultInputBoxStyles
+        }));
+        this.inputPatternIncludes.setValue(patternIncludes);
+        this.inputPatternIncludes.setOnlySearchInOpenEditors(onlyOpenEditors);
+        this._register(this.inputPatternIncludes.onCancel(() => this.cancelSearch(false)));
+        this._register(this.inputPatternIncludes.onChangeSearchInEditorsBox(() => this.triggerQueryChange()));
+        this.trackInputBox(this.inputPatternIncludes.inputFocusTracker, this.inputPatternIncludesFocused);
+        const excludesList = append(this.queryDetails, $('.file-types.excludes'));
+        const excludesTitle = ( localize(10823, "files to exclude"));
+        append(excludesList, $('h4', undefined, excludesTitle));
+        this.inputPatternExcludes = this._register(this.instantiationService.createInstance(ExcludePatternInputWidget, excludesList, this.contextViewService, {
+            ariaLabel: excludesTitle,
+            placeholder: ( localize(10824, "e.g. *.ts, src/**/exclude")),
+            showPlaceholderOnFocus: true,
+            history: patternExclusionsHistory,
+            inputBoxStyles: defaultInputBoxStyles
+        }));
+        this.inputPatternExcludes.setValue(patternExclusions);
+        this.inputPatternExcludes.setUseExcludesAndIgnoreFiles(useExcludesAndIgnoreFiles);
+        this._register(this.inputPatternExcludes.onCancel(() => this.cancelSearch(false)));
+        this._register(this.inputPatternExcludes.onChangeIgnoreBox(() => this.triggerQueryChange()));
+        this.trackInputBox(this.inputPatternExcludes.inputFocusTracker, this.inputPatternExclusionsFocused);
+        const updateHasFilePatternKey = () => this.hasFilePatternKey.set(this.inputPatternIncludes.getValue().length > 0 || this.inputPatternExcludes.getValue().length > 0);
+        updateHasFilePatternKey();
+        const onFilePatternSubmit = (triggeredOnType) => {
+            this.triggerQueryChange({ triggeredOnType, delay: this.searchConfig.searchOnTypeDebouncePeriod });
+            if (triggeredOnType) {
+                updateHasFilePatternKey();
+            }
+        };
+        this._register(this.inputPatternIncludes.onSubmit(onFilePatternSubmit));
+        this._register(this.inputPatternExcludes.onSubmit(onFilePatternSubmit));
+        this.messagesElement = append(this.container, $('.messages.text-search-provider-messages'));
+        if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
+            this.showSearchWithoutFolderMessage();
+        }
+        this.createSearchResultsView(this.container);
+        if (filePatterns !== '' || patternExclusions !== '' || patternIncludes !== '' || queryDetailsExpanded !== '' || !useExcludesAndIgnoreFiles) {
+            this.toggleQueryDetails(true, true, true);
+        }
+        this._onSearchResultChangedDisposable = this._register(this.viewModel.onSearchResultChanged(async (event) => await this.onSearchResultsChanged(event)));
+        this._onAIResultChangedDisposable?.dispose();
+        this._onAIResultChangedDisposable = this._register(this.viewModel.searchResult.aiTextSearchResult.onChange((e) => {
+            if (this.tree && this.tree.hasNode(this.searchResult.aiTextSearchResult) && !e.removed) {
+                this.tree.updateChildren(this.searchResult.aiTextSearchResult);
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(visible => this.onVisibilityChanged(visible)));
+        this.updateIndentStyles(this.themeService.getFileIconTheme());
+        this._register(this.themeService.onDidFileIconThemeChange(this.updateIndentStyles, this));
+    }
+    updateIndentStyles(theme) {
+        this.resultsElement.classList.toggle('hide-arrows', this.isTreeLayoutViewVisible && theme.hidesExplorerArrows);
+    }
+    async onVisibilityChanged(visible) {
+        this.viewletVisible.set(visible);
+        if (visible) {
+            if (this.changedWhileHidden) {
+                await this.refreshAndUpdateCount();
+                this.changedWhileHidden = false;
+            }
+        }
+        else {
+            this.lastFocusState = 'input';
+        }
+        this.viewModel?.searchResult.toggleHighlights(visible);
+    }
+    get searchAndReplaceWidget() {
+        return this.searchWidget;
+    }
+    get searchIncludePattern() {
+        return this.inputPatternIncludes;
+    }
+    get searchExcludePattern() {
+        return this.inputPatternExcludes;
+    }
+    createSearchWidget(container) {
+        const contentPattern = this.viewletState.query?.contentPattern || '';
+        const replaceText = this.viewletState.query?.replaceText || '';
+        const isRegex = this.viewletState.query?.regex === true;
+        const isWholeWords = this.viewletState.query?.wholeWords === true;
+        const isCaseSensitive = this.viewletState.query?.caseSensitive === true;
+        const history = this.searchHistoryService.load();
+        const searchHistory = history.search || this.viewletState.query?.searchHistory || [];
+        const replaceHistory = history.replace || this.viewletState.query?.replaceHistory || [];
+        const showReplace = typeof this.viewletState.view?.showReplace === 'boolean' ? this.viewletState.view.showReplace : true;
+        const preserveCase = this.viewletState.query?.preserveCase === true;
+        const isInNotebookMarkdownInput = this.viewletState.query?.isInNotebookMarkdownInput ?? true;
+        const isInNotebookMarkdownPreview = this.viewletState.query?.isInNotebookMarkdownPreview ?? true;
+        const isInNotebookCellInput = this.viewletState.query?.isInNotebookCellInput ?? true;
+        const isInNotebookCellOutput = this.viewletState.query?.isInNotebookCellOutput ?? true;
+        this.searchWidget = this._register(this.instantiationService.createInstance(SearchWidget, container, {
+            value: contentPattern,
+            replaceValue: replaceText,
+            isRegex: isRegex,
+            isCaseSensitive: isCaseSensitive,
+            isWholeWords: isWholeWords,
+            searchHistory: searchHistory,
+            replaceHistory: replaceHistory,
+            preserveCase: preserveCase,
+            inputBoxStyles: defaultInputBoxStyles,
+            toggleStyles: defaultToggleStyles,
+            notebookOptions: {
+                isInNotebookMarkdownInput,
+                isInNotebookMarkdownPreview,
+                isInNotebookCellInput,
+                isInNotebookCellOutput,
+            }
+        }));
+        if (!this.searchWidget.searchInput || !this.searchWidget.replaceInput) {
+            this.logService.warn(`Cannot fully create search widget. Search or replace input undefined. SearchInput: ${this.searchWidget.searchInput}, ReplaceInput: ${this.searchWidget.replaceInput}`);
+            return;
+        }
+        if (showReplace) {
+            this.searchWidget.toggleReplace(true);
+        }
+        this._register(this.searchWidget.onSearchSubmit(options => {
+            const shouldRenderAIResults = this.configurationService.getValue('search').searchView.semanticSearchBehavior;
+            if (shouldRenderAIResults === SemanticSearchBehavior.Auto) {
+                this.logService.info(`SearchView: Automatically rendering AI results`);
+            }
+            this.triggerQueryChange({
+                ...options,
+                shouldKeepAIResults: false,
+                shouldUpdateAISearch: shouldRenderAIResults === SemanticSearchBehavior.Auto,
+            });
+        }));
+        this._register(this.searchWidget.onSearchCancel(({ focus }) => this.cancelSearch(focus)));
+        this._register(this.searchWidget.searchInput.onDidOptionChange(() => {
+            this.triggerQueryChange({ shouldKeepAIResults: true });
+        }));
+        this._register(this.searchWidget.getNotebookFilters().onDidChange(() => this.triggerQueryChange({ shouldKeepAIResults: true })));
+        const updateHasPatternKey = () => this.hasSearchPatternKey.set(this.searchWidget.searchInput ? (this.searchWidget.searchInput.getValue().length > 0) : false);
+        updateHasPatternKey();
+        this._register(this.searchWidget.searchInput.onDidChange(() => updateHasPatternKey()));
+        const updateHasReplacePatternKey = () => this.hasReplacePatternKey.set(this.searchWidget.getReplaceValue().length > 0);
+        updateHasReplacePatternKey();
+        this._register(this.searchWidget.replaceInput.inputBox.onDidChange(() => updateHasReplacePatternKey()));
+        this._register(this.searchWidget.onDidHeightChange(() => this.reLayout()));
+        this._register(this.searchWidget.onReplaceToggled(() => this.reLayout()));
+        this._register(this.searchWidget.onReplaceStateChange(async (state) => {
+            this.viewModel.replaceActive = state;
+            await this.refreshTreeController.queue();
+        }));
+        this._register(this.searchWidget.onPreserveCaseChange(async (state) => {
+            this.viewModel.preserveCase = state;
+            await this.refreshTreeController.queue();
+        }));
+        this._register(this.searchWidget.onReplaceValueChanged(() => {
+            this.viewModel.replaceString = this.searchWidget.getReplaceValue();
+            this.delayedRefresh.trigger(async () => this.refreshTreeController.queue());
+        }));
+        this._register(this.searchWidget.onBlur(() => {
+            this.toggleQueryDetailsButton.focus();
+        }));
+        this._register(this.searchWidget.onReplaceAll(() => this.replaceAll()));
+        this.trackInputBox(this.searchWidget.searchInputFocusTracker);
+        this.trackInputBox(this.searchWidget.replaceInputFocusTracker);
+    }
+    shouldShowAIResults() {
+        const hasProvider = SearchContext.hasAIResultProvider.getValue(this.contextKeyService);
+        return !!hasProvider;
+    }
+    async onConfigurationUpdated(event) {
+        if (event && (event.affectsConfiguration('search.decorations.colors') || event.affectsConfiguration('search.decorations.badges'))) {
+            return this.refreshTreeController.queue();
+        }
+    }
+    trackInputBox(inputFocusTracker, contextKey) {
+        if (!inputFocusTracker) {
+            return;
+        }
+        this._register(inputFocusTracker.onDidFocus(() => {
+            this.lastFocusState = 'input';
+            this.inputBoxFocused.set(true);
+            contextKey?.set(true);
+        }));
+        this._register(inputFocusTracker.onDidBlur(() => {
+            this.inputBoxFocused.set(this.searchWidget.searchInputHasFocus()
+                || this.searchWidget.replaceInputHasFocus()
+                || this.inputPatternIncludes.inputHasFocus()
+                || this.inputPatternExcludes.inputHasFocus());
+            contextKey?.set(false);
+        }));
+    }
+    async onSearchResultsChanged(event) {
+        if (this.isVisible()) {
+            return this.refreshAndUpdateCount(event);
+        }
+        else {
+            this.changedWhileHidden = true;
+        }
+    }
+    async refreshAndUpdateCount(event) {
+        this.searchWidget.setReplaceAllActionState(!this.viewModel.searchResult.isEmpty());
+        this.updateSearchResultCount(this.viewModel.searchResult.query.userDisabledExcludesAndIgnoreFiles, this.viewModel.searchResult.query?.onlyOpenEditors, event?.clearingAll);
+        return this.refreshTreeController.queue(event);
+    }
+    originalShouldCollapse(match) {
+        const collapseResults = this.searchConfig.collapseResults;
+        return (collapseResults === 'alwaysCollapse' ||
+            (!(isSearchTreeMatch(match)) && match.count() > 10 && collapseResults !== 'alwaysExpand')) ?
+            ObjectTreeElementCollapseState.PreserveOrCollapsed : ObjectTreeElementCollapseState.PreserveOrExpanded;
+    }
+    shouldCollapseAccordingToConfig(match) {
+        const collapseResults = this.originalShouldCollapse(match);
+        if (collapseResults === ObjectTreeElementCollapseState.PreserveOrCollapsed) {
+            return true;
+        }
+        return false;
+    }
+    replaceAll() {
+        if (this.viewModel.searchResult.count() === 0) {
+            return;
+        }
+        const occurrences = this.viewModel.searchResult.count();
+        const fileCount = this.viewModel.searchResult.fileCount();
+        const replaceValue = this.searchWidget.getReplaceValue() || '';
+        const afterReplaceAllMessage = this.buildAfterReplaceAllMessage(occurrences, fileCount, replaceValue);
+        let progressComplete;
+        let progressReporter;
+        this.progressService.withProgress({ location: this.getProgressLocation(), delay: 100, total: occurrences }, p => {
+            progressReporter = p;
+            return ( new Promise(resolve => progressComplete = resolve));
+        });
+        const confirmation = {
+            title: ( localize(10825, "Replace All")),
+            message: this.buildReplaceAllConfirmationMessage(occurrences, fileCount, replaceValue),
+            primaryButton: ( localize(10826, "&&Replace"))
+        };
+        this.dialogService.confirm(confirmation).then(res => {
+            if (res.confirmed) {
+                this.searchWidget.setReplaceAllActionState(false);
+                this.viewModel.searchResult.replaceAll(progressReporter).then(() => {
+                    progressComplete();
+                    const messageEl = this.clearMessage();
+                    append(messageEl, afterReplaceAllMessage);
+                    this.reLayout();
+                }, (error) => {
+                    progressComplete();
+                    this.notificationService.error(error);
+                });
+            }
+            else {
+                progressComplete();
+            }
+        });
+    }
+    buildAfterReplaceAllMessage(occurrences, fileCount, replaceValue) {
+        if (occurrences === 1) {
+            if (fileCount === 1) {
+                if (replaceValue) {
+                    return localize(
+                        10827,
+                        "Replaced {0} occurrence across {1} file with '{2}'.",
+                        occurrences,
+                        fileCount,
+                        replaceValue
+                    );
+                }
+                return localize(10828, "Replaced {0} occurrence across {1} file.", occurrences, fileCount);
+            }
+            if (replaceValue) {
+                return localize(
+                    10829,
+                    "Replaced {0} occurrence across {1} files with '{2}'.",
+                    occurrences,
+                    fileCount,
+                    replaceValue
+                );
+            }
+            return localize(10830, "Replaced {0} occurrence across {1} files.", occurrences, fileCount);
+        }
+        if (fileCount === 1) {
+            if (replaceValue) {
+                return localize(
+                    10831,
+                    "Replaced {0} occurrences across {1} file with '{2}'.",
+                    occurrences,
+                    fileCount,
+                    replaceValue
+                );
+            }
+            return localize(10832, "Replaced {0} occurrences across {1} file.", occurrences, fileCount);
+        }
+        if (replaceValue) {
+            return localize(
+                10833,
+                "Replaced {0} occurrences across {1} files with '{2}'.",
+                occurrences,
+                fileCount,
+                replaceValue
+            );
+        }
+        return localize(
+            10834,
+            "Replaced {0} occurrences across {1} files.",
+            occurrences,
+            fileCount
+        );
+    }
+    buildReplaceAllConfirmationMessage(occurrences, fileCount, replaceValue) {
+        const truncateValue = (value) => {
+            if (!value) {
+                return value;
+            }
+            const lines = value.split('\n');
+            if (lines.length > 10) {
+                return lines.slice(0, 10).join('\n') + '\n...';
+            }
+            return value;
+        };
+        const displayReplaceValue = truncateValue(replaceValue);
+        if (occurrences === 1) {
+            if (fileCount === 1) {
+                if (displayReplaceValue) {
+                    return localize(
+                        10835,
+                        "Replace {0} occurrence across {1} file with '{2}'?",
+                        occurrences,
+                        fileCount,
+                        displayReplaceValue
+                    );
+                }
+                return localize(10836, "Replace {0} occurrence across {1} file?", occurrences, fileCount);
+            }
+            if (displayReplaceValue) {
+                return localize(
+                    10837,
+                    "Replace {0} occurrence across {1} files with '{2}'?",
+                    occurrences,
+                    fileCount,
+                    displayReplaceValue
+                );
+            }
+            return localize(10838, "Replace {0} occurrence across {1} files?", occurrences, fileCount);
+        }
+        if (fileCount === 1) {
+            if (displayReplaceValue) {
+                return localize(
+                    10839,
+                    "Replace {0} occurrences across {1} file with '{2}'?",
+                    occurrences,
+                    fileCount,
+                    displayReplaceValue
+                );
+            }
+            return localize(10840, "Replace {0} occurrences across {1} file?", occurrences, fileCount);
+        }
+        if (displayReplaceValue) {
+            return localize(
+                10841,
+                "Replace {0} occurrences across {1} files with '{2}'?",
+                occurrences,
+                fileCount,
+                displayReplaceValue
+            );
+        }
+        return localize(10842, "Replace {0} occurrences across {1} files?", occurrences, fileCount);
+    }
+    clearMessage() {
+        this.searchWithoutFolderMessageElement = undefined;
+        const wasHidden = this.messagesElement.style.display === 'none';
+        clearNode(this.messagesElement);
+        show(this.messagesElement);
+        this.messageDisposables.clear();
+        const newMessage = append(this.messagesElement, $('.message'));
+        if (wasHidden) {
+            this.reLayout();
+        }
+        return newMessage;
+    }
+    createSearchResultsView(container) {
+        this.resultsElement = append(container, $('.results.show-file-icons.file-icon-themable-tree'));
+        const delegate = this.instantiationService.createInstance(SearchDelegate);
+        const identityProvider = {
+            getId(element) {
+                return element.id();
+            }
+        };
+        this.searchDataSource = this.instantiationService.createInstance(SearchViewDataSource, this);
+        this.treeLabels = this._register(this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility }));
+        this.tree = this._register(this.instantiationService.createInstance((WorkbenchCompressibleAsyncDataTree), 'SearchView', this.resultsElement, delegate, {
+            isIncompressible: (element) => {
+                if (isSearchTreeFolderMatch(element) && !isTextSearchHeading(element.parent()) && !(isSearchTreeFolderMatchWorkspaceRoot(element.parent())) && !(isSearchTreeFolderMatchNoRoot(element.parent()))) {
+                    return false;
+                }
+                return true;
+            }
+        }, [
+            this._register(this.instantiationService.createInstance(FolderMatchRenderer, this, this.treeLabels)),
+            this._register(this.instantiationService.createInstance(FileMatchRenderer, this, this.treeLabels)),
+            this._register(this.instantiationService.createInstance(TextSearchResultRenderer, this.treeLabels)),
+            this._register(this.instantiationService.createInstance(MatchRenderer, this)),
+        ], this.searchDataSource, {
+            identityProvider,
+            accessibilityProvider: this.treeAccessibilityProvider,
+            dnd: this.instantiationService.createInstance(ResourceListDnDHandler, element => {
+                if (isSearchTreeFileMatch(element)) {
+                    return element.resource;
+                }
+                if (isSearchTreeMatch(element)) {
+                    return withSelection(element.parent().resource, element.range());
+                }
+                return null;
+            }),
+            multipleSelectionSupport: true,
+            selectionNavigation: true,
+            overrideStyles: this.getLocationBasedColors().listOverrideStyles,
+            paddingBottom: SearchDelegate.ITEM_HEIGHT,
+            collapseByDefault: (e) => {
+                if (isTextSearchHeading(e)) {
+                    return e.isAIContributed;
+                }
+                if (isSearchTreeFolderMatch(e) && e.matches().length === 1 && isSearchTreeFolderMatch(e.matches()[0])) {
+                    return false;
+                }
+                return this.shouldCollapseAccordingToConfig(e);
+            }
+        }));
+        SearchContext.SearchResultListFocusedKey.bindTo(this.tree.contextKeyService);
+        this.tree.setInput(this.viewModel.searchResult);
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+        const updateHasSomeCollapsible = () => this.toggleCollapseStateDelayer.trigger(() => this.hasSomeCollapsibleResultKey.set(this.hasSomeCollapsible()));
+        updateHasSomeCollapsible();
+        this._register(this.tree.onDidChangeCollapseState(() => updateHasSomeCollapsible()));
+        this._register(this.tree.onDidChangeModel(() => updateHasSomeCollapsible()));
+        this._register(Event.debounce(this.tree.onDidOpen, (last, event) => event, DEBOUNCE_DELAY, true)(options => {
+            if (isSearchTreeMatch(options.element)) {
+                const selectedMatch = options.element;
+                this.currentSelectedFileMatch?.setSelectedMatch(null);
+                this.currentSelectedFileMatch = selectedMatch.parent();
+                this.currentSelectedFileMatch.setSelectedMatch(selectedMatch);
+                this.onFocus(selectedMatch, options.editorOptions.preserveFocus, options.sideBySide, options.editorOptions.pinned);
+            }
+        }));
+        this._register(Event.debounce(this.tree.onDidChangeFocus, (last, event) => event, DEBOUNCE_DELAY, true)(() => {
+            const selection = this.tree.getSelection();
+            const focus = this.tree.getFocus()[0];
+            if (selection.length > 1 && isSearchTreeMatch(focus)) {
+                this.onFocus(focus, true);
+            }
+        }));
+        this._register(Event.any(this.tree.onDidFocus, this.tree.onDidChangeFocus)(() => {
+            const focus = this.tree.getFocus()[0];
+            if (this.tree.isDOMFocused()) {
+                const firstElem = this.tree.getFirstElementChild(this.tree.getInput());
+                this.firstMatchFocused.set(firstElem === focus);
+                this.fileMatchOrMatchFocused.set(!!focus);
+                this.fileMatchFocused.set(isSearchTreeFileMatch(focus));
+                this.folderMatchFocused.set(isSearchTreeFolderMatch(focus));
+                this.matchFocused.set(isSearchTreeMatch(focus));
+                this.fileMatchOrFolderMatchFocus.set(isSearchTreeFileMatch(focus) || isSearchTreeFolderMatch(focus));
+                this.fileMatchOrFolderMatchWithResourceFocus.set(isSearchTreeFileMatch(focus) || isSearchTreeFolderMatchWithResource(focus));
+                this.folderMatchWithResourceFocused.set(isSearchTreeFolderMatchWithResource(focus));
+                this.searchResultHeaderFocused.set(isSearchHeader(focus));
+                this.lastFocusState = 'tree';
+            }
+            let editable = false;
+            if (isSearchTreeMatch(focus)) {
+                editable = !focus.isReadonly;
+            }
+            else if (isSearchTreeFileMatch(focus)) {
+                editable = !focus.hasOnlyReadOnlyMatches();
+            }
+            else if (isSearchTreeFolderMatch(focus)) {
+                editable = !focus.hasOnlyReadOnlyMatches();
+            }
+            this.isEditableItem.set(editable);
+        }));
+        this._register(this.tree.onDidBlur(() => {
+            this.firstMatchFocused.reset();
+            this.fileMatchOrMatchFocused.reset();
+            this.fileMatchFocused.reset();
+            this.folderMatchFocused.reset();
+            this.matchFocused.reset();
+            this.fileMatchOrFolderMatchFocus.reset();
+            this.fileMatchOrFolderMatchWithResourceFocus.reset();
+            this.folderMatchWithResourceFocused.reset();
+            this.searchResultHeaderFocused.reset();
+            this.isEditableItem.reset();
+        }));
+    }
+    onContextMenu(e) {
+        e.browserEvent.preventDefault();
+        e.browserEvent.stopPropagation();
+        const selection = this.tree.getSelection();
+        let arg;
+        let context;
+        if (selection && selection.length > 0) {
+            arg = e.element;
+            context = selection;
+        }
+        else {
+            context = e.element;
+        }
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.SearchContext,
+            menuActionOptions: { shouldForwardArgs: true, arg },
+            contextKeyService: this.contextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => context,
+        });
+    }
+    hasSomeCollapsible() {
+        const viewer = this.getControl();
+        const navigator = viewer.navigate();
+        let node = navigator.first();
+        const shouldShowAI = this.shouldShowAIResults();
+        do {
+            if (node && !viewer.isCollapsed(node) && (!shouldShowAI || !(isTextSearchHeading(node)))) {
+                return true;
+            }
+        } while (node = navigator.next());
+        return false;
+    }
+    async selectNextMatch() {
+        if (!this.hasSearchResults()) {
+            return;
+        }
+        const [selected] = this.tree.getSelection();
+        if (selected && !(isSearchTreeMatch(selected))) {
+            if (this.tree.isCollapsed(selected)) {
+                await this.tree.expand(selected);
+            }
+        }
+        const navigator = this.tree.navigate(selected);
+        let next = navigator.next();
+        if (!next) {
+            next = navigator.first();
+        }
+        while (next && !(isSearchTreeMatch(next))) {
+            if (this.tree.isCollapsed(next)) {
+                await this.tree.expand(next);
+            }
+            next = navigator.next();
+        }
+        if (next) {
+            if (next === selected) {
+                this.tree.setFocus([]);
+            }
+            const event = getSelectionKeyboardEvent(undefined, false, false);
+            this.tree.setFocus([next], event);
+            this.tree.setSelection([next], event);
+            this.tree.reveal(next);
+            const ariaLabel = this.treeAccessibilityProvider.getAriaLabel(next);
+            if (ariaLabel) {
+                status(ariaLabel);
+            }
+        }
+    }
+    async selectPreviousMatch() {
+        if (!this.hasSearchResults()) {
+            return;
+        }
+        const [selected] = this.tree.getSelection();
+        let navigator = this.tree.navigate(selected);
+        let prev = navigator.previous();
+        while (!prev || (!(isSearchTreeMatch(prev)) && !this.tree.isCollapsed(prev))) {
+            const nextPrev = prev ? navigator.previous() : navigator.last();
+            if (!prev && !nextPrev) {
+                return;
+            }
+            prev = nextPrev;
+        }
+        while (prev && !(isSearchTreeMatch(prev))) {
+            const nextItem = navigator.next();
+            if (!nextItem) {
+                break;
+            }
+            await this.tree.expand(prev);
+            navigator = this.tree.navigate(nextItem);
+            prev = nextItem ? navigator.previous() : navigator.last();
+        }
+        if (prev) {
+            if (prev === selected) {
+                this.tree.setFocus([]);
+            }
+            const event = getSelectionKeyboardEvent(undefined, false, false);
+            this.tree.setFocus([prev], event);
+            this.tree.setSelection([prev], event);
+            this.tree.reveal(prev);
+            const ariaLabel = this.treeAccessibilityProvider.getAriaLabel(prev);
+            if (ariaLabel) {
+                status(ariaLabel);
+            }
+        }
+    }
+    moveFocusToResults() {
+        this.tree.domFocus();
+    }
+    focus() {
+        super.focus();
+        if (this.lastFocusState === 'input' || !this.hasSearchResults()) {
+            const updatedText = this.searchConfig.seedOnFocus ? this.updateTextFromSelection({ allowSearchOnType: false }) : false;
+            this.searchWidget.focus(undefined, undefined, updatedText);
+        }
+        else {
+            this.tree.domFocus();
+        }
+    }
+    updateTextFromFindWidgetOrSelection({ allowUnselectedWord = true, allowSearchOnType = true }) {
+        let activeEditor = this.editorService.activeTextEditorControl;
+        if (isCodeEditor(activeEditor) && !activeEditor?.hasTextFocus()) {
+            const controller = CommonFindController.get(activeEditor);
+            if (controller && controller.isFindInputFocused()) {
+                return this.updateTextFromFindWidget(controller, { allowSearchOnType });
+            }
+            const editors = this.codeEditorService.listCodeEditors();
+            activeEditor = editors.find(editor => editor instanceof EmbeddedCodeEditorWidget && editor.getParentEditor() === activeEditor && editor.hasTextFocus())
+                ?? activeEditor;
+        }
+        return this.updateTextFromSelection({ allowUnselectedWord, allowSearchOnType }, activeEditor);
+    }
+    updateTextFromFindWidget(controller, { allowSearchOnType = true }) {
+        if (!this.searchConfig.seedWithNearestWord && (getActiveWindow().getSelection()?.toString() ?? '') === '') {
+            return false;
+        }
+        const searchString = controller.getState().searchString;
+        if (searchString === '') {
+            return false;
+        }
+        this.searchWidget.searchInput?.setCaseSensitive(controller.getState().matchCase);
+        this.searchWidget.searchInput?.setWholeWords(controller.getState().wholeWord);
+        this.searchWidget.searchInput?.setRegex(controller.getState().isRegex);
+        this.updateText(searchString, allowSearchOnType);
+        return true;
+    }
+    updateTextFromSelection({ allowUnselectedWord = true, allowSearchOnType = true }, editor) {
+        const seedSearchStringFromSelection = this.configurationService.getValue('editor').find.seedSearchStringFromSelection;
+        if (!seedSearchStringFromSelection || seedSearchStringFromSelection === 'never') {
+            return false;
+        }
+        let selectedText = this.getSearchTextFromEditor(allowUnselectedWord, editor);
+        if (selectedText === null) {
+            return false;
+        }
+        if (this.searchWidget.searchInput?.getRegex()) {
+            selectedText = escapeRegExpCharacters(selectedText);
+        }
+        this.updateText(selectedText, allowSearchOnType);
+        return true;
+    }
+    updateText(text, allowSearchOnType = true) {
+        if (allowSearchOnType && !this.viewModel.searchResult.isDirty) {
+            this.searchWidget.setValue(text);
+        }
+        else {
+            this.pauseSearching = true;
+            this.searchWidget.setValue(text);
+            this.pauseSearching = false;
+        }
+    }
+    focusNextInputBox() {
+        if (this.searchWidget.searchInputHasFocus()) {
+            if (this.searchWidget.isReplaceShown()) {
+                this.searchWidget.focus(true, true);
+            }
+            else {
+                this.moveFocusFromSearchOrReplace();
+            }
+            return;
+        }
+        if (this.searchWidget.replaceInputHasFocus()) {
+            this.moveFocusFromSearchOrReplace();
+            return;
+        }
+        if (this.inputPatternIncludes.inputHasFocus()) {
+            this.inputPatternExcludes.focus();
+            this.inputPatternExcludes.select();
+            return;
+        }
+        if (this.inputPatternExcludes.inputHasFocus()) {
+            this.selectTreeIfNotSelected();
+            return;
+        }
+    }
+    moveFocusFromSearchOrReplace() {
+        if (this.showsFileTypes()) {
+            this.toggleQueryDetails(true, this.showsFileTypes());
+        }
+        else {
+            this.selectTreeIfNotSelected();
+        }
+    }
+    focusPreviousInputBox() {
+        if (this.searchWidget.searchInputHasFocus()) {
+            return;
+        }
+        if (this.searchWidget.replaceInputHasFocus()) {
+            this.searchWidget.focus(true);
+            return;
+        }
+        if (this.inputPatternIncludes.inputHasFocus()) {
+            this.searchWidget.focus(true, true);
+            return;
+        }
+        if (this.inputPatternExcludes.inputHasFocus()) {
+            this.inputPatternIncludes.focus();
+            this.inputPatternIncludes.select();
+            return;
+        }
+        if (this.tree.isDOMFocused()) {
+            this.moveFocusFromResults();
+            return;
+        }
+    }
+    moveFocusFromResults() {
+        if (this.showsFileTypes()) {
+            this.toggleQueryDetails(true, true, false, true);
+        }
+        else {
+            this.searchWidget.focus(true, true);
+        }
+    }
+    reLayout() {
+        if (this.isDisposed || !this.size) {
+            return;
+        }
+        const actionsPosition = this.searchConfig.actionsPosition;
+        this.getContainer().classList.toggle(SearchView_1.ACTIONS_RIGHT_CLASS_NAME, actionsPosition === 'right');
+        this.searchWidget.setWidth(this.size.width - 28 );
+        this.inputPatternExcludes.setWidth(this.size.width - 28 );
+        this.inputPatternIncludes.setWidth(this.size.width - 28 );
+        const widgetHeight = getTotalHeight(this.searchWidgetsContainerElement);
+        const messagesHeight = getTotalHeight(this.messagesElement);
+        this.tree.layout(this.size.height - widgetHeight - messagesHeight, this.size.width - 28);
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.size = new Dimension(width, height);
+        this.reLayout();
+    }
+    getControl() {
+        return this.tree;
+    }
+    allSearchFieldsClear() {
+        return this.searchWidget.getReplaceValue() === '' &&
+            (!this.searchWidget.searchInput || this.searchWidget.searchInput.getValue() === '');
+    }
+    allFilePatternFieldsClear() {
+        return this.searchExcludePattern.getValue() === '' &&
+            this.searchIncludePattern.getValue() === '';
+    }
+    hasSearchResults() {
+        return !this.viewModel.searchResult.isEmpty();
+    }
+    clearSearchResults(clearInput = true) {
+        this.viewModel.searchResult.clear();
+        this.showEmptyStage(true);
+        if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
+            this.showSearchWithoutFolderMessage();
+        }
+        if (clearInput) {
+            if (this.allSearchFieldsClear()) {
+                this.clearFilePatternFields();
+            }
+            this.searchWidget.clear();
+        }
+        this.viewModel.cancelSearch();
+        this.viewModel.cancelAISearch();
+        this.tree.ariaLabel = ( localize(10843, "Empty Search"));
+        this.accessibilitySignalService.playSignal(AccessibilitySignal.clear);
+        this.reLayout();
+    }
+    clearFilePatternFields() {
+        this.searchExcludePattern.clear();
+        this.searchIncludePattern.clear();
+    }
+    cancelSearch(focus = true) {
+        if (this.viewModel.cancelSearch() && this.viewModel.cancelAISearch()) {
+            if (focus) {
+                this.searchWidget.focus();
+            }
+            return true;
+        }
+        return false;
+    }
+    selectTreeIfNotSelected() {
+        if (this.tree.getNode(undefined)) {
+            this.tree.domFocus();
+            const selection = this.tree.getSelection();
+            if (selection.length === 0) {
+                const event = getSelectionKeyboardEvent();
+                this.tree.focusNext(undefined, undefined, event);
+                this.tree.setSelection(this.tree.getFocus(), event);
+            }
+        }
+    }
+    getSearchTextFromEditor(allowUnselectedWord, editor) {
+        if (isAncestorOfActiveElement(this.getContainer())) {
+            return null;
+        }
+        editor = editor ?? this.editorService.activeTextEditorControl;
+        if (!editor) {
+            return null;
+        }
+        const allowUnselected = this.searchConfig.seedWithNearestWord && allowUnselectedWord;
+        return getSelectionTextFromEditor(allowUnselected, editor);
+    }
+    showsFileTypes() {
+        return this.queryDetails.classList.contains('more');
+    }
+    toggleCaseSensitive() {
+        this.searchWidget.searchInput?.setCaseSensitive(!this.searchWidget.searchInput.getCaseSensitive());
+        this.triggerQueryChange({ shouldKeepAIResults: true });
+    }
+    toggleWholeWords() {
+        this.searchWidget.searchInput?.setWholeWords(!this.searchWidget.searchInput.getWholeWords());
+        this.triggerQueryChange({ shouldKeepAIResults: true });
+    }
+    toggleRegex() {
+        this.searchWidget.searchInput?.setRegex(!this.searchWidget.searchInput.getRegex());
+        this.triggerQueryChange({ shouldKeepAIResults: true });
+    }
+    togglePreserveCase() {
+        this.searchWidget.replaceInput?.setPreserveCase(!this.searchWidget.replaceInput.getPreserveCase());
+        this.triggerQueryChange({ shouldKeepAIResults: true });
+    }
+    setSearchParameters(args = {}) {
+        if (typeof args.isCaseSensitive === 'boolean') {
+            this.searchWidget.searchInput?.setCaseSensitive(args.isCaseSensitive);
+        }
+        if (typeof args.matchWholeWord === 'boolean') {
+            this.searchWidget.searchInput?.setWholeWords(args.matchWholeWord);
+        }
+        if (typeof args.isRegex === 'boolean') {
+            this.searchWidget.searchInput?.setRegex(args.isRegex);
+        }
+        if (typeof args.filesToInclude === 'string') {
+            this.searchIncludePattern.setValue(String(args.filesToInclude));
+        }
+        if (typeof args.filesToExclude === 'string') {
+            this.searchExcludePattern.setValue(String(args.filesToExclude));
+        }
+        if (typeof args.query === 'string') {
+            this.searchWidget.searchInput?.setValue(args.query);
+        }
+        if (typeof args.replace === 'string') {
+            this.searchWidget.replaceInput?.setValue(args.replace);
+        }
+        else {
+            if (this.searchWidget.replaceInput && this.searchWidget.replaceInput.getValue() !== '') {
+                this.searchWidget.replaceInput.setValue('');
+            }
+        }
+        if (typeof args.triggerSearch === 'boolean' && args.triggerSearch) {
+            this.triggerQueryChange();
+        }
+        if (typeof args.preserveCase === 'boolean') {
+            this.searchWidget.replaceInput?.setPreserveCase(args.preserveCase);
+        }
+        if (typeof args.useExcludeSettingsAndIgnoreFiles === 'boolean') {
+            this.inputPatternExcludes.setUseExcludesAndIgnoreFiles(args.useExcludeSettingsAndIgnoreFiles);
+        }
+        if (typeof args.onlyOpenEditors === 'boolean') {
+            this.searchIncludePattern.setOnlySearchInOpenEditors(args.onlyOpenEditors);
+        }
+    }
+    toggleQueryDetails(moveFocus = true, show, skipLayout, reverse) {
+        show = typeof show === 'undefined' ? !this.queryDetails.classList.contains('more') : Boolean(show);
+        if (!this.viewletState.query) {
+            this.viewletState.query = {};
+        }
+        this.viewletState.query.queryDetailsExpanded = show;
+        skipLayout = Boolean(skipLayout);
+        if (show) {
+            this.toggleQueryDetailsButton.setAttribute('aria-expanded', 'true');
+            this.queryDetails.classList.add('more');
+            if (moveFocus) {
+                if (reverse) {
+                    this.inputPatternExcludes.focus();
+                    this.inputPatternExcludes.select();
+                }
+                else {
+                    this.inputPatternIncludes.focus();
+                    this.inputPatternIncludes.select();
+                }
+            }
+        }
+        else {
+            this.toggleQueryDetailsButton.setAttribute('aria-expanded', 'false');
+            this.queryDetails.classList.remove('more');
+            if (moveFocus) {
+                this.searchWidget.focus();
+            }
+        }
+        if (!skipLayout && this.size) {
+            this.reLayout();
+        }
+    }
+    searchInFolders(folderPaths = []) {
+        this._searchWithIncludeOrExclude(true, folderPaths);
+    }
+    searchOutsideOfFolders(folderPaths = []) {
+        this._searchWithIncludeOrExclude(false, folderPaths);
+    }
+    _searchWithIncludeOrExclude(include, folderPaths) {
+        if (!folderPaths.length || ( folderPaths.some(folderPath => folderPath === '.'))) {
+            this.inputPatternIncludes.setValue('');
+            this.searchWidget.focus();
+            return;
+        }
+        if (!this.showsFileTypes()) {
+            this.toggleQueryDetails(true, true);
+        }
+        (include ? this.inputPatternIncludes : this.inputPatternExcludes).setValue(folderPaths.join(', '));
+        this.searchWidget.focus(false);
+    }
+    triggerQueryChange(_options) {
+        const options = { preserveFocus: true, triggeredOnType: false, delay: 0, ..._options };
+        if (options.triggeredOnType && !this.searchConfig.searchOnType) {
+            return;
+        }
+        if (!this.pauseSearching) {
+            const delay = options.triggeredOnType ? options.delay : 0;
+            this.triggerQueryDelayer.trigger(() => {
+                this._onQueryChanged(options.preserveFocus, options.triggeredOnType, options.shouldKeepAIResults, options.shouldUpdateAISearch);
+            }, delay);
+        }
+    }
+    _getExcludePattern() {
+        return this.inputPatternExcludes.getValue().trim();
+    }
+    _getIncludePattern() {
+        return this.inputPatternIncludes.getValue().trim();
+    }
+    _onQueryChanged(preserveFocus, triggeredOnType = false, shouldKeepAIResults = false, shouldUpdateAISearch = false) {
+        if (!(this.searchWidget.searchInput?.inputBox.isInputValid())) {
+            return;
+        }
+        const isRegex = this.searchWidget.searchInput.getRegex();
+        const isInNotebookMarkdownInput = this.searchWidget.getNotebookFilters().markupInput;
+        const isInNotebookMarkdownPreview = this.searchWidget.getNotebookFilters().markupPreview;
+        const isInNotebookCellInput = this.searchWidget.getNotebookFilters().codeInput;
+        const isInNotebookCellOutput = this.searchWidget.getNotebookFilters().codeOutput;
+        const isWholeWords = this.searchWidget.searchInput.getWholeWords();
+        const isCaseSensitive = this.searchWidget.searchInput.getCaseSensitive();
+        const contentPattern = this.searchWidget.searchInput.getValue();
+        const excludePatternText = this._getExcludePattern();
+        const includePatternText = this._getIncludePattern();
+        const useExcludesAndIgnoreFiles = this.inputPatternExcludes.useExcludesAndIgnoreFiles();
+        const onlySearchInOpenEditors = this.inputPatternIncludes.onlySearchInOpenEditors();
+        if (contentPattern.length === 0) {
+            this.clearSearchResults(false);
+            this.clearMessage();
+            this.clearAIResults();
+            return;
+        }
+        const content = {
+            pattern: contentPattern,
+            isRegExp: isRegex,
+            isCaseSensitive: isCaseSensitive,
+            isWordMatch: isWholeWords,
+            notebookInfo: {
+                isInNotebookMarkdownInput,
+                isInNotebookMarkdownPreview,
+                isInNotebookCellInput,
+                isInNotebookCellOutput
+            }
+        };
+        const excludePattern = [{ pattern: this.inputPatternExcludes.getValue() }];
+        const includePattern = this.inputPatternIncludes.getValue();
+        const charsPerLine = content.isRegExp ? 10000 : 1000;
+        const options = {
+            _reason: 'searchView',
+            extraFileResources: this.instantiationService.invokeFunction(getOutOfWorkspaceEditorResources),
+            maxResults: this.searchConfig.maxResults ?? undefined,
+            disregardIgnoreFiles: !useExcludesAndIgnoreFiles || undefined,
+            disregardExcludeSettings: !useExcludesAndIgnoreFiles || undefined,
+            onlyOpenEditors: onlySearchInOpenEditors,
+            excludePattern,
+            includePattern,
+            previewOptions: {
+                matchLines: 1,
+                charsPerLine
+            },
+            isSmartCase: this.searchConfig.smartCase,
+            expandPatterns: true
+        };
+        const folderResources = this.contextService.getWorkspace().folders;
+        const onQueryValidationError = (err) => {
+            this.searchWidget.searchInput?.showMessage({ content: err.message, type: MessageType.ERROR });
+            this.viewModel.searchResult.clear();
+        };
+        let query;
+        try {
+            query = this.queryBuilder.text(content, ( folderResources.map(folder => folder.uri)), options);
+        }
+        catch (err) {
+            onQueryValidationError(err);
+            return;
+        }
+        this.validateQuery(query).then(() => {
+            if (!shouldKeepAIResults && shouldUpdateAISearch && this.tree.hasNode(this.searchResult.aiTextSearchResult)) {
+                this.tree.collapse(this.searchResult.aiTextSearchResult);
+            }
+            this.onQueryTriggered(query, options, excludePatternText, includePatternText, triggeredOnType, shouldKeepAIResults, shouldUpdateAISearch);
+            if (!preserveFocus) {
+                this.searchWidget.focus(false, undefined, true);
+            }
+        }, onQueryValidationError);
+    }
+    validateQuery(query) {
+        const folderQueriesExistP = ( query.folderQueries.map(fq => {
+            return this.fileService.exists(fq.folder).catch(() => false);
+        }));
+        return Promise.all(folderQueriesExistP).then(existResults => {
+            const existingFolderQueries = query.folderQueries.filter((folderQuery, i) => existResults[i]);
+            if (!query.folderQueries.length || existingFolderQueries.length) {
+                query.folderQueries = existingFolderQueries;
+            }
+            else {
+                const nonExistantPath = query.folderQueries[0].folder.fsPath;
+                const searchPathNotFoundError = ( localize(10844, "Search path not found: {0}", nonExistantPath));
+                return Promise.reject(( new Error(searchPathNotFoundError)));
+            }
+            return undefined;
+        });
+    }
+    onQueryTriggered(query, options, excludePatternText, includePatternText, triggeredOnType, shouldKeepAIResults, shouldUpdateAISearch) {
+        this.addToSearchHistoryDelayer.trigger(() => {
+            this.searchWidget.searchInput?.onSearchSubmit();
+            this.inputPatternExcludes.onSearchSubmit();
+            this.inputPatternIncludes.onSearchSubmit();
+        });
+        this.viewModel.cancelSearch(true);
+        if (!shouldKeepAIResults) {
+            this.clearAIResults();
+        }
+        this.currentSearchQ = this.currentSearchQ
+            .then(() => this.doSearch(query, excludePatternText, includePatternText, triggeredOnType, shouldKeepAIResults, shouldUpdateAISearch))
+            .then(() => undefined, () => undefined);
+    }
+    async _updateResults() {
+        if (this.state === SearchUIState.Idle) {
+            return;
+        }
+        try {
+            const fileCount = this.viewModel.searchResult.fileCount();
+            if (this._visibleMatches !== fileCount) {
+                this._visibleMatches = fileCount;
+                await this.refreshAndUpdateCount();
+            }
+        }
+        finally {
+            this._refreshResultsScheduler.schedule();
+        }
+    }
+    async expandIfSingularResult() {
+        const collapseResults = this.searchConfig.collapseResults;
+        if (collapseResults !== 'alwaysCollapse' && this.viewModel.searchResult.matches().length === 1) {
+            const onlyMatch = this.viewModel.searchResult.matches()[0];
+            await this.tree.expandTo(onlyMatch);
+            if (onlyMatch.count() < 50) {
+                await this.tree.expand(onlyMatch);
+            }
+        }
+    }
+    appendSearchWithAIButton(messageEl) {
+        const searchWithAIButtonTooltip = appendKeyBindingLabel(( localize(10845, "Search with AI.")), this.keybindingService.lookupKeybinding(SearchCommandIds.SearchWithAIActionId));
+        const searchWithAIButtonText = ( localize(10846, "Search with AI"));
+        const searchWithAIButton = this.messageDisposables.add(( new SearchLinkButton(searchWithAIButtonText, () => {
+            this.commandService.executeCommand(SearchCommandIds.SearchWithAIActionId);
+        }, this.hoverService, searchWithAIButtonTooltip)));
+        append(messageEl, searchWithAIButton.element);
+    }
+    async onSearchComplete(progressComplete, excludePatternText, includePatternText, completed, shouldDoFinalRefresh = true, keywords) {
+        this.state = SearchUIState.Idle;
+        progressComplete();
+        if (shouldDoFinalRefresh) {
+            await this.refreshAndUpdateCount();
+        }
+        const allResults = !this.viewModel.searchResult.isEmpty();
+        const aiResults = this.searchResult.getCachedSearchComplete(true);
+        if (completed?.exit === SearchCompletionExitCode.NewSearchStarted) {
+            return;
+        }
+        SearchContext.AIResultsRequested.bindTo(this.contextKeyService).set(this.shouldShowAIResults() && !!aiResults);
+        if (completed && this.tree.hasNode(this.searchResult.aiTextSearchResult) && this.tree.isCollapsed(this.searchResult.aiTextSearchResult)) {
+            this.tree.expand(this.searchResult.aiTextSearchResult);
+            return;
+        }
+        if (!allResults) {
+            const hasExcludes = !!excludePatternText;
+            const hasIncludes = !!includePatternText;
+            let message;
+            if (!completed) {
+                message = SEARCH_CANCELLED_MESSAGE;
+            }
+            else if (this.inputPatternIncludes.onlySearchInOpenEditors()) {
+                if (hasIncludes && hasExcludes) {
+                    message = ( localize(
+                        10847,
+                        "No results found in open editors matching '{0}' excluding '{1}' - ",
+                        includePatternText,
+                        excludePatternText
+                    ));
+                }
+                else if (hasIncludes) {
+                    message = ( localize(
+                        10848,
+                        "No results found in open editors matching '{0}' - ",
+                        includePatternText
+                    ));
+                }
+                else if (hasExcludes) {
+                    message = ( localize(
+                        10849,
+                        "No results found in open editors excluding '{0}' - ",
+                        excludePatternText
+                    ));
+                }
+                else {
+                    message = ( localize(
+                        10850,
+                        "No results found in open editors. Review your configured exclusions and check your gitignore files - "
+                    ));
+                }
+            }
+            else {
+                if (hasIncludes && hasExcludes) {
+                    message = ( localize(
+                        10851,
+                        "No results found in '{0}' excluding '{1}' - ",
+                        includePatternText,
+                        excludePatternText
+                    ));
+                }
+                else if (hasIncludes) {
+                    message = ( localize(10852, "No results found in '{0}' - ", includePatternText));
+                }
+                else if (hasExcludes) {
+                    message = ( localize(10853, "No results found excluding '{0}' - ", excludePatternText));
+                }
+                else {
+                    message = ( localize(
+                        10854,
+                        "No results found. Review your configured exclusions and check your gitignore files - "
+                    ));
+                }
+            }
+            status(message);
+            const messageEl = this.clearMessage();
+            append(messageEl, message);
+            if (this.shouldShowAIResults()) {
+                this.appendSearchWithAIButton(messageEl);
+                append(messageEl, $('span', undefined, ' - '));
+            }
+            if (!completed) {
+                const searchAgainButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10855, "Search again")), () => this.triggerQueryChange({ preserveFocus: false }), this.hoverService)));
+                append(messageEl, searchAgainButton.element);
+            }
+            else if (hasIncludes || hasExcludes) {
+                const searchAgainButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10856, "Search again in all files")), this.onSearchAgain.bind(this), this.hoverService)));
+                append(messageEl, searchAgainButton.element);
+            }
+            else {
+                const openSettingsButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10857, "Open Settings")), this.onOpenSettings.bind(this), this.hoverService)));
+                append(messageEl, openSettingsButton.element);
+            }
+            if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
+                this.showSearchWithoutFolderMessage();
+            }
+            this.reLayout();
+        }
+        else {
+            this.viewModel.searchResult.toggleHighlights(this.isVisible());
+            status(( localize(
+                10858,
+                "Search returned {0} results in {1} files",
+                this.viewModel.searchResult.count(),
+                this.viewModel.searchResult.fileCount()
+            )));
+        }
+        if (completed && completed.limitHit) {
+            completed.messages.push({ type: TextSearchCompleteMessageType.Warning, text: ( localize(
+                10859,
+                "The result set only contains a subset of all matches. Be more specific in your search to narrow down the results."
+            )) });
+        }
+        if (completed && completed.messages) {
+            for (const message of completed.messages) {
+                this.addMessage(message);
+            }
+        }
+        this.reLayout();
+    }
+    async onSearchError(e, progressComplete, excludePatternText, includePatternText, completed, shouldDoFinalRefresh = true) {
+        this.state = SearchUIState.Idle;
+        if (isCancellationError(e)) {
+            return this.onSearchComplete(progressComplete, excludePatternText, includePatternText, completed, shouldDoFinalRefresh);
+        }
+        else {
+            progressComplete();
+            this.searchWidget.searchInput?.showMessage({ content: e.message, type: MessageType.ERROR });
+            this.viewModel.searchResult.clear();
+            return Promise.resolve();
+        }
+    }
+    clearAIResults() {
+        this.model.searchResult.aiTextSearchResult.hidden = true;
+        this.refreshTreeController.clearAllPending();
+        this._pendingSemanticSearchPromise = undefined;
+        this._cachedResults = undefined;
+        this._cachedKeywords = [];
+        this.model.cancelAISearch(true);
+        this.model.clearAiSearchResults();
+    }
+    async requestAIResults() {
+        this.logService.info(`SearchView: Requesting semantic results from keybinding. Cached: ${!!this.cachedResults}`);
+        if ((!this.cachedResults || this.cachedResults.results.length === 0) && !this._pendingSemanticSearchPromise) {
+            this.clearAIResults();
+        }
+        this.model.searchResult.aiTextSearchResult.hidden = false;
+        await this.queueRefreshTree();
+        await forcedExpandRecursively(this.getControl(), this.model.searchResult.aiTextSearchResult);
+    }
+    async addAIResults() {
+        const excludePatternText = this._getExcludePattern();
+        const includePatternText = this._getIncludePattern();
+        this.searchWidget.searchInput?.clearMessage();
+        this.showEmptyStage();
+        this._visibleMatches = 0;
+        this.tree.setSelection([]);
+        this.tree.setFocus([]);
+        this.viewModel.replaceString = this.searchWidget.getReplaceValue();
+        let aiSearchPromise = this._pendingSemanticSearchPromise;
+        if (!aiSearchPromise) {
+            this.viewModel.searchResult.setAIQueryUsingTextQuery();
+            aiSearchPromise = this._pendingSemanticSearchPromise = this.viewModel.aiSearch(() => {
+                if (this._pendingSemanticSearchPromise === aiSearchPromise) {
+                    this._pendingSemanticSearchPromise = undefined;
+                }
+            });
+        }
+        aiSearchPromise.then((complete) => {
+            this.updateSearchResultCount(this.viewModel.searchResult.query?.userDisabledExcludesAndIgnoreFiles, this.viewModel.searchResult.query?.onlyOpenEditors, false);
+            return this.onSearchComplete(() => { }, excludePatternText, includePatternText, complete, false, complete.aiKeywords);
+        }, (e) => {
+            return this.onSearchError(e, () => { }, excludePatternText, includePatternText, undefined, false);
+        });
+    }
+    doSearch(query, excludePatternText, includePatternText, triggeredOnType, shouldKeepAIResults, shouldUpdateAISearch) {
+        let progressComplete;
+        this.progressService.withProgress({ location: this.getProgressLocation(), delay: triggeredOnType ? 300 : 0 }, _progress => {
+            return ( new Promise(resolve => progressComplete = resolve));
+        });
+        this.searchWidget.searchInput?.clearMessage();
+        this.state = SearchUIState.Searching;
+        this.showEmptyStage();
+        if (this.model.searchResult.aiTextSearchResult.hidden && shouldUpdateAISearch) {
+            this.logService.info(`SearchView: Semantic search visible. Keep semantic results: ${shouldKeepAIResults}. Update semantic search: ${shouldUpdateAISearch}`);
+            this.model.searchResult.aiTextSearchResult.hidden = false;
+        }
+        const slowTimer = setTimeout(() => {
+            this.state = SearchUIState.SlowSearch;
+        }, 2000);
+        this._visibleMatches = 0;
+        this._refreshResultsScheduler.schedule();
+        this.searchWidget.setReplaceAllActionState(false);
+        this.tree.setSelection([]);
+        this.tree.setFocus([]);
+        this.viewModel.replaceString = this.searchWidget.getReplaceValue();
+        const result = this.viewModel.search(query);
+        if (!shouldKeepAIResults || shouldUpdateAISearch) {
+            this.viewModel.searchResult.setAIQueryUsingTextQuery(query);
+        }
+        if (this.configurationService.getValue('search').searchView.keywordSuggestions) {
+            this.getKeywordSuggestions();
+        }
+        return result.asyncResults.then((complete) => {
+            clearTimeout(slowTimer);
+            const config = this.configurationService.getValue('search').searchView.semanticSearchBehavior;
+            if (complete.results.length === 0 && config === SemanticSearchBehavior.RunOnEmpty) {
+                this.logService.info(`SearchView: Requesting semantic results on empty search.`);
+                this.model.searchResult.aiTextSearchResult.hidden = false;
+            }
+            return this.onSearchComplete(progressComplete, excludePatternText, includePatternText, complete);
+        }, (e) => {
+            clearTimeout(slowTimer);
+            return this.onSearchError(e, progressComplete, excludePatternText, includePatternText);
+        });
+    }
+    onOpenSettings(e) {
+        EventHelper.stop(e, false);
+        this.openSettings('@id:files.exclude,search.exclude,search.useParentIgnoreFiles,search.useGlobalIgnoreFiles,search.useIgnoreFiles');
+    }
+    openSettings(query) {
+        const options = { query };
+        return this.contextService.getWorkbenchState() !== WorkbenchState.EMPTY ?
+            this.preferencesService.openWorkspaceSettings(options) :
+            this.preferencesService.openUserSettings(options);
+    }
+    onSearchAgain() {
+        this.inputPatternExcludes.setValue('');
+        this.inputPatternIncludes.setValue('');
+        this.inputPatternIncludes.setOnlySearchInOpenEditors(false);
+        this.triggerQueryChange({ preserveFocus: false });
+    }
+    onEnableExcludes() {
+        this.toggleQueryDetails(false, true);
+        this.searchExcludePattern.setUseExcludesAndIgnoreFiles(true);
+    }
+    onDisableSearchInOpenEditors() {
+        this.toggleQueryDetails(false, true);
+        this.inputPatternIncludes.setOnlySearchInOpenEditors(false);
+    }
+    updateSearchResultCount(disregardExcludesAndIgnores, onlyOpenEditors, clear = false) {
+        if (this._cachedKeywords.length > 0) {
+            return;
+        }
+        const fileCount = this.viewModel.searchResult.fileCount(this.viewModel.searchResult.aiTextSearchResult.hidden);
+        const resultCount = this.viewModel.searchResult.count(this.viewModel.searchResult.aiTextSearchResult.hidden);
+        this.hasSearchResultsKey.set(fileCount > 0);
+        const msgWasHidden = this.messagesElement.style.display === 'none';
+        const messageEl = this.clearMessage();
+        const resultMsg = clear ? '' : this.buildResultCountMessage(resultCount, fileCount);
+        this.tree.ariaLabel = resultMsg + ( localize(
+            10860,
+            " - Search: {0}",
+            this.searchResult.query?.contentPattern.pattern ?? ''
+        ));
+        append(messageEl, resultMsg);
+        if (fileCount > 0) {
+            if (disregardExcludesAndIgnores) {
+                const excludesDisabledMessage = ' - ' + ( localize(10861, "exclude settings and ignore files are disabled")) + ' ';
+                const enableExcludesButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10862, "enable")), this.onEnableExcludes.bind(this), this.hoverService, ( localize(10863, "Use Exclude Settings and Ignore Files")))));
+                append(messageEl, $('span', undefined, excludesDisabledMessage, '(', enableExcludesButton.element, ')'));
+            }
+            if (onlyOpenEditors) {
+                const searchingInOpenMessage = ' - ' + ( localize(10864, "searching only in open files")) + ' ';
+                const disableOpenEditorsButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10865, "disable")), this.onDisableSearchInOpenEditors.bind(this), this.hoverService, ( localize(10866, "Search in entire workspace")))));
+                append(messageEl, $('span', undefined, searchingInOpenMessage, '(', disableOpenEditorsButton.element, ')'));
+            }
+            append(messageEl, ' - ');
+            const openInEditorTooltip = appendKeyBindingLabel(( localize(10867, "Copy current search results to an editor")), this.keybindingService.lookupKeybinding(SearchCommandIds.OpenInEditorCommandId));
+            const openInEditorButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10868, "Open in editor")), () => this.instantiationService.invokeFunction(createEditorFromSearchResult, this.searchResult, this.searchIncludePattern.getValue(), this.searchExcludePattern.getValue(), this.searchIncludePattern.onlySearchInOpenEditors()), this.hoverService, openInEditorTooltip)));
+            append(messageEl, openInEditorButton.element);
+            append(messageEl, ' - ');
+            this.appendSearchWithAIButton(messageEl);
+            this.reLayout();
+        }
+        else if (!msgWasHidden) {
+            hide(this.messagesElement);
+        }
+    }
+    handleKeywordClick(keyword, index) {
+        this.searchWidget.searchInput?.setValue(keyword);
+        this.triggerQueryChange({ preserveFocus: false, triggeredOnType: false, shouldKeepAIResults: false });
+        this.telemetryService.publicLog2('searchKeywordClick', {
+            index,
+            maxKeywords: this._cachedKeywords.length
+        });
+    }
+    updateKeywordSuggestionUI(keyword) {
+        const element = this.messagesElement.firstChild;
+        if (this._cachedKeywords.length > 0) {
+            if (this._cachedKeywords.length >= 3) {
+                return;
+            }
+            append(element, ', ');
+            const index = this._cachedKeywords.length;
+            const button = this.messageDisposables.add(( new SearchLinkButton(
+                keyword.keyword,
+                () => this.handleKeywordClick(keyword.keyword, index),
+                this.hoverService
+            )));
+            append(element, button.element);
+        }
+        else {
+            const messageEl = this.clearMessage();
+            messageEl.classList.add('ai-keywords');
+            const resultMsg = ( localize(10869, "Search instead for: "));
+            append(messageEl, resultMsg);
+            const button = this.messageDisposables.add(( new SearchLinkButton(
+                keyword.keyword,
+                () => this.handleKeywordClick(keyword.keyword, 0),
+                this.hoverService
+            )));
+            append(messageEl, button.element);
+        }
+        this._cachedKeywords.push(keyword.keyword);
+    }
+    async getKeywordSuggestions() {
+        let aiSearchPromise = this._pendingSemanticSearchPromise;
+        if (!aiSearchPromise) {
+            this.viewModel.searchResult.setAIQueryUsingTextQuery();
+            aiSearchPromise = this._pendingSemanticSearchPromise = this.viewModel.aiSearch(result => {
+                if (result && isAIKeyword(result)) {
+                    this.updateKeywordSuggestionUI(result);
+                    return;
+                }
+                if (this._pendingSemanticSearchPromise === aiSearchPromise) {
+                    this._pendingSemanticSearchPromise = undefined;
+                }
+            });
+        }
+        this._cachedResults = await aiSearchPromise;
+    }
+    addMessage(message) {
+        const messageBox = this.messagesElement.firstChild;
+        if (!messageBox) {
+            return;
+        }
+        append(messageBox, renderSearchMessage(message, this.instantiationService, this.notificationService, this.openerService, this.commandService, this.messageDisposables, () => this.triggerQueryChange()));
+    }
+    buildResultCountMessage(resultCount, fileCount) {
+        if (resultCount === 1 && fileCount === 1) {
+            return localize(10870, "{0} result in {1} file", resultCount, fileCount);
+        }
+        else if (resultCount === 1) {
+            return localize(10871, "{0} result in {1} files", resultCount, fileCount);
+        }
+        else if (fileCount === 1) {
+            return localize(10872, "{0} results in {1} file", resultCount, fileCount);
+        }
+        else {
+            return localize(10873, "{0} results in {1} files", resultCount, fileCount);
+        }
+    }
+    showSearchWithoutFolderMessage() {
+        this.searchWithoutFolderMessageElement = this.clearMessage();
+        const textEl = append(this.searchWithoutFolderMessageElement, $('p', undefined, ( localize(
+            10874,
+            "You have not opened or specified a folder. Only open files are currently searched - "
+        ))));
+        const openFolderButton = this.messageDisposables.add(( new SearchLinkButton(( localize(10875, "Open Folder")), () => {
+            this.commandService.executeCommand(OpenFolderAction.ID).catch(err => onUnexpectedError(err));
+        }, this.hoverService)));
+        append(textEl, openFolderButton.element);
+    }
+    showEmptyStage(forceHideMessages = false) {
+        const showingCancelled = (this.messagesElement.firstChild?.textContent?.indexOf(SEARCH_CANCELLED_MESSAGE) ?? -1) > -1;
+        if (showingCancelled || forceHideMessages || !this.configurationService.getValue().search.searchOnType) {
+            hide(this.messagesElement);
+        }
+        show(this.resultsElement);
+        this.currentSelectedFileMatch = undefined;
+    }
+    shouldOpenInNotebookEditor(match, uri) {
+        return isIMatchInNotebook(match) || (uri.scheme !== Schemas.untitled && this.notebookService.getContributedNotebookTypes(uri).length > 0);
+    }
+    onFocus(lineMatch, preserveFocus, sideBySide, pinned) {
+        const useReplacePreview = this.configurationService.getValue().search.useReplacePreview;
+        const resource = isSearchTreeMatch(lineMatch) ? lineMatch.parent().resource : lineMatch.resource;
+        return (useReplacePreview && this.viewModel.isReplaceActive() && !!this.viewModel.replaceString && !(this.shouldOpenInNotebookEditor(lineMatch, resource))) ?
+            this.replaceService.openReplacePreview(lineMatch, preserveFocus, sideBySide, pinned) :
+            this.open(lineMatch, preserveFocus, sideBySide, pinned, resource);
+    }
+    async open(element, preserveFocus, sideBySide, pinned, resourceInput) {
+        const selection = getEditorSelectionFromMatch(element, this.viewModel);
+        const oldParentMatches = isSearchTreeMatch(element) ? element.parent().matches() : [];
+        const resource = resourceInput ?? (isSearchTreeMatch(element) ? element.parent().resource : element.resource);
+        let editor;
+        const options = {
+            preserveFocus,
+            pinned,
+            selection,
+            revealIfVisible: true,
+        };
+        try {
+            editor = await this.editorService.openEditor({
+                resource: resource,
+                options,
+            }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+            const editorControl = editor?.getControl();
+            if (isSearchTreeMatch(element) && preserveFocus && isCodeEditor(editorControl)) {
+                this.viewModel.searchResult.getRangeHighlightDecorations().highlightRange(editorControl.getModel(), element.range());
+            }
+            else {
+                this.viewModel.searchResult.getRangeHighlightDecorations().removeHighlightRange();
+            }
+        }
+        catch (err) {
+            onUnexpectedError(err);
+            return;
+        }
+        if (editor instanceof NotebookEditor) {
+            const elemParent = element.parent();
+            if (isSearchTreeMatch(element)) {
+                if (isIMatchInNotebook(element)) {
+                    element.parent().showMatch(element);
+                }
+                else {
+                    const editorWidget = editor.getControl();
+                    if (editorWidget) {
+                        elemParent.bindNotebookEditorWidget(editorWidget);
+                        await elemParent.updateMatchesForEditorWidget();
+                        const matchIndex = oldParentMatches.findIndex(e => e.id() === element.id());
+                        const matches = elemParent.matches();
+                        const match = matchIndex >= matches.length ? matches[matches.length - 1] : matches[matchIndex];
+                        if (isIMatchInNotebook(match)) {
+                            elemParent.showMatch(match);
+                            if (!this.tree.getFocus().includes(match) || !this.tree.getSelection().includes(match)) {
+                                this.tree.setSelection([match], getSelectionKeyboardEvent());
+                                this.tree.setFocus([match]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    openEditorWithMultiCursor(element) {
+        const resource = isSearchTreeMatch(element) ? element.parent().resource : element.resource;
+        return this.editorService.openEditor({
+            resource: resource,
+            options: {
+                preserveFocus: false,
+                pinned: true,
+                revealIfVisible: true
+            }
+        }).then(editor => {
+            if (editor) {
+                let fileMatch = null;
+                if (isSearchTreeFileMatch(element)) {
+                    fileMatch = element;
+                }
+                else if (isSearchTreeMatch(element)) {
+                    fileMatch = element.parent();
+                }
+                if (fileMatch) {
+                    const selections = ( fileMatch.matches().map(m => ( new Selection(
+                        m.range().startLineNumber,
+                        m.range().startColumn,
+                        m.range().endLineNumber,
+                        m.range().endColumn
+                    ))));
+                    const codeEditor = getCodeEditor(editor.getControl());
+                    if (codeEditor) {
+                        const multiCursorController = MultiCursorSelectionController.get(codeEditor);
+                        multiCursorController?.selectAllUsingSelections(selections);
+                    }
+                }
+            }
+            this.viewModel.searchResult.getRangeHighlightDecorations().removeHighlightRange();
+        }, onUnexpectedError);
+    }
+    onUntitledDidDispose(resource) {
+        if (!this.viewModel) {
+            return;
+        }
+        let matches = this.viewModel.searchResult.matches();
+        for (let i = 0, len = matches.length; i < len; i++) {
+            if (( resource.toString()) === ( matches[i].resource.toString())) {
+                this.viewModel.searchResult.remove(matches[i]);
+            }
+        }
+        matches = this.viewModel.searchResult.matches(true);
+        for (let i = 0, len = matches.length; i < len; i++) {
+            if (( resource.toString()) === ( matches[i].resource.toString())) {
+                this.viewModel.searchResult.remove(matches[i]);
+            }
+        }
+    }
+    onFilesChanged(e) {
+        if (!this.viewModel || (this.searchConfig.sortOrder !== SearchSortOrder.Modified && !e.gotDeleted())) {
+            return;
+        }
+        const matches = this.viewModel.searchResult.matches();
+        if (e.gotDeleted()) {
+            const deletedMatches = matches.filter(m => e.contains(m.resource, FileChangeType.DELETED));
+            this.viewModel.searchResult.remove(deletedMatches);
+        }
+        else {
+            const changedMatches = matches.filter(m => e.contains(m.resource));
+            if (changedMatches.length && this.searchConfig.sortOrder === SearchSortOrder.Modified) {
+                this.updateFileStats(changedMatches).then(async () => this.refreshTreeController.queue());
+            }
+        }
+    }
+    get searchConfig() {
+        return this.configurationService.getValue('search');
+    }
+    clearHistory() {
+        this.searchWidget.clearHistory();
+        this.inputPatternExcludes.clearHistory();
+        this.inputPatternIncludes.clearHistory();
+    }
+    saveState() {
+        if (!this.searchWidget) {
+            return;
+        }
+        const patternExcludes = this.inputPatternExcludes?.getValue().trim() ?? '';
+        const patternIncludes = this.inputPatternIncludes?.getValue().trim() ?? '';
+        const onlyOpenEditors = this.inputPatternIncludes?.onlySearchInOpenEditors() ?? false;
+        const useExcludesAndIgnoreFiles = this.inputPatternExcludes?.useExcludesAndIgnoreFiles() ?? true;
+        const preserveCase = this.viewModel.preserveCase;
+        if (!this.viewletState.query) {
+            this.viewletState.query = {};
+        }
+        if (this.searchWidget.searchInput) {
+            const isRegex = this.searchWidget.searchInput.getRegex();
+            const isWholeWords = this.searchWidget.searchInput.getWholeWords();
+            const isCaseSensitive = this.searchWidget.searchInput.getCaseSensitive();
+            const contentPattern = this.searchWidget.searchInput.getValue();
+            const isInNotebookCellInput = this.searchWidget.getNotebookFilters().codeInput;
+            const isInNotebookCellOutput = this.searchWidget.getNotebookFilters().codeOutput;
+            const isInNotebookMarkdownInput = this.searchWidget.getNotebookFilters().markupInput;
+            const isInNotebookMarkdownPreview = this.searchWidget.getNotebookFilters().markupPreview;
+            this.viewletState.query.contentPattern = contentPattern;
+            this.viewletState.query.regex = isRegex;
+            this.viewletState.query.wholeWords = isWholeWords;
+            this.viewletState.query.caseSensitive = isCaseSensitive;
+            this.viewletState.query.isInNotebookMarkdownInput = isInNotebookMarkdownInput;
+            this.viewletState.query.isInNotebookMarkdownPreview = isInNotebookMarkdownPreview;
+            this.viewletState.query.isInNotebookCellInput = isInNotebookCellInput;
+            this.viewletState.query.isInNotebookCellOutput = isInNotebookCellOutput;
+        }
+        this.viewletState.query.folderExclusions = patternExcludes;
+        this.viewletState.query.folderIncludes = patternIncludes;
+        this.viewletState.query.useExcludesAndIgnoreFiles = useExcludesAndIgnoreFiles;
+        this.viewletState.query.preserveCase = preserveCase;
+        this.viewletState.query.onlyOpenEditors = onlyOpenEditors;
+        const isReplaceShown = this.searchAndReplaceWidget.isReplaceShown();
+        if (!this.viewletState.view) {
+            this.viewletState.view = {};
+        }
+        this.viewletState.view.showReplace = isReplaceShown;
+        this.viewletState.view.treeLayout = this.isTreeLayoutViewVisible;
+        this.viewletState.query.replaceText = isReplaceShown && this.searchWidget.getReplaceValue();
+        this._saveSearchHistoryService();
+        this.memento.saveMemento();
+        super.saveState();
+    }
+    _saveSearchHistoryService() {
+        if (this.searchWidget === undefined) {
+            return;
+        }
+        const history = Object.create(null);
+        const searchHistory = this.searchWidget.getSearchHistory();
+        if (searchHistory && searchHistory.length) {
+            history.search = searchHistory;
+        }
+        const replaceHistory = this.searchWidget.getReplaceHistory();
+        if (replaceHistory && replaceHistory.length) {
+            history.replace = replaceHistory;
+        }
+        const patternExcludesHistory = this.inputPatternExcludes.getHistory();
+        if (patternExcludesHistory && patternExcludesHistory.length) {
+            history.exclude = patternExcludesHistory;
+        }
+        const patternIncludesHistory = this.inputPatternIncludes.getHistory();
+        if (patternIncludesHistory && patternIncludesHistory.length) {
+            history.include = patternIncludesHistory;
+        }
+        this.searchHistoryService.save(history);
+    }
+    async updateFileStats(elements) {
+        const files = ( elements.map(f => f.resolveFileStat(this.fileService)));
+        await Promise.all(files);
+    }
+    removeFileStats() {
+        for (const fileMatch of this.searchResult.matches()) {
+            fileMatch.fileStat = undefined;
+        }
+        for (const fileMatch of this.searchResult.matches(true)) {
+            fileMatch.fileStat = undefined;
+        }
+    }
+    dispose() {
+        this.isDisposed = true;
+        this.saveState();
+        super.dispose();
+    }
+};
+SearchView = SearchView_1 = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, IProgressService)),
+    ( __param(5, INotificationService)),
+    ( __param(6, IDialogService)),
+    ( __param(7, ICommandService)),
+    ( __param(8, IContextViewService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, IViewDescriptorService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IWorkspaceContextService)),
+    ( __param(13, ISearchViewModelWorkbenchService)),
+    ( __param(14, IContextKeyService)),
+    ( __param(15, IReplaceService)),
+    ( __param(16, ITextFileService)),
+    ( __param(17, IPreferencesService)),
+    ( __param(18, IThemeService)),
+    ( __param(19, ISearchHistoryService)),
+    ( __param(20, IContextMenuService)),
+    ( __param(21, IAccessibilityService)),
+    ( __param(22, IKeybindingService)),
+    ( __param(23, IStorageService)),
+    ( __param(24, IOpenerService)),
+    ( __param(25, IHoverService)),
+    ( __param(26, INotebookService)),
+    ( __param(27, ILogService)),
+    ( __param(28, IAccessibilitySignalService)),
+    ( __param(29, ITelemetryService))
+], SearchView));
+class SearchLinkButton extends Disposable {
+    constructor(label, handler, hoverService, tooltip) {
+        super();
+        this.element = $('a.pointer', { tabindex: 0 }, label);
+        this._register(hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), this.element, tooltip));
+        this.addEventHandlers(handler);
+    }
+    addEventHandlers(handler) {
+        const wrappedHandler = (e) => {
+            EventHelper.stop(e, false);
+            handler(e);
+        };
+        this._register(addDisposableListener(this.element, EventType.CLICK, wrappedHandler));
+        this._register(addDisposableListener(this.element, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Space) || event.equals(KeyCode.Enter)) {
+                wrappedHandler(e);
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        }));
+    }
+}
+function getEditorSelectionFromMatch(element, viewModel) {
+    let match = null;
+    if (isSearchTreeMatch(element)) {
+        match = element;
+    }
+    if (isSearchTreeFileMatch(element) && element.count() > 0) {
+        match = element.matches()[element.matches().length - 1];
+    }
+    if (match) {
+        const range = match.range();
+        if (viewModel.isReplaceActive() && !!viewModel.replaceString) {
+            const replaceString = match.replaceString;
+            return {
+                startLineNumber: range.startLineNumber,
+                startColumn: range.startColumn,
+                endLineNumber: range.startLineNumber,
+                endColumn: range.startColumn + replaceString.length
+            };
+        }
+        return range;
+    }
+    return undefined;
+}
+function getSelectionTextFromEditor(allowUnselectedWord, activeEditor) {
+    let editor = activeEditor;
+    if (isDiffEditor(editor)) {
+        if (editor.getOriginalEditor().hasTextFocus()) {
+            editor = editor.getOriginalEditor();
+        }
+        else {
+            editor = editor.getModifiedEditor();
+        }
+    }
+    if (!isCodeEditor(editor) || !editor.hasModel()) {
+        return null;
+    }
+    const range = editor.getSelection();
+    if (!range) {
+        return null;
+    }
+    if (range.isEmpty()) {
+        if (allowUnselectedWord) {
+            const wordAtPosition = editor.getModel().getWordAtPosition(range.getStartPosition());
+            return wordAtPosition?.word ?? null;
+        }
+        else {
+            return null;
+        }
+    }
+    let searchText = '';
+    for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {
+        let lineText = editor.getModel().getLineContent(i);
+        if (i === range.endLineNumber) {
+            lineText = lineText.substring(0, range.endColumn - 1);
+        }
+        if (i === range.startLineNumber) {
+            lineText = lineText.substring(range.startColumn - 1);
+        }
+        if (i !== range.startLineNumber) {
+            lineText = '\n' + lineText;
+        }
+        searchText += lineText;
+    }
+    return searchText;
+}
+let SearchViewDataSource = class SearchViewDataSource {
+    constructor(searchView, configurationService) {
+        this.searchView = searchView;
+        this.configurationService = configurationService;
+    }
+    get searchConfig() {
+        return this.configurationService.getValue('search');
+    }
+    createSearchResultIterator(searchResult) {
+        const ret = [];
+        if (this.searchView.shouldShowAIResults() && searchResult.searchModel.hasPlainResults && !searchResult.aiTextSearchResult.hidden) {
+            ret.push(searchResult.aiTextSearchResult);
+        }
+        if (!searchResult.plainTextSearchResult.isEmpty()) {
+            if (!this.searchView.shouldShowAIResults() || searchResult.aiTextSearchResult.hidden) {
+                return this.createTextSearchResultIterator(searchResult.plainTextSearchResult);
+            }
+            ret.push(searchResult.plainTextSearchResult);
+        }
+        return ret;
+    }
+    createTextSearchResultIterator(textSearchResult) {
+        const folderMatches = textSearchResult.folderMatches()
+            .filter(fm => !fm.isEmpty())
+            .sort(searchMatchComparer);
+        if (folderMatches.length === 1) {
+            return this.createFolderIterator(folderMatches[0]);
+        }
+        return folderMatches;
+    }
+    createFolderIterator(folderMatch) {
+        const matchArray = this.searchView.isTreeLayoutViewVisible ? folderMatch.matches() : folderMatch.allDownstreamFileMatches();
+        let matches = matchArray;
+        if (!(folderMatch instanceof AIFolderMatchWorkspaceRootImpl)) {
+            matches = matchArray.sort((a, b) => searchMatchComparer(a, b, this.searchConfig.sortOrder));
+        }
+        return matches;
+    }
+    createFileIterator(fileMatch) {
+        const matches = fileMatch.matches().sort(searchMatchComparer);
+        return matches;
+    }
+    hasChildren(element) {
+        if (isSearchTreeMatch(element)) {
+            return false;
+        }
+        if (isTextSearchHeading(element) && element.isAIContributed) {
+            return true;
+        }
+        const hasChildren = element.hasChildren;
+        return hasChildren;
+    }
+    getChildren(element) {
+        if (isSearchResult(element)) {
+            return this.createSearchResultIterator(element);
+        }
+        else if (isTextSearchHeading(element)) {
+            if (element.isAIContributed && (!this.searchView.model.hasAIResults || !!this.searchView._pendingSemanticSearchPromise)) {
+                if (this.searchView.cachedResults) {
+                    return this.createTextSearchResultIterator(element);
+                }
+                this.searchView.addAIResults();
+                return ( new Promise(resolve => {
+                    const disposable = element.onChange(() => {
+                        disposable.dispose();
+                        resolve(this.createTextSearchResultIterator(element));
+                    });
+                }));
+            }
+            return this.createTextSearchResultIterator(element);
+        }
+        else if (isSearchTreeFolderMatch(element)) {
+            return this.createFolderIterator(element);
+        }
+        else if (isSearchTreeFileMatch(element)) {
+            return this.createFileIterator(element);
+        }
+        return [];
+    }
+    getParent(element) {
+        const parent = element.parent();
+        if (isSearchResult(parent)) {
+            throw ( new Error('Invalid element passed to getParent'));
+        }
+        return parent;
+    }
+};
+SearchViewDataSource = ( __decorate([
+    ( __param(1, IConfigurationService))
+], SearchViewDataSource));
+let RefreshTreeController = class RefreshTreeController extends Disposable {
+    constructor(searchView, geSearchConfig, fileService) {
+        super();
+        this.searchView = searchView;
+        this.geSearchConfig = geSearchConfig;
+        this.fileService = fileService;
+        this.queuedIChangeEvents = [];
+        this.refreshTreeThrottler = this._register(( new Throttler()));
+    }
+    clearAllPending() {
+        this.searchView.getControl().cancelAllRefreshPromises(true);
+    }
+    async queue(e) {
+        if (e) {
+            this.queuedIChangeEvents.push(e);
+        }
+        return this.refreshTreeThrottler.queue(this.refreshTreeUsingQueue.bind(this));
+    }
+    async refreshTreeUsingQueue() {
+        const aggregateChangeEvent = this.queuedIChangeEvents.length === 0 ? undefined : {
+            elements: ( this.queuedIChangeEvents.map(e => e.elements)).flat(),
+            added: ( this.queuedIChangeEvents.some(e => e.added)),
+            removed: ( this.queuedIChangeEvents.some(e => e.removed)),
+            clearingAll: ( this.queuedIChangeEvents.some(e => e.clearingAll)),
+        };
+        this.queuedIChangeEvents = [];
+        return this.refreshTree(aggregateChangeEvent);
+    }
+    async retrieveFileStats() {
+        const files = ( this.searchView.model.searchResult.matches().filter(f => !f.fileStat).map(f => f.resolveFileStat(this.fileService)));
+        await Promise.all(files);
+    }
+    async refreshTree(event) {
+        const searchConfig = this.geSearchConfig();
+        if (!event || event.added || event.removed) {
+            if (searchConfig.sortOrder === SearchSortOrder.Modified) {
+                await this.retrieveFileStats()
+                    .then(() => this.searchView.getControl().updateChildren(undefined));
+            }
+            else {
+                await this.searchView.getControl().updateChildren(undefined);
+            }
+        }
+        else {
+            if (searchConfig.sortOrder === SearchSortOrder.CountAscending ||
+                searchConfig.sortOrder === SearchSortOrder.CountDescending) {
+                await this.searchView.getControl().updateChildren(undefined);
+            }
+            else {
+                const treeHasAllElements = event.elements.every(elem => this.searchView.getControl().hasNode(elem));
+                if (treeHasAllElements) {
+                    await Promise.all(( event.elements.map(async (element) => {
+                        await this.searchView.getControl().updateChildren(element);
+                        this.searchView.getControl().rerender(element);
+                    })));
+                }
+                else {
+                    this.searchView.getControl().updateChildren(undefined);
+                }
+            }
+        }
+    }
+};
+RefreshTreeController = ( __decorate([
+    ( __param(2, IFileService))
+], RefreshTreeController));
+
+export { SearchView, SearchViewPosition, getEditorSelectionFromMatch, getSelectionTextFromEditor };