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

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

@@ -6,6 +6,7 @@ import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation
 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;
@@ -142,4 +143,11 @@ function extractRangeFromFilter(filter, unless) {
     }
     return undefined;
 }
-export { WorkspaceSymbolItem, WorkspaceSymbolProviderRegistry, extractRangeFromFilter, getOutOfWorkspaceEditorResources, getWorkspaceSymbols };
+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 };

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

@@ -0,0 +1,477 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { extname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ToggleCaseSensitiveKeybinding, ToggleWholeWordKeybinding, ToggleRegexKeybinding } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findModel.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { Extensions } from '../../../common/contributions.js';
+import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+import { ActiveEditorContext } from '../../../common/contextkeys.js';
+import { IViewsService } from '../../../common/views.js';
+import { getSearchView } from '../../search/browser/searchActionsBase.js';
+import { searchRefreshIcon, searchNewEditorIcon } from '../../search/browser/searchIcons.js';
+import { HasSearchResults, SearchViewFocusedKey, SearchInputBoxFocusedKey } from '../../search/common/constants.js';
+import { InSearchEditor, OpenNewEditorCommandId, OpenEditorCommandId, SearchEditorID, ToggleSearchEditorContextLinesCommandId, SearchEditorScheme } from './constants.js';
+import { SearchEditor } from './searchEditor.js';
+import { openNewSearchEditor, createEditorFromSearchResult, toggleSearchEditorCaseSensitiveCommand, toggleSearchEditorWholeWordCommand, toggleSearchEditorRegexCommand, toggleSearchEditorContextLinesCommand, modifySearchEditorContextLinesCommand, selectAllSearchEditorMatchesCommand, openSearchEditor } from './searchEditorActions.js';
+import { SearchEditorInput, SEARCH_EDITOR_EXT, getOrMakeSearchEditorInput } from './searchEditorInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { VIEW_ID } from '../../../services/search/common/search.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { IWorkingCopyEditorService } from '../../../services/workingCopy/common/workingCopyEditorService.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const OpenInEditorCommandId = 'search.action.openInEditor';
+const OpenNewEditorToSideCommandId = 'search.action.openNewEditorToSide';
+const FocusQueryEditorWidgetCommandId = 'search.action.focusQueryEditorWidget';
+const FocusQueryEditorFilesToIncludeCommandId = 'search.action.focusFilesToInclude';
+const FocusQueryEditorFilesToExcludeCommandId = 'search.action.focusFilesToExclude';
+const ToggleSearchEditorCaseSensitiveCommandId = 'toggleSearchEditorCaseSensitive';
+const ToggleSearchEditorWholeWordCommandId = 'toggleSearchEditorWholeWord';
+const ToggleSearchEditorRegexCommandId = 'toggleSearchEditorRegex';
+const IncreaseSearchEditorContextLinesCommandId = 'increaseSearchEditorContextLines';
+const DecreaseSearchEditorContextLinesCommandId = 'decreaseSearchEditorContextLines';
+const RerunSearchEditorSearchCommandId = 'rerunSearchEditorSearch';
+const CleanSearchEditorStateCommandId = 'cleanSearchEditorState';
+const SelectAllSearchEditorMatchesCommandId = 'selectAllSearchEditorMatches';
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(SearchEditor, SearchEditor.ID, ( localize('searchEditor', "Search Editor"))), [
+    ( new SyncDescriptor(SearchEditorInput))
+]);
+let SearchEditorContribution = class SearchEditorContribution {
+    constructor(editorResolverService, instantiationService) {
+        editorResolverService.registerEditor('*' + SEARCH_EDITOR_EXT, {
+            id: SearchEditorInput.ID,
+            label: ( localize('promptOpenWith.searchEditor.displayName', "Search Editor")),
+            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
+            priority: RegisteredEditorPriority.default,
+        }, {
+            singlePerResource: true,
+            canSupportResource: resource => (extname(resource) === SEARCH_EDITOR_EXT)
+        }, {
+            createEditorInput: ({ resource }) => {
+                return { editor: instantiationService.invokeFunction(getOrMakeSearchEditorInput, { from: 'existingFile', fileUri: resource }) };
+            }
+        });
+    }
+};
+SearchEditorContribution = ( __decorate([
+    ( __param(0, IEditorResolverService)),
+    ( __param(1, IInstantiationService))
+], SearchEditorContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(SearchEditorContribution, 1 );
+CommandsRegistry.registerCommand(CleanSearchEditorStateCommandId, (accessor) => {
+    const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+    if (activeEditorPane instanceof SearchEditor) {
+        activeEditorPane.cleanState();
+    }
+});
+const category = { value: ( localize('search', "Search Editor")), original: 'Search Editor' };
+const translateLegacyConfig = (legacyConfig = {}) => {
+    const config = {};
+    const overrides = {
+        includes: 'filesToInclude',
+        excludes: 'filesToExclude',
+        wholeWord: 'matchWholeWord',
+        caseSensitive: 'isCaseSensitive',
+        regexp: 'isRegexp',
+        useIgnores: 'useExcludeSettingsAndIgnoreFiles',
+    };
+    Object.entries(legacyConfig).forEach(([key, value]) => {
+        config[overrides[key] ?? key] = value;
+    });
+    return config;
+};
+const openArgDescription = {
+    description: 'Open a new search editor. Arguments passed can include variables like ${relativeFileDirname}.',
+    args: [{
+            name: 'Open new Search Editor args',
+            schema: {
+                properties: {
+                    query: { type: 'string' },
+                    filesToInclude: { type: 'string' },
+                    filesToExclude: { type: 'string' },
+                    contextLines: { type: 'number' },
+                    matchWholeWord: { type: 'boolean' },
+                    isCaseSensitive: { type: 'boolean' },
+                    isRegexp: { type: 'boolean' },
+                    useExcludeSettingsAndIgnoreFiles: { type: 'boolean' },
+                    showIncludesExcludes: { type: 'boolean' },
+                    triggerSearch: { type: 'boolean' },
+                    focusResults: { type: 'boolean' },
+                    onlyOpenEditors: { type: 'boolean' },
+                }
+            }
+        }]
+};
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'search.searchEditor.action.deleteFileResults',
+            title: { value: ( localize('searchEditor.deleteResultBlock', "Delete File Results")), original: 'Delete File Results' },
+            keybinding: {
+                weight: 100 ,
+                primary: 2048  | 1024  | 1 ,
+            },
+            precondition: InSearchEditor,
+            category,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const contextService = accessor.get(IContextKeyService).getContext(document.activeElement);
+        if (contextService.getValue(InSearchEditor.serialize())) {
+            accessor.get(IEditorService).activeEditorPane.deleteResultBlock();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenNewEditorCommandId,
+            title: { value: ( localize('search.openNewSearchEditor', "New Search Editor")), original: 'New Search Editor' },
+            category,
+            f1: true,
+            description: openArgDescription
+        });
+    }
+    async run(accessor, args) {
+        await accessor.get(IInstantiationService).invokeFunction(openNewSearchEditor, translateLegacyConfig({ location: 'new', ...args }));
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenEditorCommandId,
+            title: { value: ( localize('search.openSearchEditor', "Open Search Editor")), original: 'Open Search Editor' },
+            category,
+            f1: true,
+            description: openArgDescription
+        });
+    }
+    async run(accessor, args) {
+        await accessor.get(IInstantiationService).invokeFunction(openNewSearchEditor, translateLegacyConfig({ location: 'reuse', ...args }));
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenNewEditorToSideCommandId,
+            title: { value: ( localize('search.openNewEditorToSide', "Open New Search Editor to the Side")), original: 'Open new Search Editor to the Side' },
+            category,
+            f1: true,
+            description: openArgDescription
+        });
+    }
+    async run(accessor, args) {
+        await accessor.get(IInstantiationService).invokeFunction(openNewSearchEditor, translateLegacyConfig(args), true);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenInEditorCommandId,
+            title: { value: ( localize('search.openResultsInEditor', "Open Results in Editor")), original: 'Open Results in Editor' },
+            category,
+            f1: true,
+            keybinding: {
+                primary: 512  | 3 ,
+                when: ( ContextKeyExpr.and(HasSearchResults, SearchViewFocusedKey)),
+                weight: 200 ,
+                mac: {
+                    primary: 2048  | 3
+                }
+            },
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const searchView = getSearchView(viewsService);
+        if (searchView) {
+            await instantiationService.invokeFunction(createEditorFromSearchResult, searchView.searchResult, searchView.searchIncludePattern.getValue(), searchView.searchExcludePattern.getValue(), searchView.searchIncludePattern.onlySearchInOpenEditors());
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RerunSearchEditorSearchCommandId,
+            title: { value: ( localize('search.rerunSearchInEditor', "Search Again")), original: 'Search Again' },
+            category,
+            keybinding: {
+                primary: 2048  | 1024  | 48 ,
+                when: InSearchEditor,
+                weight: 100
+            },
+            icon: searchRefreshIcon,
+            menu: [{
+                    id: MenuId.EditorTitle,
+                    group: 'navigation',
+                    when: ( ActiveEditorContext.isEqualTo(SearchEditorID))
+                },
+                {
+                    id: MenuId.CommandPalette,
+                    when: ( ActiveEditorContext.isEqualTo(SearchEditorID))
+                }]
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.triggerSearch({ resetCursor: false });
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: FocusQueryEditorWidgetCommandId,
+            title: { value: ( localize('search.action.focusQueryEditorWidget', "Focus Search Editor Input")), original: 'Focus Search Editor Input' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                primary: 9 ,
+                weight: 100
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusSearchInput();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: FocusQueryEditorFilesToIncludeCommandId,
+            title: { value: ( localize(
+                'search.action.focusFilesToInclude',
+                "Focus Search Editor Files to Include"
+            )), original: 'Focus Search Editor Files to Include' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusFilesToIncludeInput();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: FocusQueryEditorFilesToExcludeCommandId,
+            title: { value: ( localize(
+                'search.action.focusFilesToExclude',
+                "Focus Search Editor Files to Exclude"
+            )), original: 'Focus Search Editor Files to Exclude' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusFilesToExcludeInput();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorCaseSensitiveCommandId,
+            title: { value: ( localize('searchEditor.action.toggleSearchEditorCaseSensitive', "Toggle Match Case")), original: 'Toggle Match Case' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchInputBoxFocusedKey,
+            }, ToggleCaseSensitiveKeybinding)
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorCaseSensitiveCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorWholeWordCommandId,
+            title: { value: ( localize(
+                'searchEditor.action.toggleSearchEditorWholeWord',
+                "Toggle Match Whole Word"
+            )), original: 'Toggle Match Whole Word' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchInputBoxFocusedKey,
+            }, ToggleWholeWordKeybinding)
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorWholeWordCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorRegexCommandId,
+            title: { value: ( localize(
+                'searchEditor.action.toggleSearchEditorRegex',
+                "Toggle Use Regular Expression"
+            )), original: 'Toggle Use Regular Expression"' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchInputBoxFocusedKey,
+            }, ToggleRegexKeybinding)
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorRegexCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorContextLinesCommandId,
+            title: { value: ( localize(
+                'searchEditor.action.toggleSearchEditorContextLines',
+                "Toggle Context Lines"
+            )), original: 'Toggle Context Lines"' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 42 ,
+                mac: { primary: 2048  | 512  | 42  }
+            }
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorContextLinesCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: IncreaseSearchEditorContextLinesCommandId,
+            title: { original: 'Increase Context Lines', value: ( localize(
+                'searchEditor.action.increaseSearchEditorContextLines',
+                "Increase Context Lines"
+            )) },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 86
+            }
+        });
+    }
+    run(accessor) { modifySearchEditorContextLinesCommand(accessor, true); }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: DecreaseSearchEditorContextLinesCommandId,
+            title: { original: 'Decrease Context Lines', value: ( localize(
+                'searchEditor.action.decreaseSearchEditorContextLines',
+                "Decrease Context Lines"
+            )) },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 88
+            }
+        });
+    }
+    run(accessor) { modifySearchEditorContextLinesCommand(accessor, false); }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SelectAllSearchEditorMatchesCommandId,
+            title: { original: 'Select All Matches', value: ( localize('searchEditor.action.selectAllSearchEditorMatches', "Select All Matches")) },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 42 ,
+            }
+        });
+    }
+    run(accessor) {
+        selectAllSearchEditorMatchesCommand(accessor);
+    }
+});
+registerAction2(class OpenSearchEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: 'search.action.openNewEditorFromView',
+            title: ( localize('search.openNewEditor', "Open New Search Editor")),
+            category,
+            icon: searchNewEditorIcon,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.equals('view', VIEW_ID)),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        return openSearchEditor(accessor);
+    }
+});
+let SearchEditorWorkingCopyEditorHandler = class SearchEditorWorkingCopyEditorHandler extends Disposable {
+    constructor(instantiationService, workingCopyEditorService) {
+        super();
+        this.instantiationService = instantiationService;
+        this._register(workingCopyEditorService.registerHandler(this));
+    }
+    handles(workingCopy) {
+        return workingCopy.resource.scheme === SearchEditorScheme;
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handles(workingCopy)) {
+            return false;
+        }
+        return editor instanceof SearchEditorInput && isEqual(workingCopy.resource, editor.modelUri);
+    }
+    createEditor(workingCopy) {
+        const input = this.instantiationService.invokeFunction(getOrMakeSearchEditorInput, { from: 'model', modelUri: workingCopy.resource });
+        input.setDirty(true);
+        return input;
+    }
+};
+SearchEditorWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyEditorService))
+], SearchEditorWorkingCopyEditorHandler));
+workbenchContributionsRegistry.registerWorkbenchContribution(SearchEditorWorkingCopyEditorHandler, 2 );