@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

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

@@ -25,16 +25,16 @@ import { overviewRulerFindMatchForeground, minimapFindMatch } from 'monaco-edito
 import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { FindMatchDecorationModel } from '../../../../../../../override/vs/workbench/contrib/notebook/browser/contrib/find/findMatchDecorationModel.js';
-import { CellEditState } from '../../notebook/browser/notebookBrowser.js';
 import { NotebookEditorWidget } from '../../../../../../../override/vs/workbench/contrib/notebook/browser/notebookEditorWidget.js';
 import { INotebookEditorService } from '../../notebook/browser/services/notebookEditorService.js';
 import { NotebookCellsChangeType } from '../../notebook/common/notebookCommon.js';
-import { INotebookSearchService } from './notebookSearch.js';
 import { IReplaceService } from './replace.js';
 import { isIFileMatchWithCells, rawCellPrefix, contentMatchesToTextSearchMatches, webviewMatchesToTextSearchMatches, CellSearchModel } from './searchNotebookHelpers.js';
+import { INotebookSearchService } from '../common/notebookSearch.js';
 import { ReplacePattern } from '../../../services/search/common/replace.js';
 import { OneLineRange, resultIsMatch, ISearchService } from '../../../services/search/common/search.js';
 import { editorMatchesToTextSearchResults, addContextToEditorMatches } from '../../../services/search/common/searchHelpers.js';
