@codingame/monaco-vscode-search-service-override 4.3.1 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-search-service-override",
-  "version": "4.3.1",
+  "version": "4.4.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,14 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.3.1"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.4.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./worker": {
+      "default": "./worker.js"
+    }
   }
 }

package/search.d.ts

@@ -1,5 +1,12 @@
 import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
 
-declare function getServiceOverride(): IEditorOverrideServices;
+interface SearchServiceOverrideProps {
+    /**
+     * Is an `HTMLFileSystemProvider` is used as only provider for the `file` scheme directly (without overlay)
+     * Enable this option to enable searching local filesystem
+     */
+    useHtmlFileSystemProvider: boolean;
+}
+declare function getServiceOverride({ useHtmlFileSystemProvider }: SearchServiceOverrideProps): IEditorOverrideServices;
 
 export { getServiceOverride as default };

package/search.js

@@ -5,12 +5,13 @@ import { ISearchViewModelWorkbenchService, SearchViewModelWorkbenchService } fro
 import { ISearchHistoryService, SearchHistoryService } from 'vscode/vscode/vs/workbench/contrib/search/common/searchHistoryService';
 import { IReplaceService } from 'vscode/vscode/vs/workbench/contrib/search/browser/replace';
 import { ReplaceService } from './vscode/src/vs/workbench/contrib/search/browser/replaceService.js';
+import { RemoteSearchService } from './vscode/src/vs/workbench/services/search/browser/searchService.js';
 import './vscode/src/vs/workbench/contrib/search/browser/search.contribution.js';
 import './vscode/src/vs/workbench/contrib/searchEditor/browser/searchEditor.contribution.js';
 
