@codingame/monaco-vscode-api 5.2.0 → 6.0.0

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

@@ -0,0 +1,785 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/anythingQuickAccess.css.js';
+import { QuickPickItemScorerAccessor, QuickInputHideReason, quickPickItemScorerAccessor } from '../../../../platform/quickinput/common/quickInput.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
+import { PickerQuickAccessProvider, TriggerAction } from '../../../../platform/quickinput/browser/pickerQuickAccess.js';
+import { prepareQuery, scoreItemFuzzy, compareItemsByFuzzyScore } from '../../../../base/common/fuzzyScorer.js';
+import { QueryBuilder } from '../../../services/search/common/queryBuilder.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { extractRangeFromFilter, getOutOfWorkspaceEditorResources } from '../common/search.js';
+import { ISearchService } from '../../../services/search/common/search.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { untildify } from '../../../../base/common/labels.js';
+import { IPathService } from '../../../services/path/common/pathService.service.js';
+import { URI } from '../../../../base/common/uri.js';
+import { toLocalResource, basenameOrAuthority, dirname } from '../../../../base/common/resources.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.service.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { ILabelService } from '../../../../platform/label/common/label.service.js';
+import { getIconClasses } from '../../../../editor/common/services/getIconClasses.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { isEditorInput, EditorResourceAccessor } from '../../../common/editor.js';
+import { SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { ThrottledDelayer } from '../../../../base/common/async.js';
+import { top } from '../../../../base/common/arrays.js';
+import { FileQueryCacheState } from '../common/cacheState.js';
+import { IHistoryService } from '../../../services/history/common/history.service.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.service.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { SymbolsQuickAccessProvider } from './symbolsQuickAccess.js';
+import { DefaultQuickAccessFilterValue, Extensions } from '../../../../platform/quickinput/common/quickAccess.js';
+import { PickerEditorState } from '../../../browser/quickaccess.js';
+import { GotoSymbolQuickAccessProvider } from '../../codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { ScrollType } from '../../../../editor/common/editorCommon.js';
+import { Event } from '../../../../base/common/event.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { Lazy } from '../../../../base/common/lazy.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { ASK_QUICK_QUESTION_ACTION_ID } from '../../chat/browser/actions/chatQuickInputActions.js';
+import { IQuickChatService } from '../../chat/browser/chat.service.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { ICustomEditorLabelService } from '../../../services/editor/common/customEditorLabelService.service.js';
+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, ScrollType.Smooth);
+        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 configuration = { ...this.configuration, includeSymbols: options.includeSymbols ?? this.configuration.includeSymbols };
+        const query = prepareQuery(filter);
+        if (options.enableEditorSymbolSearch && options.includeSymbols) {
+            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) {
+            for (const pick of options.additionPicks) {
+                if (pick.type === 'separator') {
+                    picks.push(pick);
+                    continue;
+                }
+                if (!query.original) {
+                    pick.highlights = undefined;
+                    picks.push(pick);
+                    continue;
+                }
+                const { score, labelMatch, descriptionMatch } = scoreItemFuzzy(pick, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache);
+                if (!score) {
+                    continue;
+                }
+                pick.highlights = {
+                    label: labelMatch,
+                    description: descriptionMatch
+                };
+                picks.push(pick);
+            }
+        }
+        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: options.filter ? picks.filter((p) => options.filter?.(p)) : picks,
+            additionalPicks: (async () => {
+                const additionalPicksExcludes = ( (new ResourceMap()));
+                for (const historyEditorPick of historyEditorPicks) {
+                    if (historyEditorPick.resource) {
+                        additionalPicksExcludes.set(historyEditorPick.resource, true);
+                    }
+                }
+                let additionalPicks = await this.getAdditionalPicks(query, additionalPicksExcludes, configuration.includeSymbols, token);
+                if (options.filter) {
+                    additionalPicks = additionalPicks.filter((p) => options.filter?.(p));
+                }
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                return additionalPicks.length > 0 ? [
+                    { type: 'separator', label: 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, includeSymbols, token) {
+        const [filePicks, symbolPicks] = await Promise.all([
+            this.getFilePicks(query, excludes, token),
+            this.getWorkspaceSymbolPicks(query, includeSymbols, 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, includeSymbols, token) {
+        if (!query.normalized ||
+            !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 };