+var FileMatch_1, FolderMatch_1, RangeHighlightDecorations_1;
 class Match {
     static { this.MAX_PREVIEW_CHARS = 250; }
     constructor(_parent, _fullPreviewLines, _fullPreviewRange, _documentRange) {
@@ -69,7 +69,7 @@ class Match {
     preview() {
         let before = this._oneLinePreviewText.substring(0, this._rangeInPreviewText.startColumn - 1), inside = this.getMatchString(), after = this._oneLinePreviewText.substring(this._rangeInPreviewText.endColumn - 1);
         before = lcut(before, 26);
-        before = before.trimLeft();
+        before = before.trimStart();
         let charsRemaining = Match.MAX_PREVIEW_CHARS - before.length;
         inside = inside.substr(0, charsRemaining);
         charsRemaining -= inside.length;
@@ -170,6 +170,10 @@ class CellMatch {
             this._webviewMatches.delete(match.id());
         }
     }
+    clearAllMatches() {
+        this._contentMatches.clear();
+        this._webviewMatches.clear();
+    }
     addContentMatches(textSearchMatches) {
         const contentMatches = textSearchMatchesToNotebookMatches();
         contentMatches.forEach((match) => {
@@ -240,6 +244,7 @@ class MatchInNotebook extends Match {
     }
 }
 let FileMatch = class FileMatch extends Disposable {
+    static { FileMatch_1 = this; }
     static { this._CURRENT_FIND_MATCH = ModelDecorationOptions.register({
         description: 'search-current-find-match',
         stickiness: 1 ,
@@ -268,7 +273,7 @@ let FileMatch = class FileMatch extends Disposable {
         }
     }); }
     static getDecorationOption(selected) {
-        return (selected ? FileMatch._CURRENT_FIND_MATCH : FileMatch._FIND_MATCH);
+        return (selected ? FileMatch_1._CURRENT_FIND_MATCH : FileMatch_1._FIND_MATCH);
     }
     get context() {
         return ( new Map(this._context));
@@ -442,7 +447,7 @@ let FileMatch = class FileMatch extends Disposable {
             const newDecorations = (this.parent().showHighlights
                 ? ( this.matches().map(match => ({
                     range: match.range(),
-                    options: FileMatch.getDecorationOption(this.isMatchSelected(match))
+                    options: FileMatch_1.getDecorationOption(this.isMatchSelected(match))
                 })))
                 : []);
             this._modelDecorations = accessor.deltaDecorations(this._modelDecorations, newDecorations);
@@ -634,6 +639,7 @@ let FileMatch = class FileMatch extends Disposable {
                 const existingRawCell = oldCellMatches.get(`${rawCellPrefix}${index}`);
                 if (existingRawCell) {
                     existingRawCell.setCellModel(match.cell);
+                    existingRawCell.clearAllMatches();
                     existingCell = existingRawCell;
                 }
             }
@@ -720,27 +726,27 @@ let FileMatch = class FileMatch extends Disposable {
             }
         }
         else {
-            match.cell.updateEditState(CellEditState.Editing, 'focusNotebookCell');
+            match.cell.updateEditState(match.cell.getEditState(), 'focusNotebookCell');
             this._notebookEditorWidget.setCellEditorSelection(match.cell, match.range());
             this._notebookEditorWidget.revealRangeInCenterIfOutsideViewportAsync(match.cell, match.range());
         }
     }
 };
-FileMatch = ( __decorate([
+FileMatch = FileMatch_1 = ( __decorate([
     ( __param(7, IModelService)),
     ( __param(8, IReplaceService)),
     ( __param(9, ILabelService)),
     ( __param(10, INotebookEditorService))
 ], FileMatch));
-let FolderMatch = class FolderMatch extends Disposable {
-    constructor(_resource, _id, _index, _query, _parent, _searchModel, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService) {
+let FolderMatch = FolderMatch_1 = class FolderMatch extends Disposable {
+    constructor(_resource, _id, _index, _query, _parent, _searchResult, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService) {
         super();
         this._resource = _resource;
         this._id = _id;
         this._index = _index;
         this._query = _query;
         this._parent = _parent;
-        this._searchModel = _searchModel;
+        this._searchResult = _searchResult;
         this._closestRoot = _closestRoot;
         this.replaceService = replaceService;
         this.instantiationService = instantiationService;
@@ -758,7 +764,7 @@ let FolderMatch = class FolderMatch extends Disposable {
         this._name = ( new Lazy(() => this.resource ? labelService.getUriBasenameLabel(this.resource) : ''));
     }
     get searchModel() {
-        return this._searchModel;
+        return this._searchResult.searchModel;
     }
     get showHighlights() {
         return this._parent.showHighlights;
@@ -821,7 +827,7 @@ let FolderMatch = class FolderMatch extends Disposable {
         }
     }
     createIntermediateFolderMatch(resource, id, index, query, baseWorkspaceFolder) {
-        const folderMatch = this.instantiationService.createInstance(FolderMatchWithResource, resource, id, index, query, this, this._searchModel, baseWorkspaceFolder);
+        const folderMatch = this.instantiationService.createInstance(FolderMatchWithResource, resource, id, index, query, this, this._searchResult, baseWorkspaceFolder);
         this.configureIntermediateMatch(folderMatch);
         this.doAddFolder(folderMatch);
         return folderMatch;
@@ -907,19 +913,21 @@ let FolderMatch = class FolderMatch extends Disposable {
         raw.forEach(rawFileMatch => {
             const existingFileMatch = this.getDownstreamFileMatch(rawFileMatch.resource);
             if (existingFileMatch) {
-                rawFileMatch
-                    .results
-                    .filter(resultIsMatch)
-                    .forEach(m => {
-                    textSearchResultToMatches(m, existingFileMatch)
-                        .forEach(m => existingFileMatch.add(m));
-                });
+                if (rawFileMatch.results) {
+                    rawFileMatch
+                        .results
+                        .filter(resultIsMatch)
+                        .forEach(m => {
+                        textSearchResultToMatches(m, existingFileMatch)
+                            .forEach(m => existingFileMatch.add(m));
+                    });
+                }
                 if (isIFileMatchWithCells(rawFileMatch)) {
                     rawFileMatch.cellResults?.forEach(rawCellMatch => {
                         const existingCellMatch = existingFileMatch.getCellMatch(rawCellMatch.cell.id);
                         if (existingCellMatch) {
                             existingCellMatch.addContentMatches(rawCellMatch.contentResults);
-                            existingCellMatch.addContentMatches(rawCellMatch.webviewResults);
+                            existingCellMatch.addWebviewMatches(rawCellMatch.webviewResults);
                         }
                         else {
                             existingFileMatch.addCellMatch(rawCellMatch);
@@ -955,7 +963,7 @@ let FolderMatch = class FolderMatch extends Disposable {
     }
     isInParentChain(folderMatch) {
         let matchItem = this;
-        while (matchItem instanceof FolderMatch) {
+        while (matchItem instanceof FolderMatch_1) {
             if (matchItem.id() === folderMatch.id()) {
                 return true;
             }
@@ -1056,15 +1064,15 @@ let FolderMatch = class FolderMatch extends Disposable {
         super.dispose();
     }
 };
-FolderMatch = ( __decorate([
+FolderMatch = FolderMatch_1 = ( __decorate([
     ( __param(7, IReplaceService)),
     ( __param(8, IInstantiationService)),
     ( __param(9, ILabelService)),
     ( __param(10, IUriIdentityService))
 ], FolderMatch));
 let FolderMatchWithResource = class FolderMatchWithResource extends FolderMatch {
-    constructor(_resource, _id, _index, _query, _parent, _searchModel, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService) {
-        super(_resource, _id, _index, _query, _parent, _searchModel, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService);
+    constructor(_resource, _id, _index, _query, _parent, _searchResult, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService) {
+        super(_resource, _id, _index, _query, _parent, _searchResult, _closestRoot, replaceService, instantiationService, labelService, uriIdentityService);
         this._normalizedResource = ( new Lazy(
             () => this.uriIdentityService.extUri.removeTrailingPathSeparator(this.uriIdentityService.extUri.normalizePath(this.resource))
         ));
@@ -1083,8 +1091,8 @@ FolderMatchWithResource = ( __decorate([
     ( __param(10, IUriIdentityService))
 ], FolderMatchWithResource));
 let FolderMatchWorkspaceRoot = class FolderMatchWorkspaceRoot extends FolderMatchWithResource {
-    constructor(_resource, _id, _index, _query, _parent, _searchModel, replaceService, instantiationService, labelService, uriIdentityService) {
-        super(_resource, _id, _index, _query, _parent, _searchModel, null, replaceService, instantiationService, labelService, uriIdentityService);
+    constructor(_resource, _id, _index, _query, _parent, replaceService, instantiationService, labelService, uriIdentityService) {
+        super(_resource, _id, _index, _query, _parent, _parent, null, replaceService, instantiationService, labelService, uriIdentityService);
     }
     normalizedUriParent(uri) {
         return this.uriIdentityService.extUri.normalizePath(this.uriIdentityService.extUri.dirname(uri));
@@ -1126,14 +1134,14 @@ let FolderMatchWorkspaceRoot = class FolderMatchWorkspaceRoot extends FolderMatc
     }
 };
 FolderMatchWorkspaceRoot = ( __decorate([
-    ( __param(6, IReplaceService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, ILabelService)),
-    ( __param(9, IUriIdentityService))
+    ( __param(5, IReplaceService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IUriIdentityService))
 ], FolderMatchWorkspaceRoot));
 let FolderMatchNoRoot = class FolderMatchNoRoot extends FolderMatch {
-    constructor(_id, _index, _query, _parent, _searchModel, replaceService, instantiationService, labelService, uriIdentityService) {
-        super(null, _id, _index, _query, _parent, _searchModel, null, replaceService, instantiationService, labelService, uriIdentityService);
+    constructor(_id, _index, _query, _parent, replaceService, instantiationService, labelService, uriIdentityService) {
+        super(null, _id, _index, _query, _parent, _parent, null, replaceService, instantiationService, labelService, uriIdentityService);
     }
     createAndConfigureFileMatch(rawFileMatch, searchInstanceID) {
         const fileMatch = this.instantiationService.createInstance(FileMatch, this._query.contentPattern, this._query.previewOptions, this._query.maxResults, this, rawFileMatch, null, searchInstanceID);
@@ -1144,10 +1152,10 @@ let FolderMatchNoRoot = class FolderMatchNoRoot extends FolderMatch {
     }
 };
 FolderMatchNoRoot = ( __decorate([
-    ( __param(5, IReplaceService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, ILabelService)),
-    ( __param(8, IUriIdentityService))
+    ( __param(4, IReplaceService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ILabelService)),
+    ( __param(7, IUriIdentityService))
 ], FolderMatchNoRoot));
 let elemAIndex = -1;
 let elemBIndex = -1;
@@ -1265,16 +1273,16 @@ function createParentList(element) {
     return parentArray;
 }
 let SearchResult = class SearchResult extends Disposable {
-    constructor(_searchModel, replaceService, instantiationService, modelService, uriIdentityService, notebookEditorService) {
+    constructor(searchModel, replaceService, instantiationService, modelService, uriIdentityService, notebookEditorService) {
         super();
-        this._searchModel = _searchModel;
+        this.searchModel = searchModel;
         this.replaceService = replaceService;
         this.instantiationService = instantiationService;
         this.modelService = modelService;
         this.uriIdentityService = uriIdentityService;
         this.notebookEditorService = notebookEditorService;
         this._onChange = this._register(( new PauseableEmitter({
-            merge: this.mergeEvents
+            merge: mergeSearchResultEvents
         })));
         this.onChange = this._onChange.event;
         this._folderMatches = [];
@@ -1359,23 +1367,6 @@ let SearchResult = class SearchResult extends Disposable {
         this._otherFilesMatch = this._createBaseFolderMatch(null, 'otherFiles', this._folderMatches.length + 1, query);
         this._query = query;
     }
-    mergeEvents(events) {
-        const retEvent = {
-            elements: [],
-            added: false,
-            removed: false,
-        };
-        events.forEach((e) => {
-            if (e.added) {
-                retEvent.added = true;
-            }
-            if (e.removed) {
-                retEvent.removed = true;
-            }
-            retEvent.elements = retEvent.elements.concat(e.elements);
-        });
-        return retEvent;
-    }
     onDidAddNotebookEditorWidget(widget) {
         this._onWillChangeModelListener?.dispose();
         this._onWillChangeModelListener = widget.onWillChangeModel((model) => {
@@ -1405,18 +1396,15 @@ let SearchResult = class SearchResult extends Disposable {
     _createBaseFolderMatch(resource, id, index, query) {
         let folderMatch;
         if (resource) {
-            folderMatch = this.instantiationService.createInstance(FolderMatchWorkspaceRoot, resource, id, index, query, this, this._searchModel);
+            folderMatch = this.instantiationService.createInstance(FolderMatchWorkspaceRoot, resource, id, index, query, this);
         }
         else {
-            folderMatch = this.instantiationService.createInstance(FolderMatchNoRoot, id, index, query, this, this._searchModel);
+            folderMatch = this.instantiationService.createInstance(FolderMatchNoRoot, id, index, query, this);
         }
         const disposable = folderMatch.onChange((event) => this._onChange.fire(event));
         folderMatch.onDispose(() => disposable.dispose());
         return folderMatch;
     }
-    get searchModel() {
-        return this._searchModel;
-    }
     add(allRaw, searchInstanceID, silent = false) {
         const { byFolder, other } = this.groupFilesByFolder(allRaw);
         byFolder.forEach(raw => {
@@ -1592,9 +1580,14 @@ let SearchModel = class SearchModel extends Disposable {
         this._resultQueue = [];
         this._onReplaceTermChanged = this._register(( new Emitter()));
         this.onReplaceTermChanged = this._onReplaceTermChanged.event;
+        this._onSearchResultChanged = this._register(( new PauseableEmitter({
+            merge: mergeSearchResultEvents
+        })));
+        this.onSearchResultChanged = this._onSearchResultChanged.event;
         this.currentCancelTokenSource = null;
         this.searchCancelledForNewSearch = false;
         this._searchResult = this.instantiationService.createInstance(SearchResult, this);
+        this._searchResultChangedListener = this._register(this._searchResult.onChange((e) => this._onSearchResultChanged.fire(e)));
     }
     isReplaceActive() {
         return this._replaceActive;
@@ -1624,22 +1617,53 @@ let SearchModel = class SearchModel extends Disposable {
     get searchResult() {
         return this._searchResult;
     }
-    async doSearch(query, progressEmitter, searchQuery, searchInstanceID, onProgress) {
-        const searchStart = Date.now();
-        const tokenSource = this.currentCancelTokenSource = ( new CancellationTokenSource());
-        const onProgressCall = (p) => {
+    set searchResult(searchResult) {
+        this._searchResult.dispose();
+        this._searchResultChangedListener.dispose();
+        this._searchResult = searchResult;
+        this._searchResult.searchModel = this;
+        this._searchResultChangedListener = this._register(this._searchResult.onChange((e) => this._onSearchResultChanged.fire(e)));
+    }
+    doSearch(query, progressEmitter, searchQuery, searchInstanceID, onProgress, callerToken) {
+        const asyncGenerateOnProgress = async (p) => {
+            progressEmitter.fire();
+            this.onSearchProgress(p, searchInstanceID, false);
+            onProgress?.(p);
+        };
+        const syncGenerateOnProgress = (p) => {
             progressEmitter.fire();
-            this.onSearchProgress(p, searchInstanceID);
+            this.onSearchProgress(p, searchInstanceID, true);
             onProgress?.(p);
         };
-        const notebookResult = await this.notebookSearchService.notebookSearch(query, this.currentCancelTokenSource.token, searchInstanceID, onProgressCall);
-        const currentResult = await this.searchService.textSearch(searchQuery, this.currentCancelTokenSource.token, onProgressCall, notebookResult?.scannedFiles);
-        tokenSource.dispose();
-        const searchLength = Date.now() - searchStart;
-        this.logService.trace(`whole search time | ${searchLength}ms`);
-        return notebookResult ? { ...currentResult, ...notebookResult.completeData } : currentResult;
-    }
-    async search(query, onProgress) {
+        const tokenSource = this.currentCancelTokenSource = ( new CancellationTokenSource(callerToken));
+        const notebookResult = this.notebookSearchService.notebookSearch(query, tokenSource.token, searchInstanceID, asyncGenerateOnProgress);
+        const textResult = this.searchService.textSearchSplitSyncAsync(searchQuery, this.currentCancelTokenSource.token, asyncGenerateOnProgress, notebookResult.openFilesToScan, notebookResult.allScannedFiles);
+        const syncResults = textResult.syncResults.results;
+        syncResults.forEach(p => { if (p) {
+            syncGenerateOnProgress(p);
+        } });
+        const getAsyncResults = async () => {
+            const searchStart = Date.now();
+            const allClosedEditorResults = await textResult.asyncResults;
+            const resolvedNotebookResults = await notebookResult.completeData;
+            tokenSource.dispose();
+            const searchLength = Date.now() - searchStart;
+            const resolvedResult = {
+                results: [...allClosedEditorResults.results, ...resolvedNotebookResults.results],
+                messages: [...allClosedEditorResults.messages, ...resolvedNotebookResults.messages],
+                limitHit: allClosedEditorResults.limitHit || resolvedNotebookResults.limitHit,
+                exit: allClosedEditorResults.exit,
+                stats: allClosedEditorResults.stats,
+            };
+            this.logService.trace(`whole search time | ${searchLength}ms`);
+            return resolvedResult;
+        };
+        return {
+            asyncResults: getAsyncResults(),
+            syncResults
+        };
+    }
+    search(query, onProgress, callerToken) {
         this.cancelSearch(true);
         this._searchQuery = query;
         if (!this.searchConfig.searchOnType) {
@@ -1650,14 +1674,31 @@ let SearchModel = class SearchModel extends Disposable {
         const progressEmitter = ( new Emitter());
         this._replacePattern = ( new ReplacePattern(this.replaceString, this._searchQuery.contentPattern));
         this._startStreamDelay = ( new Promise(resolve => setTimeout(resolve, this.searchConfig.searchOnType ? 150 : 0)));
-        const currentRequest = this.doSearch(query, progressEmitter, this._searchQuery, searchInstanceID, onProgress);
+        const req = this.doSearch(query, progressEmitter, this._searchQuery, searchInstanceID, onProgress, callerToken);
+        const asyncResults = req.asyncResults;
+        const syncResults = req.syncResults;
+        if (onProgress) {
+            syncResults.forEach(p => {
+                if (p) {
+                    onProgress(p);
+                }
+            });
+        }
         const start = Date.now();
-        Promise.race([currentRequest, Event.toPromise(progressEmitter.event)]).finally(() => {
+        Promise.race([asyncResults, Event.toPromise(progressEmitter.event)]).finally(() => {
             this.telemetryService.publicLog('searchResultsFirstRender', { duration: Date.now() - start });
         });
-        currentRequest.then(value => this.onSearchCompleted(value, Date.now() - start, searchInstanceID), e => this.onSearchError(e, Date.now() - start));
         try {
-            return await currentRequest;
+            return {
+                asyncResults: asyncResults.then(value => {
+                    this.onSearchCompleted(value, Date.now() - start, searchInstanceID);
+                    return value;
+                }, e => {
+                    this.onSearchError(e, Date.now() - start);
+                    throw e;
+                }),
+                syncResults
+            };
         }
         finally {
             this.telemetryService.publicLog('searchResultsFinished', { duration: Date.now() - start });
@@ -1696,13 +1737,22 @@ let SearchModel = class SearchModel extends Disposable {
             this.searchCancelledForNewSearch = false;
         }
     }
-    async onSearchProgress(p, searchInstanceID) {
+    onSearchProgress(p, searchInstanceID, sync = true) {
         if (p.resource) {
             this._resultQueue.push(p);
-            await this._startStreamDelay;
-            if (this._resultQueue.length) {
-                this._searchResult.add(this._resultQueue, searchInstanceID, true);
-                this._resultQueue.length = 0;
+            if (sync) {
+                if (this._resultQueue.length) {
+                    this._searchResult.add(this._resultQueue, searchInstanceID, true);
+                    this._resultQueue.length = 0;
+                }
+            }
+            else {
+                this._startStreamDelay.then(() => {
+                    if (this._resultQueue.length) {
+                        this._searchResult.add(this._resultQueue, searchInstanceID, true);
+                        this._resultQueue.length = 0;
+                    }
+                });
             }
         }
     }
@@ -1722,6 +1772,10 @@ let SearchModel = class SearchModel extends Disposable {
         this.searchResult.dispose();
         super.dispose();
     }
+    transferSearchResult(other) {
+        other.searchResult = this._searchResult;
+        this._searchResult = this.instantiationService.createInstance(SearchResult, this);
+    }
 };
 SearchModel = ( __decorate([
     ( __param(0, ISearchService)),
@@ -1731,7 +1785,7 @@ SearchModel = ( __decorate([
     ( __param(4, ILogService)),
     ( __param(5, INotebookSearchService))
 ], SearchModel));
-let SearchWorkbenchService = class SearchWorkbenchService {
+let SearchViewModelWorkbenchService = class SearchViewModelWorkbenchService {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;
         this._searchModel = null;
@@ -1743,11 +1797,12 @@ let SearchWorkbenchService = class SearchWorkbenchService {
         return this._searchModel;
     }
 };
-SearchWorkbenchService = ( __decorate([
+SearchViewModelWorkbenchService = ( __decorate([
     ( __param(0, IInstantiationService))
-], SearchWorkbenchService));
-const ISearchWorkbenchService = ( createDecorator('searchWorkbenchService'));
+], SearchViewModelWorkbenchService));
+const ISearchViewModelWorkbenchService = ( createDecorator('searchViewModelWorkbenchService'));
 let RangeHighlightDecorations = class RangeHighlightDecorations {
+    static { RangeHighlightDecorations_1 = this; }
     constructor(_modelService) {
         this._modelService = _modelService;
         this._decorationId = null;
@@ -1778,7 +1833,7 @@ let RangeHighlightDecorations = class RangeHighlightDecorations {
     doHighlightRange(model, range) {
         this.removeHighlightRange();
         model.changeDecorations((accessor) => {
-            this._decorationId = accessor.addDecoration(range, RangeHighlightDecorations._RANGE_HIGHLIGHT_DECORATION);
+            this._decorationId = accessor.addDecoration(range, RangeHighlightDecorations_1._RANGE_HIGHLIGHT_DECORATION);
         });
         this.setModel(model);
     }
@@ -1815,7 +1870,7 @@ let RangeHighlightDecorations = class RangeHighlightDecorations {
         isWholeLine: true
     }); }
 };
-RangeHighlightDecorations = ( __decorate([
+RangeHighlightDecorations = RangeHighlightDecorations_1 = ( __decorate([
     ( __param(0, IModelService))
 ], RangeHighlightDecorations));
 function textSearchResultToMatches(rawMatch, fileMatch) {
@@ -1857,4 +1912,21 @@ function getFileMatches(matches) {
     });
     return fileMatches.concat(( folderMatches.map(e => e.allDownstreamFileMatches())).flat());
 }
-export { CellMatch, FileMatch, FolderMatch, FolderMatchNoRoot, FolderMatchWithResource, FolderMatchWorkspaceRoot, ISearchWorkbenchService, Match, MatchInNotebook, RangeHighlightDecorations, SearchModel, SearchResult, SearchWorkbenchService, arrayContainsElementOrParent, compareNotebookPos, searchComparer, searchMatchComparer, textSearchMatchesToNotebookMatches };
+function mergeSearchResultEvents(events) {
+    const retEvent = {
+        elements: [],
+        added: false,
+        removed: false,
+    };
+    events.forEach((e) => {
+        if (e.added) {
+            retEvent.added = true;
+        }
+        if (e.removed) {
+            retEvent.removed = true;
+        }
+        retEvent.elements = retEvent.elements.concat(e.elements);
+    });
+    return retEvent;
+}
+export { CellMatch, FileMatch, FolderMatch, FolderMatchNoRoot, FolderMatchWithResource, FolderMatchWorkspaceRoot, ISearchViewModelWorkbenchService, Match, MatchInNotebook, RangeHighlightDecorations, SearchModel, SearchResult, SearchViewModelWorkbenchService, arrayContainsElementOrParent, compareNotebookPos, searchComparer, searchMatchComparer, textSearchMatchesToNotebookMatches };

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

@@ -7,6 +7,9 @@ function isIFileMatchWithCells(object) {
     return 'cellResults' in object;
 }
 function contentMatchesToTextSearchMatches(contentMatches, cell) {
+    return genericCellMatchesToTextSearchMatches(contentMatches, cell instanceof CellSearchModel ? cell.inputTextBuffer : cell.textBuffer);
+}
+function genericCellMatchesToTextSearchMatches(contentMatches, buffer, cell) {
     let previousEndLine = -1;
     const contextGroupings = [];
     let currentContextGrouping = [];
@@ -28,7 +31,7 @@ function contentMatchesToTextSearchMatches(contentMatches, cell) {
         const firstLine = grouping[0].range.startLineNumber;
         const lastLine = grouping[grouping.length - 1].range.endLineNumber;
         for (let i = firstLine; i <= lastLine; i++) {
-            lineTexts.push(cell.textBuffer.getLineContent(i));
+            lineTexts.push(buffer.getLineContent(i));
         }
         return ( new TextSearchMatch(lineTexts.join('\n') + '\n', ( grouping.map(m => ( new Range(
             m.range.startLineNumber - 1,
@@ -51,12 +54,14 @@ function webviewMatchesToTextSearchMatches(webviewMatches) {
 }
 const rawCellPrefix = 'rawCell#';
 class CellSearchModel extends Disposable {
-    constructor(_source, _textBuffer, _uri, _cellIndex) {
+    constructor(_source, _inputTextBuffer, _outputs, _uri, _cellIndex) {
         super();
         this._source = _source;
-        this._textBuffer = _textBuffer;
+        this._inputTextBuffer = _inputTextBuffer;
+        this._outputs = _outputs;
         this._uri = _uri;
         this._cellIndex = _cellIndex;
+        this._outputTextBuffers = undefined;
     }
     get id() {
         return `${rawCellPrefix}${this._cellIndex}`;
@@ -64,36 +69,65 @@ class CellSearchModel extends Disposable {
     get uri() {
         return this._uri;
     }
-    getFullModelRange() {
-        const lineCount = this.textBuffer.getLineCount();
-        return ( new Range(1, 1, lineCount, this.getLineMaxColumn(lineCount)));
+    _getFullModelRange(buffer) {
+        const lineCount = buffer.getLineCount();
+        return ( new Range(1, 1, lineCount, this._getLineMaxColumn(buffer, lineCount)));
     }
-    getLineMaxColumn(lineNumber) {
-        if (lineNumber < 1 || lineNumber > this.textBuffer.getLineCount()) {
+    _getLineMaxColumn(buffer, lineNumber) {
+        if (lineNumber < 1 || lineNumber > buffer.getLineCount()) {
             throw new Error('Illegal value for lineNumber');
         }
-        return this.textBuffer.getLineLength(lineNumber) + 1;
+        return buffer.getLineLength(lineNumber) + 1;
+    }
+    get inputTextBuffer() {
+        if (!this._inputTextBuffer) {
+            const builder = ( new PieceTreeTextBufferBuilder());
+            builder.acceptChunk(this._source);
+            const bufferFactory = builder.finish(true);
+            const { textBuffer, disposable } = bufferFactory.create(1 );
+            this._inputTextBuffer = textBuffer;
+            this._register(disposable);
+        }
+        return this._inputTextBuffer;
+    }
+    get outputTextBuffers() {
+        if (!this._outputTextBuffers) {
+            this._outputTextBuffers = ( this._outputs.map((output) => {
+                const builder = ( new PieceTreeTextBufferBuilder());
+                builder.acceptChunk(( output.data.toString()));
+                const bufferFactory = builder.finish(true);
+                const { textBuffer, disposable } = bufferFactory.create(1 );
+                this._register(disposable);
+                return textBuffer;
+            }));
+        }
+        return this._outputTextBuffers;
     }
-    get textBuffer() {
-        if (this._textBuffer) {
-            return this._textBuffer;
+    findInInputs(target) {
+        const searchParams = ( new SearchParams(target, false, false, null));
+        const searchData = searchParams.parseSearchRequest();
+        if (!searchData) {
+            return [];
         }
-        const builder = ( new PieceTreeTextBufferBuilder());
-        builder.acceptChunk(this._source);
-        const bufferFactory = builder.finish(true);
-        const { textBuffer, disposable } = bufferFactory.create(1 );
-        this._textBuffer = textBuffer;
-        this._register(disposable);
-        return this._textBuffer;
+        const fullInputRange = this._getFullModelRange(this.inputTextBuffer);
+        return this.inputTextBuffer.findMatchesLineByLine(fullInputRange, searchData, true, 5000);
     }
-    find(target) {
+    findInOutputs(target) {
         const searchParams = ( new SearchParams(target, false, false, null));
         const searchData = searchParams.parseSearchRequest();
         if (!searchData) {
             return [];
         }
-        const fullRange = this.getFullModelRange();
-        return this.textBuffer.findMatchesLineByLine(fullRange, searchData, true, 5000);
+        return ( this.outputTextBuffers.map(buffer => {
+            const matches = buffer.findMatchesLineByLine(this._getFullModelRange(buffer), searchData, true, 5000);
+            if (matches.length === 0) {
+                return undefined;
+            }
+            return {
+                textBuffer: buffer,
+                matches
+            };
+        })).filter((item) => !!item);
     }
 }
-export { CellSearchModel, contentMatchesToTextSearchMatches, isIFileMatchWithCells, rawCellPrefix, webviewMatchesToTextSearchMatches };
+export { CellSearchModel, contentMatchesToTextSearchMatches, genericCellMatchesToTextSearchMatches, isIFileMatchWithCells, rawCellPrefix, webviewMatchesToTextSearchMatches };