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

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 };

package/dist/vscode/vs/workbench/contrib/search/common/cacheState.js

@@ -0,0 +1,85 @@
+import { defaultGenerator } from 'monaco-editor/esm/vs/base/common/idGenerator.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+var LoadingPhase;
+( (function(LoadingPhase) {
+    LoadingPhase[LoadingPhase["Created"] = 1] = "Created";
+    LoadingPhase[LoadingPhase["Loading"] = 2] = "Loading";
+    LoadingPhase[LoadingPhase["Loaded"] = 3] = "Loaded";
+    LoadingPhase[LoadingPhase["Errored"] = 4] = "Errored";
+    LoadingPhase[LoadingPhase["Disposed"] = 5] = "Disposed";
+})(LoadingPhase || (LoadingPhase = {})));
+class FileQueryCacheState {
+    get cacheKey() {
+        if (this.loadingPhase === LoadingPhase.Loaded || !this.previousCacheState) {
+            return this._cacheKey;
+        }
+        return this.previousCacheState.cacheKey;
+    }
+    get isLoaded() {
+        const isLoaded = this.loadingPhase === LoadingPhase.Loaded;
+        return isLoaded || !this.previousCacheState ? isLoaded : this.previousCacheState.isLoaded;
+    }
+    get isUpdating() {
+        const isUpdating = this.loadingPhase === LoadingPhase.Loading;
+        return isUpdating || !this.previousCacheState ? isUpdating : this.previousCacheState.isUpdating;
+    }
+    constructor(cacheQuery, loadFn, disposeFn, previousCacheState) {
+        this.cacheQuery = cacheQuery;
+        this.loadFn = loadFn;
+        this.disposeFn = disposeFn;
+        this.previousCacheState = previousCacheState;
+        this._cacheKey = defaultGenerator.nextId();
+        this.query = this.cacheQuery(this._cacheKey);
+        this.loadingPhase = LoadingPhase.Created;
+        if (this.previousCacheState) {
+            const current = Object.assign({}, this.query, { cacheKey: null });
+            const previous = Object.assign({}, this.previousCacheState.query, { cacheKey: null });
+            if (!equals(current, previous)) {
+                this.previousCacheState.dispose();
+                this.previousCacheState = undefined;
+            }
+        }
+    }
+    load() {
+        if (this.isUpdating) {
+            return this;
+        }
+        this.loadingPhase = LoadingPhase.Loading;
+        this.loadPromise = (async () => {
+            try {
+                await this.loadFn(this.query);
+                this.loadingPhase = LoadingPhase.Loaded;
+                if (this.previousCacheState) {
+                    this.previousCacheState.dispose();
+                    this.previousCacheState = undefined;
+                }
+            }
+            catch (error) {
+                this.loadingPhase = LoadingPhase.Errored;
+                throw error;
+            }
+        })();
+        return this;
+    }
+    dispose() {
+        if (this.loadPromise) {
+            (async () => {
+                try {
+                    await this.loadPromise;
+                }
+                catch (error) {
+                }
+                this.loadingPhase = LoadingPhase.Disposed;
+                this.disposeFn(this._cacheKey);
+            })();
+        }
+        else {
+            this.loadingPhase = LoadingPhase.Disposed;
+        }
+        if (this.previousCacheState) {
+            this.previousCacheState.dispose();
+            this.previousCacheState = undefined;
+        }
+    }
+}
+export { FileQueryCacheState };

package/dist/vscode/vs/workbench/contrib/search/common/constants.js

