@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

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

@@ -1,759 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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, Extensions } 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 { 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 { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { ASK_QUICK_QUESTION_ACTION_ID } from '../../chat/browser/actions/chatQuickInputActions.js';
-import { IQuickChatService } from '../../chat/browser/chat.js';
-var AnythingQuickAccessProvider_1;
-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: ( localize('noAnythingResults', "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) {
-        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.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: getIEditor(activeEditorPane.getControl())?.saveViewState() ?? undefined,
-                    };
-                }
-            }
-            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_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,
-            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_1.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_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) {
-        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);
-    }
-    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: ( localize('helpPickAriaLabel', "{0}, {1}", label, helpEntry.description)),
-                accept: () => {
-                    this.quickInputService.quickAccess.show(provider.prefix, {
-                        preserveValue: true,
-                        providerOptions: providerSpecificOptions
-                    });
-                }
-            };
-        })));
-        if (this.quickChatService.enabled) {
-            providers.push({
-                label: ( localize('chat', "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.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 = 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))
-], AnythingQuickAccessProvider));
-export { AnythingQuickAccessProvider };