-function getServiceOverride() {
+function getServiceOverride({ useHtmlFileSystemProvider }) {
     return {
-        [( ISearchService.toString())]: new SyncDescriptor(SearchService, [], true),
+        [( ISearchService.toString())]: useHtmlFileSystemProvider ? new SyncDescriptor(RemoteSearchService, [], true) : new SyncDescriptor(SearchService, [], true),
         [( ISearchViewModelWorkbenchService.toString())]: new SyncDescriptor(SearchViewModelWorkbenchService, [], true),
         [( ISearchHistoryService.toString())]: new SyncDescriptor(SearchHistoryService, [], true),
         [( IReplaceService.toString())]: new SyncDescriptor(ReplaceService, [], true)

package/vscode/src/vs/workbench/services/search/browser/searchService.js

@@ -0,0 +1,185 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import 'vscode/vscode/vs/workbench/services/search/common/search';
+import { SearchService } from '../common/searchService.js';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { SimpleWorkerClient, logOnceWebWorkerWarning } from 'vscode/vscode/vs/base/common/worker/simpleWorker';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DefaultWorkerFactory } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
+import { memoize } from 'vscode/vscode/vs/base/common/decorators';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { WebFileSystemAccess } from 'vscode/vscode/vs/platform/files/browser/webFileSystemAccess';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { TextSearchCompleteMessageType } from 'vscode/vscode/vs/workbench/services/search/common/searchExtTypes';
+
+let RemoteSearchService = class RemoteSearchService extends SearchService {
+    constructor(modelService, editorService, telemetryService, logService, extensionService, fileService, instantiationService, uriIdentityService) {
+        super(modelService, editorService, telemetryService, logService, extensionService, fileService, uriIdentityService);
+        this.instantiationService = instantiationService;
+        const searchProvider = this.instantiationService.createInstance(LocalFileSearchWorkerClient);
+        this.registerSearchResultProvider(Schemas.file, 0 , searchProvider);
+        this.registerSearchResultProvider(Schemas.file, 1 , searchProvider);
+    }
+};
+RemoteSearchService = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IExtensionService)),
+    ( __param(5, IFileService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IUriIdentityService))
+], RemoteSearchService));
+let LocalFileSearchWorkerClient = class LocalFileSearchWorkerClient extends Disposable {
+    constructor(fileService, uriIdentityService) {
+        super();
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidReceiveTextSearchMatch = ( new Emitter());
+        this.onDidReceiveTextSearchMatch = this._onDidReceiveTextSearchMatch.event;
+        this.queryId = 0;
+        this._worker = null;
+        this._workerFactory = ( new DefaultWorkerFactory('localFileSearchWorker'));
+    }
+    sendTextSearchMatch(match, queryId) {
+        this._onDidReceiveTextSearchMatch.fire({ match, queryId });
+    }
+    get fileSystemProvider() {
+        return this.fileService.getProvider(Schemas.file);
+    }
+    async cancelQuery(queryId) {
+        const proxy = await this._getOrCreateWorker().getProxyObject();
+        proxy.cancelQuery(queryId);
+    }
+    async textSearch(query, onProgress, token) {
+        try {
+            const queryDisposables = ( new DisposableStore());
+            const proxy = await this._getOrCreateWorker().getProxyObject();
+            const results = [];
+            let limitHit = false;
+            await Promise.all(( query.folderQueries.map(async (fq) => {
+                const queryId = this.queryId++;
+                queryDisposables.add(token?.onCancellationRequested(e => this.cancelQuery(queryId)) || Disposable.None);
+                const handle = await this.fileSystemProvider.getHandle(fq.folder);
+                if (!handle || !WebFileSystemAccess.isFileSystemDirectoryHandle(handle)) {
+                    console.error('Could not get directory handle for ', fq);
+                    return;
+                }
+                const reviveMatch = (result) => ({
+                    resource: URI.revive(result.resource),
+                    results: revive(result.results)
+                });
+                queryDisposables.add(this.onDidReceiveTextSearchMatch(e => {
+                    if (e.queryId === queryId) {
+                        onProgress?.(reviveMatch(e.match));
+                    }
+                }));
+                const ignorePathCasing = this.uriIdentityService.extUri.ignorePathCasing(fq.folder);
+                const folderResults = await proxy.searchDirectory(handle, query, fq, ignorePathCasing, queryId);
+                for (const folderResult of folderResults.results) {
+                    results.push(revive(folderResult));
+                }
+                if (folderResults.limitHit) {
+                    limitHit = true;
+                }
+            })));
+            queryDisposables.dispose();
+            const result = { messages: [], results, limitHit };
+            return result;
+        }
+        catch (e) {
+            console.error('Error performing web worker text search', e);
+            return {
+                results: [],
+                messages: [{
+                        text: ( localizeWithPath(
+                            'vs/workbench/services/search/browser/searchService',
+                            'errorSearchText',
+                            "Unable to search with Web Worker text searcher"
+                        )), type: TextSearchCompleteMessageType.Warning
+                    }],
+            };
+        }
+    }
+    async fileSearch(query, token) {
+        try {
+            const queryDisposables = ( new DisposableStore());
+            let limitHit = false;
+            const proxy = await this._getOrCreateWorker().getProxyObject();
+            const results = [];
+            await Promise.all(( query.folderQueries.map(async (fq) => {
+                const queryId = this.queryId++;
+                queryDisposables.add(token?.onCancellationRequested(e => this.cancelQuery(queryId)) || Disposable.None);
+                const handle = await this.fileSystemProvider.getHandle(fq.folder);
+                if (!handle || !WebFileSystemAccess.isFileSystemDirectoryHandle(handle)) {
+                    console.error('Could not get directory handle for ', fq);
+                    return;
+                }
+                const caseSensitive = this.uriIdentityService.extUri.ignorePathCasing(fq.folder);
+                const folderResults = await proxy.listDirectory(handle, query, fq, caseSensitive, queryId);
+                for (const folderResult of folderResults.results) {
+                    results.push({ resource: URI.joinPath(fq.folder, folderResult) });
+                }
+                if (folderResults.limitHit) {
+                    limitHit = true;
+                }
+            })));
+            queryDisposables.dispose();
+            const result = { messages: [], results, limitHit };
+            return result;
+        }
+        catch (e) {
+            console.error('Error performing web worker file search', e);
+            return {
+                results: [],
+                messages: [{
+                        text: ( localizeWithPath(
+                            'vs/workbench/services/search/browser/searchService',
+                            'errorSearchFile',
+                            "Unable to search with Web Worker file searcher"
+                        )), type: TextSearchCompleteMessageType.Warning
+                    }],
+            };
+        }
+    }
+    async clearCache(cacheKey) {
+        if (this.cache?.key === cacheKey) {
+            this.cache = undefined;
+        }
+    }
+    _getOrCreateWorker() {
+        if (!this._worker) {
+            try {
+                this._worker = this._register(( new SimpleWorkerClient(
+                    this._workerFactory,
+                    'vs/workbench/services/search/worker/localFileSearch',
+                    this
+                )));
+            }
+            catch (err) {
+                logOnceWebWorkerWarning(err);
+                throw err;
+            }
+        }
+        return this._worker;
+    }
+};
+LocalFileSearchWorkerClient.__decorator = ( __decorate([
+    memoize
+], LocalFileSearchWorkerClient.prototype, "fileSystemProvider", null));
+LocalFileSearchWorkerClient = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUriIdentityService))
+], LocalFileSearchWorkerClient));
+
+export { LocalFileSearchWorkerClient, RemoteSearchService };

