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

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

@@ -0,0 +1,467 @@
+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$2 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { defaultQuickAccessContextKeyValue } from '../../../browser/quickaccess.js';
+import { Extensions } from '../../../common/views.js';
+import { GotoSymbolQuickAccessProvider } from '../../codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js';
+import { AnythingQuickAccessProvider } from './anythingQuickAccess.js';
+import { registerContributions } from './replaceContributions.js';
+import { searchViewIcon } from './searchIcons.js';
+import { SearchView } from './searchView.js';
+import { registerContributions as registerContributions$1 } from './searchWidget.js';
+import { SymbolsQuickAccessProvider } from './symbolsQuickAccess.js';
+import { VIEWLET_ID, SEARCH_EXCLUDE_CONFIG, VIEW_ID } from '../../../services/search/common/search.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
+import { getWorkspaceSymbols } from '../common/search.js';
+import { ShowAllSymbolsActionId } from '../common/constants.js';
+registerContributions();
+registerContributions$1();
+const SEARCH_MODE_CONFIG = 'search.mode';
+const viewContainer = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+    id: VIEWLET_ID,
+    title: { value: ( nls.localize('name', "Search")), original: 'Search' },
+    ctorDescriptor: ( new SyncDescriptor(
+        ViewPaneContainer,
+        [VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }]
+    )),
+    hideIfEmpty: true,
+    icon: searchViewIcon,
+    order: 1,
+}, 0 , { doNotRegisterOpenCommand: true });
+const viewDescriptor = {
+    id: VIEW_ID,
+    containerIcon: searchViewIcon,
+    name: ( nls.localize('search', "Search")),
+    ctorDescriptor: ( new SyncDescriptor(SearchView)),
+    canToggleVisibility: false,
+    canMoveView: true,
+    openCommandActionDescriptor: {
+        id: viewContainer.id,
+        mnemonicTitle: ( nls.localize({ key: 'miViewSearch', comment: ['&& denotes a mnemonic'] }, "&&Search")),
+        keybindings: {
+            primary: 2048  | 1024  | 36 ,
+            when: ( ContextKeyExpr.regex('neverMatch', /doesNotMatch/))
+        },
+        order: 1
+    }
+};
+( Registry.as(Extensions.ViewsRegistry)).registerViews([viewDescriptor], viewContainer);
+const quickAccessRegistry = ( Registry.as(Extensions$1.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$2.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."))
+        }
+    }
+});
+CommandsRegistry.registerCommand('_executeWorkspaceSymbolProvider', async function (accessor, ...args) {
+    const [query] = args;
+    assertType(typeof query === 'string');
+    const result = await getWorkspaceSymbols(query);
+    return ( result.map(item => item.symbol));
+});

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

@@ -0,0 +1,17 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { VIEW_ID } from '../../../services/search/common/search.js';
+function isSearchViewFocused(viewsService) {
+    const searchView = getSearchView(viewsService);
+    const activeElement = document.activeElement;
+    return !!(searchView && activeElement && dom.isAncestor(activeElement, searchView.getContainer()));
+}
+function appendKeyBindingLabel(label, inputKeyBinding) {
+    return doAppendKeyBindingLabel(label, inputKeyBinding);
+}
+function getSearchView(viewsService) {
+    return viewsService.getActiveViewWithId(VIEW_ID);
+}
+function doAppendKeyBindingLabel(label, keyBinding) {
+    return keyBinding ? label + ' (' + keyBinding.getLabel() + ')' : label;
+}
+export { appendKeyBindingLabel, getSearchView, isSearchViewFocused };

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

@@ -0,0 +1,41 @@
+import { ContextScopedFindInput } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { NotebookFindInputFilterButton } from '../../notebook/browser/contrib/find/notebookFindReplaceWidget.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+class SearchFindInput extends ContextScopedFindInput {
+    constructor(container, contextViewProvider, options, contextKeyService, contextMenuService, instantiationService, filters, filterStartVisiblitity) {
+        super(container, contextViewProvider, options, contextKeyService);
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this.filters = filters;
+        this._filterChecked = false;
+        this._visible = false;
+        this._findFilter = this._register(( new NotebookFindInputFilterButton(filters, contextMenuService, instantiationService, options, ( nls.localize('searchFindInputNotebookFilter.label', "Notebook Find Filters")))));
+        this.inputBox.paddingRight = (this.caseSensitive?.width() ?? 0) + (this.wholeWords?.width() ?? 0) + (this.regex?.width() ?? 0) + this._findFilter.width;
+        this.controls.appendChild(this._findFilter.container);
+        this._findFilter.container.classList.add('monaco-custom-toggle');
+        this.filterVisible = filterStartVisiblitity;
+    }
+    set filterVisible(show) {
+        this._findFilter.container.style.display = show ? '' : 'none';
+        this._visible = show;
+        this.updateStyles();
+    }
+    setEnabled(enabled) {
+        super.setEnabled(enabled);
+        if (enabled && (!this._filterChecked || !this._visible)) {
+            this.regex?.enable();
+        }
+        else {
+            this.regex?.disable();
+        }
+    }
+    updateStyles() {
+        this._filterChecked =
+            !this.filters.markupInput ||
+                !this.filters.markupPreview ||
+                !this.filters.codeInput ||
+                !this.filters.codeOutput;
+        this._findFilter.applyStyles(this._filterChecked);
+    }
+}
+export { SearchFindInput };

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