@@ -0,0 +1,31 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const OpenInEditorCommandId = 'search.action.openInEditor';
+const ToggleCaseSensitiveCommandId = 'toggleSearchCaseSensitive';
+const ToggleWholeWordCommandId = 'toggleSearchWholeWord';
+const ToggleRegexCommandId = 'toggleSearchRegex';
+const TogglePreserveCaseId = 'toggleSearchPreserveCase';
+const ShowAllSymbolsActionId = 'workbench.action.showAllSymbols';
+const SearchViewVisibleKey = ( new RawContextKey('searchViewletVisible', true));
+const SearchViewFocusedKey = ( new RawContextKey('searchViewletFocus', false));
+const InputBoxFocusedKey = ( new RawContextKey('inputBoxFocus', false));
+const SearchInputBoxFocusedKey = ( new RawContextKey('searchInputBoxFocus', false));
+const ReplaceInputBoxFocusedKey = ( new RawContextKey('replaceInputBoxFocus', false));
+const PatternIncludesFocusedKey = ( new RawContextKey('patternIncludesInputBoxFocus', false));
+const PatternExcludesFocusedKey = ( new RawContextKey('patternExcludesInputBoxFocus', false));
+const ReplaceActiveKey = ( new RawContextKey('replaceActive', false));
+const HasSearchResults = ( new RawContextKey('hasSearchResult', false));
+const FirstMatchFocusKey = ( new RawContextKey('firstMatchFocus', false));
+const FileMatchOrMatchFocusKey = ( new RawContextKey('fileMatchOrMatchFocus', false));
+const FileMatchOrFolderMatchFocusKey = ( new RawContextKey('fileMatchOrFolderMatchFocus', false));
+const FileMatchOrFolderMatchWithResourceFocusKey = ( new RawContextKey('fileMatchOrFolderMatchWithResourceFocus', false));
+const FileFocusKey = ( new RawContextKey('fileMatchFocus', false));
+const FolderFocusKey = ( new RawContextKey('folderMatchFocus', false));
+const ResourceFolderFocusKey = ( new RawContextKey('folderMatchWithResourceFocus', false));
+const IsEditableItemKey = ( new RawContextKey('isEditableItem', true));
+const MatchFocusKey = ( new RawContextKey('matchFocus', false));
+const ViewHasSearchPatternKey = ( new RawContextKey('viewHasSearchPattern', false));
+const ViewHasReplacePatternKey = ( new RawContextKey('viewHasReplacePattern', false));
+const ViewHasFilePatternKey = ( new RawContextKey('viewHasFilePattern', false));
+const ViewHasSomeCollapsibleKey = ( new RawContextKey('viewHasSomeCollapsibleResult', false));
+const InTreeViewKey = ( new RawContextKey('inTreeView', false));
+export { FileFocusKey, FileMatchOrFolderMatchFocusKey, FileMatchOrFolderMatchWithResourceFocusKey, FileMatchOrMatchFocusKey, FirstMatchFocusKey, FolderFocusKey, HasSearchResults, InTreeViewKey, InputBoxFocusedKey, IsEditableItemKey, MatchFocusKey, OpenInEditorCommandId, PatternExcludesFocusedKey, PatternIncludesFocusedKey, ReplaceActiveKey, ReplaceInputBoxFocusedKey, ResourceFolderFocusKey, SearchInputBoxFocusedKey, SearchViewFocusedKey, SearchViewVisibleKey, ShowAllSymbolsActionId, ToggleCaseSensitiveCommandId, TogglePreserveCaseId, ToggleRegexCommandId, ToggleWholeWordCommandId, ViewHasFilePatternKey, ViewHasReplacePatternKey, ViewHasSearchPatternKey, ViewHasSomeCollapsibleKey };

package/dist/vscode/vs/workbench/contrib/search/common/search.js

@@ -1,3 +1,14 @@
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { groupBy } from 'monaco-editor/esm/vs/base/common/arrays.js';
 var WorkspaceSymbolProviderRegistry;
 ( (function(WorkspaceSymbolProviderRegistry) {
     const _supports = [];
@@ -24,4 +35,119 @@ var WorkspaceSymbolProviderRegistry;
     }
     WorkspaceSymbolProviderRegistry.all = all;
 })(WorkspaceSymbolProviderRegistry || (WorkspaceSymbolProviderRegistry = {})));