package/vscode/src/vs/workbench/services/search/common/getFileResults.js

@@ -0,0 +1,103 @@
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+
+const getFileResults = (bytes, pattern, options) => {
+    let text;
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) {
+        text = ( new TextDecoder('utf-16le')).decode(bytes);
+    }
+    else if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+        text = ( new TextDecoder('utf-16be')).decode(bytes);
+    }
+    else {
+        text = ( new TextDecoder('utf8')).decode(bytes);
+        if (text.slice(0, 1000).includes('\uFFFD') && bytes.includes(0)) {
+            return [];
+        }
+    }
+    const results = [];
+    const patternIndecies = [];
+    let patternMatch = null;
+    let remainingResultQuota = options.remainingResultQuota;
+    while (remainingResultQuota >= 0 && (patternMatch = pattern.exec(text))) {
+        patternIndecies.push({ matchStartIndex: patternMatch.index, matchedText: patternMatch[0] });
+        remainingResultQuota--;
+    }
+    if (patternIndecies.length) {
+        const contextLinesNeeded = ( new Set());
+        const resultLines = ( new Set());
+        const lineRanges = [];
+        const readLine = (lineNumber) => text.slice(lineRanges[lineNumber].start, lineRanges[lineNumber].end);
+        let prevLineEnd = 0;
+        let lineEndingMatch = null;
+        const lineEndRegex = /\r?\n/g;
+        while ((lineEndingMatch = lineEndRegex.exec(text))) {
+            lineRanges.push({ start: prevLineEnd, end: lineEndingMatch.index });
+            prevLineEnd = lineEndingMatch.index + lineEndingMatch[0].length;
+        }
+        if (prevLineEnd < text.length) {
+            lineRanges.push({ start: prevLineEnd, end: text.length });
+        }
+        let startLine = 0;
+        for (const { matchStartIndex, matchedText } of patternIndecies) {
+            if (remainingResultQuota < 0) {
+                break;
+            }
+            while (Boolean(lineRanges[startLine + 1]) && matchStartIndex > lineRanges[startLine].end) {
+                startLine++;
+            }
+            let endLine = startLine;
+            while (Boolean(lineRanges[endLine + 1]) && matchStartIndex + matchedText.length > lineRanges[endLine].end) {
+                endLine++;
+            }
+            if (options.beforeContext) {
+                for (let contextLine = Math.max(0, startLine - options.beforeContext); contextLine < startLine; contextLine++) {
+                    contextLinesNeeded.add(contextLine);
+                }
+            }
+            let previewText = '';
+            let offset = 0;
+            for (let matchLine = startLine; matchLine <= endLine; matchLine++) {
+                let previewLine = readLine(matchLine);
+                if (options.previewOptions?.charsPerLine && previewLine.length > options.previewOptions.charsPerLine) {
+                    offset = Math.max(matchStartIndex - lineRanges[startLine].start - 20, 0);
+                    previewLine = previewLine.substr(offset, options.previewOptions.charsPerLine);
+                }
+                previewText += `${previewLine}\n`;
+                resultLines.add(matchLine);
+            }
+            const fileRange = ( new Range(
+                startLine,
+                matchStartIndex - lineRanges[startLine].start,
+                endLine,
+                matchStartIndex + matchedText.length - lineRanges[endLine].start
+            ));
+            const previewRange = ( new Range(
+                0,
+                matchStartIndex - lineRanges[startLine].start - offset,
+                endLine - startLine,
+                matchStartIndex + matchedText.length - lineRanges[endLine].start - (endLine === startLine ? offset : 0)
+            ));
+            const match = {
+                ranges: fileRange,
+                preview: { text: previewText, matches: previewRange },
+            };
+            results.push(match);
+            if (options.afterContext) {
+                for (let contextLine = endLine + 1; contextLine <= Math.min(endLine + options.afterContext, lineRanges.length - 1); contextLine++) {
+                    contextLinesNeeded.add(contextLine);
+                }
+            }
+        }
+        for (const contextLine of contextLinesNeeded) {
+            if (!( resultLines.has(contextLine))) {
+                results.push({
+                    text: readLine(contextLine),
+                    lineNumber: contextLine + 1,
+                });
+            }
+        }
+    }
+    return results;
+};
+
+export { getFileResults };

