@codingame/monaco-vscode-search-service-override 5.3.0 → 6.0.0

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

@@ -1,764 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import './media/anythingQuickAccess.css.js';
-import { QuickPickItemScorerAccessor, QuickInputHideReason, quickPickItemScorerAccessor } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
-import { PickerQuickAccessProvider, TriggerAction } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
-import { prepareQuery, compareItemsByFuzzyScore, scoreItemFuzzy } from 'vscode/vscode/vs/base/common/fuzzyScorer';
-import { QueryBuilder } from 'vscode/vscode/vs/workbench/services/search/common/queryBuilder';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { extractRangeFromFilter, getOutOfWorkspaceEditorResources } from 'vscode/vscode/vs/workbench/contrib/search/common/search';
-import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search.service';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { untildify } from 'vscode/vscode/vs/base/common/labels';
-import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { toLocalResource, basenameOrAuthority, dirname } from 'vscode/vscode/vs/base/common/resources';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { Disposable, DisposableStore, MutableDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
-import { getIconClasses } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { isEditorInput, EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
-import { SIDE_GROUP, ACTIVE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { ThrottledDelayer } from 'vscode/vscode/vs/base/common/async';
-import { top } from 'vscode/vscode/vs/base/common/arrays';
-import { FileQueryCacheState } from '../common/cacheState.js';
-import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/common/history.service';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { SymbolsQuickAccessProvider } from './symbolsQuickAccess.js';
-import { DefaultQuickAccessFilterValue, Extensions } from 'vscode/vscode/vs/platform/quickinput/common/quickAccess';
-import { PickerEditorState } from 'vscode/vscode/vs/workbench/browser/quickaccess';
-import { GotoSymbolQuickAccessProvider } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { ASK_QUICK_QUESTION_ACTION_ID } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions';
-import { IQuickChatService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { ICustomEditorLabelService } from 'vscode/vscode/vs/workbench/services/editor/common/customEditorLabelService.service';
-
-var AnythingQuickAccessProvider_1;
-const _moduleId = "vs/workbench/contrib/search/browser/anythingQuickAccess";
-function isEditorSymbolQuickPickItem(pick) {
-    const candidate = pick;
-    return !!candidate?.range && !!candidate.resource;
-}
-let AnythingQuickAccessProvider = class AnythingQuickAccessProvider extends PickerQuickAccessProvider {
-    static { AnythingQuickAccessProvider_1 = this; }
-    static { this.PREFIX = ''; }
-    static { this.NO_RESULTS_PICK = {
-        label: ( localizeWithPath(_moduleId, 0, "No matching results"))
-    }; }
-    static { this.MAX_RESULTS = 512; }
-    static { this.TYPING_SEARCH_DELAY = 200; }
-    static { this.SYMBOL_PICKS_MERGE_DELAY = 200; }
-    get defaultFilterValue() {
-        if (this.configuration.preserveInput) {
-            return DefaultQuickAccessFilterValue.LAST;
-        }
-        return undefined;
-    }
-    constructor(instantiationService, searchService, contextService, pathService, environmentService, fileService, labelService, modelService, languageService, workingCopyService, configurationService, editorService, historyService, filesConfigurationService, textModelService, uriIdentityService, quickInputService, keybindingService, quickChatService, logService, customEditorLabelService) {
-        super(AnythingQuickAccessProvider_1.PREFIX, {
-            canAcceptInBackground: true,
-            noResultsPick: AnythingQuickAccessProvider_1.NO_RESULTS_PICK
-        });
-        this.instantiationService = instantiationService;
-        this.searchService = searchService;
-        this.contextService = contextService;
-        this.pathService = pathService;
-        this.environmentService = environmentService;
-        this.fileService = fileService;
-        this.labelService = labelService;
-        this.modelService = modelService;
-        this.languageService = languageService;
-        this.workingCopyService = workingCopyService;
-        this.configurationService = configurationService;
-        this.editorService = editorService;
-        this.historyService = historyService;
-        this.filesConfigurationService = filesConfigurationService;
-        this.textModelService = textModelService;
-        this.uriIdentityService = uriIdentityService;
-        this.quickInputService = quickInputService;
-        this.keybindingService = keybindingService;
-        this.quickChatService = quickChatService;
-        this.logService = logService;
-        this.customEditorLabelService = customEditorLabelService;
-        this.pickState = this._register(new (class extends Disposable {
-            constructor(provider, instantiationService) {
-                super();
-                this.provider = provider;
-                this.instantiationService = instantiationService;
-                this.picker = undefined;
-                this.editorViewState = this._register(this.instantiationService.createInstance(PickerEditorState));
-                this.scorerCache = Object.create(null);
-                this.fileQueryCache = undefined;
-                this.lastOriginalFilter = undefined;
-                this.lastFilter = undefined;
-                this.lastRange = undefined;
-                this.lastGlobalPicks = undefined;
-                this.isQuickNavigating = undefined;
-            }
-            set(picker) {
-                this.picker = picker;
-                Event.once(picker.onDispose)(() => {
-                    if (picker === this.picker) {
-                        this.picker = undefined;
-                    }
-                });
-                const isQuickNavigating = !!picker.quickNavigate;
-                if (!isQuickNavigating) {
-                    this.fileQueryCache = this.provider.createFileQueryCache();
-                    this.scorerCache = Object.create(null);
-                }
-                this.isQuickNavigating = isQuickNavigating;
-                this.lastOriginalFilter = undefined;
-                this.lastFilter = undefined;
-                this.lastRange = undefined;
-                this.lastGlobalPicks = undefined;
-                this.editorViewState.reset();
-            }
-        })(this, this.instantiationService));
-        this.labelOnlyEditorHistoryPickAccessor = ( (new QuickPickItemScorerAccessor({ skipDescription: true })));
-        this.fileQueryDelayer = this._register(( (new ThrottledDelayer(AnythingQuickAccessProvider_1.TYPING_SEARCH_DELAY))));
-        this.fileQueryBuilder = this.instantiationService.createInstance(QueryBuilder);
-        this.lazyRegistry = ( (new Lazy(() => ( (Registry.as(Extensions.Quickaccess))))));
-        this.workspaceSymbolsQuickAccess = this._register(this.instantiationService.createInstance(SymbolsQuickAccessProvider));
-        this.editorSymbolsQuickAccess = this.instantiationService.createInstance(GotoSymbolQuickAccessProvider);
-    }
-    get configuration() {
-        const editorConfig = this.configurationService.getValue().workbench?.editor;
-        const searchConfig = this.configurationService.getValue().search;
-        const quickAccessConfig = this.configurationService.getValue().workbench.quickOpen;
-        return {
-            openEditorPinned: !editorConfig?.enablePreviewFromQuickOpen || !editorConfig?.enablePreview,
-            openSideBySideDirection: editorConfig?.openSideBySideDirection,
-            includeSymbols: searchConfig?.quickOpen.includeSymbols,
-            includeHistory: searchConfig?.quickOpen.includeHistory,
-            historyFilterSortOrder: searchConfig?.quickOpen.history.filterSortOrder,
-            preserveInput: quickAccessConfig.preserveInput
-        };
-    }
-    provide(picker, token, runOptions) {
-        const disposables = ( (new DisposableStore()));
-        this.pickState.set(picker);
-        const editorDecorationsDisposable = disposables.add(( (new MutableDisposable())));
-        disposables.add(picker.onDidChangeActive(() => {
-            editorDecorationsDisposable.value = undefined;
-            const [item] = picker.activeItems;
-            if (isEditorSymbolQuickPickItem(item)) {
-                editorDecorationsDisposable.value = this.decorateAndRevealSymbolRange(item);
-            }
-        }));
-        disposables.add(Event.once(picker.onDidHide)(({ reason }) => {
-            if (reason === QuickInputHideReason.Gesture) {
-                this.pickState.editorViewState.restore();
-            }
-        }));
-        disposables.add(super.provide(picker, token, runOptions));
-        return disposables;
-    }
-    decorateAndRevealSymbolRange(pick) {
-        const activeEditor = this.editorService.activeEditor;
-        if (!this.uriIdentityService.extUri.isEqual(pick.resource, activeEditor?.resource)) {
-            return Disposable.None;
-        }
-        const activeEditorControl = this.editorService.activeTextEditorControl;
-        if (!activeEditorControl) {
-            return Disposable.None;
-        }
-        this.pickState.editorViewState.set();
-        activeEditorControl.revealRangeInCenter(pick.range.selection, 0 );
-        this.addDecorations(activeEditorControl, pick.range.decoration);
-        return toDisposable(() => this.clearDecorations(activeEditorControl));
-    }
-    _getPicks(originalFilter, disposables, token, runOptions) {
-        const filterWithRange = extractRangeFromFilter(originalFilter, [GotoSymbolQuickAccessProvider.PREFIX]);
-        let filter;
-        if (filterWithRange) {
-            filter = filterWithRange.filter;
-        }
-        else {
-            filter = originalFilter;
-        }
-        this.pickState.lastRange = filterWithRange?.range;
-        if (originalFilter !== this.pickState.lastOriginalFilter && filter === this.pickState.lastFilter) {
-            return null;
-        }
-        const lastWasFiltering = !!this.pickState.lastOriginalFilter;
-        this.pickState.lastOriginalFilter = originalFilter;
-        this.pickState.lastFilter = filter;
-        const picks = this.pickState.picker?.items;
-        const activePick = this.pickState.picker?.activeItems[0];
-        if (picks && activePick) {
-            const activePickIsEditorSymbol = isEditorSymbolQuickPickItem(activePick);
-            const activePickIsNoResultsInEditorSymbols = activePick === AnythingQuickAccessProvider_1.NO_RESULTS_PICK && filter.indexOf(GotoSymbolQuickAccessProvider.PREFIX) >= 0;
-            if (!activePickIsEditorSymbol && !activePickIsNoResultsInEditorSymbols) {
-                this.pickState.lastGlobalPicks = {
-                    items: picks,
-                    active: activePick
-                };
-            }
-        }
-        return this.doGetPicks(filter, {
-            ...runOptions,
-            enableEditorSymbolSearch: lastWasFiltering
-        }, disposables, token);
-    }
-    doGetPicks(filter, options, disposables, token) {
-        const query = prepareQuery(filter);
-        if (options.enableEditorSymbolSearch) {
-            const editorSymbolPicks = this.getEditorSymbolPicks(query, disposables, token);
-            if (editorSymbolPicks) {
-                return editorSymbolPicks;
-            }
-        }
-        const activePick = this.pickState.picker?.activeItems[0];
-        if (isEditorSymbolQuickPickItem(activePick) && this.pickState.lastGlobalPicks) {
-            return this.pickState.lastGlobalPicks;
-        }
-        const historyEditorPicks = this.getEditorHistoryPicks(query);
-        let picks = ( (new Array()));
-        if (options.additionPicks) {
-            picks.push(...options.additionPicks);
-        }
-        if (this.pickState.isQuickNavigating) {
-            if (picks.length > 0) {
-                picks.push({ type: 'separator', label: ( localizeWithPath(_moduleId, 1, "recently opened")) });
-            }
-            picks = historyEditorPicks;
-        }
-        else {
-            if (options.includeHelp) {
-                picks.push(...this.getHelpPicks(query, token, options));
-            }
-            if (historyEditorPicks.length !== 0) {
-                picks.push({ type: 'separator', label: ( localizeWithPath(_moduleId, 1, "recently opened")) });
-                picks.push(...historyEditorPicks);
-            }
-        }
-        return {
-            picks,
-            additionalPicks: (async () => {
-                const additionalPicksExcludes = ( (new ResourceMap()));
-                for (const historyEditorPick of historyEditorPicks) {
-                    if (historyEditorPick.resource) {
-                        additionalPicksExcludes.set(historyEditorPick.resource, true);
-                    }
-                }
-                const additionalPicks = await this.getAdditionalPicks(query, additionalPicksExcludes, token);
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                return additionalPicks.length > 0 ? [
-                    { type: 'separator', label: this.configuration.includeSymbols ? ( localizeWithPath(_moduleId, 2, "file and symbol results")) : ( localizeWithPath(_moduleId, 3, "file results")) },
-                    ...additionalPicks
-                ] : [];
-            })(),
-            mergeDelay: AnythingQuickAccessProvider_1.SYMBOL_PICKS_MERGE_DELAY
-        };
-    }
-    async getAdditionalPicks(query, excludes, token) {
-        const [filePicks, symbolPicks] = await Promise.all([
-            this.getFilePicks(query, excludes, token),
-            this.getWorkspaceSymbolPicks(query, token)
-        ]);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const sortedAnythingPicks = top([...filePicks, ...symbolPicks], (anyPickA, anyPickB) => compareItemsByFuzzyScore(anyPickA, anyPickB, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache), AnythingQuickAccessProvider_1.MAX_RESULTS);
-        const filteredAnythingPicks = [];
-        for (const anythingPick of sortedAnythingPicks) {
-            if (anythingPick.highlights) {
-                filteredAnythingPicks.push(anythingPick);
-            }
-            else {
-                const { score, labelMatch, descriptionMatch } = scoreItemFuzzy(anythingPick, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache);
-                if (!score) {
-                    continue;
-                }
-                anythingPick.highlights = {
-                    label: labelMatch,
-                    description: descriptionMatch
-                };
-                filteredAnythingPicks.push(anythingPick);
-            }
-        }
-        return filteredAnythingPicks;
-    }
-    getEditorHistoryPicks(query) {
-        const configuration = this.configuration;
-        if (!query.normalized) {
-            return (
-                 (this.historyService.getHistory().map(editor => this.createAnythingPick(editor, configuration)))
-            );
-        }
-        if (!this.configuration.includeHistory) {
-            return [];
-        }
-        const editorHistoryScorerAccessor = query.containsPathSeparator ? quickPickItemScorerAccessor : this.labelOnlyEditorHistoryPickAccessor;
-        const editorHistoryPicks = [];
-        for (const editor of this.historyService.getHistory()) {
-            const resource = editor.resource;
-            if (!resource || (!this.fileService.hasProvider(resource) && resource.scheme !== Schemas.untitled && resource.scheme !== Schemas.vscodeTerminal)) {
-                continue;
-            }
-            const editorHistoryPick = this.createAnythingPick(editor, configuration);
-            const { score, labelMatch, descriptionMatch } = scoreItemFuzzy(editorHistoryPick, query, false, editorHistoryScorerAccessor, this.pickState.scorerCache);
-            if (!score) {
-                continue;
-            }
-            editorHistoryPick.highlights = {
-                label: labelMatch,
-                description: descriptionMatch
-            };
-            editorHistoryPicks.push(editorHistoryPick);
-        }
-        if (this.configuration.historyFilterSortOrder === 'recency') {
-            return editorHistoryPicks;
-        }
-        return editorHistoryPicks.sort((editorA, editorB) => compareItemsByFuzzyScore(editorA, editorB, query, false, editorHistoryScorerAccessor, this.pickState.scorerCache));
-    }
-    createFileQueryCache() {
-        return ( (new FileQueryCacheState(
-            cacheKey => this.fileQueryBuilder.file(this.contextService.getWorkspace().folders, this.getFileQueryOptions({ cacheKey })),
-            query => this.searchService.fileSearch(query),
-            cacheKey => this.searchService.clearCache(cacheKey),
-            this.pickState.fileQueryCache
-        ))).load();
-    }
-    async getFilePicks(query, excludes, token) {
-        if (!query.normalized) {
-            return [];
-        }
-        const absolutePathResult = await this.getAbsolutePathFileResult(query, token);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        let fileMatches;
-        if (absolutePathResult) {
-            if (( (excludes.has(absolutePathResult)))) {
-                return [];
-            }
-            const absolutePathPick = this.createAnythingPick(absolutePathResult, this.configuration);
-            absolutePathPick.highlights = {
-                label: [{ start: 0, end: absolutePathPick.label.length }],
-                description: absolutePathPick.description ? [{ start: 0, end: absolutePathPick.description.length }] : undefined
-            };
-            return [absolutePathPick];
-        }
-        if (this.pickState.fileQueryCache?.isLoaded) {
-            fileMatches = await this.doFileSearch(query, token);
-        }
-        else {
-            fileMatches = await this.fileQueryDelayer.trigger(async () => {
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                return this.doFileSearch(query, token);
-            });
-        }
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const configuration = this.configuration;
-        return (
-             (fileMatches
-                .filter(resource => !( (excludes.has(resource))))
-                .map(resource => this.createAnythingPick(resource, configuration)))
-        );
-    }
-    async doFileSearch(query, token) {
-        const [fileSearchResults, relativePathFileResults] = await Promise.all([
-            this.getFileSearchResults(query, token),
-            this.getRelativePathFileResults(query, token)
-        ]);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        if (!relativePathFileResults) {
-            return fileSearchResults;
-        }
-        const relativePathFileResultsMap = ( (new ResourceMap()));
-        for (const relativePathFileResult of relativePathFileResults) {
-            relativePathFileResultsMap.set(relativePathFileResult, true);
-        }
-        return [
-            ...fileSearchResults.filter(result => !( (relativePathFileResultsMap.has(result)))),
-            ...relativePathFileResults
-        ];
-    }
-    async getFileSearchResults(query, token) {
-        let filePattern = '';
-        if (query.values && query.values.length > 1) {
-            filePattern = query.values[0].original;
-        }
-        else {
-            filePattern = query.original;
-        }
-        const fileSearchResults = await this.doGetFileSearchResults(filePattern, token);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        if (fileSearchResults.limitHit && query.values && query.values.length > 1) {
-            const additionalFileSearchResults = await this.doGetFileSearchResults(query.original, token);
-            if (token.isCancellationRequested) {
-                return [];
-            }
-            const existingFileSearchResultsMap = ( (new ResourceMap()));
-            for (const fileSearchResult of fileSearchResults.results) {
-                existingFileSearchResultsMap.set(fileSearchResult.resource, true);
-            }
-            for (const additionalFileSearchResult of additionalFileSearchResults.results) {
-                if (!( (existingFileSearchResultsMap.has(additionalFileSearchResult.resource)))) {
-                    fileSearchResults.results.push(additionalFileSearchResult);
-                }
-            }
-        }
-        return (
-             (fileSearchResults.results.map(result => result.resource))
-        );
-    }
-    doGetFileSearchResults(filePattern, token) {
-        const start = Date.now();
-        return this.searchService.fileSearch(this.fileQueryBuilder.file(this.contextService.getWorkspace().folders, this.getFileQueryOptions({
-            filePattern,
-            cacheKey: this.pickState.fileQueryCache?.cacheKey,
-            maxResults: AnythingQuickAccessProvider_1.MAX_RESULTS
-        })), token).finally(() => {
-            this.logService.trace(`QuickAccess fileSearch ${Date.now() - start}ms`);
-        });
-    }
-    getFileQueryOptions(input) {
-        return {
-            _reason: 'openFileHandler',
-            extraFileResources: this.instantiationService.invokeFunction(getOutOfWorkspaceEditorResources),
-            filePattern: input.filePattern || '',
-            cacheKey: input.cacheKey,
-            maxResults: input.maxResults || 0,
-            sortByScore: true
-        };
-    }
-    async getAbsolutePathFileResult(query, token) {
-        if (!query.containsPathSeparator) {
-            return;
-        }
-        const userHome = await this.pathService.userHome();
-        const detildifiedQuery = untildify(query.original, userHome.scheme === Schemas.file ? userHome.fsPath : userHome.path);
-        if (token.isCancellationRequested) {
-            return;
-        }
-        const isAbsolutePathQuery = (await this.pathService.path).isAbsolute(detildifiedQuery);
-        if (token.isCancellationRequested) {
-            return;
-        }
-        if (isAbsolutePathQuery) {
-            const resource = toLocalResource(await this.pathService.fileURI(detildifiedQuery), this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
-            if (token.isCancellationRequested) {
-                return;
-            }
-            try {
-                if ((await this.fileService.stat(resource)).isFile) {
-                    return resource;
-                }
-            }
-            catch (error) {
-            }
-        }
-        return;
-    }
-    async getRelativePathFileResults(query, token) {
-        if (!query.containsPathSeparator) {
-            return;
-        }
-        const isAbsolutePathQuery = (await this.pathService.path).isAbsolute(query.original);
-        if (!isAbsolutePathQuery) {
-            const resources = [];
-            for (const folder of this.contextService.getWorkspace().folders) {
-                if (token.isCancellationRequested) {
-                    break;
-                }
-                const resource = toLocalResource(folder.toResource(query.original), this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
-                try {
-                    if ((await this.fileService.stat(resource)).isFile) {
-                        resources.push(resource);
-                    }
-                }
-                catch (error) {
-                }
-            }
-            return resources;
-        }
-        return;
-    }
-    getHelpPicks(query, token, runOptions) {
-        if (query.normalized) {
-            return [];
-        }
-        const providers = this.lazyRegistry.value.getQuickAccessProviders()
-            .filter(p => ( (p.helpEntries.some(h => h.commandCenterOrder !== undefined))))
-            .flatMap(provider => ( (provider.helpEntries
-            .filter(h => h.commandCenterOrder !== undefined)
-            .map(helpEntry => {
-            const providerSpecificOptions = {
-                ...runOptions,
-                includeHelp: provider.prefix === AnythingQuickAccessProvider_1.PREFIX ? false : runOptions?.includeHelp
-            };
-            const label = helpEntry.commandCenterLabel ?? helpEntry.description;
-            return {
-                label,
-                description: helpEntry.prefix ?? provider.prefix,
-                commandCenterOrder: helpEntry.commandCenterOrder,
-                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
-                ariaLabel: ( localizeWithPath(_moduleId, 4, "{0}, {1}", label, helpEntry.description)),
-                accept: () => {
-                    this.quickInputService.quickAccess.show(provider.prefix, {
-                        preserveValue: true,
-                        providerOptions: providerSpecificOptions
-                    });
-                }
-            };
-        }))));
-        if (this.quickChatService.enabled) {
-            providers.push({
-                label: ( localizeWithPath(_moduleId, 5, "Open Quick Chat")),
-                commandCenterOrder: 30,
-                keybinding: this.keybindingService.lookupKeybinding(ASK_QUICK_QUESTION_ACTION_ID),
-                accept: () => this.quickChatService.toggle()
-            });
-        }
-        return providers.sort((a, b) => a.commandCenterOrder - b.commandCenterOrder);
-    }
-    async getWorkspaceSymbolPicks(query, token) {
-        const configuration = this.configuration;
-        if (!query.normalized ||
-            !configuration.includeSymbols ||
-            this.pickState.lastRange
-        ) {
-            return [];
-        }
-        return this.workspaceSymbolsQuickAccess.getSymbolPicks(query.original, {
-            skipLocal: true,
-            skipSorting: true,
-            delay: AnythingQuickAccessProvider_1.TYPING_SEARCH_DELAY
-        }, token);
-    }
-    getEditorSymbolPicks(query, disposables, token) {
-        const filterSegments = query.original.split(GotoSymbolQuickAccessProvider.PREFIX);
-        const filter = filterSegments.length > 1 ? filterSegments[filterSegments.length - 1].trim() : undefined;
-        if (typeof filter !== 'string') {
-            return null;
-        }
-        const activeGlobalPick = this.pickState.lastGlobalPicks?.active;
-        if (!activeGlobalPick) {
-            return null;
-        }
-        const activeGlobalResource = activeGlobalPick.resource;
-        if (!activeGlobalResource || (!this.fileService.hasProvider(activeGlobalResource) && activeGlobalResource.scheme !== Schemas.untitled)) {
-            return null;
-        }
-        if (activeGlobalPick.label.includes(GotoSymbolQuickAccessProvider.PREFIX) || activeGlobalPick.description?.includes(GotoSymbolQuickAccessProvider.PREFIX)) {
-            if (filterSegments.length < 3) {
-                return null;
-            }
-        }
-        return this.doGetEditorSymbolPicks(activeGlobalPick, activeGlobalResource, filter, disposables, token);
-    }
-    async doGetEditorSymbolPicks(activeGlobalPick, activeGlobalResource, filter, disposables, token) {
-        try {
-            this.pickState.editorViewState.set();
-            await this.pickState.editorViewState.openTransientEditor({
-                resource: activeGlobalResource,
-                options: { preserveFocus: true, revealIfOpened: true, ignoreError: true }
-            });
-        }
-        catch (error) {
-            return [];
-        }
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        let model = this.modelService.getModel(activeGlobalResource);
-        if (!model) {
-            try {
-                const modelReference = disposables.add(await this.textModelService.createModelReference(activeGlobalResource));
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                model = modelReference.object.textEditorModel;
-            }
-            catch (error) {
-                return [];
-            }
-        }
-        const editorSymbolPicks = (await this.editorSymbolsQuickAccess.getSymbolPicks(model, filter, { extraContainerLabel: stripIcons(activeGlobalPick.label) }, disposables, token));
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        return (
-             (editorSymbolPicks.map(editorSymbolPick => {
-                if (editorSymbolPick.type === 'separator') {
-                    return editorSymbolPick;
-                }
-                return {
-                    ...editorSymbolPick,
-                    resource: activeGlobalResource,
-                    description: editorSymbolPick.description,
-                    trigger: (buttonIndex, keyMods) => {
-                        this.openAnything(activeGlobalResource, { keyMods, range: editorSymbolPick.range?.selection, forceOpenSideBySide: true });
-                        return TriggerAction.CLOSE_PICKER;
-                    },
-                    accept: (keyMods, event) => this.openAnything(activeGlobalResource, { keyMods, range: editorSymbolPick.range?.selection, preserveFocus: event.inBackground, forcePinned: event.inBackground })
-                };
-            }))
-        );
-    }
-    addDecorations(editor, range) {
-        this.editorSymbolsQuickAccess.addDecorations(editor, range);
-    }
-    clearDecorations(editor) {
-        this.editorSymbolsQuickAccess.clearDecorations(editor);
-    }
-    createAnythingPick(resourceOrEditor, configuration) {
-        const isEditorHistoryEntry = !URI.isUri(resourceOrEditor);
-        let resource;
-        let label;
-        let description = undefined;
-        let isDirty = undefined;
-        let extraClasses;
-        let icon = undefined;
-        if (isEditorInput(resourceOrEditor)) {
-            resource = EditorResourceAccessor.getOriginalUri(resourceOrEditor);
-            label = resourceOrEditor.getName();
-            description = resourceOrEditor.getDescription();
-            isDirty = resourceOrEditor.isDirty() && !resourceOrEditor.isSaving();
-            extraClasses = resourceOrEditor.getLabelExtraClasses();
-            icon = resourceOrEditor.getIcon();
-        }
-        else {
-            resource = URI.isUri(resourceOrEditor) ? resourceOrEditor : resourceOrEditor.resource;
-            const customLabel = this.customEditorLabelService.getName(resource);
-            label = customLabel || basenameOrAuthority(resource);
-            description = this.labelService.getUriLabel(!!customLabel ? resource : dirname(resource), { relative: true });
-            isDirty = this.workingCopyService.isDirty(resource) && !this.filesConfigurationService.hasShortAutoSaveDelay(resource);
-            extraClasses = [];
-        }
-        const labelAndDescription = description ? `${label} ${description}` : label;
-        const iconClassesValue = ( (new Lazy(
-            () => getIconClasses(this.modelService, this.languageService, resource, undefined, icon).concat(extraClasses)
-        )));
-        const buttonsValue = ( (new Lazy(() => {
-            const openSideBySideDirection = configuration.openSideBySideDirection;
-            const buttons = [];
-            buttons.push({
-                iconClass: openSideBySideDirection === 'right' ? ThemeIcon.asClassName(Codicon.splitHorizontal) : ThemeIcon.asClassName(Codicon.splitVertical),
-                tooltip: openSideBySideDirection === 'right' ?
-                    ( localizeWithPath(_moduleId, 6, "Open to the Side")) :
-                    ( localizeWithPath(_moduleId, 7, "Open to the Bottom"))
-            });
-            if (isEditorHistoryEntry) {
-                buttons.push({
-                    iconClass: isDirty ? ('dirty-anything ' + ThemeIcon.asClassName(Codicon.circleFilled)) : ThemeIcon.asClassName(Codicon.close),
-                    tooltip: ( localizeWithPath(_moduleId, 8, "Remove from Recently Opened")),
-                    alwaysVisible: isDirty
-                });
-            }
-            return buttons;
-        })));
-        return {
-            resource,
-            label,
-            ariaLabel: isDirty ? ( localizeWithPath(_moduleId, 9, "{0} unsaved changes", labelAndDescription)) : labelAndDescription,
-            description,
-            get iconClasses() { return iconClassesValue.value; },
-            get buttons() { return buttonsValue.value; },
-            trigger: (buttonIndex, keyMods) => {
-                switch (buttonIndex) {
-                    case 0:
-                        this.openAnything(resourceOrEditor, { keyMods, range: this.pickState.lastRange, forceOpenSideBySide: true });
-                        return TriggerAction.CLOSE_PICKER;
-                    case 1:
-                        if (!URI.isUri(resourceOrEditor)) {
-                            this.historyService.removeFromHistory(resourceOrEditor);
-                            return TriggerAction.REMOVE_ITEM;
-                        }
-                }
-                return TriggerAction.NO_ACTION;
-            },
-            accept: (keyMods, event) => this.openAnything(resourceOrEditor, { keyMods, range: this.pickState.lastRange, preserveFocus: event.inBackground, forcePinned: event.inBackground })
-        };
-    }
-    async openAnything(resourceOrEditor, options) {
-        const editorOptions = {
-            preserveFocus: options.preserveFocus,
-            pinned: options.keyMods?.ctrlCmd || options.forcePinned || this.configuration.openEditorPinned,
-            selection: options.range ? Range.collapseToStart(options.range) : undefined
-        };
-        const targetGroup = options.keyMods?.alt || (this.configuration.openEditorPinned && options.keyMods?.ctrlCmd) || options.forceOpenSideBySide ? SIDE_GROUP : ACTIVE_GROUP;
-        if (targetGroup === SIDE_GROUP) {
-            await this.pickState.editorViewState.restore();
-        }
-        if (isEditorInput(resourceOrEditor)) {
-            await this.editorService.openEditor(resourceOrEditor, editorOptions, targetGroup);
-        }
-        else {
-            let resourceEditorInput;
-            if (URI.isUri(resourceOrEditor)) {
-                resourceEditorInput = {
-                    resource: resourceOrEditor,
-                    options: editorOptions
-                };
-            }
-            else {
-                resourceEditorInput = {
-                    ...resourceOrEditor,
-                    options: {
-                        ...resourceOrEditor.options,
-                        ...editorOptions
-                    }
-                };
-            }
-            await this.editorService.openEditor(resourceEditorInput, targetGroup);
-        }
-    }
-};
-AnythingQuickAccessProvider = AnythingQuickAccessProvider_1 = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, ISearchService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IPathService))),
-    ( (__param(4, IWorkbenchEnvironmentService))),
-    ( (__param(5, IFileService))),
-    ( (__param(6, ILabelService))),
-    ( (__param(7, IModelService))),
-    ( (__param(8, ILanguageService))),
-    ( (__param(9, IWorkingCopyService))),
-    ( (__param(10, IConfigurationService))),
-    ( (__param(11, IEditorService))),
-    ( (__param(12, IHistoryService))),
-    ( (__param(13, IFilesConfigurationService))),
-    ( (__param(14, ITextModelService))),
-    ( (__param(15, IUriIdentityService))),
-    ( (__param(16, IQuickInputService))),
-    ( (__param(17, IKeybindingService))),
-    ( (__param(18, IQuickChatService))),
-    ( (__param(19, ILogService))),
-    ( (__param(20, ICustomEditorLabelService)))
-], AnythingQuickAccessProvider)));
-
-export { AnythingQuickAccessProvider };