@codingame/monaco-vscode-api 5.3.0 → 6.0.0

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/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:var(--vscode-icon-x-content);font-family:var(--vscode-icon-x-font-family)}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/search/browser/notebookSearch/notebookSearchService.js

@@ -6,7 +6,7 @@ import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { IUriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentity.service.js';
 import { INotebookService } from '../../../notebook/common/notebookService.service.js';
 import { contentMatchesToTextSearchMatches, webviewMatchesToTextSearchMatches } from './searchNotebookHelpers.js';
-import { pathIncludedInQuery } from '../../../../services/search/common/search.js';
+import { QueryType, pathIncludedInQuery } from '../../../../services/search/common/search.js';
 import { ISearchService } from '../../../../services/search/common/search.service.js';
 import { coalesce } from '../../../../../base/common/arrays.js';
 import { isNumber } from '../../../../../base/common/types.js';
@@ -26,7 +26,7 @@ let NotebookSearchService = class NotebookSearchService {
         this.queryBuilder = instantiationService.createInstance(QueryBuilder);
     }
     notebookSearch(query, token, searchInstanceID, onProgress) {
-        if (query.type !== 2 ) {
+        if (query.type !== QueryType.Text) {
             return {
                 openFilesToScan: ( new ResourceSet()),
                 completeData: Promise.resolve({

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

@@ -3,13 +3,16 @@ import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IListService } from '../../../../platform/list/browser/listService.service.js';
+import { ViewContainerLocation } from '../../../common/views.js';
 import { IViewsService } from '../../../services/views/common/viewsService.service.js';
-import { SearchContext } from '../common/constants.js';
+import { SearchCommandIds, SearchContext } from '../common/constants.js';
 import { OpenEditorCommandId } from '../../searchEditor/browser/constants.js';
 import { FileMatch, Match } from './searchModel.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
 import { resolveResourcesForSearchIncludes } from '../../../services/search/common/queryBuilder.js';
 import { getMultiSelectedResources } from '../../files/browser/files.js';
 import { IExplorerService } from '../../files/browser/files.service.js';
@@ -22,17 +25,18 @@ import { category, getSearchView, openSearchView, getElementsToOperateOn } from
 import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.service.js';
 import { IHistoryService } from '../../../services/history/common/history.service.js';
 import { Schemas } from '../../../../base/common/network.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
 const _moduleId = "vs/workbench/contrib/search/browser/searchActionsFind";
 registerAction2(class RestrictSearchToFolderAction extends Action2 {
     constructor() {
         super({
-            id: "search.action.restrictSearchToFolder" ,
+            id: SearchCommandIds.RestrictSearchToFolderId,
             title: ( localize2WithPath(_moduleId, 0, "Restrict Search to Folder")),
             category,
             keybinding: {
-                weight: 200 ,
+                weight: KeybindingWeight.WorkbenchContrib,
                 when: ( (ContextKeyExpr.and(SearchContext.SearchViewVisibleKey, SearchContext.ResourceFolderFocusKey))),
-                primary: 1024  | 512  | 36 ,
+                primary: KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.KeyF,
             },
             menu: [
                 {
@@ -51,28 +55,25 @@ registerAction2(class RestrictSearchToFolderAction extends Action2 {
 registerAction2(class ExpandSelectedTreeCommandAction extends Action2 {
     constructor() {
         super({
-            id: "search.action.expandRecursively" ,
+            id: SearchCommandIds.ExpandRecursivelyCommandId,
             title: ( localizeWithPath(_moduleId, 1, "Expand Recursively")),
             category,
             menu: [{
                     id: MenuId.SearchContext,
-                    when: ( (ContextKeyExpr.and(
-                         (ContextKeyExpr.or(SearchContext.FileFocusKey, SearchContext.FolderFocusKey)),
-                        SearchContext.HasSearchResults
-                    ))),
+                    when: ( (ContextKeyExpr.and(SearchContext.FolderFocusKey, SearchContext.HasSearchResults))),
                     group: 'search',
                     order: 4
                 }]
         });
     }
-    async run(accessor) {
-        await expandSelectSubtree(accessor);
+    run(accessor) {
+        expandSelectSubtree(accessor);
     }
 });
 registerAction2(class ExcludeFolderFromSearchAction extends Action2 {
     constructor() {
         super({
-            id: "search.action.excludeFromSearch" ,
+            id: SearchCommandIds.ExcludeFolderFromSearchId,
             title: ( localize2WithPath(_moduleId, 2, "Exclude Folder from Search")),
             category,
             menu: [
@@ -92,7 +93,7 @@ registerAction2(class ExcludeFolderFromSearchAction extends Action2 {
 registerAction2(class RevealInSideBarForSearchResultsAction extends Action2 {
     constructor() {
         super({
-            id: "search.action.revealInSideBar" ,
+            id: SearchCommandIds.RevealInSideBarForSearchResults,
             title: ( localize2WithPath(_moduleId, 3, "Reveal in Explorer View")),
             category,
             menu: [{
@@ -121,7 +122,7 @@ registerAction2(class RevealInSideBarForSearchResultsAction extends Action2 {
         else {
             return;
         }
-        paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , false).then((viewlet) => {
+        paneCompositeService.openPaneComposite(VIEWLET_ID, ViewContainerLocation.Sidebar, false).then((viewlet) => {
             if (!viewlet) {
                 return;
             }
@@ -138,7 +139,7 @@ registerAction2(class RevealInSideBarForSearchResultsAction extends Action2 {
 registerAction2(class FindInFilesAction extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.findInFiles" ,
+            id: SearchCommandIds.FindInFilesActionId,
             title: {
                 ...( localize2WithPath(_moduleId, 4, "Find in Files")),
                 mnemonicTitle: ( localizeWithPath(_moduleId, 5, "Find &&in Files")),
@@ -169,8 +170,8 @@ registerAction2(class FindInFilesAction extends Action2 {
             },
             category,
             keybinding: {
-                weight: 200 ,
-                primary: 2048  | 1024  | 36 ,
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.KeyF,
             },
             menu: [{
                     id: MenuId.MenubarEditMenu,
@@ -187,13 +188,13 @@ registerAction2(class FindInFilesAction extends Action2 {
 registerAction2(class FindInFolderAction extends Action2 {
     constructor() {
         super({
-            id: "filesExplorer.findInFolder" ,
+            id: SearchCommandIds.FindInFolderId,
             title: ( localize2WithPath(_moduleId, 8, "Find in Folder...")),
             category,
             keybinding: {
-                weight: 200 ,
+                weight: KeybindingWeight.WorkbenchContrib,
                 when: ( (ContextKeyExpr.and(FilesExplorerFocusCondition, ExplorerFolderContext))),
-                primary: 1024  | 512  | 36 ,
+                primary: KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.KeyF,
             },
             menu: [
                 {
@@ -212,7 +213,7 @@ registerAction2(class FindInFolderAction extends Action2 {
 registerAction2(class FindInWorkspaceAction extends Action2 {
     constructor() {
         super({
-            id: "filesExplorer.findInWorkspace" ,
+            id: SearchCommandIds.FindInWorkspaceId,
             title: ( localize2WithPath(_moduleId, 9, "Find in Workspace...")),
             category,
             menu: [
@@ -259,7 +260,7 @@ async function searchWithFolderCommand(accessor, isFromExplorer, isIncludes, res
     const mode = searchConfig.mode;
     let resources;
     if (isFromExplorer) {
-        resources = getMultiSelectedResources(resource, listService, accessor.get(IEditorService), accessor.get(IExplorerService));
+        resources = getMultiSelectedResources(resource, listService, accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IExplorerService));
     }
     else {
         const searchView = getSearchView(accessor.get(IViewsService));

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

@@ -13,13 +13,14 @@ import { lcut } from '../../../../base/common/strings.js';
 import { TernarySearchTree } from '../../../../base/common/ternarySearchTree.js';
 import { URI } from '../../../../base/common/uri.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { OverviewRulerLane, FindMatch } from '../../../../editor/common/model.js';
+import { TrackedRangeStickiness, OverviewRulerLane, MinimapPosition, FindMatch } from '../../../../editor/common/model.js';
 import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILabelService } from '../../../../platform/label/common/label.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
 import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import '../../../../platform/theme/common/colorUtils.js';
@@ -44,10 +45,12 @@ import { isINotebookFileMatchWithModel, contentMatchesToTextSearchMatches, webvi
 import { INotebookSearchService } from '../common/notebookSearch.service.js';
 import { isINotebookFileMatchNoModel, rawCellPrefix } from '../common/searchNotebookHelpers.js';
 import { ReplacePattern } from '../../../services/search/common/replace.js';
-import { OneLineRange, resultIsMatch } from '../../../services/search/common/search.js';
+import { OneLineRange, resultIsMatch, SearchSortOrder, QueryType, SearchCompletionExitCode } from '../../../services/search/common/search.js';
 import { ISearchService } from '../../../services/search/common/search.service.js';
 import { editorMatchesToTextSearchResults, getTextSearchMatchWithModelContext } from '../../../services/search/common/searchHelpers.js';
 import { CellSearchModel } from '../common/cellSearchModel.js';
+import { CellFindMatchModel } from '../../notebook/browser/contrib/find/findModel.js';
+import { coalesce } from '../../../../base/common/arrays.js';
 var FileMatch_1, FolderMatch_1, RangeHighlightDecorations_1;
 class Match {
     static { this.MAX_PREVIEW_CHARS = 250; }
@@ -268,7 +271,7 @@ let FileMatch = class FileMatch extends Disposable {
     static { FileMatch_1 = this; }
     static { this._CURRENT_FIND_MATCH = ModelDecorationOptions.register({
         description: 'search-current-find-match',
-        stickiness: 1 ,
+        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
         zIndex: 13,
         className: 'currentFindMatch',
         overviewRuler: {
@@ -277,12 +280,12 @@ let FileMatch = class FileMatch extends Disposable {
         },
         minimap: {
             color: themeColorFromId(minimapFindMatch),
-            position: 1
+            position: MinimapPosition.Inline
         }
     }); }
     static { this._FIND_MATCH = ModelDecorationOptions.register({
         description: 'search-find-match',
-        stickiness: 1 ,
+        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
         className: 'findMatch',
         overviewRuler: {
             color: themeColorFromId(overviewRulerFindMatchForeground),
@@ -290,7 +293,7 @@ let FileMatch = class FileMatch extends Disposable {
         },
         minimap: {
             color: themeColorFromId(minimapFindMatch),
-            position: 1
+            position: MinimapPosition.Inline
         }
     }); }
     static getDecorationOption(selected) {
@@ -466,7 +469,7 @@ let FileMatch = class FileMatch extends Disposable {
         }
         this._model.changeDecorations((accessor) => {
             const newDecorations = (this.parent().showHighlights
-                ? ( this.matches().map(match => ({
+                ? ( this.matches().map((match) => ({
                     range: match.range(),
                     options: FileMatch_1.getDecorationOption(this.isMatchSelected(match))
                 })))
@@ -680,22 +683,23 @@ let FileMatch = class FileMatch extends Disposable {
         if (!this._findMatchDecorationModel) {
             return;
         }
-        const cellFindMatch = ( cells.map((cell) => {
-            const webviewMatches = ( cell.webviewMatches.map(match => {
+        const cellFindMatch = coalesce(( cells.map((cell) => {
+            const webviewMatches = coalesce(( cell.webviewMatches.map((match) => {
+                if (!match.webviewIndex) {
+                    return undefined;
+                }
                 return {
                     index: match.webviewIndex,
                 };
-            }));
+            })));
+            if (!cell.cell) {
+                return undefined;
+            }
             const findMatches = ( cell.contentMatches.map(match => {
                 return ( new FindMatch(match.range(), [match.text()]));
             }));
-            return {
-                cell: cell.cell,
-                index: cell.cellIndex,
-                contentMatches: findMatches,
-                webviewMatches: webviewMatches
-            };
-        }));
+            return ( new CellFindMatchModel(cell.cell, cell.cellIndex, findMatches, webviewMatches));
+        })));
         try {
             this._findMatchDecorationModel.setAllFindMatchesDecorations(cellFindMatch);
         }
@@ -1186,7 +1190,7 @@ FolderMatchNoRoot = ( __decorate([
 ], FolderMatchNoRoot));
 let elemAIndex = -1;
 let elemBIndex = -1;
-function searchMatchComparer(elementA, elementB, sortOrder = "default" ) {
+function searchMatchComparer(elementA, elementB, sortOrder = SearchSortOrder.Default) {
     if (elementA instanceof FileMatch && elementB instanceof FolderMatch) {
         return 1;
     }
@@ -1200,13 +1204,13 @@ function searchMatchComparer(elementA, elementB, sortOrder = "default" ) {
             return elemAIndex - elemBIndex;
         }
         switch (sortOrder) {
-            case "countDescending" :
+            case SearchSortOrder.CountDescending:
                 return elementB.count() - elementA.count();
-            case "countAscending" :
+            case SearchSortOrder.CountAscending:
                 return elementA.count() - elementB.count();
-            case "type" :
+            case SearchSortOrder.Type:
                 return compareFileExtensions(elementA.name(), elementB.name());
-            case "fileNames" :
+            case SearchSortOrder.FileNames:
                 return compareFileNames(elementA.name(), elementB.name());
             default:
                 if (!elementA.resource || !elementB.resource) {
@@ -1217,15 +1221,15 @@ function searchMatchComparer(elementA, elementB, sortOrder = "default" ) {
     }
     if (elementA instanceof FileMatch && elementB instanceof FileMatch) {
         switch (sortOrder) {
-            case "countDescending" :
+            case SearchSortOrder.CountDescending:
                 return elementB.count() - elementA.count();
-            case "countAscending" :
+            case SearchSortOrder.CountAscending:
                 return elementA.count() - elementB.count();
-            case "type" :
+            case SearchSortOrder.Type:
                 return compareFileExtensions(elementA.name(), elementB.name());
-            case "fileNames" :
+            case SearchSortOrder.FileNames:
                 return compareFileNames(elementA.name(), elementB.name());
-            case "modified" : {
+            case SearchSortOrder.Modified: {
                 const fileStatA = elementA.fileStat;
                 const fileStatB = elementB.fileStat;
                 if (fileStatA && fileStatB) {
@@ -1268,7 +1272,7 @@ function compareNotebookPos(match1, match2) {
         return 1;
     }
 }
-function searchComparer(elementA, elementB, sortOrder = "default" ) {
+function searchComparer(elementA, elementB, sortOrder = SearchSortOrder.Default) {
     const elemAParents = createParentList(elementA);
     const elemBParents = createParentList(elementB);
     let i = elemAParents.length - 1;
@@ -1696,7 +1700,7 @@ let SearchModel = class SearchModel extends Disposable {
         }
         else {
             if (this._searchQuery) {
-                await this.aiSearch({ ...this._searchQuery, contentPattern: this._searchQuery.contentPattern.pattern, type: 3  }, onProgress, this.currentCancelTokenSource?.token);
+                await this.aiSearch({ ...this._searchQuery, contentPattern: this._searchQuery.contentPattern.pattern, type: QueryType.aiText }, onProgress, this.currentCancelTokenSource?.token);
             }
         }
     }
@@ -1706,7 +1710,7 @@ let SearchModel = class SearchModel extends Disposable {
             onProgress?.(p);
         });
         return this.progressService.withProgress({
-            location: 15 ,
+            location: ProgressLocation.Notification,
             type: 'syncing',
             title: 'Searching for AI results...',
         }, async (_) => promise);
@@ -1849,7 +1853,7 @@ let SearchModel = class SearchModel extends Disposable {
     onSearchError(e, duration, ai) {
         if (isCancellationError(e)) {
             this.onSearchCompleted((ai ? this.aiSearchCancelledForNewSearch : this.searchCancelledForNewSearch)
-                ? { exit: 1 , results: [], messages: [] }
+                ? { exit: SearchCompletionExitCode.NewSearchStarted, results: [], messages: [] }
                 : undefined, duration, '', ai);
             if (ai) {
                 this.aiSearchCancelledForNewSearch = false;
@@ -1997,7 +2001,7 @@ let RangeHighlightDecorations = class RangeHighlightDecorations {
     }
     static { this._RANGE_HIGHLIGHT_DECORATION = ModelDecorationOptions.register({
         description: 'search-range-highlight',
-        stickiness: 1 ,
+        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
         className: 'rangeHighlight',
         isWholeLine: true
     }); }

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

@@ -0,0 +1,222 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { PickerQuickAccessProvider, TriggerAction } from '../../../../platform/quickinput/browser/pickerQuickAccess.js';
+import { ThrottledDelayer } from '../../../../base/common/async.js';
+import { getWorkspaceSymbols } from '../common/search.js';
+import { SymbolKind, SymbolKinds, SymbolTag } from '../../../../editor/common/languages.js';
+import { ILabelService } from '../../../../platform/label/common/label.service.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
+import { SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { getSelectionSearchString } from '../../../../editor/contrib/find/browser/findController.js';
+import { prepareQuery, pieceToQuery, scoreFuzzy2 } from '../../../../base/common/fuzzyScorer.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+var SymbolsQuickAccessProvider_1;
+const _moduleId = "vs/workbench/contrib/search/browser/symbolsQuickAccess";
+let SymbolsQuickAccessProvider = class SymbolsQuickAccessProvider extends PickerQuickAccessProvider {
+    static { SymbolsQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '#'; }
+    static { this.TYPING_SEARCH_DELAY = 200; }
+    static { this.TREAT_AS_GLOBAL_SYMBOL_TYPES = ( (new Set([
+        SymbolKind.Class,
+        SymbolKind.Enum,
+        SymbolKind.File,
+        SymbolKind.Interface,
+        SymbolKind.Namespace,
+        SymbolKind.Package,
+        SymbolKind.Module
+    ]))); }
+    get defaultFilterValue() {
+        const editor = this.codeEditorService.getFocusedCodeEditor();
+        if (editor) {
+            return getSelectionSearchString(editor) ?? undefined;
+        }
+        return undefined;
+    }
+    constructor(labelService, openerService, editorService, configurationService, codeEditorService) {
+        super(SymbolsQuickAccessProvider_1.PREFIX, {
+            canAcceptInBackground: true,
+            noResultsPick: {
+                label: ( localizeWithPath(_moduleId, 0, "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_1.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_1.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(SymbolTag.Deprecated) >= 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' ? ( localizeWithPath(_moduleId, 1, "Open to the Side")) : ( localizeWithPath(_moduleId, 2, "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 = SymbolsQuickAccessProvider_1 = ( (__decorate([
+    ( (__param(0, ILabelService))),
+    ( (__param(1, IOpenerService))),
+    ( (__param(2, IEditorService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, ICodeEditorService)))
+], SymbolsQuickAccessProvider)));
+export { SymbolsQuickAccessProvider };