package/vscode/src/vs/workbench/services/search/worker/localFileSearch.js

@@ -0,0 +1,262 @@
+import { parse, match } from 'vscode/vscode/vs/base/common/glob';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { relative } from 'vscode/vscode/vs/base/common/path';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { getFileResults } from '../common/getFileResults.js';
+import { IgnoreFile } from 'vscode/vscode/vs/workbench/services/search/common/ignoreFile';
+import { createRegExp } from 'vscode/vscode/vs/base/common/strings';
+import { Promises } from 'vscode/vscode/vs/base/common/async';
+import { ExtUri } from 'vscode/vscode/vs/base/common/resources';
+
+const time = async (name, task) => {
+    {
+        return task();
+    }
+};
+function create(host) {
+    return ( new LocalFileSearchSimpleWorker(host));
+}
+class LocalFileSearchSimpleWorker {
+    constructor(host) {
+        this.host = host;
+        this.cancellationTokens = ( new Map());
+    }
+    cancelQuery(queryId) {
+        this.cancellationTokens.get(queryId)?.cancel();
+    }
+    registerCancellationToken(queryId) {
+        const source = ( new CancellationTokenSource());
+        this.cancellationTokens.set(queryId, source);
+        return source;
+    }
+    async listDirectory(handle, query, folderQuery, ignorePathCasing, queryId) {
+        const revivedFolderQuery = reviveFolderQuery(folderQuery);
+        const extUri = ( new ExtUri(() => ignorePathCasing));
+        const token = this.registerCancellationToken(queryId);
+        const entries = [];
+        let limitHit = false;
+        let count = 0;
+        const max = query.maxResults || 512;
+        const filePatternMatcher = query.filePattern
+            ? (name) => query.filePattern.split('').every(c => name.includes(c))
+            : (name) => true;
+        await time('listDirectory', () => this.walkFolderQuery(handle, reviveQueryProps(query), revivedFolderQuery, extUri, file => {
+            if (!filePatternMatcher(file.name)) {
+                return;
+            }
+            count++;
+            if (max && count > max) {
+                limitHit = true;
+                token.cancel();
+            }
+            return entries.push(file.path);
+        }, token.token));
+        return {
+            results: entries,
+            limitHit
+        };
+    }
+    async searchDirectory(handle, query, folderQuery, ignorePathCasing, queryId) {
+        const revivedQuery = reviveFolderQuery(folderQuery);
+        const extUri = ( new ExtUri(() => ignorePathCasing));
+        return time('searchInFiles', async () => {
+            const token = this.registerCancellationToken(queryId);
+            const results = [];
+            const pattern = createSearchRegExp(query.contentPattern);
+            const onGoingProcesses = [];
+            let resultCount = 0;
+            const limitHit = false;
+            const processFile = async (file) => {
+                if (token.token.isCancellationRequested) {
+                    return;
+                }
+                const contents = await file.resolve();
+                if (token.token.isCancellationRequested) {
+                    return;
+                }
+                const bytes = ( new Uint8Array(contents));
+                const fileResults = getFileResults(bytes, pattern, {
+                    afterContext: query.afterContext ?? 0,
+                    beforeContext: query.beforeContext ?? 0,
+                    previewOptions: query.previewOptions,
+                    remainingResultQuota: query.maxResults ? (query.maxResults - resultCount) : 10000,
+                });
+                if (fileResults.length) {
+                    resultCount += fileResults.length;
+                    if (query.maxResults && resultCount > query.maxResults) {
+                        token.cancel();
+                    }
+                    const match = {
+                        resource: URI.joinPath(revivedQuery.folder, file.path),
+                        results: fileResults,
+                    };
+                    this.host.sendTextSearchMatch(match, queryId);
+                    results.push(match);
+                }
+            };
+            await time('walkFolderToResolve', () => this.walkFolderQuery(handle, reviveQueryProps(query), revivedQuery, extUri, async (file) => onGoingProcesses.push(processFile(file)), token.token));
+            await time('resolveOngoingProcesses', () => Promise.all(onGoingProcesses));
+            return {
+                results,
+                limitHit,
+            };
+        });
+    }
+    async walkFolderQuery(handle, queryProps, folderQuery, extUri, onFile, token) {
+        const folderExcludes = parse(folderQuery.excludePattern ?? {}, { trimForExclusions: true });
+        const isFolderExcluded = (path, basename, hasSibling) => {
+            path = path.slice(1);
+            if (folderExcludes(path, basename, hasSibling)) {
+                return true;
+            }
+            if (pathExcludedInQuery(queryProps, path)) {
+                return true;
+            }
+            return false;
+        };
+        const isFileIncluded = (path, basename, hasSibling) => {
+            path = path.slice(1);
+            if (folderExcludes(path, basename, hasSibling)) {
+                return false;
+            }
+            if (!pathIncludedInQuery(queryProps, path, extUri)) {
+                return false;
+            }
+            return true;
+        };
+        const processFile = (file, prior) => {
+            const resolved = {
+                type: 'file',
+                name: file.name,
+                path: prior,
+                resolve: () => file.getFile().then(r => r.arrayBuffer())
+            };
+            return resolved;
+        };
+        const isFileSystemDirectoryHandle = (handle) => {
+            return handle.kind === 'directory';
+        };
+        const isFileSystemFileHandle = (handle) => {
+            return handle.kind === 'file';
+        };
+        const processDirectory = async (directory, prior, ignoreFile) => {
+            if (!folderQuery.disregardIgnoreFiles) {
+                const ignoreFiles = await Promise.all([
+                    directory.getFileHandle('.gitignore').catch(e => undefined),
+                    directory.getFileHandle('.ignore').catch(e => undefined),
+                ]);
+                await Promise.all(( ignoreFiles.map(async (file) => {
+                    if (!file) {
+                        return;
+                    }
+                    const ignoreContents = ( new TextDecoder('utf8')).decode(( new Uint8Array(await (await file.getFile()).arrayBuffer())));
+                    ignoreFile = ( new IgnoreFile(ignoreContents, prior, ignoreFile));
+                })));
+            }
+            const entries = Promises.withAsyncBody(async (c) => {
+                const files = [];
+                const dirs = [];
+                const entries = [];
+                const sibilings = ( new Set());
+                for await (const entry of directory.entries()) {
+                    entries.push(entry);
+                    sibilings.add(entry[0]);
+                }
+                for (const [basename, handle] of entries) {
+                    if (token.isCancellationRequested) {
+                        break;
+                    }
+                    const path = prior + basename;
+                    if (ignoreFile && !ignoreFile.isPathIncludedInTraversal(path, handle.kind === 'directory')) {
+                        continue;
+                    }
+                    const hasSibling = (query) => ( sibilings.has(query));
+                    if (isFileSystemDirectoryHandle(handle) && !isFolderExcluded(path, basename, hasSibling)) {
+                        dirs.push(processDirectory(handle, path + '/', ignoreFile));
+                    }
+                    else if (isFileSystemFileHandle(handle) && isFileIncluded(path, basename, hasSibling)) {
+                        files.push(processFile(handle, path));
+                    }
+                }
+                c([...(await Promise.all(dirs)), ...files]);
+            });
+            return {
+                type: 'dir',
+                name: directory.name,
+                entries
+            };
+        };
+        const resolveDirectory = async (directory, onFile) => {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            await Promise.all(( (await directory.entries)
+                .sort((a, b) => -(a.type === 'dir' ? 0 : 1) + (b.type === 'dir' ? 0 : 1))
+                .map(async (entry) => {
+                if (entry.type === 'dir') {
+                    return resolveDirectory(entry, onFile);
+                }
+                else {
+                    return onFile(entry);
+                }
+            })));
+        };
+        const processed = await time('process', () => processDirectory(handle, '/'));
+        await time('resolve', () => resolveDirectory(processed, onFile));
+    }
+}
+function createSearchRegExp(options) {
+    return createRegExp(options.pattern, !!options.isRegExp, {
+        wholeWord: options.isWordMatch,
+        global: true,
+        matchCase: options.isCaseSensitive,
+        multiline: true,
+        unicode: true,
+    });
+}
+function reviveFolderQuery(folderQuery) {
+    return {
+        ...folderQuery,
+        folder: URI.revive(folderQuery.folder),
+    };
+}
+function reviveQueryProps(queryProps) {
+    return {
+        ...queryProps,
+        extraFileResources: queryProps.extraFileResources?.map(r => URI.revive(r)),
+        folderQueries: ( queryProps.folderQueries.map(fq => reviveFolderQuery(fq))),
+    };
+}
+function pathExcludedInQuery(queryProps, fsPath) {
+    if (queryProps.excludePattern && match(queryProps.excludePattern, fsPath)) {
+        return true;
+    }
+    return false;
+}
+function pathIncludedInQuery(queryProps, path, extUri) {
+    if (queryProps.excludePattern && match(queryProps.excludePattern, path)) {
+        return false;
+    }
+    if (queryProps.includePattern || queryProps.usingSearchPaths) {
+        if (queryProps.includePattern && match(queryProps.includePattern, path)) {
+            return true;
+        }
+        if (queryProps.usingSearchPaths) {
+            return !!queryProps.folderQueries && ( queryProps.folderQueries.some(fq => {
+                const searchPath = fq.folder;
+                const uri = URI.file(path);
+                if (extUri.isEqualOrParent(uri, searchPath)) {
+                    const relPath = relative(searchPath.path, uri.path);
+                    return !fq.includePattern || !!match(fq.includePattern, relPath);
+                }
+                else {
+                    return false;
+                }
+            }));
+        }
+        return false;
+    }
+    return true;
+}
+
+export { LocalFileSearchSimpleWorker, create };

package/worker.js

@@ -0,0 +1 @@
+import './workers/localFileSearch.worker.js';

package/workers/localFileSearch.worker.js

@@ -0,0 +1,9 @@
+import { create } from '../vscode/src/vs/workbench/services/search/worker/localFileSearch.js';
+import { SimpleWorkerServer } from 'vscode/vscode/vs/base/common/worker/simpleWorker';
+
+const simpleWorker = new SimpleWorkerServer((msg) => {
+    globalThis.postMessage(msg);
+}, create);
+globalThis.onmessage = (e) => {
+    simpleWorker.onmessage(e.data);
+};