@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

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

@@ -0,0 +1,757 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/anythingQuickAccess.css.js';
+import { QuickPickItemScorerAccessor, QuickInputHideReason, quickPickItemScorerAccessor, IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { prepareQuery, compareItemsByFuzzyScore, scoreItemFuzzy } from 'monaco-editor/esm/vs/base/common/fuzzyScorer.js';
+import { QueryBuilder } from '../../../services/search/common/queryBuilder.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { extractRangeFromFilter, getOutOfWorkspaceEditorResources } from '../common/search.js';
+import { ISearchService } from '../../../services/search/common/search.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { untildify } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { IPathService } from '../../../services/path/common/pathService.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { toLocalResource, basenameOrAuthority, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { MutableDisposable, Disposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { isEditorInput, EditorResourceAccessor } from '../../../common/editor.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { top } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { FileQueryCacheState } from '../common/cacheState.js';
+import { IHistoryService } from '../../../services/history/common/history.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { SymbolsQuickAccessProvider } from './symbolsQuickAccess.js';
+import { DefaultQuickAccessFilterValue } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { GotoSymbolQuickAccessProvider } from '../../codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { getIEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { HelpQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/helpQuickAccess.js';
+import { CommandsQuickAccessProvider } from '../../quickaccess/browser/commandsQuickAccess.js';
+import { DEBUG_QUICK_ACCESS_PREFIX } from '../../debug/browser/debugCommands.js';
+import { TasksQuickAccessProvider } from '../../tasks/browser/tasksQuickAccess.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+function isEditorSymbolQuickPickItem(pick) {
+    const candidate = pick;
+    return !!candidate?.range && !!candidate.resource;
+}
+let AnythingQuickAccessProvider = class AnythingQuickAccessProvider extends PickerQuickAccessProvider {
+    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) {
+        super(AnythingQuickAccessProvider.PREFIX, {
+            canAcceptInBackground: true,
+            noResultsPick: AnythingQuickAccessProvider.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.pickState = new (class {
+            constructor(provider, editorService) {
+                this.provider = provider;
+                this.editorService = editorService;
+                this.picker = undefined;
+                this.editorViewState = undefined;
+                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;
+                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 = undefined;
+            }
+            rememberEditorViewState() {
+                if (this.editorViewState) {
+                    return;
+                }
+                const activeEditorPane = this.editorService.activeEditorPane;
+                if (activeEditorPane) {
+                    this.editorViewState = {
+                        group: activeEditorPane.group,
+                        editor: activeEditorPane.input,
+                        state: withNullAsUndefined(getIEditor(activeEditorPane.getControl())?.saveViewState())
+                    };
+                }
+            }
+            async restoreEditorViewState() {
+                if (this.editorViewState) {
+                    const options = {
+                        viewState: this.editorViewState.state,
+                        preserveFocus: true
+                    };
+                    await this.editorViewState.group.openEditor(this.editorViewState.editor, options);
+                }
+            }
+        })(this, this.editorService);
+        this.labelOnlyEditorHistoryPickAccessor = ( new QuickPickItemScorerAccessor({ skipDescription: true }));
+        this.fileQueryDelayer = this._register(( new ThrottledDelayer(AnythingQuickAccessProvider.TYPING_SEARCH_DELAY)));
+        this.fileQueryBuilder = this.instantiationService.createInstance(QueryBuilder);
+        this.helpQuickAccess = this.instantiationService.createInstance(HelpQuickAccessProvider);
+        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,
+            shortAutoSaveDelay: this.filesConfigurationService.getAutoSaveMode() === 1 ,
+            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(once(picker.onDidHide)(({ reason }) => {
+            if (reason === QuickInputHideReason.Gesture) {
+                this.pickState.restoreEditorViewState();
+            }
+        }));
+        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.rememberEditorViewState();
+        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.NO_RESULTS_PICK && filter.indexOf(GotoSymbolQuickAccessProvider.PREFIX) >= 0;
+            if (!activePickIsEditorSymbol && !activePickIsNoResultsInEditorSymbols) {
+                this.pickState.lastGlobalPicks = {
+                    items: picks,
+                    active: activePick
+                };
+            }
+        }
+        return this.doGetPicks(filter, { enableEditorSymbolSearch: lastWasFiltering, includeHelp: runOptions?.includeHelp, from: runOptions?.from }, 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;
+        if (this.pickState.isQuickNavigating) {
+            picks = historyEditorPicks;
+        }
+        else {
+            picks = [];
+            if (options.includeHelp) {
+                picks.push(...this.getHelpPicks(query, token, options));
+            }
+            if (historyEditorPicks.length !== 0) {
+                picks.push({ type: 'separator', label: ( localize('recentlyOpenedSeparator', "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 ? ( localize('fileAndSymbolResultsSeparator', "file and symbol results")) : ( localize('fileResultsSeparator', "file results")) },
+                    ...additionalPicks
+                ] : [];
+            })(),
+            mergeDelay: AnythingQuickAccessProvider.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.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) {
+        return this.searchService.fileSearch(this.fileQueryBuilder.file(this.contextService.getWorkspace().folders, this.getFileQueryOptions({
+            filePattern,
+            cacheKey: this.pickState.fileQueryCache?.cacheKey,
+            maxResults: AnythingQuickAccessProvider.MAX_RESULTS
+        })), token);
+    }
+    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.helpQuickAccess.getQuickAccessProviders();
+        const mapOfProviders = ( new Map());
+        for (const provider of providers) {
+            mapOfProviders.set(provider.prefix, provider);
+        }
+        const importantProviders = [];
+        const AddProvider = (prefix, modifications = {}) => {
+            if (( mapOfProviders.has(prefix))) {
+                const provider = mapOfProviders.get(prefix);
+                provider.label = provider.description;
+                provider.description = provider.prefix;
+                const providerSpecificOptions = {
+                    ...runOptions,
+                    includeHelp: provider.prefix === AnythingQuickAccessProvider.PREFIX ? false : runOptions?.includeHelp
+                };
+                importantProviders.push({
+                    ...mapOfProviders.get(prefix),
+                    ...modifications,
+                    accept: () => {
+                        this.quickInputService.quickAccess.show(provider.prefix, {
+                            preserveValue: true,
+                            providerOptions: providerSpecificOptions
+                        });
+                    }
+                });
+            }
+        };
+        AddProvider(AnythingQuickAccessProvider.PREFIX);
+        AddProvider(CommandsQuickAccessProvider.PREFIX);
+        AddProvider(GotoSymbolQuickAccessProvider.PREFIX);
+        AddProvider(DEBUG_QUICK_ACCESS_PREFIX);
+        AddProvider(TasksQuickAccessProvider.PREFIX);
+        AddProvider(HelpQuickAccessProvider.PREFIX, {
+            label: ( localize('more', 'More'))
+        });
+        return importantProviders;
+    }
+    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.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.rememberEditorViewState();
+            await this.editorService.openEditor({
+                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;
+        if (isEditorInput(resourceOrEditor)) {
+            resource = EditorResourceAccessor.getOriginalUri(resourceOrEditor);
+            label = resourceOrEditor.getName();
+            description = resourceOrEditor.getDescription();
+            isDirty = resourceOrEditor.isDirty() && !resourceOrEditor.isSaving();
+            extraClasses = resourceOrEditor.getLabelExtraClasses();
+        }
+        else {
+            resource = URI.isUri(resourceOrEditor) ? resourceOrEditor : resourceOrEditor.resource;
+            label = basenameOrAuthority(resource);
+            description = this.labelService.getUriLabel(dirname(resource), { relative: true });
+            isDirty = this.workingCopyService.isDirty(resource) && !configuration.shortAutoSaveDelay;
+            extraClasses = [];
+        }
+        const labelAndDescription = description ? `${label} ${description}` : label;
+        const iconClassesValue = ( new Lazy(
+            () => getIconClasses(this.modelService, this.languageService, resource).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' ?
+                    ( localize(
+                        { key: 'openToSide', comment: ['Open this file in a split editor on the left/right side'] },
+                        "Open to the Side"
+                    )) :
+                    ( localize(
+                        { key: 'openToBottom', comment: ['Open this file in a split editor on the bottom'] },
+                        "Open to the Bottom"
+                    ))
+            });
+            if (isEditorHistoryEntry) {
+                buttons.push({
+                    iconClass: isDirty ? ('dirty-anything ' + ThemeIcon.asClassName(Codicon.circleFilled)) : ThemeIcon.asClassName(Codicon.close),
+                    tooltip: ( localize('closeEditor', "Remove from Recently Opened")),
+                    alwaysVisible: isDirty
+                });
+            }
+            return buttons;
+        }));
+        return {
+            resource,
+            label,
+            ariaLabel: isDirty ? ( localize('filePickAriaLabelDirty', "{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.restoreEditorViewState();
+        }
+        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.PREFIX = '';
+AnythingQuickAccessProvider.NO_RESULTS_PICK = {
+    label: ( localize('noAnythingResults', "No matching results"))
+};
+AnythingQuickAccessProvider.MAX_RESULTS = 512;
+AnythingQuickAccessProvider.TYPING_SEARCH_DELAY = 200;
+AnythingQuickAccessProvider.SYMBOL_PICKS_MERGE_DELAY = 200;
+AnythingQuickAccessProvider = ( __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))
+], AnythingQuickAccessProvider));
+export { AnythingQuickAccessProvider };