@@ -0,0 +1,35 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const searchDetailsIcon = registerIcon('search-details', Codicon.ellipsis, ( localize('searchDetailsIcon', 'Icon to make search details visible.')));
+const searchShowContextIcon = registerIcon('search-show-context', Codicon.listSelection, ( localize(
+ 'searchShowContextIcon',
+ 'Icon for toggle the context in the search editor.'
+)));
+const searchHideReplaceIcon = registerIcon('search-hide-replace', Codicon.chevronRight, ( localize(
+ 'searchHideReplaceIcon',
+ 'Icon to collapse the replace section in the search view.'
+)));
+const searchShowReplaceIcon = registerIcon('search-show-replace', Codicon.chevronDown, ( localize(
+ 'searchShowReplaceIcon',
+ 'Icon to expand the replace section in the search view.'
+)));
+const searchReplaceAllIcon = registerIcon('search-replace-all', Codicon.replaceAll, ( localize('searchReplaceAllIcon', 'Icon for replace all in the search view.')));
+registerIcon('search-replace', Codicon.replace, ( localize('searchReplaceIcon', 'Icon for replace in the search view.')));
+registerIcon('search-remove', Codicon.close, ( localize('searchRemoveIcon', 'Icon to remove a search result.')));
+const searchRefreshIcon = registerIcon('search-refresh', Codicon.refresh, ( localize('searchRefreshIcon', 'Icon for refresh in the search view.')));
+registerIcon('search-collapse-results', Codicon.collapseAll, ( localize('searchCollapseAllIcon', 'Icon for collapse results in the search view.')));
+registerIcon('search-expand-results', Codicon.expandAll, ( localize('searchExpandAllIcon', 'Icon for expand results in the search view.')));
+registerIcon('search-tree', Codicon.listTree, ( localize(
+ 'searchShowAsTree',
+ 'Icon for viewing results as a tree in the search view.'
+)));
+registerIcon('search-list', Codicon.listFlat, ( localize(
+ 'searchShowAsList',
+ 'Icon for viewing results as a list in the search view.'
+)));
+registerIcon('search-clear-results', Codicon.clearAll, ( localize('searchClearIcon', 'Icon for clear results in the search view.')));
+registerIcon('search-stop', Codicon.searchStop, ( localize('searchStopIcon', 'Icon for stop in the search view.')));
+const searchViewIcon = registerIcon('search-view-icon', Codicon.search, ( localize('searchViewIcon', 'View icon of the search view.')));
+const searchNewEditorIcon = registerIcon('search-new-editor', Codicon.newFile, ( localize('searchNewEditorIcon', 'Icon for the action to open a new search editor.')));
+export { searchDetailsIcon, searchHideReplaceIcon, searchNewEditorIcon, searchRefreshIcon, searchReplaceAllIcon, searchShowContextIcon, searchShowReplaceIcon, searchViewIcon };

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

@@ -0,0 +1,58 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { SeverityIcon } from 'monaco-editor/esm/vs/platform/severityIcon/browser/severityIcon.js';
+import { TextSearchCompleteMessageType } from '../../../services/search/common/searchExtTypes.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+const renderSearchMessage = (message, instantiationService, notificationService, openerService, commandService, disposableStore, triggerSearch) => {
+    const div = dom.$('div.providerMessage');
+    const linkedText = parseLinkedText(message.text);
+    dom.append(div, dom.$('.' +
+        SeverityIcon.className(message.type === TextSearchCompleteMessageType.Information
+            ? Severity.Info
+            : Severity.Warning)
+            .split(' ')
+            .join('.')));
+    for (const node of linkedText.nodes) {
+        if (typeof node === 'string') {
+            dom.append(div, document.createTextNode(node));
+        }
+        else {
+            const link = instantiationService.createInstance(Link, div, node, {
+                opener: async (href) => {
+                    if (!message.trusted) {
+                        return;
+                    }
+                    const parsed = ( URI.parse(href, true));
+                    if (parsed.scheme === Schemas.command && message.trusted) {
+                        const result = await commandService.executeCommand(parsed.path);
+                        if (result?.triggerSearch) {
+                            triggerSearch();
+                        }
+                    }
+                    else if (parsed.scheme === Schemas.https) {
+                        openerService.open(parsed);
+                    }
+                    else {
+                        if (parsed.scheme === Schemas.command && !message.trusted) {
+                            notificationService.error(( nls.localize(
+                                'unable to open trust',
+                                "Unable to open command link from untrusted source: {0}",
+                                href
+                            )));
+                        }
+                        else {
+                            notificationService.error(( nls.localize('unable to open', "Unable to open unknown link: {0}", href)));
+                        }
+                    }
+                }
+            });
+            disposableStore.add(link);
+        }
+    }
+    return div;
+};
+export { renderSearchMessage };