@codingame/monaco-vscode-api 1.79.0 → 1.79.1

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".quick-input-list .quick-input-list-entry.has-actions:hover .quick-input-list-entry-action-bar .action-label.dirty-anything:before{content:\"\\ea76\"}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,428 @@
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { AbstractGotoLineQuickAccessProvider } from 'monaco-editor/esm/vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { defaultQuickAccessContextKeyValue } from '../../../browser/quickaccess.js';
+import { GotoSymbolQuickAccessProvider } from '../../codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js';
+import { AnythingQuickAccessProvider } from './anythingQuickAccess.js';
+import { SymbolsQuickAccessProvider } from './symbolsQuickAccess.js';
+import { SEARCH_EXCLUDE_CONFIG } from '../../../services/search/common/search.js';
+import { ShowAllSymbolsActionId } from '../common/constants.js';
+import product$1 from '../../../../platform/product/common/product.js';
+const SEARCH_MODE_CONFIG = 'search.mode';
+const quickAccessRegistry = ( Registry.as(Extensions.Quickaccess));
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: AnythingQuickAccessProvider,
+    prefix: AnythingQuickAccessProvider.PREFIX,
+    placeholder: ( nls.localize(
+        'anythingQuickAccessPlaceholder',
+        "Search files by name (append {0} to go to line or {1} to go to symbol)",
+        AbstractGotoLineQuickAccessProvider.PREFIX,
+        GotoSymbolQuickAccessProvider.PREFIX
+    )),
+    contextKey: defaultQuickAccessContextKeyValue,
+    helpEntries: [{ description: ( nls.localize('anythingQuickAccess', "Go to File")), commandId: 'workbench.action.quickOpen' }]
+});
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: SymbolsQuickAccessProvider,
+    prefix: SymbolsQuickAccessProvider.PREFIX,
+    placeholder: ( nls.localize('symbolsQuickAccessPlaceholder', "Type the name of a symbol to open.")),
+    contextKey: 'inWorkspaceSymbolsPicker',
+    helpEntries: [{ description: ( nls.localize('symbolsQuickAccess', "Go to Symbol in Workspace")), commandId: ShowAllSymbolsActionId }]
+});
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'search',
+    order: 13,
+    title: ( nls.localize('searchConfigurationTitle', "Search")),
+    type: 'object',
+    properties: {
+        [SEARCH_EXCLUDE_CONFIG]: {
+            type: 'object',
+            markdownDescription: ( nls.localize(
+                'exclude',
+                "Configure [glob patterns](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options) for excluding files and folders in fulltext searches and quick open. Inherits all glob patterns from the `#files.exclude#` setting."
+            )),
+            default: { '**/node_modules': true, '**/bower_components': true, '**/*.code-search': true },
+            additionalProperties: {
+                anyOf: [
+                    {
+                        type: 'boolean',
+                        description: ( nls.localize(
+                            'exclude.boolean',
+                            "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."
+                        )),
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            when: {
+                                type: 'string',
+                                pattern: '\\w*\\$\\(basename\\)\\w*',
+                                default: '$(basename).ext',
+                                markdownDescription: ( nls.localize(
+                                    { key: 'exclude.when', comment: ['\\$(basename) should not be translated'] },
+                                    'Additional check on the siblings of a matching file. Use \\$(basename) as variable for the matching file name.'
+                                ))
+                            }
+                        }
+                    }
+                ]
+            },
+            scope: 4
+        },
+        [SEARCH_MODE_CONFIG]: {
+            type: 'string',
+            enum: ['view', 'reuseEditor', 'newEditor'],
+            default: 'view',
+            markdownDescription: ( nls.localize(
+                'search.mode',
+                "Controls where new `Search: Find in Files` and `Find in Folder` operations occur: either in the search view, or in a search editor."
+            )),
+            enumDescriptions: [
+                ( nls.localize(
+                    'search.mode.view',
+                    "Search in the search view, either in the panel or side bars."
+                )),
+                ( nls.localize(
+                    'search.mode.reuseEditor',
+                    "Search in an existing search editor if present, otherwise in a new search editor."
+                )),
+                ( nls.localize('search.mode.newEditor', "Search in a new search editor.")),
+            ]
+        },
+        'search.useRipgrep': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'useRipgrep',
+                "This setting is deprecated and now falls back on \"search.usePCRE2\"."
+            )),
+            deprecationMessage: ( nls.localize(
+                'useRipgrepDeprecated',
+                "Deprecated. Consider \"search.usePCRE2\" for advanced regex feature support."
+            )),
+            default: true
+        },
+        'search.maintainFileSearchCache': {
+            type: 'boolean',
+            deprecationMessage: ( nls.localize(
+                'maintainFileSearchCacheDeprecated',
+                "The search cache is kept in the extension host which never shuts down, so this setting is no longer needed."
+            )),
+            description: ( nls.localize(
+                'search.maintainFileSearchCache',
+                "When enabled, the searchService process will be kept alive instead of being shut down after an hour of inactivity. This will keep the file search cache in memory."
+            )),
+            default: false
+        },
+        'search.useIgnoreFiles': {
+            type: 'boolean',
+            markdownDescription: ( nls.localize(
+                'useIgnoreFiles',
+                "Controls whether to use `.gitignore` and `.ignore` files when searching for files."
+            )),
+            default: true,
+            scope: 4
+        },
+        'search.useGlobalIgnoreFiles': {
+            type: 'boolean',
+            markdownDescription: ( nls.localize(
+                'useGlobalIgnoreFiles',
+                "Controls whether to use your global gitignore file (e.g., from `$HOME/.config/git/ignore`) when searching for files. Requires `#search.useIgnoreFiles#` to be enabled."
+            )),
+            default: false,
+            scope: 4
+        },
+        'search.useParentIgnoreFiles': {
+            type: 'boolean',
+            markdownDescription: ( nls.localize(
+                'useParentIgnoreFiles',
+                "Controls whether to use `.gitignore` and `.ignore` files in parent directories when searching for files. Requires `#search.useIgnoreFiles#` to be enabled."
+            )),
+            default: false,
+            scope: 4
+        },
+        'search.quickOpen.includeSymbols': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.quickOpen.includeSymbols',
+                "Whether to include results from a global symbol search in the file results for Quick Open."
+            )),
+            default: false
+        },
+        'search.quickOpen.includeHistory': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.quickOpen.includeHistory',
+                "Whether to include results from recently opened files in the file results for Quick Open."
+            )),
+            default: true
+        },
+        'search.quickOpen.history.filterSortOrder': {
+            'type': 'string',
+            'enum': ['default', 'recency'],
+            'default': 'default',
+            'enumDescriptions': [
+                ( nls.localize(
+                    'filterSortOrder.default',
+                    'History entries are sorted by relevance based on the filter value used. More relevant entries appear first.'
+                )),
+                ( nls.localize(
+                    'filterSortOrder.recency',
+                    'History entries are sorted by recency. More recently opened entries appear first.'
+                ))
+            ],
+            'description': ( nls.localize(
+                'filterSortOrder',
+                "Controls sorting order of editor history in quick open when filtering."
+            ))
+        },
+        'search.followSymlinks': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.followSymlinks',
+                "Controls whether to follow symlinks while searching."
+            )),
+            default: true
+        },
+        'search.smartCase': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.smartCase',
+                "Search case-insensitively if the pattern is all lowercase, otherwise, search case-sensitively."
+            )),
+            default: false
+        },
+        'search.globalFindClipboard': {
+            type: 'boolean',
+            default: false,
+            description: ( nls.localize(
+                'search.globalFindClipboard',
+                "Controls whether the search view should read or modify the shared find clipboard on macOS."
+            )),
+            included: platform.isMacintosh
+        },
+        'search.location': {
+            type: 'string',
+            enum: ['sidebar', 'panel'],
+            default: 'sidebar',
+            description: ( nls.localize(
+                'search.location',
+                "Controls whether the search will be shown as a view in the sidebar or as a panel in the panel area for more horizontal space."
+            )),
+            deprecationMessage: ( nls.localize(
+                'search.location.deprecationMessage',
+                "This setting is deprecated. You can drag the search icon to a new location instead."
+            ))
+        },
+        'search.maxResults': {
+            type: ['number', 'null'],
+            default: 20000,
+            markdownDescription: ( nls.localize(
+                'search.maxResults',
+                "Controls the maximum number of search results, this can be set to `null` (empty) to return unlimited results."
+            ))
+        },
+        'search.collapseResults': {
+            type: 'string',
+            enum: ['auto', 'alwaysCollapse', 'alwaysExpand'],
+            enumDescriptions: [
+                ( nls.localize(
+                    'search.collapseResults.auto',
+                    "Files with less than 10 results are expanded. Others are collapsed."
+                )),
+                '',
+                ''
+            ],
+            default: 'alwaysExpand',
+            description: ( nls.localize(
+                'search.collapseAllResults',
+                "Controls whether the search results will be collapsed or expanded."
+            )),
+        },
+        'search.useReplacePreview': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize(
+                'search.useReplacePreview',
+                "Controls whether to open Replace Preview when selecting or replacing a match."
+            )),
+        },
+        'search.showLineNumbers': {
+            type: 'boolean',
+            default: false,
+            description: ( nls.localize(
+                'search.showLineNumbers',
+                "Controls whether to show line numbers for search results."
+            )),
+        },
+        'search.usePCRE2': {
+            type: 'boolean',
+            default: false,
+            description: ( nls.localize(
+                'search.usePCRE2',
+                "Whether to use the PCRE2 regex engine in text search. This enables using some advanced regex features like lookahead and backreferences. However, not all PCRE2 features are supported - only features that are also supported by JavaScript."
+            )),
+            deprecationMessage: ( nls.localize(
+                'usePCRE2Deprecated',
+                "Deprecated. PCRE2 will be used automatically when using regex features that are only supported by PCRE2."
+            )),
+        },
+        'search.actionsPosition': {
+            type: 'string',
+            enum: ['auto', 'right'],
+            enumDescriptions: [
+                ( nls.localize(
+                    'search.actionsPositionAuto',
+                    "Position the actionbar to the right when the search view is narrow, and immediately after the content when the search view is wide."
+                )),
+                ( nls.localize(
+                    'search.actionsPositionRight',
+                    "Always position the actionbar to the right."
+                )),
+            ],
+            default: 'right',
+            description: ( nls.localize(
+                'search.actionsPosition',
+                "Controls the positioning of the actionbar on rows in the search view."
+            ))
+        },
+        'search.searchOnType': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize('search.searchOnType', "Search all files as you type."))
+        },
+        'search.seedWithNearestWord': {
+            type: 'boolean',
+            default: false,
+            description: ( nls.localize(
+                'search.seedWithNearestWord',
+                "Enable seeding search from the word nearest the cursor when the active editor has no selection."
+            ))
+        },
+        'search.seedOnFocus': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: ( nls.localize(
+                'search.seedOnFocus',
+                "Update the search query to the editor's selected text when focusing the search view. This happens either on click or when triggering the `workbench.views.search.focus` command."
+            ))
+        },
+        'search.searchOnTypeDebouncePeriod': {
+            type: 'number',
+            default: 300,
+            markdownDescription: ( nls.localize(
+                'search.searchOnTypeDebouncePeriod',
+                "When {0} is enabled, controls the timeout in milliseconds between a character being typed and the search starting. Has no effect when {0} is disabled.",
+                '`#search.searchOnType#`'
+            ))
+        },
+        'search.searchEditor.doubleClickBehaviour': {
+            type: 'string',
+            enum: ['selectWord', 'goToLocation', 'openLocationToSide'],
+            default: 'goToLocation',
+            enumDescriptions: [
+                ( nls.localize(
+                    'search.searchEditor.doubleClickBehaviour.selectWord',
+                    "Double-clicking selects the word under the cursor."
+                )),
+                ( nls.localize(
+                    'search.searchEditor.doubleClickBehaviour.goToLocation',
+                    "Double-clicking opens the result in the active editor group."
+                )),
+                ( nls.localize(
+                    'search.searchEditor.doubleClickBehaviour.openLocationToSide',
+                    "Double-clicking opens the result in the editor group to the side, creating one if it does not yet exist."
+                )),
+            ],
+            markdownDescription: ( nls.localize(
+                'search.searchEditor.doubleClickBehaviour',
+                "Configure effect of double-clicking a result in a search editor."
+            ))
+        },
+        'search.searchEditor.reusePriorSearchConfiguration': {
+            type: 'boolean',
+            default: false,
+            markdownDescription: ( nls.localize(
+                { key: 'search.searchEditor.reusePriorSearchConfiguration', comment: ['"Search Editor" is a type of editor that can display search results. "includes, excludes, and flags" refers to the "files to include" and "files to exclude" input boxes, and the flags that control whether a query is case-sensitive or a regex.'] },
+                "When enabled, new Search Editors will reuse the includes, excludes, and flags of the previously opened Search Editor."
+            ))
+        },
+        'search.searchEditor.defaultNumberOfContextLines': {
+            type: ['number', 'null'],
+            default: 1,
+            markdownDescription: ( nls.localize(
+                'search.searchEditor.defaultNumberOfContextLines',
+                "The default number of surrounding context lines to use when creating new Search Editors. If using `#search.searchEditor.reusePriorSearchConfiguration#`, this can be set to `null` (empty) to use the prior Search Editor's configuration."
+            ))
+        },
+        'search.sortOrder': {
+            'type': 'string',
+            'enum': ["default" , "fileNames" , "type" , "modified" , "countDescending" , "countAscending" ],
+            'default': "default" ,
+            'enumDescriptions': [
+                ( nls.localize(
+                    'searchSortOrder.default',
+                    "Results are sorted by folder and file names, in alphabetical order."
+                )),
+                ( nls.localize(
+                    'searchSortOrder.filesOnly',
+                    "Results are sorted by file names ignoring folder order, in alphabetical order."
+                )),
+                ( nls.localize(
+                    'searchSortOrder.type',
+                    "Results are sorted by file extensions, in alphabetical order."
+                )),
+                ( nls.localize(
+                    'searchSortOrder.modified',
+                    "Results are sorted by file last modified date, in descending order."
+                )),
+                ( nls.localize(
+                    'searchSortOrder.countDescending',
+                    "Results are sorted by count per file, in descending order."
+                )),
+                ( nls.localize(
+                    'searchSortOrder.countAscending',
+                    "Results are sorted by count per file, in ascending order."
+                ))
+            ],
+            'description': ( nls.localize('search.sortOrder', "Controls sorting order of search results."))
+        },
+        'search.decorations.colors': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.decorations.colors',
+                "Controls whether search file decorations should use colors."
+            )),
+            default: true
+        },
+        'search.decorations.badges': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.decorations.badges',
+                "Controls whether search file decorations should use badges."
+            )),
+            default: true
+        },
+        'search.defaultViewMode': {
+            'type': 'string',
+            'enum': ["tree" , "list" ],
+            'default': "list" ,
+            'enumDescriptions': [
+                ( nls.localize('scm.defaultViewMode.tree', "Shows search results as a tree.")),
+                ( nls.localize('scm.defaultViewMode.list', "Shows search results as a list."))
+            ],
+            'description': ( nls.localize('search.defaultViewMode', "Controls the default search result view mode."))
+        },
+        'search.experimental.notebookSearch': {
+            type: 'boolean',
+            description: ( nls.localize(
+                'search.experimental.notebookSearch',
+                "Controls whether to use the experimental notebook search in the global search. Please reload your VS Code instance for changes to this setting to take effect."
+            )),
+            default: typeof product$1.quality === 'string' && product$1.quality !== 'stable',
+        },
+    }
+});

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