-export { WorkspaceSymbolProviderRegistry };
+class WorkspaceSymbolItem {
+    constructor(symbol, provider) {
+        this.symbol = symbol;
+        this.provider = provider;
+    }
+}
+async function getWorkspaceSymbols(query, token = CancellationToken.None) {
+    const all = [];
+    const promises = ( WorkspaceSymbolProviderRegistry.all().map(async (provider) => {
+        try {
+            const value = await provider.provideWorkspaceSymbols(query, token);
+            if (!value) {
+                return;
+            }
+            for (const symbol of value) {
+                all.push(( new WorkspaceSymbolItem(symbol, provider)));
+            }
+        }
+        catch (err) {
+            onUnexpectedExternalError(err);
+        }
+    }));
+    await Promise.all(promises);
+    if (token.isCancellationRequested) {
+        return [];
+    }
+    function compareItems(a, b) {
+        let res = compare(a.symbol.name, b.symbol.name);
+        if (res === 0) {
+            res = a.symbol.kind - b.symbol.kind;
+        }
+        if (res === 0) {
+            res = compare(( a.symbol.location.uri.toString()), ( b.symbol.location.uri.toString()));
+        }
+        if (res === 0) {
+            if (a.symbol.location.range && b.symbol.location.range) {
+                if (!Range.areIntersecting(a.symbol.location.range, b.symbol.location.range)) {
+                    res = Range.compareRangesUsingStarts(a.symbol.location.range, b.symbol.location.range);
+                }
+            }
+            else if (a.provider.resolveWorkspaceSymbol && !b.provider.resolveWorkspaceSymbol) {
+                res = -1;
+            }
+            else if (!a.provider.resolveWorkspaceSymbol && b.provider.resolveWorkspaceSymbol) {
+                res = 1;
+            }
+        }
+        if (res === 0) {
+            res = compare(a.symbol.containerName ?? '', b.symbol.containerName ?? '');
+        }
+        return res;
+    }
+    return ( groupBy(all, compareItems).map(group => group[0])).flat();
+}
+function getOutOfWorkspaceEditorResources(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const contextService = accessor.get(IWorkspaceContextService);
+    const fileService = accessor.get(IFileService);
+    const resources = ( editorService.editors
+        .map(
+        editor => EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
+    ))
+        .filter(resource => !!resource && !contextService.isInsideWorkspace(resource) && fileService.hasProvider(resource));
+    return resources;
+}
+const LINE_COLON_PATTERN = /\s?[#:\(](?:line )?(\d*)(?:[#:,](\d*))?\)?\s*$/;
+function extractRangeFromFilter(filter, unless) {
+    if (!filter || unless?.some(value => filter.indexOf(value) !== -1)) {
+        return undefined;
+    }
+    let range = undefined;
+    const patternMatch = LINE_COLON_PATTERN.exec(filter);
+    if (patternMatch) {
+        const startLineNumber = parseInt(patternMatch[1] ?? '', 10);
+        if (isNumber(startLineNumber)) {
+            range = {
+                startLineNumber: startLineNumber,
+                startColumn: 1,
+                endLineNumber: startLineNumber,
+                endColumn: 1
+            };
+            const startColumn = parseInt(patternMatch[2] ?? '', 10);
+            if (isNumber(startColumn)) {
+                range = {
+                    startLineNumber: range.startLineNumber,
+                    startColumn: startColumn,
+                    endLineNumber: range.endLineNumber,
+                    endColumn: startColumn
+                };
+            }
+        }
+        else if (patternMatch[1] === '') {
+            range = {
+                startLineNumber: 1,
+                startColumn: 1,
+                endLineNumber: 1,
+                endColumn: 1
+            };
+        }
+    }
+    if (patternMatch && range) {
+        return {
+            filter: filter.substr(0, patternMatch.index),
+            range
+        };
+    }
+    return undefined;
+}
+var SearchUIState;
+( (function(SearchUIState) {
+    SearchUIState[SearchUIState["Idle"] = 0] = "Idle";
+    SearchUIState[SearchUIState["Searching"] = 1] = "Searching";
+    SearchUIState[SearchUIState["SlowSearch"] = 2] = "SlowSearch";
+})(SearchUIState || (SearchUIState = {})));
+const SearchStateKey = ( new RawContextKey('searchState', SearchUIState.Idle));
+export { SearchStateKey, SearchUIState, WorkspaceSymbolItem, WorkspaceSymbolProviderRegistry, extractRangeFromFilter, getOutOfWorkspaceEditorResources, getWorkspaceSymbols };

package/dist/vscode/vs/workbench/contrib/search/common/searchHistoryService.js

@@ -0,0 +1,42 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ISearchHistoryService = ( createDecorator('searchHistoryService'));
+let SearchHistoryService = class SearchHistoryService {
+    constructor(storageService) {
+        this.storageService = storageService;
+        this._onDidClearHistory = ( new Emitter());
+        this.onDidClearHistory = this._onDidClearHistory.event;
+    }
+    clearHistory() {
+        this.storageService.remove(SearchHistoryService.SEARCH_HISTORY_KEY, 1 );
+        this._onDidClearHistory.fire();
+    }
+    load() {
+        let result;
+        const raw = this.storageService.get(SearchHistoryService.SEARCH_HISTORY_KEY, 1 );
+        if (raw) {
+            try {
+                result = JSON.parse(raw);
+            }
+            catch (e) {
+            }
+        }
+        return result || {};
+    }
+    save(history) {
+        if (isEmptyObject(history)) {
+            this.storageService.remove(SearchHistoryService.SEARCH_HISTORY_KEY, 1 );
+        }
+        else {
+            this.storageService.store(SearchHistoryService.SEARCH_HISTORY_KEY, JSON.stringify(history), 1 , 1 );
+        }
+    }
+};
+SearchHistoryService.SEARCH_HISTORY_KEY = 'workbench.search.history';
+SearchHistoryService = ( __decorate([
+    ( __param(0, IStorageService))
+], SearchHistoryService));
+export { ISearchHistoryService, SearchHistoryService };

package/dist/vscode/vs/workbench/contrib/searchEditor/browser/constants.js

@@ -0,0 +1,11 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const InSearchEditor = ( new RawContextKey('inSearchEditor', false));
+const SearchEditorScheme = 'search-editor';
+const SearchEditorWorkingCopyTypeId = 'search/editor';
+const SearchEditorFindMatchClass = 'searchEditorFindMatch';
+const SearchEditorID = 'workbench.editor.searchEditor';
+const OpenNewEditorCommandId = 'search.action.openNewEditor';
+const OpenEditorCommandId = 'search.action.openEditor';
+const ToggleSearchEditorContextLinesCommandId = 'toggleSearchEditorContextLines';
+const SearchEditorInputTypeId = 'workbench.editorinputs.searchEditorInput';
+export { InSearchEditor, OpenEditorCommandId, OpenNewEditorCommandId, SearchEditorFindMatchClass, SearchEditorID, SearchEditorInputTypeId, SearchEditorScheme, SearchEditorWorkingCopyTypeId, ToggleSearchEditorContextLinesCommandId };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".search-editor{display:flex;flex-direction:column}.search-editor .search-results{flex:1}.search-editor .query-container{margin:0 12px 12px 19px;padding-top:6px}.search-editor .search-widget .toggle-replace-button{align-items:center;background-position:50%;background-repeat:no-repeat;box-sizing:border-box;cursor:pointer;display:flex;height:100%;justify-content:center;left:0;position:absolute;top:0;width:16px}.search-editor .search-widget .replace-container,.search-editor .search-widget .search-container{align-items:center;display:flex}.search-editor .search-widget .monaco-findInput{display:inline-block;vertical-align:middle;width:100%}.search-editor .search-widget .monaco-inputbox>.ibwrapper{height:100%}.search-editor .search-widget .monaco-inputbox>.ibwrapper>.mirror,.search-editor .search-widget .monaco-inputbox>.ibwrapper>textarea.input{padding:3px 3px 3px 6px}.search-editor .search-widget .monaco-inputbox>.ibwrapper>.mirror{max-height:134px}.search-editor .search-widget .monaco-inputbox>.ibwrapper>textarea.input{height:26px;overflow:initial}.search-editor .monaco-inputbox>.ibwrapper>textarea.input{scrollbar-width:none}.search-editor .monaco-inputbox>.ibwrapper>textarea.input::-webkit-scrollbar{display:none}.search-editor .search-widget .context-lines-input{margin-left:5px;margin-right:2px;max-width:50px}.search-editor .search-widget .context-lines-input input[type=number]::-webkit-inner-spin-button{-webkit-appearance:none!important}.search-editor .search-widget .replace-container{display:inline-flex;margin-top:6px;position:relative}.search-editor .search-widget .replace-input{display:flex;height:25px;position:relative;vertical-align:middle;width:auto!important}.search-editor .search-widget .replace-input>.controls{position:absolute;right:2px;top:3px}.search-editor .search-widget .replace-container.disabled{display:none}.search-editor .search-widget .replace-container .monaco-action-bar{height:25px;margin-left:0}.search-editor .search-widget .replace-container .monaco-action-bar .action-item .codicon{align-items:center;background-repeat:no-repeat;display:flex;height:25px;justify-content:center;margin-right:0;width:25px}.search-editor .includes-excludes{min-height:1em;position:relative}.search-editor .includes-excludes .expand{cursor:pointer;height:16px;position:absolute;right:-2px;width:25px;z-index:2}.search-editor .includes-excludes .file-types{display:none}.search-editor .includes-excludes.expanded .file-types{display:inherit}.search-editor .includes-excludes.expanded .file-types:last-child{padding-bottom:10px}.search-editor .includes-excludes.expanded h4{font-size:11px;font-weight:400;margin:0;overflow:hidden;padding:4px 0 0;text-overflow:ellipsis;white-space:nowrap}.search-editor .messages{cursor:default;margin-top:-5px}.search-editor .message{padding-left:7px;padding-right:22px;padding-top:0}.search-editor a.prominent{text-decoration:underline}.monaco-editor .searchEditorFindMatch{background-color:var(--vscode-searchEditor-findMatchBackground);border:1px solid var(--vscode-searchEditor-findMatchBorder);box-sizing:border-box}.monaco-editor.hc-black .searchEditorFindMatch,.monaco-editor.hc-light .searchEditorFindMatch{border:1px dotted var(--vscode-searchEditor-findMatchBorder)}";
+n(css,{});
+export { css, css as default };