@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -0,0 +1,2175 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $ as $$1, hide, append, addDisposableListener, clearNode, show, getActiveWindow, getTotalHeight, Dimension, isAncestorOfActiveElement, EventHelper, EventType } from '../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { ObjectTreeElementCollapseState } from '../../../../base/browser/ui/tree/tree.js';
+import { Delayer, RunOnceScheduler } from '../../../../base/common/async.js';
+import { isCancellationError, onUnexpectedError } from '../../../../base/common/errors.js';
+import { Event } from '../../../../base/common/event.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { isMacintosh, isNative } from '../../../../base/common/platform.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Schemas } from '../../../../base/common/network.js';
+import './media/searchview.css.js';
+import { isCodeEditor, getCodeEditor, isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.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 { localizeWithPath } from '../../../../nls.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextViewService, IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { WorkbenchCompressibleObjectTree, getSelectionKeyboardEvent } from '../../../../platform/list/browser/listService.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { withSelection, IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { defaultInputBoxStyles, defaultToggleStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { OpenFileFolderAction, 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.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, MatchRenderer } from './searchResultsView.js';
+import { SearchWidget } from './searchWidget.js';
+import { SearchContext } from '../common/constants.js';
+import { IReplaceService } from './replace.js';
+import { SearchStateKey, SearchUIState, getOutOfWorkspaceEditorResources } from '../common/search.js';
+import { SearchHistoryService, ISearchHistoryService } from '../common/searchHistoryService.js';
+import { SearchModelLocation, searchMatchComparer, FileMatch, SearchResult, FolderMatch, Match, FolderMatchWithResource, MatchInNotebook, ISearchViewModelWorkbenchService } from './searchModel.js';
+import { createEditorFromSearchResult } from '../../searchEditor/browser/searchEditorActions.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { QueryBuilder } from '../../../services/search/common/queryBuilder.js';
+import '../../../services/search/common/search.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { INotebookService } from '../../notebook/common/notebookService.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { TextSearchCompleteMessageType } from '../../../services/search/common/searchExtTypes.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var SearchView_1;
+const $ = $$1;
+const SEARCH_CANCELLED_MESSAGE = ( localizeWithPath(
+    'vs/workbench/contrib/search/browser/searchView',
+    'searchCanceled',
+    "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, telemetryService, notebookService, logService, accessibilitySignalService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        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.isDisposed = false;
+        this.lastFocusState = 'input';
+        this.messageDisposables = ( new DisposableStore());
+        this.changedWhileHidden = false;
+        this.currentSearchQ = Promise.resolve();
+        this.pauseSearching = false;
+        this._visibleMatches = 0;
+        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.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.aiResultsVisibleKey = SearchContext.AIResultsVisibleKey.bindTo(this.contextKeyService);
+        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.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService])));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('search.sortOrder')) {
+                if (this.searchConfig.sortOrder === "modified" ) {
+                    this.removeFileStats();
+                }
+                this.refreshTree();
+            }
+            else if (e.affectsConfiguration('search.aiResults')) {
+                this.refreshHasAISetting();
+            }
+        }));
+        this.viewModel = this._register(this.searchViewModelWorkbenchService.searchModel);
+        this.queryBuilder = this.instantiationService.createInstance(QueryBuilder);
+        this.memento = ( new Memento(this.id, storageService));
+        this.viewletState = this.memento.getMemento(1 , 1 );
+        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 === "tree") );
+        this._refreshResultsScheduler = this._register(( new RunOnceScheduler(this._updateResults.bind(this), 80)));
+        this._register(this.storageService.onWillSaveState(() => {
+            this._saveSearchHistoryService();
+        }));
+        this._register(this.storageService.onDidChangeValue(1 , SearchHistoryService.SEARCH_HISTORY_KEY, this._register(( new DisposableStore())))(() => {
+            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);
+            }
+        }));
+    }
+    get isTreeLayoutViewVisible() {
+        return this.treeViewKey.get() ?? false;
+    }
+    set isTreeLayoutViewVisible(visible) {
+        this.treeViewKey.set(visible);
+    }
+    get aiResultsVisible() {
+        return this.aiResultsVisibleKey.get() ?? false;
+    }
+    set aiResultsVisible(visible) {
+        this.aiResultsVisibleKey.set(visible);
+    }
+    setTreeView(visible) {
+        if (visible === this.isTreeLayoutViewVisible) {
+            return;
+        }
+        this.isTreeLayoutViewVisible = visible;
+        this.updateIndentStyles(this.themeService.getFileIconTheme());
+        this.refreshTree();
+    }
+    async setAIResultsVisible(visible) {
+        if (visible === this.aiResultsVisible) {
+            return;
+        }
+        this.aiResultsVisible = visible;
+        if (this.viewModel.searchResult.isEmpty()) {
+            return;
+        }
+        this.model.cancelAISearch();
+        if (visible) {
+            await this.model.addAIResults();
+        }
+        else {
+            this.searchWidget.toggleReplace(false);
+        }
+        this.onSearchResultsChanged();
+        this.onSearchComplete(() => { }, undefined, undefined, this.viewModel.searchResult.getCachedSearchComplete(visible));
+    }
+    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;
+    }
+    refreshHasAISetting() {
+        const val = this.shouldShowAIButton();
+        if (val && this.searchWidget.searchInput) {
+            this.searchWidget.searchInput.shouldShowAIButton = val;
+        }
+    }
+    onDidChangeWorkbenchState() {
+        if (this.contextService.getWorkbenchState() !== 1  && 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((event) => this.onSearchResultsChanged(event)));
+        this.searchViewModelWorkbenchService.searchModel = searchModel;
+        this.viewModel = searchModel;
+        this.onSearchResultsChanged();
+        this.refreshInputs();
+        asyncResults.then((complete) => {
+            clearTimeout(slowTimer);
+            this.onSearchComplete(progressComplete, undefined, undefined, complete);
+        }, (e) => {
+            clearTimeout(slowTimer);
+            this.onSearchError(e, progressComplete, undefined, undefined);
+        });
+        const collapseResults = this.searchConfig.collapseResults;
+        if (collapseResults !== 'alwaysCollapse' && this.viewModel.searchResult.matches(this.aiResultsVisible).length === 1) {
+            const onlyMatch = this.viewModel.searchResult.matches(this.aiResultsVisible)[0];
+            if (onlyMatch.count() < 50) {
+                this.tree.expand(onlyMatch);
+            }
+        }
+    }
+    renderBody(parent) {
+        super.renderBody(parent);
+        this.container = append(parent, $$1('.search-view'));
+        this.searchWidgetsContainerElement = append(this.container, $('.search-widgets-container'));
+        this.createSearchWidget(this.searchWidgetsContainerElement);
+        this.refreshHasAISetting();
+        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'));
+        this.toggleQueryDetailsButton = append(this.queryDetails, $('.more' + ThemeIcon.asCSSSelector(searchDetailsIcon), { tabindex: 0, role: 'button' }));
+        this._register(setupCustomHover(getDefaultHoverDelegate('element'), this.toggleQueryDetailsButton, ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'moreSearch',
+            "Toggle Search Details"
+        ))));
+        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(3 ) || event.equals(10 )) {
+                EventHelper.stop(e);
+                this.toggleQueryDetails(false);
+            }
+        }));
+        this._register(addDisposableListener(this.toggleQueryDetailsButton, EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(1024  | 2 )) {
+                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 = ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'searchScope.includes',
+            "files to include"
+        ));
+        append(folderIncludesList, $('h4', undefined, filesToIncludeTitle));
+        this.inputPatternIncludes = this._register(this.instantiationService.createInstance(IncludePatternInputWidget, folderIncludesList, this.contextViewService, {
+            ariaLabel: filesToIncludeTitle,
+            placeholder: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'placeholder.includes',
+                "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 = ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'searchScope.excludes',
+            "files to exclude"
+        ));
+        append(excludesList, $('h4', undefined, excludesTitle));
+        this.inputPatternExcludes = this._register(this.instantiationService.createInstance(ExcludePatternInputWidget, excludesList, this.contextViewService, {
+            ariaLabel: excludesTitle,
+            placeholder: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'placeholder.excludes',
+                "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() === 1 ) {
+            this.showSearchWithoutFolderMessage();
+        }
+        this.createSearchResultsView(this.container);
+        if (filePatterns !== '' || patternExclusions !== '' || patternIncludes !== '' || queryDetailsExpanded !== '' || !useExcludesAndIgnoreFiles) {
+            this.toggleQueryDetails(true, true, true);
+        }
+        this._onSearchResultChangedDisposable = this._register(this.viewModel.onSearchResultChanged((event) => this.onSearchResultsChanged(event)));
+        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);
+    }
+    onVisibilityChanged(visible) {
+        this.viewletVisible.set(visible);
+        if (visible) {
+            if (this.changedWhileHidden) {
+                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,
+            },
+            initialAIButtonVisibility: this.shouldShowAIButton()
+        }));
+        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 => this.triggerQueryChange(options)));
+        this._register(this.searchWidget.onSearchCancel(({ focus }) => this.cancelSearch(focus)));
+        this._register(this.searchWidget.searchInput.onDidOptionChange(() => {
+            if (this.searchWidget.searchInput && this.searchWidget.searchInput.isAIEnabled !== this.aiResultsVisible) {
+                this.setAIResultsVisible(this.searchWidget.searchInput.isAIEnabled);
+            }
+            else {
+                this.triggerQueryChange();
+            }
+        }));
+        this._register(this.searchWidget.getNotebookFilters().onDidChange(() => this.triggerQueryChange()));
+        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((state) => {
+            this.viewModel.replaceActive = state;
+            this.refreshTree();
+        }));
+        this._register(this.searchWidget.onPreserveCaseChange((state) => {
+            this.viewModel.preserveCase = state;
+            this.refreshTree();
+        }));
+        this._register(this.searchWidget.onReplaceValueChanged(() => {
+            this.viewModel.replaceString = this.searchWidget.getReplaceValue();
+            this.delayedRefresh.trigger(() => this.refreshTree());
+        }));
+        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);
+    }
+    shouldShowAIButton() {
+        const hasProvider = SearchContext.hasAIResultProvider.getValue(this.contextKeyService);
+        return !!(this.configurationService.getValue('search.aiResults') && hasProvider);
+    }
+    onConfigurationUpdated(event) {
+        if (event && (event.affectsConfiguration('search.decorations.colors') || event.affectsConfiguration('search.decorations.badges'))) {
+            this.refreshTree();
+        }
+    }
+    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);
+        }));
+    }
+    onSearchResultsChanged(event) {
+        if (this.isVisible()) {
+            return this.refreshAndUpdateCount(event);
+        }
+        else {
+            this.changedWhileHidden = true;
+        }
+    }
+    refreshAndUpdateCount(event) {
+        this.searchWidget.setReplaceAllActionState(!this.viewModel.searchResult.isEmpty(this.aiResultsVisible));
+        this.updateSearchResultCount(this.viewModel.searchResult.query.userDisabledExcludesAndIgnoreFiles, this.viewModel.searchResult.query?.onlyOpenEditors, event?.clearingAll);
+        return this.refreshTree(event);
+    }
+    refreshTree(event) {
+        const collapseResults = this.searchConfig.collapseResults;
+        if (!event || event.added || event.removed) {
+            if (this.searchConfig.sortOrder === "modified" ) {
+                this.retrieveFileStats()
+                    .then(() => this.tree.setChildren(null, this.createResultIterator(collapseResults)));
+            }
+            else {
+                this.tree.setChildren(null, this.createResultIterator(collapseResults));
+            }
+        }
+        else {
+            if (this.searchConfig.sortOrder === "countAscending"  ||
+                this.searchConfig.sortOrder === "countDescending" ) {
+                this.tree.setChildren(null, this.createResultIterator(collapseResults));
+            }
+            else {
+                event.elements.forEach(element => {
+                    this.tree.setChildren(element, this.createIterator(element, collapseResults));
+                    this.tree.rerender(element);
+                });
+            }
+        }
+    }
+    createResultIterator(collapseResults) {
+        const folderMatches = this.searchResult.folderMatches(this.aiResultsVisible)
+            .filter(fm => !fm.isEmpty())
+            .sort(searchMatchComparer);
+        if (folderMatches.length === 1) {
+            return this.createFolderIterator(folderMatches[0], collapseResults, true);
+        }
+        return ( Iterable.map(folderMatches, folderMatch => {
+            const children = this.createFolderIterator(folderMatch, collapseResults, true);
+            return { element: folderMatch, children, incompressible: true };
+        }));
+    }
+    createFolderIterator(folderMatch, collapseResults, childFolderIncompressible) {
+        const sortOrder = this.searchConfig.sortOrder;
+        const matchArray = this.isTreeLayoutViewVisible ? folderMatch.matches() : folderMatch.allDownstreamFileMatches();
+        const matches = matchArray.sort((a, b) => searchMatchComparer(a, b, sortOrder));
+        return ( Iterable.map(matches, match => {
+            let children;
+            if (match instanceof FileMatch) {
+                children = this.createFileIterator(match);
+            }
+            else {
+                children = this.createFolderIterator(match, collapseResults, false);
+            }
+            const collapsed = (collapseResults === 'alwaysCollapse' || (match.count() > 10 && collapseResults !== 'alwaysExpand')) ? ObjectTreeElementCollapseState.PreserveOrCollapsed : ObjectTreeElementCollapseState.PreserveOrExpanded;
+            return { element: match, children, collapsed, incompressible: (match instanceof FileMatch) ? true : childFolderIncompressible };
+        }));
+    }
+    createFileIterator(fileMatch) {
+        let matches = fileMatch.matches().sort(searchMatchComparer);
+        if (!this.aiResultsVisible) {
+            matches = matches.filter(e => !e.aiContributed);
+        }
+        return ( Iterable.map(matches, r => ({ element: r, incompressible: true })));
+    }
+    createIterator(match, collapseResults) {
+        return match instanceof SearchResult ? this.createResultIterator(collapseResults) :
+            match instanceof FolderMatch ? this.createFolderIterator(match, collapseResults, false) :
+                this.createFileIterator(match);
+    }
+    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: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'replaceAll.confirmation.title',
+                "Replace All"
+            )),
+            message: this.buildReplaceAllConfirmationMessage(occurrences, fileCount, replaceValue),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                { key: 'replaceAll.confirm.button', comment: ['&& denotes a mnemonic'] },
+                "&&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 ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'replaceAll.occurrence.file.message',
+                        "Replaced {0} occurrence across {1} file with '{2}'.",
+                        occurrences,
+                        fileCount,
+                        replaceValue
+                    ));
+                }
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'removeAll.occurrence.file.message',
+                    "Replaced {0} occurrence across {1} file.",
+                    occurrences,
+                    fileCount
+                ));
+            }
+            if (replaceValue) {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'replaceAll.occurrence.files.message',
+                    "Replaced {0} occurrence across {1} files with '{2}'.",
+                    occurrences,
+                    fileCount,
+                    replaceValue
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'removeAll.occurrence.files.message',
+                "Replaced {0} occurrence across {1} files.",
+                occurrences,
+                fileCount
+            ));
+        }
+        if (fileCount === 1) {
+            if (replaceValue) {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'replaceAll.occurrences.file.message',
+                    "Replaced {0} occurrences across {1} file with '{2}'.",
+                    occurrences,
+                    fileCount,
+                    replaceValue
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'removeAll.occurrences.file.message',
+                "Replaced {0} occurrences across {1} file.",
+                occurrences,
+                fileCount
+            ));
+        }
+        if (replaceValue) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'replaceAll.occurrences.files.message',
+                "Replaced {0} occurrences across {1} files with '{2}'.",
+                occurrences,
+                fileCount,
+                replaceValue
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'removeAll.occurrences.files.message',
+            "Replaced {0} occurrences across {1} files.",
+            occurrences,
+            fileCount
+        ));
+    }
+    buildReplaceAllConfirmationMessage(occurrences, fileCount, replaceValue) {
+        if (occurrences === 1) {
+            if (fileCount === 1) {
+                if (replaceValue) {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'removeAll.occurrence.file.confirmation.message',
+                        "Replace {0} occurrence across {1} file with '{2}'?",
+                        occurrences,
+                        fileCount,
+                        replaceValue
+                    ));
+                }
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'replaceAll.occurrence.file.confirmation.message',
+                    "Replace {0} occurrence across {1} file?",
+                    occurrences,
+                    fileCount
+                ));
+            }
+            if (replaceValue) {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'removeAll.occurrence.files.confirmation.message',
+                    "Replace {0} occurrence across {1} files with '{2}'?",
+                    occurrences,
+                    fileCount,
+                    replaceValue
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'replaceAll.occurrence.files.confirmation.message',
+                "Replace {0} occurrence across {1} files?",
+                occurrences,
+                fileCount
+            ));
+        }
+        if (fileCount === 1) {
+            if (replaceValue) {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'removeAll.occurrences.file.confirmation.message',
+                    "Replace {0} occurrences across {1} file with '{2}'?",
+                    occurrences,
+                    fileCount,
+                    replaceValue
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'replaceAll.occurrences.file.confirmation.message',
+                "Replace {0} occurrences across {1} file?",
+                occurrences,
+                fileCount
+            ));
+        }
+        if (replaceValue) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'removeAll.occurrences.files.confirmation.message',
+                "Replace {0} occurrences across {1} files with '{2}'?",
+                occurrences,
+                fileCount,
+                replaceValue
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'replaceAll.occurrences.files.confirmation.message',
+            "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.treeLabels = this._register(this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility }));
+        this.tree = this._register(this.instantiationService.createInstance(WorkbenchCompressibleObjectTree, 'SearchView', this.resultsElement, delegate, [
+            this._register(this.instantiationService.createInstance(FolderMatchRenderer, this, this.treeLabels)),
+            this._register(this.instantiationService.createInstance(FileMatchRenderer, this, this.treeLabels)),
+            this._register(this.instantiationService.createInstance(MatchRenderer, this)),
+        ], {
+            identityProvider,
+            accessibilityProvider: this.treeAccessibilityProvider,
+            dnd: this.instantiationService.createInstance(ResourceListDnDHandler, element => {
+                if (element instanceof FileMatch) {
+                    return element.resource;
+                }
+                if (element instanceof Match) {
+                    return withSelection(element.parent().resource, element.range());
+                }
+                return null;
+            }),
+            multipleSelectionSupport: true,
+            selectionNavigation: true,
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            },
+            paddingBottom: SearchDelegate.ITEM_HEIGHT
+        }));
+        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 (options.element instanceof Match) {
+                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 && focus instanceof Match) {
+                this.onFocus(focus, true);
+            }
+        }));
+        this._register(Event.any(this.tree.onDidFocus, this.tree.onDidChangeFocus)(() => {
+            const focus = this.tree.getFocus()[0];
+            if (this.tree.isDOMFocused()) {
+                this.firstMatchFocused.set(this.tree.navigate().first() === focus);
+                this.fileMatchOrMatchFocused.set(!!focus);
+                this.fileMatchFocused.set(focus instanceof FileMatch);
+                this.folderMatchFocused.set(focus instanceof FolderMatch);
+                this.matchFocused.set(focus instanceof Match);
+                this.fileMatchOrFolderMatchFocus.set(focus instanceof FileMatch || focus instanceof FolderMatch);
+                this.fileMatchOrFolderMatchWithResourceFocus.set(focus instanceof FileMatch || focus instanceof FolderMatchWithResource);
+                this.folderMatchWithResourceFocused.set(focus instanceof FolderMatchWithResource);
+                this.lastFocusState = 'tree';
+            }
+            let editable = false;
+            if (focus instanceof Match) {
+                editable = (focus instanceof MatchInNotebook) ? !focus.isReadonly() : true;
+            }
+            else if (focus instanceof FileMatch) {
+                editable = !focus.hasOnlyReadOnlyMatches();
+            }
+            else if (focus instanceof FolderMatch) {
+                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.isEditableItem.reset();
+        }));
+    }
+    onContextMenu(e) {
+        e.browserEvent.preventDefault();
+        e.browserEvent.stopPropagation();
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.SearchContext,
+            menuActionOptions: { shouldForwardArgs: true },
+            contextKeyService: this.contextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => e.element,
+        });
+    }
+    hasSomeCollapsible() {
+        const viewer = this.getControl();
+        const navigator = viewer.navigate();
+        let node = navigator.first();
+        do {
+            if (!viewer.isCollapsed(node)) {
+                return true;
+            }
+        } while (node = navigator.next());
+        return false;
+    }
+    selectNextMatch() {
+        if (!this.hasSearchResults()) {
+            return;
+        }
+        const [selected] = this.tree.getSelection();
+        if (selected && !(selected instanceof Match)) {
+            if (this.tree.isCollapsed(selected)) {
+                this.tree.expand(selected);
+            }
+        }
+        const navigator = this.tree.navigate(selected);
+        let next = navigator.next();
+        if (!next) {
+            next = navigator.first();
+        }
+        while (next && !(next instanceof Match)) {
+            if (this.tree.isCollapsed(next)) {
+                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);
+            }
+        }
+    }
+    selectPreviousMatch() {
+        if (!this.hasSearchResults()) {
+            return;
+        }
+        const [selected] = this.tree.getSelection();
+        let navigator = this.tree.navigate(selected);
+        let prev = navigator.previous();
+        while (!prev || (!(prev instanceof Match) && !this.tree.isCollapsed(prev))) {
+            const nextPrev = prev ? navigator.previous() : navigator.last();
+            if (!prev && !nextPrev) {
+                return;
+            }
+            prev = nextPrev;
+        }
+        while (!(prev instanceof Match)) {
+            const nextItem = navigator.next();
+            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(this.aiResultsVisible);
+    }
+    clearSearchResults(clearInput = true) {
+        this.viewModel.searchResult.clear();
+        this.showEmptyStage(true);
+        if (this.contextService.getWorkbenchState() === 1 ) {
+            this.showSearchWithoutFolderMessage();
+        }
+        if (clearInput) {
+            if (this.allSearchFieldsClear()) {
+                this.clearFilePatternFields();
+            }
+            this.searchWidget.clear();
+        }
+        this.viewModel.cancelSearch();
+        this.tree.ariaLabel = ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'emptySearch',
+            "Empty Search"
+        ));
+        this.accessibilitySignalService.playSignal(AccessibilitySignal.clear);
+        this.reLayout();
+    }
+    clearFilePatternFields() {
+        this.searchExcludePattern.clear();
+        this.searchIncludePattern.clear();
+    }
+    cancelSearch(focus = true) {
+        if (this.viewModel.cancelSearch()) {
+            if (focus) {
+                this.searchWidget.focus();
+            }
+            return true;
+        }
+        return false;
+    }
+    selectTreeIfNotSelected() {
+        if (this.tree.getNode(null)) {
+            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();
+    }
+    toggleWholeWords() {
+        this.searchWidget.searchInput?.setWholeWords(!this.searchWidget.searchInput.getWholeWords());
+        this.triggerQueryChange();
+    }
+    toggleRegex() {
+        this.searchWidget.searchInput?.setRegex(!this.searchWidget.searchInput.getRegex());
+        this.triggerQueryChange();
+    }
+    togglePreserveCase() {
+        this.searchWidget.replaceInput?.setPreserveCase(!this.searchWidget.replaceInput.getPreserveCase());
+        this.triggerQueryChange();
+    }
+    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) {
+        const cls = 'more';
+        show = typeof show === 'undefined' ? !this.queryDetails.classList.contains(cls) : Boolean(show);
+        this.viewletState['query.queryDetailsExpanded'] = show;
+        skipLayout = Boolean(skipLayout);
+        if (show) {
+            this.toggleQueryDetailsButton.setAttribute('aria-expanded', 'true');
+            this.queryDetails.classList.add(cls);
+            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(cls);
+            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);
+            }, delay);
+        }
+    }
+    _onQueryChanged(preserveFocus, triggeredOnType = 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.inputPatternExcludes.getValue().trim();
+        const includePatternText = this.inputPatternIncludes.getValue().trim();
+        const useExcludesAndIgnoreFiles = this.inputPatternExcludes.useExcludesAndIgnoreFiles();
+        const onlySearchInOpenEditors = this.inputPatternIncludes.onlySearchInOpenEditors();
+        if (contentPattern.length === 0) {
+            this.clearSearchResults(false);
+            this.clearMessage();
+            return;
+        }
+        const content = {
+            pattern: contentPattern,
+            isRegExp: isRegex,
+            isCaseSensitive: isCaseSensitive,
+            isWordMatch: isWholeWords,
+            notebookInfo: {
+                isInNotebookMarkdownInput,
+                isInNotebookMarkdownPreview,
+                isInNotebookCellInput,
+                isInNotebookCellOutput
+            }
+        };
+        const excludePattern = 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: 3  });
+            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(() => {
+            this.onQueryTriggered(query, options, excludePatternText, includePatternText, triggeredOnType);
+            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 = ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'searchPathNotFoundError',
+                    "Search path not found: {0}",
+                    nonExistantPath
+                ));
+                return Promise.reject(( new Error(searchPathNotFoundError)));
+            }
+            return undefined;
+        });
+    }
+    onQueryTriggered(query, options, excludePatternText, includePatternText, triggeredOnType) {
+        this.addToSearchHistoryDelayer.trigger(() => {
+            this.searchWidget.searchInput?.onSearchSubmit();
+            this.inputPatternExcludes.onSearchSubmit();
+            this.inputPatternIncludes.onSearchSubmit();
+        });
+        this.viewModel.cancelSearch(true);
+        this.viewModel.cancelAISearch(true);
+        this.currentSearchQ = this.currentSearchQ
+            .then(() => this.doSearch(query, excludePatternText, includePatternText, triggeredOnType))
+            .then(() => undefined, () => undefined);
+    }
+    _updateResults() {
+        if (this.state === SearchUIState.Idle) {
+            return;
+        }
+        try {
+            const fileCount = this.viewModel.searchResult.fileCount(this.aiResultsVisible);
+            if (this._visibleMatches !== fileCount) {
+                this._visibleMatches = fileCount;
+                this.refreshAndUpdateCount();
+            }
+        }
+        finally {
+            this._refreshResultsScheduler.schedule();
+        }
+    }
+    onSearchComplete(progressComplete, excludePatternText, includePatternText, completed) {
+        this.state = SearchUIState.Idle;
+        progressComplete();
+        this.onSearchResultsChanged();
+        const collapseResults = this.searchConfig.collapseResults;
+        if (collapseResults !== 'alwaysCollapse' && this.viewModel.searchResult.matches(this.aiResultsVisible).length === 1) {
+            const onlyMatch = this.viewModel.searchResult.matches(this.aiResultsVisible)[0];
+            if (onlyMatch.count() < 50) {
+                this.tree.expand(onlyMatch);
+            }
+        }
+        const hasResults = !this.viewModel.searchResult.isEmpty(this.aiResultsVisible);
+        if (completed?.exit === 1 ) {
+            return;
+        }
+        if (!hasResults) {
+            const hasExcludes = !!excludePatternText;
+            const hasIncludes = !!includePatternText;
+            let message;
+            if (!completed) {
+                message = SEARCH_CANCELLED_MESSAGE;
+            }
+            else if (this.inputPatternIncludes.onlySearchInOpenEditors()) {
+                if (hasIncludes && hasExcludes) {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noOpenEditorResultsIncludesExcludes',
+                        "No results found in open editors matching '{0}' excluding '{1}' - ",
+                        includePatternText,
+                        excludePatternText
+                    ));
+                }
+                else if (hasIncludes) {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noOpenEditorResultsIncludes',
+                        "No results found in open editors matching '{0}' - ",
+                        includePatternText
+                    ));
+                }
+                else if (hasExcludes) {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noOpenEditorResultsExcludes',
+                        "No results found in open editors excluding '{0}' - ",
+                        excludePatternText
+                    ));
+                }
+                else {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noOpenEditorResultsFound',
+                        "No results found in open editors. Review your settings for configured exclusions and check your gitignore files - "
+                    ));
+                }
+            }
+            else {
+                if (hasIncludes && hasExcludes) {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noResultsIncludesExcludes',
+                        "No results found in '{0}' excluding '{1}' - ",
+                        includePatternText,
+                        excludePatternText
+                    ));
+                }
+                else if (hasIncludes) {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noResultsIncludes',
+                        "No results found in '{0}' - ",
+                        includePatternText
+                    ));
+                }
+                else if (hasExcludes) {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noResultsExcludes',
+                        "No results found excluding '{0}' - ",
+                        excludePatternText
+                    ));
+                }
+                else {
+                    message = ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/searchView',
+                        'noResultsFound',
+                        "No results found. Review your settings for configured exclusions and check your gitignore files - "
+                    ));
+                }
+            }
+            status(message);
+            const messageEl = this.clearMessage();
+            append(messageEl, message);
+            if (!completed) {
+                const searchAgainButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'rerunSearch.message',
+                    "Search again"
+                )), () => this.triggerQueryChange({ preserveFocus: false }))));
+                append(messageEl, searchAgainButton.element);
+            }
+            else if (hasIncludes || hasExcludes) {
+                const searchAgainButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'rerunSearchInAll.message',
+                    "Search again in all files"
+                )), this.onSearchAgain.bind(this))));
+                append(messageEl, searchAgainButton.element);
+            }
+            else {
+                const openSettingsButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'openSettings.message',
+                    "Open Settings"
+                )), this.onOpenSettings.bind(this))));
+                append(messageEl, openSettingsButton.element);
+            }
+            if (completed) {
+                append(messageEl, $('span', undefined, ' - '));
+                const learnMoreButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'openSettings.learnMore',
+                    "Learn More"
+                )), this.onLearnMore.bind(this))));
+                append(messageEl, learnMoreButton.element);
+            }
+            if (this.contextService.getWorkbenchState() === 1 ) {
+                this.showSearchWithoutFolderMessage();
+            }
+            this.reLayout();
+        }
+        else {
+            this.viewModel.searchResult.toggleHighlights(this.isVisible());
+            status(( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'ariaSearchResultsStatus',
+                "Search returned {0} results in {1} files",
+                this.viewModel.searchResult.count(this.aiResultsVisible),
+                this.viewModel.searchResult.fileCount()
+            )));
+        }
+        if (completed && completed.limitHit) {
+            completed.messages.push({ type: TextSearchCompleteMessageType.Warning, text: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'searchMaxResultsWarning',
+                "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();
+    }
+    onSearchError(e, progressComplete, excludePatternText, includePatternText, completed) {
+        this.state = SearchUIState.Idle;
+        if (isCancellationError(e)) {
+            return this.onSearchComplete(progressComplete, excludePatternText, includePatternText, completed);
+        }
+        else {
+            progressComplete();
+            this.searchWidget.searchInput?.showMessage({ content: e.message, type: 3  });
+            this.viewModel.searchResult.clear();
+            return Promise.resolve();
+        }
+    }
+    doSearch(query, excludePatternText, includePatternText, triggeredOnType) {
+        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();
+        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 (this.aiResultsVisible) {
+            const aiResult = this.viewModel.aiSearch({ ...query, contentPattern: query.contentPattern.pattern, type: 3  });
+            return result.asyncResults.then(() => aiResult.then((complete) => {
+                clearTimeout(slowTimer);
+                this.onSearchComplete(progressComplete, excludePatternText, includePatternText, complete);
+            }, (e) => {
+                clearTimeout(slowTimer);
+                this.onSearchError(e, progressComplete, excludePatternText, includePatternText);
+            }));
+        }
+        return result.asyncResults.then((complete) => {
+            clearTimeout(slowTimer);
+            this.onSearchComplete(progressComplete, excludePatternText, includePatternText, complete);
+        }, (e) => {
+            clearTimeout(slowTimer);
+            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() !== 1  ?
+            this.preferencesService.openWorkspaceSettings(options) :
+            this.preferencesService.openUserSettings(options);
+    }
+    onLearnMore() {
+        this.openerService.open(( URI.parse('https://go.microsoft.com/fwlink/?linkid=853977')));
+    }
+    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) {
+        const fileCount = this.viewModel.searchResult.fileCount(this.aiResultsVisible);
+        const resultCount = this.viewModel.searchResult.count(this.aiResultsVisible);
+        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 + ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'forTerm',
+            " - Search: {0}",
+            this.searchResult.query?.contentPattern.pattern ?? ''
+        ));
+        append(messageEl, resultMsg);
+        if (fileCount > 0) {
+            if (disregardExcludesAndIgnores) {
+                const excludesDisabledMessage = ' - ' + ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'useIgnoresAndExcludesDisabled',
+                    "exclude settings and ignore files are disabled"
+                )) + ' ';
+                const enableExcludesButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'excludes.enable',
+                    "enable"
+                )), this.onEnableExcludes.bind(this), ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'useExcludesAndIgnoreFilesDescription',
+                    "Use Exclude Settings and Ignore Files"
+                )))));
+                append(messageEl, $('span', undefined, excludesDisabledMessage, '(', enableExcludesButton.element, ')'));
+            }
+            if (onlyOpenEditors) {
+                const searchingInOpenMessage = ' - ' + ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'onlyOpenEditors',
+                    "searching only in open files"
+                )) + ' ';
+                const disableOpenEditorsButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'openEditors.disable',
+                    "disable"
+                )), this.onDisableSearchInOpenEditors.bind(this), ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchView',
+                    'disableOpenEditors',
+                    "Search in entire workspace"
+                )))));
+                append(messageEl, $('span', undefined, searchingInOpenMessage, '(', disableOpenEditorsButton.element, ')'));
+            }
+            append(messageEl, ' - ');
+            const openInEditorTooltip = appendKeyBindingLabel(( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'openInEditor.tooltip',
+                "Copy current search results to an editor"
+            )), this.keybindingService.lookupKeybinding("search.action.openInEditor" ));
+            const openInEditorButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'openInEditor.message',
+                "Open in editor"
+            )), () => this.instantiationService.invokeFunction(createEditorFromSearchResult, this.searchResult, this.searchIncludePattern.getValue(), this.searchExcludePattern.getValue(), this.searchIncludePattern.onlySearchInOpenEditors()), openInEditorTooltip)));
+            append(messageEl, openInEditorButton.element);
+            this.reLayout();
+        }
+        else if (!msgWasHidden) {
+            hide(this.messagesElement);
+        }
+    }
+    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 ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'search.file.result',
+                "{0} result in {1} file",
+                resultCount,
+                fileCount
+            ));
+        }
+        else if (resultCount === 1) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'search.files.result',
+                "{0} result in {1} files",
+                resultCount,
+                fileCount
+            ));
+        }
+        else if (fileCount === 1) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'search.file.results',
+                "{0} results in {1} file",
+                resultCount,
+                fileCount
+            ));
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchView',
+                'search.files.results',
+                "{0} results in {1} files",
+                resultCount,
+                fileCount
+            ));
+        }
+    }
+    showSearchWithoutFolderMessage() {
+        this.searchWithoutFolderMessageElement = this.clearMessage();
+        const textEl = append(this.searchWithoutFolderMessageElement, $('p', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'searchWithoutFolder',
+            "You have not opened or specified a folder. Only open files are currently searched - "
+        ))));
+        const openFolderButton = this.messageDisposables.add(( new SearchLinkButton(( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchView',
+            'openFolder',
+            "Open Folder"
+        )), () => {
+            this.commandService.executeCommand(isMacintosh && isNative ? OpenFileFolderAction.ID : OpenFolderAction.ID).catch(err => onUnexpectedError(err));
+        })));
+        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 match instanceof MatchInNotebook || (uri.scheme !== Schemas.untitled && this.notebookService.getContributedNotebookTypes(uri).length > 0);
+    }
+    onFocus(lineMatch, preserveFocus, sideBySide, pinned) {
+        const useReplacePreview = this.configurationService.getValue().search.useReplacePreview;
+        const resource = lineMatch instanceof Match ? 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 = element instanceof Match ? element.parent().matches() : [];
+        const resource = resourceInput ?? (element instanceof Match ? 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 (element instanceof Match && preserveFocus && isCodeEditor(editorControl)) {
+                this.viewModel.searchResult.rangeHighlightDecorations.highlightRange(editorControl.getModel(), element.range());
+            }
+            else {
+                this.viewModel.searchResult.rangeHighlightDecorations.removeHighlightRange();
+            }
+        }
+        catch (err) {
+            onUnexpectedError(err);
+            return;
+        }
+        if (editor instanceof NotebookEditor) {
+            const elemParent = element.parent();
+            if (element instanceof Match) {
+                if (element instanceof MatchInNotebook) {
+                    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 (match instanceof MatchInNotebook) {
+                            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 = element instanceof Match ? 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 (element instanceof FileMatch) {
+                    fileMatch = element;
+                }
+                else if (element instanceof Match) {
+                    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.rangeHighlightDecorations.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 !== "modified"  && !e.gotDeleted())) {
+            return;
+        }
+        const matches = this.viewModel.searchResult.matches();
+        if (e.gotDeleted()) {
+            const deletedMatches = matches.filter(m => e.contains(m.resource, 2 ));
+            this.viewModel.searchResult.remove(deletedMatches);
+        }
+        else {
+            const changedMatches = matches.filter(m => e.contains(m.resource));
+            if (changedMatches.length && this.searchConfig.sortOrder === "modified" ) {
+                this.updateFileStats(changedMatches).then(() => this.refreshTree());
+            }
+        }
+    }
+    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.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();
+        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 retrieveFileStats() {
+        const files = ( this.searchResult.matches(this.aiResultsVisible).filter(f => !f.fileStat).map(f => f.resolveFileStat(this.fileService)));
+        await Promise.all(files);
+    }
+    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, ITelemetryService)),
+    ( __param(26, INotebookService)),
+    ( __param(27, ILogService)),
+    ( __param(28, IAccessibilitySignalService))
+], SearchView));
+class SearchLinkButton extends Disposable {
+    constructor(label, handler, tooltip) {
+        super();
+        this.element = $('a.pointer', { tabindex: 0 }, label);
+        this._register(setupCustomHover(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(10 ) || event.equals(3 )) {
+                wrappedHandler(e);
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        }));
+    }
+}
+function getEditorSelectionFromMatch(element, viewModel) {
+    let match = null;
+    if (element instanceof Match) {
+        match = element;
+    }
+    if (element instanceof FileMatch && 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;
+}
+export { SearchView, getEditorSelectionFromMatch, getSelectionTextFromEditor };