@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,428 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import * as collections from 'monaco-editor/esm/vs/base/common/collections.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { untildify } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import { isAbsolutePath, isEqual, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { assertIsDefined, isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isMultilineRegexSource } from 'monaco-editor/esm/vs/editor/common/model/textModelSearch.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { toWorkspaceFolder, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IEditorGroupsService } from '../../editor/common/editorGroupsService.js';
+import { IPathService } from '../../path/common/pathService.js';
+import { pathIncludedInQuery, getExcludes } from './search.js';
+let QueryBuilder = class QueryBuilder {
+    constructor(configurationService, workspaceContextService, editorGroupsService, logService, pathService) {
+        this.configurationService = configurationService;
+        this.workspaceContextService = workspaceContextService;
+        this.editorGroupsService = editorGroupsService;
+        this.logService = logService;
+        this.pathService = pathService;
+    }
+    text(contentPattern, folderResources, options = {}) {
+        contentPattern = this.getContentPattern(contentPattern, options);
+        const searchConfig = this.configurationService.getValue();
+        const fallbackToPCRE = folderResources && ( folderResources.some(folder => {
+            const folderConfig = this.configurationService.getValue({ resource: folder });
+            return !folderConfig.search.useRipgrep;
+        }));
+        const commonQuery = this.commonQuery(folderResources?.map(toWorkspaceFolder), options);
+        return {
+            ...commonQuery,
+            type: 2 ,
+            contentPattern,
+            previewOptions: options.previewOptions,
+            maxFileSize: options.maxFileSize,
+            usePCRE2: searchConfig.search.usePCRE2 || fallbackToPCRE || false,
+            beforeContext: options.beforeContext,
+            afterContext: options.afterContext,
+            userDisabledExcludesAndIgnoreFiles: options.disregardExcludeSettings && options.disregardIgnoreFiles
+        };
+    }
+    getContentPattern(inputPattern, options) {
+        const searchConfig = this.configurationService.getValue();
+        if (inputPattern.isRegExp) {
+            inputPattern.pattern = inputPattern.pattern.replace(/\r?\n/g, '\\n');
+        }
+        const newPattern = {
+            ...inputPattern,
+            wordSeparators: searchConfig.editor.wordSeparators
+        };
+        if (this.isCaseSensitive(inputPattern, options)) {
+            newPattern.isCaseSensitive = true;
+        }
+        if (this.isMultiline(inputPattern)) {
+            newPattern.isMultiline = true;
+        }
+        return newPattern;
+    }
+    file(folders, options = {}) {
+        const commonQuery = this.commonQuery(folders, options);
+        return {
+            ...commonQuery,
+            type: 1 ,
+            filePattern: options.filePattern
+                ? options.filePattern.trim()
+                : options.filePattern,
+            exists: options.exists,
+            sortByScore: options.sortByScore,
+            cacheKey: options.cacheKey,
+        };
+    }
+    handleIncludeExclude(pattern, expandPatterns) {
+        if (!pattern) {
+            return {};
+        }
+        pattern = Array.isArray(pattern) ? ( pattern.map(normalizeSlashes)) : normalizeSlashes(pattern);
+        return expandPatterns
+            ? this.parseSearchPaths(pattern)
+            : { pattern: patternListToIExpression(...(Array.isArray(pattern) ? pattern : [pattern])) };
+    }
+    commonQuery(folderResources = [], options = {}) {
+        const includeSearchPathsInfo = this.handleIncludeExclude(options.includePattern, options.expandPatterns);
+        const excludeSearchPathsInfo = this.handleIncludeExclude(options.excludePattern, options.expandPatterns);
+        const includeFolderName = folderResources.length > 1;
+        const folderQueries = (includeSearchPathsInfo.searchPaths && includeSearchPathsInfo.searchPaths.length ?
+            ( includeSearchPathsInfo.searchPaths.map(
+                searchPath => this.getFolderQueryForSearchPath(searchPath, options, excludeSearchPathsInfo)
+            )) :
+            ( folderResources.map(
+                folder => this.getFolderQueryForRoot(folder, options, excludeSearchPathsInfo, includeFolderName)
+            )))
+            .filter(query => !!query);
+        const queryProps = {
+            _reason: options._reason,
+            folderQueries,
+            usingSearchPaths: !!(includeSearchPathsInfo.searchPaths && includeSearchPathsInfo.searchPaths.length),
+            extraFileResources: options.extraFileResources,
+            excludePattern: excludeSearchPathsInfo.pattern,
+            includePattern: includeSearchPathsInfo.pattern,
+            onlyOpenEditors: options.onlyOpenEditors,
+            maxResults: options.maxResults
+        };
+        if (options.onlyOpenEditors) {
+            const openEditors = arrays.coalesce(arrays.flatten(( this.editorGroupsService.groups.map(group => ( group.editors.map(editor => editor.resource))))));
+            this.logService.trace('QueryBuilder#commonQuery - openEditor URIs', JSON.stringify(openEditors));
+            const openEditorsInQuery = openEditors.filter(editor => pathIncludedInQuery(queryProps, editor.fsPath));
+            const openEditorsQueryProps = this.commonQueryFromFileList(openEditorsInQuery);
+            this.logService.trace('QueryBuilder#commonQuery - openEditor Query', JSON.stringify(openEditorsQueryProps));
+            return { ...queryProps, ...openEditorsQueryProps };
+        }
+        const extraFileResources = options.extraFileResources && options.extraFileResources.filter(extraFile => pathIncludedInQuery(queryProps, extraFile.fsPath));
+        queryProps.extraFileResources = extraFileResources && extraFileResources.length ? extraFileResources : undefined;
+        return queryProps;
+    }
+    commonQueryFromFileList(files) {
+        const folderQueries = [];
+        const foldersToSearch = ( new ResourceMap());
+        const includePattern = {};
+        let hasIncludedFile = false;
+        files.forEach(file => {
+            if (file.scheme === Schemas.walkThrough) {
+                return;
+            }
+            const providerExists = isAbsolutePath(file);
+            if (providerExists) {
+                const searchRoot = this.workspaceContextService.getWorkspaceFolder(file)?.uri ?? file.with({ path: paths.dirname(file.fsPath) });
+                let folderQuery = foldersToSearch.get(searchRoot);
+                if (!folderQuery) {
+                    hasIncludedFile = true;
+                    folderQuery = { folder: searchRoot, includePattern: {} };
+                    folderQueries.push(folderQuery);
+                    foldersToSearch.set(searchRoot, folderQuery);
+                }
+                const relPath = paths.relative(searchRoot.fsPath, file.fsPath);
+                assertIsDefined(folderQuery.includePattern)[relPath.replace(/\\/g, '/')] = true;
+            }
+            else {
+                if (file.fsPath) {
+                    hasIncludedFile = true;
+                    includePattern[file.fsPath] = true;
+                }
+            }
+        });
+        return {
+            folderQueries,
+            includePattern,
+            usingSearchPaths: true,
+            excludePattern: hasIncludedFile ? undefined : { '**/*': true }
+        };
+    }
+    isCaseSensitive(contentPattern, options) {
+        if (options.isSmartCase) {
+            if (contentPattern.isRegExp) {
+                if (strings.containsUppercaseCharacter(contentPattern.pattern, true)) {
+                    return true;
+                }
+            }
+            else if (strings.containsUppercaseCharacter(contentPattern.pattern)) {
+                return true;
+            }
+        }
+        return !!contentPattern.isCaseSensitive;
+    }
+    isMultiline(contentPattern) {
+        if (contentPattern.isMultiline) {
+            return true;
+        }
+        if (contentPattern.isRegExp && isMultilineRegexSource(contentPattern.pattern)) {
+            return true;
+        }
+        if (contentPattern.pattern.indexOf('\n') >= 0) {
+            return true;
+        }
+        return !!contentPattern.isMultiline;
+    }
+    parseSearchPaths(pattern) {
+        const isSearchPath = (segment) => {
+            return paths.isAbsolute(segment) || /^\.\.?([\/\\]|$)/.test(segment);
+        };
+        const patterns = Array.isArray(pattern) ? pattern : splitGlobPattern(pattern);
+        const segments = ( patterns
+            .map(segment => {
+            const userHome = this.pathService.resolvedUserHome;
+            if (userHome) {
+                return untildify(segment, userHome.scheme === Schemas.file ? userHome.fsPath : userHome.path);
+            }
+            return segment;
+        }));
+        const groups = collections.groupBy(segments, segment => isSearchPath(segment) ? 'searchPaths' : 'exprSegments');
+        const expandedExprSegments = ( ( ( (groups.exprSegments || [])
+            .map(s => strings.rtrim(s, '/')))
+            .map(s => strings.rtrim(s, '\\')))
+            .map(p => {
+            if (p[0] === '.') {
+                p = '*' + p;
+            }
+            return expandGlobalGlob(p);
+        }));
+        const result = {};
+        const searchPaths = this.expandSearchPathPatterns(groups.searchPaths || []);
+        if (searchPaths && searchPaths.length) {
+            result.searchPaths = searchPaths;
+        }
+        const exprSegments = arrays.flatten(expandedExprSegments);
+        const includePattern = patternListToIExpression(...exprSegments);
+        if (includePattern) {
+            result.pattern = includePattern;
+        }
+        return result;
+    }
+    getExcludesForFolder(folderConfig, options) {
+        return options.disregardExcludeSettings ?
+            undefined :
+            getExcludes(folderConfig, !options.disregardSearchExcludeSettings);
+    }
+    expandSearchPathPatterns(searchPaths) {
+        if (!searchPaths || !searchPaths.length) {
+            return [];
+        }
+        const expandedSearchPaths = searchPaths.flatMap(searchPath => {
+            let { pathPortion, globPortion } = splitGlobFromPath(searchPath);
+            if (globPortion) {
+                globPortion = normalizeGlobPattern(globPortion);
+            }
+            const oneExpanded = this.expandOneSearchPath(pathPortion);
+            return oneExpanded.flatMap(oneExpandedResult => this.resolveOneSearchPathPattern(oneExpandedResult, globPortion));
+        });
+        const searchPathPatternMap = ( new Map());
+        expandedSearchPaths.forEach(oneSearchPathPattern => {
+            const key = ( oneSearchPathPattern.searchPath.toString());
+            const existing = searchPathPatternMap.get(key);
+            if (existing) {
+                if (oneSearchPathPattern.pattern) {
+                    existing.pattern = existing.pattern || {};
+                    existing.pattern[oneSearchPathPattern.pattern] = true;
+                }
+            }
+            else {
+                searchPathPatternMap.set(key, {
+                    searchPath: oneSearchPathPattern.searchPath,
+                    pattern: oneSearchPathPattern.pattern ? patternListToIExpression(oneSearchPathPattern.pattern) : undefined
+                });
+            }
+        });
+        return Array.from(( searchPathPatternMap.values()));
+    }
+    expandOneSearchPath(searchPath) {
+        if (paths.isAbsolute(searchPath)) {
+            const workspaceFolders = this.workspaceContextService.getWorkspace().folders;
+            if (workspaceFolders[0] && workspaceFolders[0].uri.scheme !== Schemas.file) {
+                return [{
+                        searchPath: workspaceFolders[0].uri.with({ path: searchPath })
+                    }];
+            }
+            return [{
+                    searchPath: URI.file(paths.normalize(searchPath))
+                }];
+        }
+        if (this.workspaceContextService.getWorkbenchState() === 2 ) {
+            const workspaceUri = this.workspaceContextService.getWorkspace().folders[0].uri;
+            searchPath = normalizeSlashes(searchPath);
+            if (searchPath.startsWith('../') || searchPath === '..') {
+                const resolvedPath = paths.posix.resolve(workspaceUri.path, searchPath);
+                return [{
+                        searchPath: workspaceUri.with({ path: resolvedPath })
+                    }];
+            }
+            const cleanedPattern = normalizeGlobPattern(searchPath);
+            return [{
+                    searchPath: workspaceUri,
+                    pattern: cleanedPattern
+                }];
+        }
+        else if (searchPath === './' || searchPath === '.\\') {
+            return [];
+        }
+        else {
+            const searchPathWithoutDotSlash = searchPath.replace(/^\.[\/\\]/, '');
+            const folders = this.workspaceContextService.getWorkspace().folders;
+            const folderMatches = ( folders.map(folder => {
+                const match = searchPathWithoutDotSlash.match(( new RegExp(`^${strings.escapeRegExpCharacters(folder.name)}(?:/(.*)|$)`)));
+                return match ? {
+                    match,
+                    folder
+                } : null;
+            })).filter(isDefined);
+            if (folderMatches.length) {
+                return ( folderMatches.map(match => {
+                    const patternMatch = match.match[1];
+                    return {
+                        searchPath: match.folder.uri,
+                        pattern: patternMatch && normalizeGlobPattern(patternMatch)
+                    };
+                }));
+            }
+            else {
+                const probableWorkspaceFolderNameMatch = searchPath.match(/\.[\/\\](.+)[\/\\]?/);
+                const probableWorkspaceFolderName = probableWorkspaceFolderNameMatch ? probableWorkspaceFolderNameMatch[1] : searchPath;
+                const searchPathNotFoundError = ( nls.localize(
+                    'search.noWorkspaceWithName',
+                    "Workspace folder does not exist: {0}",
+                    probableWorkspaceFolderName
+                ));
+                throw new Error(searchPathNotFoundError);
+            }
+        }
+    }
+    resolveOneSearchPathPattern(oneExpandedResult, globPortion) {
+        const pattern = oneExpandedResult.pattern && globPortion ?
+            `${oneExpandedResult.pattern}/${globPortion}` :
+            oneExpandedResult.pattern || globPortion;
+        const results = [
+            {
+                searchPath: oneExpandedResult.searchPath,
+                pattern
+            }
+        ];
+        if (pattern && !pattern.endsWith('**')) {
+            results.push({
+                searchPath: oneExpandedResult.searchPath,
+                pattern: pattern + '/**'
+            });
+        }
+        return results;
+    }
+    getFolderQueryForSearchPath(searchPath, options, searchPathExcludes) {
+        const rootConfig = this.getFolderQueryForRoot(toWorkspaceFolder(searchPath.searchPath), options, searchPathExcludes, false);
+        if (!rootConfig) {
+            return null;
+        }
+        return {
+            ...rootConfig,
+            ...{
+                includePattern: searchPath.pattern
+            }
+        };
+    }
+    getFolderQueryForRoot(folder, options, searchPathExcludes, includeFolderName) {
+        let thisFolderExcludeSearchPathPattern;
+        const folderUri = URI.isUri(folder) ? folder : folder.uri;
+        if (searchPathExcludes.searchPaths) {
+            const thisFolderExcludeSearchPath = searchPathExcludes.searchPaths.filter(sp => isEqual(sp.searchPath, folderUri))[0];
+            if (thisFolderExcludeSearchPath && !thisFolderExcludeSearchPath.pattern) {
+                return null;
+            }
+            else if (thisFolderExcludeSearchPath) {
+                thisFolderExcludeSearchPathPattern = thisFolderExcludeSearchPath.pattern;
+            }
+        }
+        const folderConfig = this.configurationService.getValue({ resource: folderUri });
+        const settingExcludes = this.getExcludesForFolder(folderConfig, options);
+        const excludePattern = {
+            ...(settingExcludes || {}),
+            ...(thisFolderExcludeSearchPathPattern || {})
+        };
+        const folderName = URI.isUri(folder) ? basename(folder) : folder.name;
+        return {
+            folder: folderUri,
+            folderName: includeFolderName ? folderName : undefined,
+            excludePattern: ( Object.keys(excludePattern)).length > 0 ? excludePattern : undefined,
+            fileEncoding: folderConfig.files && folderConfig.files.encoding,
+            disregardIgnoreFiles: typeof options.disregardIgnoreFiles === 'boolean' ? options.disregardIgnoreFiles : !folderConfig.search.useIgnoreFiles,
+            disregardGlobalIgnoreFiles: typeof options.disregardGlobalIgnoreFiles === 'boolean' ? options.disregardGlobalIgnoreFiles : !folderConfig.search.useGlobalIgnoreFiles,
+            disregardParentIgnoreFiles: typeof options.disregardParentIgnoreFiles === 'boolean' ? options.disregardParentIgnoreFiles : !folderConfig.search.useParentIgnoreFiles,
+            ignoreSymlinks: typeof options.ignoreSymlinks === 'boolean' ? options.ignoreSymlinks : !folderConfig.search.followSymlinks,
+        };
+    }
+};
+QueryBuilder = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IEditorGroupsService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IPathService))
+], QueryBuilder));
+function splitGlobFromPath(searchPath) {
+    const globCharMatch = searchPath.match(/[\*\{\}\(\)\[\]\?]/);
+    if (globCharMatch) {
+        const globCharIdx = globCharMatch.index;
+        const lastSlashMatch = searchPath.substr(0, globCharIdx).match(/[/|\\][^/\\]*$/);
+        if (lastSlashMatch) {
+            let pathPortion = searchPath.substr(0, lastSlashMatch.index);
+            if (!pathPortion.match(/[/\\]/)) {
+                pathPortion += '/';
+            }
+            return {
+                pathPortion,
+                globPortion: searchPath.substr((lastSlashMatch.index || 0) + 1)
+            };
+        }
+    }
+    return {
+        pathPortion: searchPath
+    };
+}
+function patternListToIExpression(...patterns) {
+    return patterns.length ?
+        patterns.reduce((glob, cur) => { glob[cur] = true; return glob; }, Object.create(null)) :
+        undefined;
+}
+function splitGlobPattern(pattern) {
+    return ( glob.splitGlobAware(pattern, ',')
+        .map(s => s.trim()))
+        .filter(s => !!s.length);
+}
+function expandGlobalGlob(pattern) {
+    const patterns = [
+        `**/${pattern}/**`,
+        `**/${pattern}`
+    ];
+    return ( patterns.map(p => p.replace(/\*\*\/\*\*/g, '**')));
+}
+function normalizeSlashes(pattern) {
+    return pattern.replace(/\\/g, '/');
+}
+function normalizeGlobPattern(pattern) {
+    return normalizeSlashes(pattern)
+        .replace(/^\.\//, '')
+        .replace(/\/+$/g, '');
+}
+export { QueryBuilder };

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

@@ -0,0 +1,158 @@
+import { mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import * as extpath from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { getNLines } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+const SEARCH_ELIDED_PREFIX = '⟪ ';
+const SEARCH_ELIDED_SUFFIX = ' characters skipped ⟫';
+const SEARCH_ELIDED_MIN_LEN = (SEARCH_ELIDED_PREFIX.length + SEARCH_ELIDED_SUFFIX.length + 5) * 2;
+const ISearchService = ( createDecorator('searchService'));
+function resultIsMatch(result) {
+    return !!result.preview;
+}
+function isFileMatch(p) {
+    return !!p.resource;
+}
+function isProgressMessage(p) {
+    return !!p.message;
+}
+class FileMatch {
+    constructor(resource) {
+        this.resource = resource;
+        this.results = [];
+    }
+}
+class TextSearchMatch {
+    constructor(text, range, previewOptions) {
+        this.ranges = range;
+        const ranges = Array.isArray(range) ? range : [range];
+        if (previewOptions && previewOptions.matchLines === 1 && isSingleLineRangeList(ranges)) {
+            text = getNLines(text, previewOptions.matchLines);
+            let result = '';
+            let shift = 0;
+            let lastEnd = 0;
+            const leadingChars = Math.floor(previewOptions.charsPerLine / 5);
+            const matches = [];
+            for (const range of ranges) {
+                const previewStart = Math.max(range.startColumn - leadingChars, 0);
+                const previewEnd = range.startColumn + previewOptions.charsPerLine;
+                if (previewStart > lastEnd + leadingChars + SEARCH_ELIDED_MIN_LEN) {
+                    const elision = SEARCH_ELIDED_PREFIX + (previewStart - lastEnd) + SEARCH_ELIDED_SUFFIX;
+                    result += elision + text.slice(previewStart, previewEnd);
+                    shift += previewStart - (lastEnd + elision.length);
+                }
+                else {
+                    result += text.slice(lastEnd, previewEnd);
+                }
+                matches.push(( new OneLineRange(0, range.startColumn - shift, range.endColumn - shift)));
+                lastEnd = previewEnd;
+            }
+            this.preview = { text: result, matches: Array.isArray(this.ranges) ? matches : matches[0] };
+        }
+        else {
+            const firstMatchLine = Array.isArray(range) ? range[0].startLineNumber : range.startLineNumber;
+            this.preview = {
+                text,
+                matches: mapArrayOrNot(range, r => ( new SearchRange(
+                    r.startLineNumber - firstMatchLine,
+                    r.startColumn,
+                    r.endLineNumber - firstMatchLine,
+                    r.endColumn
+                )))
+            };
+        }
+    }
+}
+function isSingleLineRangeList(ranges) {
+    const line = ranges[0].startLineNumber;
+    for (const r of ranges) {
+        if (r.startLineNumber !== line || r.endLineNumber !== line) {
+            return false;
+        }
+    }
+    return true;
+}
+class SearchRange {
+    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
+        this.startLineNumber = startLineNumber;
+        this.startColumn = startColumn;
+        this.endLineNumber = endLineNumber;
+        this.endColumn = endColumn;
+    }
+}
+class OneLineRange extends SearchRange {
+    constructor(lineNumber, startColumn, endColumn) {
+        super(lineNumber, startColumn, lineNumber, endColumn);
+    }
+}
+function getExcludes(configuration, includeSearchExcludes = true) {
+    const fileExcludes = configuration && configuration.files && configuration.files.exclude;
+    const searchExcludes = includeSearchExcludes && configuration && configuration.search && configuration.search.exclude;
+    if (!fileExcludes && !searchExcludes) {
+        return undefined;
+    }
+    if (!fileExcludes || !searchExcludes) {
+        return fileExcludes || searchExcludes;
+    }
+    let allExcludes = Object.create(null);
+    allExcludes = objects.mixin(allExcludes, objects.deepClone(fileExcludes));
+    allExcludes = objects.mixin(allExcludes, objects.deepClone(searchExcludes), true);
+    return allExcludes;
+}
+function pathIncludedInQuery(queryProps, fsPath) {
+    if (queryProps.excludePattern && glob.match(queryProps.excludePattern, fsPath)) {
+        return false;
+    }
+    if (queryProps.includePattern || queryProps.usingSearchPaths) {
+        if (queryProps.includePattern && glob.match(queryProps.includePattern, fsPath)) {
+            return true;
+        }
+        if (queryProps.usingSearchPaths) {
+            return !!queryProps.folderQueries && ( queryProps.folderQueries.some(fq => {
+                const searchPath = fq.folder.fsPath;
+                if (extpath.isEqualOrParent(fsPath, searchPath)) {
+                    const relPath = paths.relative(searchPath, fsPath);
+                    return !fq.includePattern || !!glob.match(fq.includePattern, relPath);
+                }
+                else {
+                    return false;
+                }
+            }));
+        }
+        return false;
+    }
+    return true;
+}
+var SearchErrorCode;
+( (function(SearchErrorCode) {
+    SearchErrorCode[SearchErrorCode["unknownEncoding"] = 1] = "unknownEncoding";
+    SearchErrorCode[SearchErrorCode["regexParseError"] = 2] = "regexParseError";
+    SearchErrorCode[SearchErrorCode["globParseError"] = 3] = "globParseError";
+    SearchErrorCode[SearchErrorCode["invalidLiteral"] = 4] = "invalidLiteral";
+    SearchErrorCode[SearchErrorCode["rgProcessError"] = 5] = "rgProcessError";
+    SearchErrorCode[SearchErrorCode["other"] = 6] = "other";
+    SearchErrorCode[SearchErrorCode["canceled"] = 7] = "canceled";
+})(SearchErrorCode || (SearchErrorCode = {})));
+class SearchError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+function deserializeSearchError(error) {
+    const errorMsg = error.message;
+    if (isCancellationError(error)) {
+        return ( new SearchError(errorMsg, SearchErrorCode.canceled));
+    }
+    try {
+        const details = JSON.parse(errorMsg);
+        return ( new SearchError(details.message, details.code));
+    }
+    catch (e) {
+        return ( new SearchError(errorMsg, SearchErrorCode.other));
+    }
+}
+export { FileMatch, ISearchService, OneLineRange, SearchError, SearchErrorCode, SearchRange, TextSearchMatch, deserializeSearchError, getExcludes, isFileMatch, isProgressMessage, pathIncludedInQuery, resultIsMatch };

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

@@ -0,0 +1,72 @@
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { TextSearchMatch } from './search.js';
+function editorMatchToTextSearchResult(matches, model, previewOptions) {
+    const firstLine = matches[0].range.startLineNumber;
+    const lastLine = matches[matches.length - 1].range.endLineNumber;
+    const lineTexts = [];
+    for (let i = firstLine; i <= lastLine; i++) {
+        lineTexts.push(model.getLineContent(i));
+    }
+    return ( new TextSearchMatch(lineTexts.join('\n') + '\n', ( matches.map(m => ( new Range(
+        m.range.startLineNumber - 1,
+        m.range.startColumn - 1,
+        m.range.endLineNumber - 1,
+        m.range.endColumn - 1
+    )))), previewOptions));
+}
+function editorMatchesToTextSearchResults(matches, model, previewOptions) {
+    let previousEndLine = -1;
+    const groupedMatches = [];
+    let currentMatches = [];
+    matches.forEach((match) => {
+        if (match.range.startLineNumber !== previousEndLine) {
+            currentMatches = [];
+            groupedMatches.push(currentMatches);
+        }
+        currentMatches.push(match);
+        previousEndLine = match.range.endLineNumber;
+    });
+    return ( groupedMatches.map(sameLineMatches => {
+        return editorMatchToTextSearchResult(sameLineMatches, model, previewOptions);
+    }));
+}
+function addContextToEditorMatches(matches, model, query) {
+    const results = [];
+    let prevLine = -1;
+    for (let i = 0; i < matches.length; i++) {
+        const { start: matchStartLine, end: matchEndLine } = getMatchStartEnd(matches[i]);
+        if (typeof query.beforeContext === 'number' && query.beforeContext > 0) {
+            const beforeContextStartLine = Math.max(prevLine + 1, matchStartLine - query.beforeContext);
+            for (let b = beforeContextStartLine; b < matchStartLine; b++) {
+                results.push({
+                    text: model.getLineContent(b + 1),
+                    lineNumber: b
+                });
+            }
+        }
+        results.push(matches[i]);
+        const nextMatch = matches[i + 1];
+        const nextMatchStartLine = nextMatch ? getMatchStartEnd(nextMatch).start : Number.MAX_VALUE;
+        if (typeof query.afterContext === 'number' && query.afterContext > 0) {
+            const afterContextToLine = Math.min(nextMatchStartLine - 1, matchEndLine + query.afterContext, model.getLineCount() - 1);
+            for (let a = matchEndLine + 1; a <= afterContextToLine; a++) {
+                results.push({
+                    text: model.getLineContent(a + 1),
+                    lineNumber: a
+                });
+            }
+        }
+        prevLine = matchEndLine;
+    }
+    return results;
+}
+function getMatchStartEnd(match) {
+    const matchRanges = match.ranges;
+    const matchStartLine = Array.isArray(matchRanges) ? matchRanges[0].startLineNumber : matchRanges.startLineNumber;
+    const matchEndLine = Array.isArray(matchRanges) ? matchRanges[matchRanges.length - 1].endLineNumber : matchRanges.endLineNumber;
+    return {
+        start: matchStartLine,
+        end: matchEndLine
+    };
+}
+export { addContextToEditorMatches, editorMatchesToTextSearchResults };