@@ -0,0 +1,219 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { getWorkspaceSymbols } from '../common/search.js';
+import { SymbolKinds } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.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 { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { getSelectionSearchString } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findController.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { prepareQuery, pieceToQuery, scoreFuzzy2 } from 'monaco-editor/esm/vs/base/common/fuzzyScorer.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+let SymbolsQuickAccessProvider = class SymbolsQuickAccessProvider extends PickerQuickAccessProvider {
+    get defaultFilterValue() {
+        const editor = this.codeEditorService.getFocusedCodeEditor();
+        if (editor) {
+            return withNullAsUndefined(getSelectionSearchString(editor));
+        }
+        return undefined;
+    }
+    constructor(labelService, openerService, editorService, configurationService, codeEditorService) {
+        super(SymbolsQuickAccessProvider.PREFIX, {
+            canAcceptInBackground: true,
+            noResultsPick: {
+                label: ( localize('noSymbolResults', "No matching workspace symbols"))
+            }
+        });
+        this.labelService = labelService;
+        this.openerService = openerService;
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.codeEditorService = codeEditorService;
+        this.delayer = this._register(( new ThrottledDelayer(SymbolsQuickAccessProvider.TYPING_SEARCH_DELAY)));
+    }
+    get configuration() {
+        const editorConfig = this.configurationService.getValue().workbench?.editor;
+        return {
+            openEditorPinned: !editorConfig?.enablePreviewFromQuickOpen || !editorConfig?.enablePreview,
+            openSideBySideDirection: editorConfig?.openSideBySideDirection
+        };
+    }
+    _getPicks(filter, disposables, token) {
+        return this.getSymbolPicks(filter, undefined, token);
+    }
+    async getSymbolPicks(filter, options, token) {
+        return this.delayer.trigger(async () => {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            return this.doGetSymbolPicks(prepareQuery(filter), options, token);
+        }, options?.delay);
+    }
+    async doGetSymbolPicks(query, options, token) {
+        let symbolQuery;
+        let containerQuery;
+        if (query.values && query.values.length > 1) {
+            symbolQuery = pieceToQuery(query.values[0]);
+            containerQuery = pieceToQuery(query.values.slice(1));
+        }
+        else {
+            symbolQuery = query;
+        }
+        const workspaceSymbols = await getWorkspaceSymbols(symbolQuery.original, token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const symbolPicks = [];
+        const openSideBySideDirection = this.configuration.openSideBySideDirection;
+        for (const { symbol, provider } of workspaceSymbols) {
+            if (options?.skipLocal && !( SymbolsQuickAccessProvider.TREAT_AS_GLOBAL_SYMBOL_TYPES.has(symbol.kind)) && !!symbol.containerName) {
+                continue;
+            }
+            const symbolLabel = symbol.name;
+            const symbolLabelWithIcon = `$(${SymbolKinds.toIcon(symbol.kind).id}) ${symbolLabel}`;
+            const symbolLabelIconOffset = symbolLabelWithIcon.length - symbolLabel.length;
+            let symbolScore = undefined;
+            let symbolMatches = undefined;
+            let skipContainerQuery = false;
+            if (symbolQuery.original.length > 0) {
+                if (symbolQuery !== query) {
+                    [symbolScore, symbolMatches] = scoreFuzzy2(symbolLabelWithIcon, { ...query, values: undefined  }, 0, symbolLabelIconOffset);
+                    if (typeof symbolScore === 'number') {
+                        skipContainerQuery = true;
+                    }
+                }
+                if (typeof symbolScore !== 'number') {
+                    [symbolScore, symbolMatches] = scoreFuzzy2(symbolLabelWithIcon, symbolQuery, 0, symbolLabelIconOffset);
+                    if (typeof symbolScore !== 'number') {
+                        continue;
+                    }
+                }
+            }
+            const symbolUri = symbol.location.uri;
+            let containerLabel = undefined;
+            if (symbolUri) {
+                const containerPath = this.labelService.getUriLabel(symbolUri, { relative: true });
+                if (symbol.containerName) {
+                    containerLabel = `${symbol.containerName} • ${containerPath}`;
+                }
+                else {
+                    containerLabel = containerPath;
+                }
+            }
+            let containerScore = undefined;
+            let containerMatches = undefined;
+            if (!skipContainerQuery && containerQuery && containerQuery.original.length > 0) {
+                if (containerLabel) {
+                    [containerScore, containerMatches] = scoreFuzzy2(containerLabel, containerQuery);
+                }
+                if (typeof containerScore !== 'number') {
+                    continue;
+                }
+                if (typeof symbolScore === 'number') {
+                    symbolScore += containerScore;
+                }
+            }
+            const deprecated = symbol.tags ? symbol.tags.indexOf(1 ) >= 0 : false;
+            symbolPicks.push({
+                symbol,
+                resource: symbolUri,
+                score: symbolScore,
+                label: symbolLabelWithIcon,
+                ariaLabel: symbolLabel,
+                highlights: deprecated ? undefined : {
+                    label: symbolMatches,
+                    description: containerMatches
+                },
+                description: containerLabel,
+                strikethrough: deprecated,
+                buttons: [
+                    {
+                        iconClass: openSideBySideDirection === 'right' ? ThemeIcon.asClassName(Codicon.splitHorizontal) : ThemeIcon.asClassName(Codicon.splitVertical),
+                        tooltip: openSideBySideDirection === 'right' ? ( localize('openToSide', "Open to the Side")) : ( localize('openToBottom', "Open to the Bottom"))
+                    }
+                ],
+                trigger: (buttonIndex, keyMods) => {
+                    this.openSymbol(provider, symbol, token, { keyMods, forceOpenSideBySide: true });
+                    return TriggerAction.CLOSE_PICKER;
+                },
+                accept: async (keyMods, event) => this.openSymbol(provider, symbol, token, { keyMods, preserveFocus: event.inBackground, forcePinned: event.inBackground }),
+            });
+        }
+        if (!options?.skipSorting) {
+            symbolPicks.sort((symbolA, symbolB) => this.compareSymbols(symbolA, symbolB));
+        }
+        return symbolPicks;
+    }
+    async openSymbol(provider, symbol, token, options) {
+        let symbolToOpen = symbol;
+        if (typeof provider.resolveWorkspaceSymbol === 'function') {
+            symbolToOpen = (await provider.resolveWorkspaceSymbol(symbol, token)) || symbol;
+            if (token.isCancellationRequested) {
+                return;
+            }
+        }
+        if (symbolToOpen.location.uri.scheme === Schemas.http || symbolToOpen.location.uri.scheme === Schemas.https) {
+            await this.openerService.open(symbolToOpen.location.uri, { fromUserGesture: true, allowContributedOpeners: true });
+        }
+        else {
+            await this.editorService.openEditor({
+                resource: symbolToOpen.location.uri,
+                options: {
+                    preserveFocus: options?.preserveFocus,
+                    pinned: options.keyMods.ctrlCmd || options.forcePinned || this.configuration.openEditorPinned,
+                    selection: symbolToOpen.location.range ? Range.collapseToStart(symbolToOpen.location.range) : undefined
+                }
+            }, options.keyMods.alt || (this.configuration.openEditorPinned && options.keyMods.ctrlCmd) || options?.forceOpenSideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+        }
+    }
+    compareSymbols(symbolA, symbolB) {
+        if (typeof symbolA.score === 'number' && typeof symbolB.score === 'number') {
+            if (symbolA.score > symbolB.score) {
+                return -1;
+            }
+            if (symbolA.score < symbolB.score) {
+                return 1;
+            }
+        }
+        if (symbolA.symbol && symbolB.symbol) {
+            const symbolAName = symbolA.symbol.name.toLowerCase();
+            const symbolBName = symbolB.symbol.name.toLowerCase();
+            const res = symbolAName.localeCompare(symbolBName);
+            if (res !== 0) {
+                return res;
+            }
+        }
+        if (symbolA.symbol && symbolB.symbol) {
+            const symbolAKind = SymbolKinds.toIcon(symbolA.symbol.kind).id;
+            const symbolBKind = SymbolKinds.toIcon(symbolB.symbol.kind).id;
+            return symbolAKind.localeCompare(symbolBKind);
+        }
+        return 0;
+    }
+};
+SymbolsQuickAccessProvider.PREFIX = '#';
+SymbolsQuickAccessProvider.TYPING_SEARCH_DELAY = 200;
+SymbolsQuickAccessProvider.TREAT_AS_GLOBAL_SYMBOL_TYPES = ( new Set([
+    4 ,
+    9 ,
+    0 ,
+    10 ,
+    2 ,
+    3 ,
+    1
+]));
+SymbolsQuickAccessProvider = ( __decorate([
+    ( __param(0, ILabelService)),
+    ( __param(1, IOpenerService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ICodeEditorService))
+], SymbolsQuickAccessProvider));
+export { SymbolsQuickAccessProvider };