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

package/dist/vscode/vs/workbench/services/search/common/searchService.js

@@ -0,0 +1,355 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { deserializeSearchError, pathIncludedInQuery, isFileMatch, isProgressMessage, SearchErrorCode, FileMatch } from './search.js';
+import { editorMatchesToTextSearchResults, addContextToEditorMatches } from './searchHelpers.js';
+let SearchService = class SearchService extends Disposable {
+    constructor(modelService, editorService, telemetryService, logService, extensionService, fileService, uriIdentityService) {
+        super();
+        this.modelService = modelService;
+        this.editorService = editorService;
+        this.telemetryService = telemetryService;
+        this.logService = logService;
+        this.extensionService = extensionService;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileSearchProviders = ( new Map());
+        this.textSearchProviders = ( new Map());
+        this.deferredFileSearchesByScheme = ( new Map());
+        this.deferredTextSearchesByScheme = ( new Map());
+        this.loggedSchemesMissingProviders = ( new Set());
+    }
+    registerSearchResultProvider(scheme, type, provider) {
+        let list;
+        let deferredMap;
+        if (type === 0 ) {
+            list = this.fileSearchProviders;
+            deferredMap = this.deferredFileSearchesByScheme;
+        }
+        else if (type === 1 ) {
+            list = this.textSearchProviders;
+            deferredMap = this.deferredTextSearchesByScheme;
+        }
+        else {
+            throw new Error('Unknown SearchProviderType');
+        }
+        list.set(scheme, provider);
+        if (( deferredMap.has(scheme))) {
+            deferredMap.get(scheme).complete(provider);
+            deferredMap.delete(scheme);
+        }
+        return toDisposable(() => {
+            list.delete(scheme);
+        });
+    }
+    async textSearch(query, token, onProgress, notebookURIs) {
+        const localResults = this.getLocalResults(query);
+        if (onProgress) {
+            arrays.coalesce([...( localResults.results.values())]).forEach(onProgress);
+        }
+        const onProviderProgress = (progress) => {
+            if (isFileMatch(progress)) {
+                if (!( localResults.results.has(progress.resource)) && !(notebookURIs && ( notebookURIs.has(progress.resource))) && onProgress) {
+                    onProgress(progress);
+                }
+            }
+            else if (onProgress) {
+                onProgress(progress);
+            }
+            if (isProgressMessage(progress)) {
+                this.logService.debug('SearchService#search', progress.message);
+            }
+        };
+        const otherResults = await this.doSearch(query, token, onProviderProgress);
+        return {
+            ...otherResults,
+            ...{
+                limitHit: otherResults.limitHit || localResults.limitHit
+            },
+            results: [...otherResults.results, ...arrays.coalesce([...( localResults.results.values())])]
+        };
+    }
+    fileSearch(query, token) {
+        return this.doSearch(query, token);
+    }
+    doSearch(query, token, onProgress) {
+        this.logService.trace('SearchService#search', JSON.stringify(query));
+        const schemesInQuery = this.getSchemesInQuery(query);
+        const providerActivations = [Promise.resolve(null)];
+        schemesInQuery.forEach(scheme => providerActivations.push(this.extensionService.activateByEvent(`onSearch:${scheme}`)));
+        providerActivations.push(this.extensionService.activateByEvent('onSearch:file'));
+        const providerPromise = (async () => {
+            await Promise.all(providerActivations);
+            await this.extensionService.whenInstalledExtensionsRegistered();
+            if (token && token.isCancellationRequested) {
+                return Promise.reject(( new CancellationError()));
+            }
+            const progressCallback = (item) => {
+                if (token && token.isCancellationRequested) {
+                    return;
+                }
+                onProgress?.(item);
+            };
+            const exists = await Promise.all(( query.folderQueries.map(query => this.fileService.exists(query.folder))));
+            query.folderQueries = query.folderQueries.filter((_, i) => exists[i]);
+            let completes = await this.searchWithProviders(query, progressCallback, token);
+            completes = arrays.coalesce(completes);
+            if (!completes.length) {
+                return {
+                    limitHit: false,
+                    results: [],
+                    messages: [],
+                };
+            }
+            return {
+                limitHit: completes[0] && completes[0].limitHit,
+                stats: completes[0].stats,
+                messages: arrays.coalesce(arrays.flatten(( completes.map(i => i.messages)))).filter(arrays.uniqueFilter(message => message.type + message.text + message.trusted)),
+                results: arrays.flatten(( completes.map((c) => c.results)))
+            };
+        })();
+        return ( new Promise((resolve, reject) => {
+            if (token) {
+                token.onCancellationRequested(() => {
+                    reject(( new CancellationError()));
+                });
+            }
+            providerPromise.then(resolve, reject);
+        }));
+    }
+    getSchemesInQuery(query) {
+        const schemes = ( new Set());
+        query.folderQueries?.forEach(fq => schemes.add(fq.folder.scheme));
+        query.extraFileResources?.forEach(extraFile => schemes.add(extraFile.scheme));
+        return schemes;
+    }
+    async waitForProvider(queryType, scheme) {
+        const deferredMap = queryType === 1  ?
+            this.deferredFileSearchesByScheme :
+            this.deferredTextSearchesByScheme;
+        if (( deferredMap.has(scheme))) {
+            return deferredMap.get(scheme).p;
+        }
+        else {
+            const deferred = ( new DeferredPromise());
+            deferredMap.set(scheme, deferred);
+            return deferred.p;
+        }
+    }
+    async searchWithProviders(query, onProviderProgress, token) {
+        const e2eSW = StopWatch.create(false);
+        const searchPs = [];
+        const fqs = this.groupFolderQueriesByScheme(query);
+        const someSchemeHasProvider = ( [...( fqs.keys())].some(scheme => {
+            return query.type === 1  ?
+                ( this.fileSearchProviders.has(scheme)) :
+                ( this.textSearchProviders.has(scheme));
+        }));
+        await Promise.all(( [...( fqs.keys())].map(async (scheme) => {
+            const schemeFQs = fqs.get(scheme);
+            let provider = query.type === 1  ?
+                this.fileSearchProviders.get(scheme) :
+                this.textSearchProviders.get(scheme);
+            if (!provider) {
+                if (someSchemeHasProvider) {
+                    if (!( this.loggedSchemesMissingProviders.has(scheme))) {
+                        this.logService.warn(`No search provider registered for scheme: ${scheme}. Another scheme has a provider, not waiting for ${scheme}`);
+                        this.loggedSchemesMissingProviders.add(scheme);
+                    }
+                    return;
+                }
+                else {
+                    if (!( this.loggedSchemesMissingProviders.has(scheme))) {
+                        this.logService.warn(`No search provider registered for scheme: ${scheme}, waiting`);
+                        this.loggedSchemesMissingProviders.add(scheme);
+                    }
+                    provider = await this.waitForProvider(query.type, scheme);
+                }
+            }
+            const oneSchemeQuery = {
+                ...query,
+                ...{
+                    folderQueries: schemeFQs
+                }
+            };
+            searchPs.push(query.type === 1  ?
+                provider.fileSearch(oneSchemeQuery, token) :
+                provider.textSearch(oneSchemeQuery, onProviderProgress, token));
+        })));
+        return Promise.all(searchPs).then(completes => {
+            const endToEndTime = e2eSW.elapsed();
+            this.logService.trace(`SearchService#search: ${endToEndTime}ms`);
+            completes.forEach(complete => {
+                this.sendTelemetry(query, endToEndTime, complete);
+            });
+            return completes;
+        }, err => {
+            const endToEndTime = e2eSW.elapsed();
+            this.logService.trace(`SearchService#search: ${endToEndTime}ms`);
+            const searchError = deserializeSearchError(err);
+            this.logService.trace(`SearchService#searchError: ${searchError.message}`);
+            this.sendTelemetry(query, endToEndTime, undefined, searchError);
+            throw searchError;
+        });
+    }
+    groupFolderQueriesByScheme(query) {
+        const queries = ( new Map());
+        query.folderQueries.forEach(fq => {
+            const schemeFQs = queries.get(fq.folder.scheme) || [];
+            schemeFQs.push(fq);
+            queries.set(fq.folder.scheme, schemeFQs);
+        });
+        return queries;
+    }
+    sendTelemetry(query, endToEndTime, complete, err) {
+        const fileSchemeOnly = query.folderQueries.every(fq => fq.folder.scheme === Schemas.file);
+        const otherSchemeOnly = query.folderQueries.every(fq => fq.folder.scheme !== Schemas.file);
+        const scheme = fileSchemeOnly ? Schemas.file :
+            otherSchemeOnly ? 'other' :
+                'mixed';
+        if (query.type === 1  && complete && complete.stats) {
+            const fileSearchStats = complete.stats;
+            if (fileSearchStats.fromCache) {
+                const cacheStats = fileSearchStats.detailStats;
+                this.telemetryService.publicLog2('cachedSearchComplete', {
+                    reason: query._reason,
+                    resultCount: fileSearchStats.resultCount,
+                    workspaceFolderCount: query.folderQueries.length,
+                    endToEndTime: endToEndTime,
+                    sortingTime: fileSearchStats.sortingTime,
+                    cacheWasResolved: cacheStats.cacheWasResolved,
+                    cacheLookupTime: cacheStats.cacheLookupTime,
+                    cacheFilterTime: cacheStats.cacheFilterTime,
+                    cacheEntryCount: cacheStats.cacheEntryCount,
+                    scheme
+                });
+            }
+            else {
+                const searchEngineStats = fileSearchStats.detailStats;
+                this.telemetryService.publicLog2('searchComplete', {
+                    reason: query._reason,
+                    resultCount: fileSearchStats.resultCount,
+                    workspaceFolderCount: query.folderQueries.length,
+                    endToEndTime: endToEndTime,
+                    sortingTime: fileSearchStats.sortingTime,
+                    fileWalkTime: searchEngineStats.fileWalkTime,
+                    directoriesWalked: searchEngineStats.directoriesWalked,
+                    filesWalked: searchEngineStats.filesWalked,
+                    cmdTime: searchEngineStats.cmdTime,
+                    cmdResultCount: searchEngineStats.cmdResultCount,
+                    scheme
+                });
+            }
+        }
+        else if (query.type === 2 ) {
+            let errorType;
+            if (err) {
+                errorType = err.code === SearchErrorCode.regexParseError ? 'regex' :
+                    err.code === SearchErrorCode.unknownEncoding ? 'encoding' :
+                        err.code === SearchErrorCode.globParseError ? 'glob' :
+                            err.code === SearchErrorCode.invalidLiteral ? 'literal' :
+                                err.code === SearchErrorCode.other ? 'other' :
+                                    err.code === SearchErrorCode.canceled ? 'canceled' :
+                                        'unknown';
+            }
+            this.telemetryService.publicLog2('textSearchComplete', {
+                reason: query._reason,
+                workspaceFolderCount: query.folderQueries.length,
+                endToEndTime: endToEndTime,
+                scheme,
+                error: errorType,
+            });
+        }
+    }
+    getLocalResults(query) {
+        const localResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+        let limitHit = false;
+        if (query.type === 2 ) {
+            const canonicalToOriginalResources = ( new ResourceMap());
+            for (const editorInput of this.editorService.editors) {
+                const canonical = EditorResourceAccessor.getCanonicalUri(editorInput, { supportSideBySide: SideBySideEditor.PRIMARY });
+                const original = EditorResourceAccessor.getOriginalUri(editorInput, { supportSideBySide: SideBySideEditor.PRIMARY });
+                if (canonical) {
+                    canonicalToOriginalResources.set(canonical, original ?? canonical);
+                }
+            }
+            const models = this.modelService.getModels();
+            models.forEach((model) => {
+                const resource = model.uri;
+                if (!resource) {
+                    return;
+                }
+                if (limitHit) {
+                    return;
+                }
+                const originalResource = canonicalToOriginalResources.get(resource);
+                if (!originalResource) {
+                    return;
+                }
+                if (model.getLanguageId() === 'search-result' && !(query.includePattern && query.includePattern['**/*.code-search'])) {
+                    return;
+                }
+                if (originalResource.scheme !== Schemas.untitled && !this.fileService.hasProvider(originalResource)) {
+                    return;
+                }
+                if (originalResource.scheme === 'git') {
+                    return;
+                }
+                if (!this.matches(originalResource, query)) {
+                    return;
+                }
+                const askMax = isNumber(query.maxResults) ? query.maxResults + 1 : Number.MAX_SAFE_INTEGER;
+                let matches = model.findMatches(query.contentPattern.pattern, false, !!query.contentPattern.isRegExp, !!query.contentPattern.isCaseSensitive, query.contentPattern.isWordMatch ? query.contentPattern.wordSeparators : null, false, askMax);
+                if (matches.length) {
+                    if (askMax && matches.length >= askMax) {
+                        limitHit = true;
+                        matches = matches.slice(0, askMax - 1);
+                    }
+                    const fileMatch = ( new FileMatch(originalResource));
+                    localResults.set(originalResource, fileMatch);
+                    const textSearchResults = editorMatchesToTextSearchResults(matches, model, query.previewOptions);
+                    fileMatch.results = addContextToEditorMatches(textSearchResults, model, query);
+                }
+                else {
+                    localResults.set(originalResource, null);
+                }
+            });
+        }
+        return {
+            results: localResults,
+            limitHit
+        };
+    }
+    matches(resource, query) {
+        return pathIncludedInQuery(query, resource.fsPath);
+    }
+    async clearCache(cacheKey) {
+        const clearPs = ( Array.from(( this.fileSearchProviders.values()))
+            .map(provider => provider && provider.clearCache(cacheKey)));
+        await Promise.all(clearPs);
+    }
+};
+SearchService = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IExtensionService)),
+    ( __param(5, IFileService)),
+    ( __param(6, IUriIdentityService))
+], SearchService));
+export { SearchService };

