@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/searchEditor/browser/searchEditor.js

@@ -0,0 +1,697 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { assertIsDefined, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import './media/searchEditor.css.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { ReferencesController } from 'monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/peek/referencesController.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { LongRunningOperation, IEditorProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { registerColor, inputBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { AbstractTextCodeEditor } from '../../../browser/parts/editor/textCodeEditor.js';
+import { IncludePatternInputWidget, ExcludePatternInputWidget } from '../../search/browser/patternInputWidget.js';
+import { SearchWidget } from '../../search/browser/searchWidget.js';
+import { InputBoxFocusedKey } from '../../search/common/constants.js';
+import { QueryBuilder } from '../../../services/search/common/queryBuilder.js';
+import { getOutOfWorkspaceEditorResources } from '../../search/common/search.js';
+import { SearchModel } from '../../search/browser/searchModel.js';
+import { SearchEditorID, InSearchEditor, SearchEditorInputTypeId } from './constants.js';
+import { serializeSearchResultForEditor } from './searchEditorSerialization.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { searchDetailsIcon } from '../../search/browser/searchIcons.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { renderSearchMessage } from '../../search/browser/searchMessage.js';
+import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { UnusualLineTerminatorsDetector } from 'monaco-editor/esm/vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
+import { getInputBoxStyle, defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+const RESULT_LINE_REGEX = /^(\s+)(\d+)(: |  )(\s*)(.*)$/;
+const FILE_LINE_REGEX = /^(\S.*):$/;
+let SearchEditor = class SearchEditor extends AbstractTextCodeEditor {
+    get searchResultEditor() { return this.editorControl; }
+    constructor(telemetryService, themeService, storageService, modelService, contextService, labelService, instantiationService, contextViewService, commandService, openerService, notificationService, progressService, textResourceService, editorGroupService, editorService, configurationService, fileService, logService) {
+        super(SearchEditor.ID, telemetryService, instantiationService, storageService, textResourceService, themeService, editorService, editorGroupService, fileService);
+        this.modelService = modelService;
+        this.contextService = contextService;
+        this.labelService = labelService;
+        this.contextViewService = contextViewService;
+        this.commandService = commandService;
+        this.openerService = openerService;
+        this.notificationService = notificationService;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.runSearchDelayer = ( new Delayer(0));
+        this.pauseSearching = false;
+        this.showingIncludesExcludes = false;
+        this.ongoingOperations = 0;
+        this.updatingModelForSearch = false;
+        this.container = dom.$('.search-editor');
+        this.searchOperation = this._register(( new LongRunningOperation(progressService)));
+        this._register(this.messageDisposables = ( new DisposableStore()));
+        this.searchHistoryDelayer = ( new Delayer(2000));
+        this.searchModel = this._register(this.instantiationService.createInstance(SearchModel));
+    }
+    createEditor(parent) {
+        dom.append(parent, this.container);
+        this.queryEditorContainer = dom.append(this.container, dom.$('.query-container'));
+        const searchResultContainer = dom.append(this.container, dom.$('.search-results'));
+        super.createEditor(searchResultContainer);
+        this.registerEditorListeners();
+        const scopedContextKeyService = assertIsDefined(this.scopedContextKeyService);
+        InSearchEditor.bindTo(scopedContextKeyService).set(true);
+        this.createQueryEditor(this.queryEditorContainer, this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService]))), InputBoxFocusedKey.bindTo(scopedContextKeyService));
+    }
+    createQueryEditor(container, scopedInstantiationService, inputBoxFocusedContextKey) {
+        const searchEditorInputboxStyles = getInputBoxStyle({ inputBorder: searchEditorTextInputBorder });
+        this.queryEditorWidget = this._register(scopedInstantiationService.createInstance(SearchWidget, container, { _hideReplaceToggle: true, showContextToggle: true, inputBoxStyles: searchEditorInputboxStyles, toggleStyles: defaultToggleStyles }));
+        this._register(this.queryEditorWidget.onReplaceToggled(() => this.reLayout()));
+        this._register(this.queryEditorWidget.onDidHeightChange(() => this.reLayout()));
+        this._register(this.queryEditorWidget.onSearchSubmit(({ delay }) => this.triggerSearch({ delay })));
+        if (this.queryEditorWidget.searchInput) {
+            this._register(this.queryEditorWidget.searchInput.onDidOptionChange(() => this.triggerSearch({ resetCursor: false })));
+        }
+        else {
+            this.logService.warn('SearchEditor: SearchWidget.searchInput is undefined, cannot register onDidOptionChange listener');
+        }
+        this._register(this.queryEditorWidget.onDidToggleContext(() => this.triggerSearch({ resetCursor: false })));
+        this.includesExcludesContainer = dom.append(container, dom.$('.includes-excludes'));
+        this.toggleQueryDetailsButton = dom.append(this.includesExcludesContainer, dom.$('.expand' + ThemeIcon.asCSSSelector(searchDetailsIcon), { tabindex: 0, role: 'button', title: ( localize('moreSearch', "Toggle Search Details")) }));
+        this._register(dom.addDisposableListener(this.toggleQueryDetailsButton, dom.EventType.CLICK, e => {
+            dom.EventHelper.stop(e);
+            this.toggleIncludesExcludes();
+        }));
+        this._register(dom.addDisposableListener(this.toggleQueryDetailsButton, dom.EventType.KEY_UP, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(3 ) || event.equals(10 )) {
+                dom.EventHelper.stop(e);
+                this.toggleIncludesExcludes();
+            }
+        }));
+        this._register(dom.addDisposableListener(this.toggleQueryDetailsButton, dom.EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(1024  | 2 )) {
+                if (this.queryEditorWidget.isReplaceActive()) {
+                    this.queryEditorWidget.focusReplaceAllAction();
+                }
+                else {
+                    this.queryEditorWidget.isReplaceShown() ? this.queryEditorWidget.replaceInput?.focusOnPreserve() : this.queryEditorWidget.focusRegexAction();
+                }
+                dom.EventHelper.stop(e);
+            }
+        }));
+        const folderIncludesList = dom.append(this.includesExcludesContainer, dom.$('.file-types.includes'));
+        const filesToIncludeTitle = ( localize('searchScope.includes', "files to include"));
+        dom.append(folderIncludesList, dom.$('h4', undefined, filesToIncludeTitle));
+        this.inputPatternIncludes = this._register(scopedInstantiationService.createInstance(IncludePatternInputWidget, folderIncludesList, this.contextViewService, {
+            ariaLabel: ( localize('label.includes', 'Search Include Patterns')),
+            inputBoxStyles: searchEditorInputboxStyles
+        }));
+        this.inputPatternIncludes.onSubmit(triggeredOnType => this.triggerSearch({ resetCursor: false, delay: triggeredOnType ? this.searchConfig.searchOnTypeDebouncePeriod : 0 }));
+        this._register(this.inputPatternIncludes.onChangeSearchInEditorsBox(() => this.triggerSearch()));
+        const excludesList = dom.append(this.includesExcludesContainer, dom.$('.file-types.excludes'));
+        const excludesTitle = ( localize('searchScope.excludes', "files to exclude"));
+        dom.append(excludesList, dom.$('h4', undefined, excludesTitle));
+        this.inputPatternExcludes = this._register(scopedInstantiationService.createInstance(ExcludePatternInputWidget, excludesList, this.contextViewService, {
+            ariaLabel: ( localize('label.excludes', 'Search Exclude Patterns')),
+            inputBoxStyles: searchEditorInputboxStyles
+        }));
+        this.inputPatternExcludes.onSubmit(triggeredOnType => this.triggerSearch({ resetCursor: false, delay: triggeredOnType ? this.searchConfig.searchOnTypeDebouncePeriod : 0 }));
+        this._register(this.inputPatternExcludes.onChangeIgnoreBox(() => this.triggerSearch()));
+        this.messageBox = dom.append(container, dom.$('.messages.text-search-provider-messages'));
+        [this.queryEditorWidget.searchInputFocusTracker, this.queryEditorWidget.replaceInputFocusTracker, this.inputPatternExcludes.inputFocusTracker, this.inputPatternIncludes.inputFocusTracker]
+            .forEach(tracker => {
+            if (!tracker) {
+                return;
+            }
+            this._register(tracker.onDidFocus(() => setTimeout(() => inputBoxFocusedContextKey.set(true), 0)));
+            this._register(tracker.onDidBlur(() => inputBoxFocusedContextKey.set(false)));
+        });
+    }
+    toggleRunAgainMessage(show) {
+        dom.clearNode(this.messageBox);
+        this.messageDisposables.clear();
+        if (show) {
+            const runAgainLink = dom.append(this.messageBox, dom.$('a.pointer.prominent.message', {}, ( localize('runSearch', "Run Search"))));
+            this.messageDisposables.add(dom.addDisposableListener(runAgainLink, dom.EventType.CLICK, async () => {
+                await this.triggerSearch();
+                this.searchResultEditor.focus();
+            }));
+        }
+    }
+    _getContributions() {
+        const skipContributions = [UnusualLineTerminatorsDetector.ID];
+        return EditorExtensionsRegistry.getEditorContributions().filter(c => skipContributions.indexOf(c.id) === -1);
+    }
+    getCodeEditorWidgetOptions() {
+        return { contributions: this._getContributions() };
+    }
+    registerEditorListeners() {
+        this.searchResultEditor.onMouseUp(e => {
+            if (e.event.detail === 2) {
+                const behaviour = this.searchConfig.searchEditor.doubleClickBehaviour;
+                const position = e.target.position;
+                if (position && behaviour !== 'selectWord') {
+                    const line = this.searchResultEditor.getModel()?.getLineContent(position.lineNumber) ?? '';
+                    if (line.match(RESULT_LINE_REGEX)) {
+                        this.searchResultEditor.setSelection(Range.fromPositions(position));
+                        this.commandService.executeCommand(behaviour === 'goToLocation' ? 'editor.action.goToDeclaration' : 'editor.action.openDeclarationToTheSide');
+                    }
+                    else if (line.match(FILE_LINE_REGEX)) {
+                        this.searchResultEditor.setSelection(Range.fromPositions(position));
+                        this.commandService.executeCommand('editor.action.peekDefinition');
+                    }
+                }
+            }
+        });
+        this._register(this.searchResultEditor.onDidChangeModelContent(() => {
+            if (!this.updatingModelForSearch) {
+                this.getInput()?.setDirty(true);
+            }
+        }));
+    }
+    getControl() {
+        return this.searchResultEditor;
+    }
+    focus() {
+        const viewState = this.loadEditorViewState(this.getInput());
+        if (viewState && viewState.focused === 'editor') {
+            this.searchResultEditor.focus();
+        }
+        else {
+            this.queryEditorWidget.focus();
+        }
+    }
+    focusSearchInput() {
+        this.queryEditorWidget.searchInput?.focus();
+    }
+    focusFilesToIncludeInput() {
+        if (!this.showingIncludesExcludes) {
+            this.toggleIncludesExcludes(true);
+        }
+        this.inputPatternIncludes.focus();
+    }
+    focusFilesToExcludeInput() {
+        if (!this.showingIncludesExcludes) {
+            this.toggleIncludesExcludes(true);
+        }
+        this.inputPatternExcludes.focus();
+    }
+    focusNextInput() {
+        if (this.queryEditorWidget.searchInputHasFocus()) {
+            if (this.showingIncludesExcludes) {
+                this.inputPatternIncludes.focus();
+            }
+            else {
+                this.searchResultEditor.focus();
+            }
+        }
+        else if (this.inputPatternIncludes.inputHasFocus()) {
+            this.inputPatternExcludes.focus();
+        }
+        else if (this.inputPatternExcludes.inputHasFocus()) {
+            this.searchResultEditor.focus();
+        }
+        else if (this.searchResultEditor.hasWidgetFocus()) ;
+    }
+    focusPrevInput() {
+        if (this.queryEditorWidget.searchInputHasFocus()) {
+            this.searchResultEditor.focus();
+        }
+        else if (this.inputPatternIncludes.inputHasFocus()) {
+            this.queryEditorWidget.searchInput?.focus();
+        }
+        else if (this.inputPatternExcludes.inputHasFocus()) {
+            this.inputPatternIncludes.focus();
+        }
+        else if (this.searchResultEditor.hasWidgetFocus()) ;
+    }
+    setQuery(query) {
+        this.queryEditorWidget.searchInput?.setValue(query);
+    }
+    selectQuery() {
+        this.queryEditorWidget.searchInput?.select();
+    }
+    toggleWholeWords() {
+        this.queryEditorWidget.searchInput?.setWholeWords(!this.queryEditorWidget.searchInput.getWholeWords());
+        this.triggerSearch({ resetCursor: false });
+    }
+    toggleRegex() {
+        this.queryEditorWidget.searchInput?.setRegex(!this.queryEditorWidget.searchInput.getRegex());
+        this.triggerSearch({ resetCursor: false });
+    }
+    toggleCaseSensitive() {
+        this.queryEditorWidget.searchInput?.setCaseSensitive(!this.queryEditorWidget.searchInput.getCaseSensitive());
+        this.triggerSearch({ resetCursor: false });
+    }
+    toggleContextLines() {
+        this.queryEditorWidget.toggleContextLines();
+    }
+    modifyContextLines(increase) {
+        this.queryEditorWidget.modifyContextLines(increase);
+    }
+    toggleQueryDetails() {
+        this.toggleIncludesExcludes();
+    }
+    deleteResultBlock() {
+        const linesToDelete = ( new Set());
+        const selections = this.searchResultEditor.getSelections();
+        const model = this.searchResultEditor.getModel();
+        if (!(selections && model)) {
+            return;
+        }
+        const maxLine = model.getLineCount();
+        const minLine = 1;
+        const deleteUp = (start) => {
+            for (let cursor = start; cursor >= minLine; cursor--) {
+                const line = model.getLineContent(cursor);
+                linesToDelete.add(cursor);
+                if (line[0] !== undefined && line[0] !== ' ') {
+                    break;
+                }
+            }
+        };
+        const deleteDown = (start) => {
+            linesToDelete.add(start);
+            for (let cursor = start + 1; cursor <= maxLine; cursor++) {
+                const line = model.getLineContent(cursor);
+                if (line[0] !== undefined && line[0] !== ' ') {
+                    return cursor;
+                }
+                linesToDelete.add(cursor);
+            }
+            return;
+        };
+        const endingCursorLines = [];
+        for (const selection of selections) {
+            const lineNumber = selection.startLineNumber;
+            endingCursorLines.push(deleteDown(lineNumber));
+            deleteUp(lineNumber);
+            for (let inner = selection.startLineNumber; inner <= selection.endLineNumber; inner++) {
+                linesToDelete.add(inner);
+            }
+        }
+        if (endingCursorLines.length === 0) {
+            endingCursorLines.push(1);
+        }
+        const isDefined = (x) => x !== undefined;
+        model.pushEditOperations(this.searchResultEditor.getSelections(), ( [...linesToDelete].map(line => ({ range: ( new Range(line, 1, line + 1, 1)), text: '' }))), () => ( endingCursorLines.filter(isDefined).map(line => ( new Selection(line, 1, line, 1)))));
+    }
+    cleanState() {
+        this.getInput()?.setDirty(false);
+    }
+    get searchConfig() {
+        return this.configurationService.getValue('search');
+    }
+    iterateThroughMatches(reverse) {
+        const model = this.searchResultEditor.getModel();
+        if (!model) {
+            return;
+        }
+        const lastLine = model.getLineCount() ?? 1;
+        const lastColumn = model.getLineLength(lastLine);
+        const fallbackStart = reverse ? ( new Position(lastLine, lastColumn)) : ( new Position(1, 1));
+        const currentPosition = this.searchResultEditor.getSelection()?.getStartPosition() ?? fallbackStart;
+        const matchRanges = this.getInput()?.getMatchRanges();
+        if (!matchRanges) {
+            return;
+        }
+        const matchRange = (reverse ? findPrevRange : findNextRange)(matchRanges, currentPosition);
+        this.searchResultEditor.setSelection(matchRange);
+        this.searchResultEditor.revealLineInCenterIfOutsideViewport(matchRange.startLineNumber);
+        this.searchResultEditor.focus();
+        const matchLineText = model.getLineContent(matchRange.startLineNumber);
+        const matchText = model.getValueInRange(matchRange);
+        let file = '';
+        for (let line = matchRange.startLineNumber; line >= 1; line--) {
+            const lineText = model.getValueInRange(( new Range(line, 1, line, 2)));
+            if (lineText !== ' ') {
+                file = model.getLineContent(line);
+                break;
+            }
+        }
+        alert(( localize(
+            'searchResultItem',
+            "Matched {0} at {1} in file {2}",
+            matchText,
+            matchLineText,
+            file.slice(0, file.length - 1)
+        )));
+    }
+    focusNextResult() {
+        this.iterateThroughMatches(false);
+    }
+    focusPreviousResult() {
+        this.iterateThroughMatches(true);
+    }
+    focusAllResults() {
+        this.searchResultEditor
+            .setSelections(( (this.getInput()?.getMatchRanges() ?? []).map(range => ( new Selection(
+            range.startLineNumber,
+            range.startColumn,
+            range.endLineNumber,
+            range.endColumn
+        )))));
+        this.searchResultEditor.focus();
+    }
+    async triggerSearch(_options) {
+        const options = { resetCursor: true, delay: 0, ..._options };
+        if (!this.pauseSearching) {
+            await this.runSearchDelayer.trigger(async () => {
+                this.toggleRunAgainMessage(false);
+                await this.doRunSearch();
+                if (options.resetCursor) {
+                    this.searchResultEditor.setPosition(( new Position(1, 1)));
+                    this.searchResultEditor.setScrollPosition({ scrollTop: 0, scrollLeft: 0 });
+                }
+                if (options.focusResults) {
+                    this.searchResultEditor.focus();
+                }
+            }, options.delay);
+        }
+    }
+    readConfigFromWidget() {
+        return {
+            isCaseSensitive: this.queryEditorWidget.searchInput?.getCaseSensitive() ?? false,
+            contextLines: this.queryEditorWidget.getContextLines(),
+            filesToExclude: this.inputPatternExcludes.getValue(),
+            filesToInclude: this.inputPatternIncludes.getValue(),
+            query: this.queryEditorWidget.searchInput?.getValue() ?? '',
+            isRegexp: this.queryEditorWidget.searchInput?.getRegex() ?? false,
+            matchWholeWord: this.queryEditorWidget.searchInput?.getWholeWords() ?? false,
+            useExcludeSettingsAndIgnoreFiles: this.inputPatternExcludes.useExcludesAndIgnoreFiles(),
+            onlyOpenEditors: this.inputPatternIncludes.onlySearchInOpenEditors(),
+            showIncludesExcludes: this.showingIncludesExcludes,
+            notebookSearchConfig: {
+                includeMarkupInput: this.queryEditorWidget.getNotebookFilters().markupInput,
+                includeMarkupPreview: this.queryEditorWidget.getNotebookFilters().markupPreview,
+                includeCodeInput: this.queryEditorWidget.getNotebookFilters().codeInput,
+                includeOutput: this.queryEditorWidget.getNotebookFilters().codeOutput,
+            }
+        };
+    }
+    async doRunSearch() {
+        this.searchModel.cancelSearch(true);
+        const startInput = this.getInput();
+        if (!startInput) {
+            return;
+        }
+        this.searchHistoryDelayer.trigger(() => {
+            this.queryEditorWidget.searchInput?.onSearchSubmit();
+            this.inputPatternExcludes.onSearchSubmit();
+            this.inputPatternIncludes.onSearchSubmit();
+        });
+        const config = this.readConfigFromWidget();
+        if (!config.query) {
+            return;
+        }
+        const content = {
+            pattern: config.query,
+            isRegExp: config.isRegexp,
+            isCaseSensitive: config.isCaseSensitive,
+            isWordMatch: config.matchWholeWord,
+        };
+        const options = {
+            _reason: 'searchEditor',
+            extraFileResources: this.instantiationService.invokeFunction(getOutOfWorkspaceEditorResources),
+            maxResults: withNullAsUndefined(this.searchConfig.maxResults),
+            disregardIgnoreFiles: !config.useExcludeSettingsAndIgnoreFiles || undefined,
+            disregardExcludeSettings: !config.useExcludeSettingsAndIgnoreFiles || undefined,
+            excludePattern: config.filesToExclude,
+            includePattern: config.filesToInclude,
+            onlyOpenEditors: config.onlyOpenEditors,
+            previewOptions: {
+                matchLines: 1,
+                charsPerLine: 1000
+            },
+            afterContext: config.contextLines,
+            beforeContext: config.contextLines,
+            isSmartCase: this.searchConfig.smartCase,
+            expandPatterns: true,
+            notebookSearchConfig: {
+                includeMarkupInput: config.notebookSearchConfig.includeMarkupInput,
+                includeMarkupPreview: config.notebookSearchConfig.includeMarkupPreview,
+                includeCodeInput: config.notebookSearchConfig.includeCodeInput,
+                includeOutput: config.notebookSearchConfig.includeOutput,
+            }
+        };
+        const folderResources = this.contextService.getWorkspace().folders;
+        let query;
+        try {
+            const queryBuilder = this.instantiationService.createInstance(QueryBuilder);
+            query = queryBuilder.text(content, ( folderResources.map(folder => folder.uri)), options);
+        }
+        catch (err) {
+            return;
+        }
+        this.searchOperation.start(500);
+        this.ongoingOperations++;
+        const { configurationModel } = await startInput.resolveModels();
+        configurationModel.updateConfig(config);
+        startInput.ongoingSearchOperation = this.searchModel.search(query).finally(() => {
+            this.ongoingOperations--;
+            if (this.ongoingOperations === 0) {
+                this.searchOperation.stop();
+            }
+        });
+        const searchOperation = await startInput.ongoingSearchOperation;
+        await this.onSearchComplete(searchOperation, config, startInput);
+    }
+    async onSearchComplete(searchOperation, startConfig, startInput) {
+        const input = this.getInput();
+        if (!input ||
+            input !== startInput ||
+            JSON.stringify(startConfig) !== JSON.stringify(this.readConfigFromWidget())) {
+            return;
+        }
+        input.ongoingSearchOperation = undefined;
+        const sortOrder = this.searchConfig.sortOrder;
+        if (sortOrder === "modified" ) {
+            await this.retrieveFileStats(this.searchModel.searchResult);
+        }
+        const controller = ReferencesController.get(this.searchResultEditor);
+        controller?.closeWidget(false);
+        const labelFormatter = (uri) => this.labelService.getUriLabel(uri, { relative: true });
+        const results = serializeSearchResultForEditor(this.searchModel.searchResult, startConfig.filesToInclude, startConfig.filesToExclude, startConfig.contextLines, labelFormatter, sortOrder, searchOperation?.limitHit);
+        const { resultsModel } = await input.resolveModels();
+        this.updatingModelForSearch = true;
+        this.modelService.updateModel(resultsModel, results.text);
+        this.updatingModelForSearch = false;
+        if (searchOperation && searchOperation.messages) {
+            for (const message of searchOperation.messages) {
+                this.addMessage(message);
+            }
+        }
+        this.reLayout();
+        input.setDirty(!input.hasCapability(4 ));
+        input.setMatchRanges(results.matchRanges);
+    }
+    addMessage(message) {
+        let messageBox;
+        if (this.messageBox.firstChild) {
+            messageBox = this.messageBox.firstChild;
+        }
+        else {
+            messageBox = dom.append(this.messageBox, dom.$('.message'));
+        }
+        dom.append(messageBox, renderSearchMessage(message, this.instantiationService, this.notificationService, this.openerService, this.commandService, this.messageDisposables, () => this.triggerSearch()));
+    }
+    async retrieveFileStats(searchResult) {
+        const files = ( searchResult.matches().filter(f => !f.fileStat).map(f => f.resolveFileStat(this.fileService)));
+        await Promise.all(files);
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        this.reLayout();
+    }
+    getSelected() {
+        const selection = this.searchResultEditor.getSelection();
+        if (selection) {
+            return this.searchResultEditor.getModel()?.getValueInRange(selection) ?? '';
+        }
+        return '';
+    }
+    reLayout() {
+        if (this.dimension) {
+            this.queryEditorWidget.setWidth(this.dimension.width - 28 );
+            this.searchResultEditor.layout({ height: this.dimension.height - dom.getTotalHeight(this.queryEditorContainer), width: this.dimension.width });
+            this.inputPatternExcludes.setWidth(this.dimension.width - 28 );
+            this.inputPatternIncludes.setWidth(this.dimension.width - 28 );
+        }
+    }
+    getInput() {
+        return this._input;
+    }
+    setSearchConfig(config) {
+        this.priorConfig = config;
+        if (config.query !== undefined) {
+            this.queryEditorWidget.setValue(config.query);
+        }
+        if (config.isCaseSensitive !== undefined) {
+            this.queryEditorWidget.searchInput?.setCaseSensitive(config.isCaseSensitive);
+        }
+        if (config.isRegexp !== undefined) {
+            this.queryEditorWidget.searchInput?.setRegex(config.isRegexp);
+        }
+        if (config.matchWholeWord !== undefined) {
+            this.queryEditorWidget.searchInput?.setWholeWords(config.matchWholeWord);
+        }
+        if (config.contextLines !== undefined) {
+            this.queryEditorWidget.setContextLines(config.contextLines);
+        }
+        if (config.filesToExclude !== undefined) {
+            this.inputPatternExcludes.setValue(config.filesToExclude);
+        }
+        if (config.filesToInclude !== undefined) {
+            this.inputPatternIncludes.setValue(config.filesToInclude);
+        }
+        if (config.onlyOpenEditors !== undefined) {
+            this.inputPatternIncludes.setOnlySearchInOpenEditors(config.onlyOpenEditors);
+        }
+        if (config.useExcludeSettingsAndIgnoreFiles !== undefined) {
+            this.inputPatternExcludes.setUseExcludesAndIgnoreFiles(config.useExcludeSettingsAndIgnoreFiles);
+        }
+        if (config.showIncludesExcludes !== undefined) {
+            this.toggleIncludesExcludes(config.showIncludesExcludes);
+        }
+    }
+    async setInput(newInput, options, context, token) {
+        await super.setInput(newInput, options, context, token);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const { configurationModel, resultsModel } = await newInput.resolveModels();
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.searchResultEditor.setModel(resultsModel);
+        this.pauseSearching = true;
+        this.toggleRunAgainMessage(!newInput.ongoingSearchOperation && resultsModel.getLineCount() === 1 && resultsModel.getValue() === '' && configurationModel.config.query !== '');
+        this.setSearchConfig(configurationModel.config);
+        this._register(configurationModel.onConfigDidUpdate(newConfig => {
+            if (newConfig !== this.priorConfig) {
+                this.pauseSearching = true;
+                this.setSearchConfig(newConfig);
+                this.pauseSearching = false;
+            }
+        }));
+        this.restoreViewState(context);
+        if (!options?.preserveFocus) {
+            this.focus();
+        }
+        this.pauseSearching = false;
+        if (newInput.ongoingSearchOperation) {
+            const existingConfig = this.readConfigFromWidget();
+            newInput.ongoingSearchOperation.then(complete => {
+                this.onSearchComplete(complete, existingConfig, newInput);
+            });
+        }
+    }
+    toggleIncludesExcludes(_shouldShow) {
+        const cls = 'expanded';
+        const shouldShow = _shouldShow ?? !this.includesExcludesContainer.classList.contains(cls);
+        if (shouldShow) {
+            this.toggleQueryDetailsButton.setAttribute('aria-expanded', 'true');
+            this.includesExcludesContainer.classList.add(cls);
+        }
+        else {
+            this.toggleQueryDetailsButton.setAttribute('aria-expanded', 'false');
+            this.includesExcludesContainer.classList.remove(cls);
+        }
+        this.showingIncludesExcludes = this.includesExcludesContainer.classList.contains(cls);
+        this.reLayout();
+    }
+    toEditorViewStateResource(input) {
+        if (input.typeId === SearchEditorInputTypeId) {
+            return input.modelUri;
+        }
+        return undefined;
+    }
+    computeEditorViewState(resource) {
+        const control = this.getControl();
+        const editorViewState = control.saveViewState();
+        if (!editorViewState) {
+            return undefined;
+        }
+        if (( resource.toString()) !== this.getInput()?.modelUri.toString()) {
+            return undefined;
+        }
+        return { ...editorViewState, focused: this.searchResultEditor.hasWidgetFocus() ? 'editor' : 'input' };
+    }
+    tracksEditorViewState(input) {
+        return input.typeId === SearchEditorInputTypeId;
+    }
+    restoreViewState(context) {
+        const viewState = this.loadEditorViewState(this.getInput(), context);
+        if (viewState) {
+            this.searchResultEditor.restoreViewState(viewState);
+        }
+    }
+    getAriaLabel() {
+        return this.getInput()?.getName() ?? ( localize('searchEditor', "Search"));
+    }
+};
+SearchEditor.ID = SearchEditorID;
+SearchEditor.SEARCH_EDITOR_VIEW_STATE_PREFERENCE_KEY = 'searchEditorViewState';
+SearchEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IContextViewService)),
+    ( __param(8, ICommandService)),
+    ( __param(9, IOpenerService)),
+    ( __param(10, INotificationService)),
+    ( __param(11, IEditorProgressService)),
+    ( __param(12, ITextResourceConfigurationService)),
+    ( __param(13, IEditorGroupsService)),
+    ( __param(14, IEditorService)),
+    ( __param(15, IConfigurationService)),
+    ( __param(16, IFileService)),
+    ( __param(17, ILogService))
+], SearchEditor));
+const searchEditorTextInputBorder = registerColor('searchEditor.textInputBorder', { dark: inputBorder, light: inputBorder, hcDark: inputBorder, hcLight: inputBorder }, ( localize('textInputBoxBorder', "Search editor text input box border.")));
+function findNextRange(matchRanges, currentPosition) {
+    for (const matchRange of matchRanges) {
+        if (Position.isBefore(currentPosition, matchRange.getStartPosition())) {
+            return matchRange;
+        }
+    }
+    return matchRanges[0];
+}
+function findPrevRange(matchRanges, currentPosition) {
+    for (let i = matchRanges.length - 1; i >= 0; i--) {
+        const matchRange = matchRanges[i];
+        if (Position.isBefore(matchRange.getStartPosition(), currentPosition)) {
+            {
+                return matchRange;
+            }
+        }
+    }
+    return matchRanges[matchRanges.length - 1];
+}
+export { SearchEditor };