package/dist/vscode/vs/workbench/services/search/common/textSearchManager.js

@@ -0,0 +1,309 @@
+import { flatten, mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { isThenable } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { resolvePatternsForProvider, QueryGlobTester, hasSiblingPromiseFn } from './search.js';
+class TextSearchManager {
+    constructor(query, provider, fileUtils, processType) {
+        this.query = query;
+        this.provider = provider;
+        this.fileUtils = fileUtils;
+        this.processType = processType;
+        this.collector = null;
+        this.isLimitHit = false;
+        this.resultCount = 0;
+    }
+    search(onProgress, token) {
+        const folderQueries = this.query.folderQueries || [];
+        const tokenSource = ( new CancellationTokenSource());
+        token.onCancellationRequested(() => tokenSource.cancel());
+        return ( new Promise((resolve, reject) => {
+            this.collector = ( new TextSearchResultsCollector(onProgress));
+            let isCanceled = false;
+            const onResult = (result, folderIdx) => {
+                if (isCanceled) {
+                    return;
+                }
+                if (!this.isLimitHit) {
+                    const resultSize = this.resultSize(result);
+                    if (extensionResultIsMatch(result) && typeof this.query.maxResults === 'number' && this.resultCount + resultSize > this.query.maxResults) {
+                        this.isLimitHit = true;
+                        isCanceled = true;
+                        tokenSource.cancel();
+                        result = this.trimResultToSize(result, this.query.maxResults - this.resultCount);
+                    }
+                    const newResultSize = this.resultSize(result);
+                    this.resultCount += newResultSize;
+                    if (newResultSize > 0 || !extensionResultIsMatch(result)) {
+                        this.collector.add(result, folderIdx);
+                    }
+                }
+            };
+            Promise.all(( folderQueries.map((fq, i) => {
+                return this.searchInFolder(fq, r => onResult(r, i), tokenSource.token);
+            }))).then(results => {
+                tokenSource.dispose();
+                this.collector.flush();
+                const someFolderHitLImit = ( results.some(result => !!result && !!result.limitHit));
+                resolve({
+                    limitHit: this.isLimitHit || someFolderHitLImit,
+                    messages: flatten(( results.map(result => {
+                        if (!result?.message) {
+                            return [];
+                        }
+                        if (Array.isArray(result.message)) {
+                            return result.message;
+                        }
+                        else {
+                            return [result.message];
+                        }
+                    }))),
+                    stats: {
+                        type: this.processType
+                    }
+                });
+            }, (err) => {
+                tokenSource.dispose();
+                const errMsg = toErrorMessage(err);
+                reject(( new Error(errMsg)));
+            });
+        }));
+    }
+    resultSize(result) {
+        if (extensionResultIsMatch(result)) {
+            return Array.isArray(result.ranges) ?
+                result.ranges.length :
+                1;
+        }
+        else {
+            return 0;
+        }
+    }
+    trimResultToSize(result, size) {
+        const rangesArr = Array.isArray(result.ranges) ? result.ranges : [result.ranges];
+        const matchesArr = Array.isArray(result.preview.matches) ? result.preview.matches : [result.preview.matches];
+        return {
+            ranges: rangesArr.slice(0, size),
+            preview: {
+                matches: matchesArr.slice(0, size),
+                text: result.preview.text
+            },
+            uri: result.uri
+        };
+    }
+    async searchInFolder(folderQuery, onResult, token) {
+        const queryTester = ( new QueryGlobTester(this.query, folderQuery));
+        const testingPs = [];
+        const progress = {
+            report: (result) => {
+                if (!this.validateProviderResult(result)) {
+                    return;
+                }
+                const hasSibling = folderQuery.folder.scheme === Schemas.file ?
+                    hasSiblingPromiseFn(() => {
+                        return this.fileUtils.readdir(resources.dirname(result.uri));
+                    }) :
+                    undefined;
+                const relativePath = resources.relativePath(folderQuery.folder, result.uri);
+                if (relativePath) {
+                    const included = queryTester.includedInQuery(relativePath, path.basename(relativePath), hasSibling);
+                    if (isThenable(included)) {
+                        testingPs.push(included.then(isIncluded => {
+                            if (isIncluded) {
+                                onResult(result);
+                            }
+                        }));
+                    }
+                    else if (included) {
+                        onResult(result);
+                    }
+                }
+            }
+        };
+        const searchOptions = this.getSearchOptionsForFolder(folderQuery);
+        const result = await this.provider.provideTextSearchResults(patternInfoToQuery(this.query.contentPattern), searchOptions, progress, token);
+        if (testingPs.length) {
+            await Promise.all(testingPs);
+        }
+        return result;
+    }
+    validateProviderResult(result) {
+        if (extensionResultIsMatch(result)) {
+            if (Array.isArray(result.ranges)) {
+                if (!Array.isArray(result.preview.matches)) {
+                    console.warn('INVALID - A text search provider match\'s`ranges` and`matches` properties must have the same type.');
+                    return false;
+                }
+                if (result.preview.matches.length !== result.ranges.length) {
+                    console.warn('INVALID - A text search provider match\'s`ranges` and`matches` properties must have the same length.');
+                    return false;
+                }
+            }
+            else {
+                if (Array.isArray(result.preview.matches)) {
+                    console.warn('INVALID - A text search provider match\'s`ranges` and`matches` properties must have the same length.');
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    getSearchOptionsForFolder(fq) {
+        const includes = resolvePatternsForProvider(this.query.includePattern, fq.includePattern);
+        const excludes = resolvePatternsForProvider(this.query.excludePattern, fq.excludePattern);
+        const options = {
+            folder: ( URI.from(fq.folder)),
+            excludes,
+            includes,
+            useIgnoreFiles: !fq.disregardIgnoreFiles,
+            useGlobalIgnoreFiles: !fq.disregardGlobalIgnoreFiles,
+            useParentIgnoreFiles: !fq.disregardParentIgnoreFiles,
+            followSymlinks: !fq.ignoreSymlinks,
+            encoding: fq.fileEncoding && this.fileUtils.toCanonicalName(fq.fileEncoding),
+            maxFileSize: this.query.maxFileSize,
+            maxResults: this.query.maxResults,
+            previewOptions: this.query.previewOptions,
+            afterContext: this.query.afterContext,
+            beforeContext: this.query.beforeContext
+        };
+        options.usePCRE2 = this.query.usePCRE2;
+        return options;
+    }
+}
+function patternInfoToQuery(patternInfo) {
+    return {
+        isCaseSensitive: patternInfo.isCaseSensitive || false,
+        isRegExp: patternInfo.isRegExp || false,
+        isWordMatch: patternInfo.isWordMatch || false,
+        isMultiline: patternInfo.isMultiline || false,
+        pattern: patternInfo.pattern
+    };
+}
+class TextSearchResultsCollector {
+    constructor(_onResult) {
+        this._onResult = _onResult;
+        this._currentFolderIdx = -1;
+        this._currentFileMatch = null;
+        this._batchedCollector = ( new BatchedCollector(512, items => this.sendItems(items)));
+    }
+    add(data, folderIdx) {
+        if (this._currentFileMatch && (this._currentFolderIdx !== folderIdx || !resources.isEqual(this._currentUri, data.uri))) {
+            this.pushToCollector();
+            this._currentFileMatch = null;
+        }
+        if (!this._currentFileMatch) {
+            this._currentFolderIdx = folderIdx;
+            this._currentFileMatch = {
+                resource: data.uri,
+                results: []
+            };
+        }
+        this._currentFileMatch.results.push(extensionResultToFrontendResult(data));
+    }
+    pushToCollector() {
+        const size = this._currentFileMatch && this._currentFileMatch.results ?
+            this._currentFileMatch.results.length :
+            0;
+        this._batchedCollector.addItem(this._currentFileMatch, size);
+    }
+    flush() {
+        this.pushToCollector();
+        this._batchedCollector.flush();
+    }
+    sendItems(items) {
+        this._onResult(items);
+    }
+}
+function extensionResultToFrontendResult(data) {
+    if (extensionResultIsMatch(data)) {
+        return {
+            preview: {
+                matches: mapArrayOrNot(data.preview.matches, m => ({
+                    startLineNumber: m.start.line,
+                    startColumn: m.start.character,
+                    endLineNumber: m.end.line,
+                    endColumn: m.end.character
+                })),
+                text: data.preview.text
+            },
+            ranges: mapArrayOrNot(data.ranges, r => ({
+                startLineNumber: r.start.line,
+                startColumn: r.start.character,
+                endLineNumber: r.end.line,
+                endColumn: r.end.character
+            }))
+        };
+    }
+    else {
+        return {
+            text: data.text,
+            lineNumber: data.lineNumber
+        };
+    }
+}
+function extensionResultIsMatch(data) {
+    return !!data.preview;
+}
+class BatchedCollector {
+    constructor(maxBatchSize, cb) {
+        this.maxBatchSize = maxBatchSize;
+        this.cb = cb;
+        this.totalNumberCompleted = 0;
+        this.batch = [];
+        this.batchSize = 0;
+    }
+    addItem(item, size) {
+        if (!item) {
+            return;
+        }
+        this.addItemToBatch(item, size);
+    }
+    addItems(items, size) {
+        if (!items) {
+            return;
+        }
+        this.addItemsToBatch(items, size);
+    }
+    addItemToBatch(item, size) {
+        this.batch.push(item);
+        this.batchSize += size;
+        this.onUpdate();
+    }
+    addItemsToBatch(item, size) {
+        this.batch = this.batch.concat(item);
+        this.batchSize += size;
+        this.onUpdate();
+    }
+    onUpdate() {
+        if (this.totalNumberCompleted < BatchedCollector.START_BATCH_AFTER_COUNT) {
+            this.flush();
+        }
+        else if (this.batchSize >= this.maxBatchSize) {
+            this.flush();
+        }
+        else if (!this.timeoutHandle) {
+            this.timeoutHandle = setTimeout(() => {
+                this.flush();
+            }, BatchedCollector.TIMEOUT);
+        }
+    }
+    flush() {
+        if (this.batchSize) {
+            this.totalNumberCompleted += this.batchSize;
+            this.cb(this.batch);
+            this.batch = [];
+            this.batchSize = 0;
+            if (this.timeoutHandle) {
+                clearTimeout(this.timeoutHandle);
+                this.timeoutHandle = 0;
+            }
+        }
+    }
+}
+BatchedCollector.TIMEOUT = 4000;
+BatchedCollector.START_BATCH_AFTER_COUNT = 50;
+export { BatchedCollector, TextSearchManager, TextSearchResultsCollector, extensionResultIsMatch };

package/dist/vscode/vs/workbench/services/suggest/browser/media/suggest.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".workbench-suggest-widget{display:flex;flex-direction:column;left:0;position:absolute;top:0;width:430px;z-index:40}.workbench-suggest-widget.message{align-items:center;flex-direction:row}.monaco-workbench .workbench-suggest-details,.workbench-suggest-widget{background-color:var(--vscode-editorSuggestWidget-background);border-color:var(--vscode-editorSuggestWidget-border);border-style:solid;border-width:1px;flex:0 1 auto;width:100%}.monaco-workbench.hc-black .workbench-suggest-details,.monaco-workbench.hc-black .workbench-suggest-widget,.monaco-workbench.hc-light .workbench-suggest-details,.monaco-workbench.hc-light .workbench-suggest-widget{border-width:2px}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar{display:flex}.monaco-workbench .workbench-suggest-widget .suggest-status-bar .left{padding-right:8px}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-label{color:var(--vscode-editorSuggestWidgetStatus-foreground)}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label{margin-right:0}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label:after{content:\", \";margin-right:.3em}.monaco-workbench .workbench-suggest-widget.with-status-bar .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore,.monaco-workbench .workbench-suggest-widget.with-status-bar .monaco-list .monaco-list-row>.contents>.main>.right>.readMore{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row{background-position:2px 2px;background-repeat:no-repeat;-mox-box-sizing:border-box;box-sizing:border-box;cursor:pointer;display:flex;padding-right:10px;touch-action:none;white-space:nowrap}.workbench-suggest-widget .monaco-list .monaco-list-row.focused{color:var(--vscode-editorSuggestWidget-selectedForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row.focused .codicon{color:var(--vscode-editorSuggestWidget-selectedIconForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents{flex:1;height:100%;overflow:hidden;padding-left:2px}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main{display:flex;justify-content:space-between;overflow:hidden;text-overflow:ellipsis;white-space:pre}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left,.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right{display:flex}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.focused)>.contents>.main .monaco-icon-label{color:var(--vscode-editorSuggestWidget-foreground)}.workbench-suggest-widget:not(.frozen) .monaco-highlighted-label .highlight{font-weight:700}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main .monaco-highlighted-label .highlight{color:var(--vscode-editorSuggestWidget-highlightForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row.focused>.contents>.main .monaco-highlighted-label .highlight{color:var(--vscode-editorSuggestWidget-focusHighlightForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated{opacity:.66;text-decoration:unset}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated>.monaco-icon-label-container>.monaco-icon-name-container{text-decoration:line-through}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label:before{height:100%}.workbench-suggest-widget .monaco-list .monaco-list-row .icon{background-position:50%;background-repeat:no-repeat;background-size:80%;display:block;height:16px;margin-left:2px;width:16px}.workbench-suggest-widget .monaco-list .monaco-list-row .icon.hide{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row .suggest-icon{align-items:center;display:flex;margin-right:4px}.workbench-suggest-widget.no-icons .monaco-list .monaco-list-row .icon,.workbench-suggest-widget.no-icons .monaco-list .monaco-list-row .suggest-icon:before{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row .icon.customcolor .colorspan{border:.1em solid #000;display:inline-block;height:.7em;margin:0 0 0 .3em;width:.7em}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{opacity:.7}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.signature-label{opacity:.6;overflow:hidden;text-overflow:ellipsis}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.qualifier-label{align-self:center;font-size:85%;line-height:normal;margin-left:12px;opacity:.4;overflow:hidden;text-overflow:ellipsis}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{font-size:85%;margin-left:1.1em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label>.monaco-tokenized-source{display:inline}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.right>.details-label,.workbench-suggest-widget.docs-side .monaco-list .monaco-list-row.focused:not(.string-label)>.contents>.main>.right>.details-label,.workbench-suggest-widget:not(.shows-details) .monaco-list .monaco-list-row.focused>.contents>.main>.right>.details-label{display:inline}.workbench-suggest-widget:not(.docs-side) .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right.can-expand-details>.details-label{width:calc(100% - 26px)}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left{flex-grow:1;flex-shrink:1;overflow:hidden}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.monaco-icon-label{flex-shrink:0}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.left>.monaco-icon-label{max-width:100%}.workbench-suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.left>.monaco-icon-label{flex-shrink:1}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right{flex-shrink:4;max-width:70%;overflow:hidden}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore{display:inline-block;height:18px;position:absolute;right:10px;visibility:hidden;width:18px}";
+n(css,{});
+export { css, css as default };