@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/contrib/find/browser/findController.js

@@ -0,0 +1,1046 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Delayer } from '../../../../base/common/async.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { registerMultiEditorAction, registerEditorContribution, registerEditorAction, registerEditorCommand, MultiEditorAction, EditorCommand, EditorAction } from '../../../browser/editorExtensions.js';
+import { overviewRulerRangeHighlight } from '../../../common/core/editorColorRegistry.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { OverviewRulerLane } from '../../../common/model.js';
+import { CONTEXT_FIND_WIDGET_VISIBLE, CONTEXT_FIND_INPUT_FOCUSED, FindModelBoundToEditorModel, FIND_IDS, ToggleCaseSensitiveKeybinding, ToggleWholeWordKeybinding, ToggleRegexKeybinding, ToggleSearchScopeKeybinding, TogglePreserveCaseKeybinding, CONTEXT_REPLACE_INPUT_FOCUSED } from './findModel.js';
+import { FindOptionsWidget } from './findOptionsWidget.js';
+import { FindReplaceState } from './findState.js';
+import { FindWidget } from './findWidget.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IThemeService, themeColorFromId } from '../../../../platform/theme/common/themeService.js';
+var CommonFindController_1;
+const SEARCH_STRING_MAX_LENGTH = 524288;
+function getSelectionSearchString(editor, seedSearchStringFromSelection = 'single', seedSearchStringFromNonEmptySelection = false) {
+    if (!editor.hasModel()) {
+        return null;
+    }
+    const selection = editor.getSelection();
+    if ((seedSearchStringFromSelection === 'single' && selection.startLineNumber === selection.endLineNumber)
+        || seedSearchStringFromSelection === 'multiple') {
+        if (selection.isEmpty()) {
+            const wordAtPosition = editor.getConfiguredWordAtPosition(selection.getStartPosition());
+            if (wordAtPosition && (false === seedSearchStringFromNonEmptySelection)) {
+                return wordAtPosition.word;
+            }
+        }
+        else {
+            if (editor.getModel().getValueLengthInRange(selection) < SEARCH_STRING_MAX_LENGTH) {
+                return editor.getModel().getValueInRange(selection);
+            }
+        }
+    }
+    return null;
+}
+let CommonFindController = class CommonFindController extends Disposable {
+    static { CommonFindController_1 = this; }
+    static { this.ID = 'editor.contrib.findController'; }
+    get editor() {
+        return this._editor;
+    }
+    static get(editor) {
+        return editor.getContribution(CommonFindController_1.ID);
+    }
+    constructor(editor, contextKeyService, storageService, clipboardService, notificationService) {
+        super();
+        this._editor = editor;
+        this._findWidgetVisible = CONTEXT_FIND_WIDGET_VISIBLE.bindTo(contextKeyService);
+        this._contextKeyService = contextKeyService;
+        this._storageService = storageService;
+        this._clipboardService = clipboardService;
+        this._notificationService = notificationService;
+        this._updateHistoryDelayer = ( new Delayer(500));
+        this._state = this._register(( new FindReplaceState()));
+        this.loadQueryState();
+        this._register(this._state.onFindReplaceStateChange((e) => this._onStateChanged(e)));
+        this._model = null;
+        this._register(this._editor.onDidChangeModel(() => {
+            const shouldRestartFind = (this._editor.getModel() && this._state.isRevealed);
+            this.disposeModel();
+            this._state.change({
+                searchScope: null,
+                matchCase: this._storageService.getBoolean('editor.matchCase', 1 , false),
+                wholeWord: this._storageService.getBoolean('editor.wholeWord', 1 , false),
+                isRegex: this._storageService.getBoolean('editor.isRegex', 1 , false),
+                preserveCase: this._storageService.getBoolean('editor.preserveCase', 1 , false)
+            }, false);
+            if (shouldRestartFind) {
+                this._start({
+                    forceRevealReplace: false,
+                    seedSearchStringFromSelection: 'none',
+                    seedSearchStringFromNonEmptySelection: false,
+                    seedSearchStringFromGlobalClipboard: false,
+                    shouldFocus: 0 ,
+                    shouldAnimate: false,
+                    updateSearchScope: false,
+                    loop: this._editor.getOption(41 ).loop
+                });
+            }
+        }));
+    }
+    dispose() {
+        this.disposeModel();
+        super.dispose();
+    }
+    disposeModel() {
+        if (this._model) {
+            this._model.dispose();
+            this._model = null;
+        }
+    }
+    _onStateChanged(e) {
+        this.saveQueryState(e);
+        if (e.isRevealed) {
+            if (this._state.isRevealed) {
+                this._findWidgetVisible.set(true);
+            }
+            else {
+                this._findWidgetVisible.reset();
+                this.disposeModel();
+            }
+        }
+        if (e.searchString) {
+            this.setGlobalBufferTerm(this._state.searchString);
+        }
+    }
+    saveQueryState(e) {
+        if (e.isRegex) {
+            this._storageService.store('editor.isRegex', this._state.actualIsRegex, 1 , 1 );
+        }
+        if (e.wholeWord) {
+            this._storageService.store('editor.wholeWord', this._state.actualWholeWord, 1 , 1 );
+        }
+        if (e.matchCase) {
+            this._storageService.store('editor.matchCase', this._state.actualMatchCase, 1 , 1 );
+        }
+        if (e.preserveCase) {
+            this._storageService.store('editor.preserveCase', this._state.actualPreserveCase, 1 , 1 );
+        }
+    }
+    loadQueryState() {
+        this._state.change({
+            matchCase: this._storageService.getBoolean('editor.matchCase', 1 , this._state.matchCase),
+            wholeWord: this._storageService.getBoolean('editor.wholeWord', 1 , this._state.wholeWord),
+            isRegex: this._storageService.getBoolean('editor.isRegex', 1 , this._state.isRegex),
+            preserveCase: this._storageService.getBoolean('editor.preserveCase', 1 , this._state.preserveCase)
+        }, false);
+    }
+    isFindInputFocused() {
+        return !!CONTEXT_FIND_INPUT_FOCUSED.getValue(this._contextKeyService);
+    }
+    getState() {
+        return this._state;
+    }
+    closeFindWidget() {
+        this._state.change({
+            isRevealed: false,
+            searchScope: null
+        }, false);
+        this._editor.focus();
+    }
+    toggleCaseSensitive() {
+        this._state.change({ matchCase: !this._state.matchCase }, false);
+        if (!this._state.isRevealed) {
+            this.highlightFindOptions();
+        }
+    }
+    toggleWholeWords() {
+        this._state.change({ wholeWord: !this._state.wholeWord }, false);
+        if (!this._state.isRevealed) {
+            this.highlightFindOptions();
+        }
+    }
+    toggleRegex() {
+        this._state.change({ isRegex: !this._state.isRegex }, false);
+        if (!this._state.isRevealed) {
+            this.highlightFindOptions();
+        }
+    }
+    togglePreserveCase() {
+        this._state.change({ preserveCase: !this._state.preserveCase }, false);
+        if (!this._state.isRevealed) {
+            this.highlightFindOptions();
+        }
+    }
+    toggleSearchScope() {
+        if (this._state.searchScope) {
+            this._state.change({ searchScope: null }, true);
+        }
+        else {
+            if (this._editor.hasModel()) {
+                let selections = this._editor.getSelections();
+                selections = ( selections.map(selection => {
+                    if (selection.endColumn === 1 && selection.endLineNumber > selection.startLineNumber) {
+                        selection = selection.setEndPosition(selection.endLineNumber - 1, this._editor.getModel().getLineMaxColumn(selection.endLineNumber - 1));
+                    }
+                    if (!selection.isEmpty()) {
+                        return selection;
+                    }
+                    return null;
+                })).filter((element) => !!element);
+                if (selections.length) {
+                    this._state.change({ searchScope: selections }, true);
+                }
+            }
+        }
+    }
+    setSearchString(searchString) {
+        if (this._state.isRegex) {
+            searchString = escapeRegExpCharacters(searchString);
+        }
+        this._state.change({ searchString: searchString }, false);
+    }
+    highlightFindOptions(ignoreWhenVisible = false) {
+    }
+    async _start(opts, newState) {
+        this.disposeModel();
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const stateChanges = {
+            ...newState,
+            isRevealed: true
+        };
+        if (opts.seedSearchStringFromSelection === 'single') {
+            const selectionSearchString = getSelectionSearchString(this._editor, opts.seedSearchStringFromSelection, opts.seedSearchStringFromNonEmptySelection);
+            if (selectionSearchString) {
+                if (this._state.isRegex) {
+                    stateChanges.searchString = escapeRegExpCharacters(selectionSearchString);
+                }
+                else {
+                    stateChanges.searchString = selectionSearchString;
+                }
+            }
+        }
+        else if (opts.seedSearchStringFromSelection === 'multiple' && !opts.updateSearchScope) {
+            const selectionSearchString = getSelectionSearchString(this._editor, opts.seedSearchStringFromSelection);
+            if (selectionSearchString) {
+                stateChanges.searchString = selectionSearchString;
+            }
+        }
+        if (!stateChanges.searchString && opts.seedSearchStringFromGlobalClipboard) {
+            const selectionSearchString = await this.getGlobalBufferTerm();
+            if (!this._editor.hasModel()) {
+                return;
+            }
+            if (selectionSearchString) {
+                stateChanges.searchString = selectionSearchString;
+            }
+        }
+        if (opts.forceRevealReplace || stateChanges.isReplaceRevealed) {
+            stateChanges.isReplaceRevealed = true;
+        }
+        else if (!this._findWidgetVisible.get()) {
+            stateChanges.isReplaceRevealed = false;
+        }
+        if (opts.updateSearchScope) {
+            const currentSelections = this._editor.getSelections();
+            if (( currentSelections.some(selection => !selection.isEmpty()))) {
+                stateChanges.searchScope = currentSelections;
+            }
+        }
+        stateChanges.loop = opts.loop;
+        this._state.change(stateChanges, false);
+        if (!this._model) {
+            this._model = ( new FindModelBoundToEditorModel(this._editor, this._state));
+        }
+    }
+    start(opts, newState) {
+        return this._start(opts, newState);
+    }
+    moveToNextMatch() {
+        if (this._model) {
+            this._model.moveToNextMatch();
+            return true;
+        }
+        return false;
+    }
+    moveToPrevMatch() {
+        if (this._model) {
+            this._model.moveToPrevMatch();
+            return true;
+        }
+        return false;
+    }
+    goToMatch(index) {
+        if (this._model) {
+            this._model.moveToMatch(index);
+            return true;
+        }
+        return false;
+    }
+    replace() {
+        if (this._model) {
+            this._model.replace();
+            return true;
+        }
+        return false;
+    }
+    replaceAll() {
+        if (this._model) {
+            if (this._editor.getModel()?.isTooLargeForHeapOperation()) {
+                this._notificationService.warn(( localizeWithPath(
+                    'vs/editor/contrib/find/browser/findController',
+                    'too.large.for.replaceall',
+                    "The file is too large to perform a replace all operation."
+                )));
+                return false;
+            }
+            this._model.replaceAll();
+            return true;
+        }
+        return false;
+    }
+    selectAllMatches() {
+        if (this._model) {
+            this._model.selectAllMatches();
+            this._editor.focus();
+            return true;
+        }
+        return false;
+    }
+    async getGlobalBufferTerm() {
+        if (this._editor.getOption(41 ).globalFindClipboard
+            && this._editor.hasModel()
+            && !this._editor.getModel().isTooLargeForSyncing()) {
+            return this._clipboardService.readFindText();
+        }
+        return '';
+    }
+    setGlobalBufferTerm(text) {
+        if (this._editor.getOption(41 ).globalFindClipboard
+            && this._editor.hasModel()
+            && !this._editor.getModel().isTooLargeForSyncing()) {
+            this._clipboardService.writeFindText(text);
+        }
+    }
+};
+CommonFindController = CommonFindController_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IClipboardService)),
+    ( __param(4, INotificationService))
+], CommonFindController));
+let FindController = class FindController extends CommonFindController {
+    constructor(editor, _contextViewService, _contextKeyService, _keybindingService, _themeService, notificationService, _storageService, clipboardService) {
+        super(editor, _contextKeyService, _storageService, clipboardService, notificationService);
+        this._contextViewService = _contextViewService;
+        this._keybindingService = _keybindingService;
+        this._themeService = _themeService;
+        this._widget = null;
+        this._findOptionsWidget = null;
+    }
+    async _start(opts, newState) {
+        if (!this._widget) {
+            this._createFindWidget();
+        }
+        const selection = this._editor.getSelection();
+        let updateSearchScope = false;
+        switch (this._editor.getOption(41 ).autoFindInSelection) {
+            case 'always':
+                updateSearchScope = true;
+                break;
+            case 'never':
+                updateSearchScope = false;
+                break;
+            case 'multiline': {
+                const isSelectionMultipleLine = !!selection && selection.startLineNumber !== selection.endLineNumber;
+                updateSearchScope = isSelectionMultipleLine;
+                break;
+            }
+        }
+        opts.updateSearchScope = opts.updateSearchScope || updateSearchScope;
+        await super._start(opts, newState);
+        if (this._widget) {
+            if (opts.shouldFocus === 2 ) {
+                this._widget.focusReplaceInput();
+            }
+            else if (opts.shouldFocus === 1 ) {
+                this._widget.focusFindInput();
+            }
+        }
+    }
+    highlightFindOptions(ignoreWhenVisible = false) {
+        if (!this._widget) {
+            this._createFindWidget();
+        }
+        if (this._state.isRevealed && !ignoreWhenVisible) {
+            this._widget.highlightFindOptions();
+        }
+        else {
+            this._findOptionsWidget.highlightFindOptions();
+        }
+    }
+    _createFindWidget() {
+        this._widget = this._register(( new FindWidget(
+            this._editor,
+            this,
+            this._state,
+            this._contextViewService,
+            this._keybindingService,
+            this._contextKeyService,
+            this._themeService,
+            this._storageService,
+            this._notificationService
+        )));
+        this._findOptionsWidget = this._register(( new FindOptionsWidget(this._editor, this._state, this._keybindingService)));
+    }
+    saveViewState() {
+        return this._widget?.getViewState();
+    }
+    restoreViewState(state) {
+        this._widget?.setViewState(state);
+    }
+};
+FindController = ( __decorate([
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, INotificationService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, IClipboardService))
+], FindController));
+const StartFindAction = registerMultiEditorAction(( new MultiEditorAction({
+    id: FIND_IDS.StartFindAction,
+    label: ( localizeWithPath('vs/editor/contrib/find/browser/findController', 'startFindAction', "Find")),
+    alias: 'Find',
+    precondition: ( ContextKeyExpr.or(EditorContextKeys.focus, ( ContextKeyExpr.has('editorIsOpen')))),
+    kbOpts: {
+        kbExpr: null,
+        primary: 2048  | 36 ,
+        weight: 100
+    },
+    menuOpts: {
+        menuId: MenuId.MenubarEditMenu,
+        group: '3_find',
+        title: ( localizeWithPath(
+            'vs/editor/contrib/find/browser/findController',
+            { key: 'miFind', comment: ['&& denotes a mnemonic'] },
+            "&&Find"
+        )),
+        order: 1
+    }
+})));
+StartFindAction.addImplementation(0, (accessor, editor, args) => {
+    const controller = CommonFindController.get(editor);
+    if (!controller) {
+        return false;
+    }
+    return controller.start({
+        forceRevealReplace: false,
+        seedSearchStringFromSelection: editor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+        seedSearchStringFromNonEmptySelection: editor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+        seedSearchStringFromGlobalClipboard: editor.getOption(41 ).globalFindClipboard,
+        shouldFocus: 1 ,
+        shouldAnimate: true,
+        updateSearchScope: false,
+        loop: editor.getOption(41 ).loop
+    });
+});
+const findArgDescription = {
+    description: 'Open a new In-Editor Find Widget.',
+    args: [{
+            name: 'Open a new In-Editor Find Widget args',
+            schema: {
+                properties: {
+                    searchString: { type: 'string' },
+                    replaceString: { type: 'string' },
+                    regex: { type: 'boolean' },
+                    regexOverride: {
+                        type: 'number',
+                        description: ( localizeWithPath(
+                            'vs/editor/contrib/find/browser/findController',
+                            'actions.find.isRegexOverride',
+                            'Overrides "Use Regular Expression" flag.\nThe flag will not be saved for the future.\n0: Do Nothing\n1: True\n2: False'
+                        ))
+                    },
+                    wholeWord: { type: 'boolean' },
+                    wholeWordOverride: {
+                        type: 'number',
+                        description: ( localizeWithPath(
+                            'vs/editor/contrib/find/browser/findController',
+                            'actions.find.wholeWordOverride',
+                            'Overrides "Match Whole Word" flag.\nThe flag will not be saved for the future.\n0: Do Nothing\n1: True\n2: False'
+                        ))
+                    },
+                    matchCase: { type: 'boolean' },
+                    matchCaseOverride: {
+                        type: 'number',
+                        description: ( localizeWithPath(
+                            'vs/editor/contrib/find/browser/findController',
+                            'actions.find.matchCaseOverride',
+                            'Overrides "Math Case" flag.\nThe flag will not be saved for the future.\n0: Do Nothing\n1: True\n2: False'
+                        ))
+                    },
+                    preserveCase: { type: 'boolean' },
+                    preserveCaseOverride: {
+                        type: 'number',
+                        description: ( localizeWithPath(
+                            'vs/editor/contrib/find/browser/findController',
+                            'actions.find.preserveCaseOverride',
+                            'Overrides "Preserve Case" flag.\nThe flag will not be saved for the future.\n0: Do Nothing\n1: True\n2: False'
+                        ))
+                    },
+                    findInSelection: { type: 'boolean' },
+                }
+            }
+        }]
+};
+class StartFindWithArgsAction extends EditorAction {
+    constructor() {
+        super({
+            id: FIND_IDS.StartFindWithArgs,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'startFindWithArgsAction',
+                "Find With Arguments"
+            )),
+            alias: 'Find With Arguments',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: null,
+                primary: 0,
+                weight: 100
+            },
+            metadata: findArgDescription
+        });
+    }
+    async run(accessor, editor, args) {
+        const controller = CommonFindController.get(editor);
+        if (controller) {
+            const newState = args ? {
+                searchString: args.searchString,
+                replaceString: args.replaceString,
+                isReplaceRevealed: args.replaceString !== undefined,
+                isRegex: args.isRegex,
+                wholeWord: args.matchWholeWord,
+                matchCase: args.isCaseSensitive,
+                preserveCase: args.preserveCase,
+            } : {};
+            await controller.start({
+                forceRevealReplace: false,
+                seedSearchStringFromSelection: (controller.getState().searchString.length === 0) && editor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+                seedSearchStringFromNonEmptySelection: editor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+                seedSearchStringFromGlobalClipboard: true,
+                shouldFocus: 1 ,
+                shouldAnimate: true,
+                updateSearchScope: args?.findInSelection || false,
+                loop: editor.getOption(41 ).loop
+            }, newState);
+            controller.setGlobalBufferTerm(controller.getState().searchString);
+        }
+    }
+}
+class StartFindWithSelectionAction extends EditorAction {
+    constructor() {
+        super({
+            id: FIND_IDS.StartFindWithSelection,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'startFindWithSelectionAction',
+                "Find With Selection"
+            )),
+            alias: 'Find With Selection',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: null,
+                primary: 0,
+                mac: {
+                    primary: 2048  | 35 ,
+                },
+                weight: 100
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const controller = CommonFindController.get(editor);
+        if (controller) {
+            await controller.start({
+                forceRevealReplace: false,
+                seedSearchStringFromSelection: 'multiple',
+                seedSearchStringFromNonEmptySelection: false,
+                seedSearchStringFromGlobalClipboard: false,
+                shouldFocus: 0 ,
+                shouldAnimate: true,
+                updateSearchScope: false,
+                loop: editor.getOption(41 ).loop
+            });
+            controller.setGlobalBufferTerm(controller.getState().searchString);
+        }
+    }
+}
+class MatchFindAction extends EditorAction {
+    async run(accessor, editor) {
+        const controller = CommonFindController.get(editor);
+        if (controller && !this._run(controller)) {
+            await controller.start({
+                forceRevealReplace: false,
+                seedSearchStringFromSelection: (controller.getState().searchString.length === 0) && editor.getOption(41 ).seedSearchStringFromSelection !== 'never' ? 'single' : 'none',
+                seedSearchStringFromNonEmptySelection: editor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+                seedSearchStringFromGlobalClipboard: true,
+                shouldFocus: 0 ,
+                shouldAnimate: true,
+                updateSearchScope: false,
+                loop: editor.getOption(41 ).loop
+            });
+            this._run(controller);
+        }
+    }
+}
+class NextMatchFindAction extends MatchFindAction {
+    constructor() {
+        super({
+            id: FIND_IDS.NextMatchFindAction,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'findNextMatchAction',
+                "Find Next"
+            )),
+            alias: 'Find Next',
+            precondition: undefined,
+            kbOpts: [{
+                    kbExpr: EditorContextKeys.focus,
+                    primary: 61 ,
+                    mac: { primary: 2048  | 37 , secondary: [61 ] },
+                    weight: 100
+                }, {
+                    kbExpr: ( ContextKeyExpr.and(EditorContextKeys.focus, CONTEXT_FIND_INPUT_FOCUSED)),
+                    primary: 3 ,
+                    weight: 100
+                }]
+        });
+    }
+    _run(controller) {
+        const result = controller.moveToNextMatch();
+        if (result) {
+            controller.editor.pushUndoStop();
+            return true;
+        }
+        return false;
+    }
+}
+class PreviousMatchFindAction extends MatchFindAction {
+    constructor() {
+        super({
+            id: FIND_IDS.PreviousMatchFindAction,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'findPreviousMatchAction',
+                "Find Previous"
+            )),
+            alias: 'Find Previous',
+            precondition: undefined,
+            kbOpts: [{
+                    kbExpr: EditorContextKeys.focus,
+                    primary: 1024  | 61 ,
+                    mac: { primary: 2048  | 1024  | 37 , secondary: [1024  | 61 ] },
+                    weight: 100
+                }, {
+                    kbExpr: ( ContextKeyExpr.and(EditorContextKeys.focus, CONTEXT_FIND_INPUT_FOCUSED)),
+                    primary: 1024  | 3 ,
+                    weight: 100
+                }
+            ]
+        });
+    }
+    _run(controller) {
+        return controller.moveToPrevMatch();
+    }
+}
+class MoveToMatchFindAction extends EditorAction {
+    constructor() {
+        super({
+            id: FIND_IDS.GoToMatchFindAction,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'findMatchAction.goToMatch',
+                "Go to Match..."
+            )),
+            alias: 'Go to Match...',
+            precondition: CONTEXT_FIND_WIDGET_VISIBLE
+        });
+        this._highlightDecorations = [];
+    }
+    run(accessor, editor, args) {
+        const controller = CommonFindController.get(editor);
+        if (!controller) {
+            return;
+        }
+        const matchesCount = controller.getState().matchesCount;
+        if (matchesCount < 1) {
+            const notificationService = accessor.get(INotificationService);
+            notificationService.notify({
+                severity: Severity.Warning,
+                message: ( localizeWithPath(
+                    'vs/editor/contrib/find/browser/findController',
+                    'findMatchAction.noResults',
+                    "No matches. Try searching for something else."
+                ))
+            });
+            return;
+        }
+        const quickInputService = accessor.get(IQuickInputService);
+        const inputBox = quickInputService.createInputBox();
+        inputBox.placeholder = ( localizeWithPath(
+            'vs/editor/contrib/find/browser/findController',
+            'findMatchAction.inputPlaceHolder',
+            "Type a number to go to a specific match (between 1 and {0})",
+            matchesCount
+        ));
+        const toFindMatchIndex = (value) => {
+            const index = parseInt(value);
+            if (isNaN(index)) {
+                return undefined;
+            }
+            const matchCount = controller.getState().matchesCount;
+            if (index > 0 && index <= matchCount) {
+                return index - 1;
+            }
+            else if (index < 0 && index >= -matchCount) {
+                return matchCount + index;
+            }
+            return undefined;
+        };
+        const updatePickerAndEditor = (value) => {
+            const index = toFindMatchIndex(value);
+            if (typeof index === 'number') {
+                inputBox.validationMessage = undefined;
+                controller.goToMatch(index);
+                const currentMatch = controller.getState().currentMatch;
+                if (currentMatch) {
+                    this.addDecorations(editor, currentMatch);
+                }
+            }
+            else {
+                inputBox.validationMessage = ( localizeWithPath(
+                    'vs/editor/contrib/find/browser/findController',
+                    'findMatchAction.inputValidationMessage',
+                    "Please type a number between 1 and {0}",
+                    controller.getState().matchesCount
+                ));
+                this.clearDecorations(editor);
+            }
+        };
+        inputBox.onDidChangeValue(value => {
+            updatePickerAndEditor(value);
+        });
+        inputBox.onDidAccept(() => {
+            const index = toFindMatchIndex(inputBox.value);
+            if (typeof index === 'number') {
+                controller.goToMatch(index);
+                inputBox.hide();
+            }
+            else {
+                inputBox.validationMessage = ( localizeWithPath(
+                    'vs/editor/contrib/find/browser/findController',
+                    'findMatchAction.inputValidationMessage',
+                    "Please type a number between 1 and {0}",
+                    controller.getState().matchesCount
+                ));
+            }
+        });
+        inputBox.onDidHide(() => {
+            this.clearDecorations(editor);
+            inputBox.dispose();
+        });
+        inputBox.show();
+    }
+    clearDecorations(editor) {
+        editor.changeDecorations(changeAccessor => {
+            this._highlightDecorations = changeAccessor.deltaDecorations(this._highlightDecorations, []);
+        });
+    }
+    addDecorations(editor, range) {
+        editor.changeDecorations(changeAccessor => {
+            this._highlightDecorations = changeAccessor.deltaDecorations(this._highlightDecorations, [
+                {
+                    range,
+                    options: {
+                        description: 'find-match-quick-access-range-highlight',
+                        className: 'rangeHighlight',
+                        isWholeLine: true
+                    }
+                },
+                {
+                    range,
+                    options: {
+                        description: 'find-match-quick-access-range-highlight-overview',
+                        overviewRuler: {
+                            color: themeColorFromId(overviewRulerRangeHighlight),
+                            position: OverviewRulerLane.Full
+                        }
+                    }
+                }
+            ]);
+        });
+    }
+}
+class SelectionMatchFindAction extends EditorAction {
+    async run(accessor, editor) {
+        const controller = CommonFindController.get(editor);
+        if (!controller) {
+            return;
+        }
+        const selectionSearchString = getSelectionSearchString(editor, 'single', false);
+        if (selectionSearchString) {
+            controller.setSearchString(selectionSearchString);
+        }
+        if (!this._run(controller)) {
+            await controller.start({
+                forceRevealReplace: false,
+                seedSearchStringFromSelection: 'none',
+                seedSearchStringFromNonEmptySelection: false,
+                seedSearchStringFromGlobalClipboard: false,
+                shouldFocus: 0 ,
+                shouldAnimate: true,
+                updateSearchScope: false,
+                loop: editor.getOption(41 ).loop
+            });
+            this._run(controller);
+        }
+    }
+}
+class NextSelectionMatchFindAction extends SelectionMatchFindAction {
+    constructor() {
+        super({
+            id: FIND_IDS.NextSelectionMatchFindAction,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'nextSelectionMatchFindAction',
+                "Find Next Selection"
+            )),
+            alias: 'Find Next Selection',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.focus,
+                primary: 2048  | 61 ,
+                weight: 100
+            }
+        });
+    }
+    _run(controller) {
+        return controller.moveToNextMatch();
+    }
+}
+class PreviousSelectionMatchFindAction extends SelectionMatchFindAction {
+    constructor() {
+        super({
+            id: FIND_IDS.PreviousSelectionMatchFindAction,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/find/browser/findController',
+                'previousSelectionMatchFindAction',
+                "Find Previous Selection"
+            )),
+            alias: 'Find Previous Selection',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.focus,
+                primary: 2048  | 1024  | 61 ,
+                weight: 100
+            }
+        });
+    }
+    _run(controller) {
+        return controller.moveToPrevMatch();
+    }
+}
+const StartFindReplaceAction = registerMultiEditorAction(( new MultiEditorAction({
+    id: FIND_IDS.StartFindReplaceAction,
+    label: ( localizeWithPath('vs/editor/contrib/find/browser/findController', 'startReplace', "Replace")),
+    alias: 'Replace',
+    precondition: ( ContextKeyExpr.or(EditorContextKeys.focus, ( ContextKeyExpr.has('editorIsOpen')))),
+    kbOpts: {
+        kbExpr: null,
+        primary: 2048  | 38 ,
+        mac: { primary: 2048  | 512  | 36  },
+        weight: 100
+    },
+    menuOpts: {
+        menuId: MenuId.MenubarEditMenu,
+        group: '3_find',
+        title: ( localizeWithPath(
+            'vs/editor/contrib/find/browser/findController',
+            { key: 'miReplace', comment: ['&& denotes a mnemonic'] },
+            "&&Replace"
+        )),
+        order: 2
+    }
+})));
+StartFindReplaceAction.addImplementation(0, (accessor, editor, args) => {
+    if (!editor.hasModel() || editor.getOption(90 )) {
+        return false;
+    }
+    const controller = CommonFindController.get(editor);
+    if (!controller) {
+        return false;
+    }
+    const currentSelection = editor.getSelection();
+    const findInputFocused = controller.isFindInputFocused();
+    const seedSearchStringFromSelection = !currentSelection.isEmpty()
+        && currentSelection.startLineNumber === currentSelection.endLineNumber
+        && (editor.getOption(41 ).seedSearchStringFromSelection !== 'never')
+        && !findInputFocused;
+    const shouldFocus = (findInputFocused || seedSearchStringFromSelection) ?
+        2  : 1 ;
+    return controller.start({
+        forceRevealReplace: true,
+        seedSearchStringFromSelection: seedSearchStringFromSelection ? 'single' : 'none',
+        seedSearchStringFromNonEmptySelection: editor.getOption(41 ).seedSearchStringFromSelection === 'selection',
+        seedSearchStringFromGlobalClipboard: editor.getOption(41 ).seedSearchStringFromSelection !== 'never',
+        shouldFocus: shouldFocus,
+        shouldAnimate: true,
+        updateSearchScope: false,
+        loop: editor.getOption(41 ).loop
+    });
+});
+registerEditorContribution(CommonFindController.ID, FindController, 0 );
+registerEditorAction(StartFindWithArgsAction);
+registerEditorAction(StartFindWithSelectionAction);
+registerEditorAction(NextMatchFindAction);
+registerEditorAction(PreviousMatchFindAction);
+registerEditorAction(MoveToMatchFindAction);
+registerEditorAction(NextSelectionMatchFindAction);
+registerEditorAction(PreviousSelectionMatchFindAction);
+const FindCommand = EditorCommand.bindToContribution(CommonFindController.get);
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.CloseFindWidgetCommand,
+    precondition: CONTEXT_FIND_WIDGET_VISIBLE,
+    handler: x => x.closeFindWidget(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: ( ContextKeyExpr.and(EditorContextKeys.focus, ContextKeyExpr.not('isComposing'))),
+        primary: 9 ,
+        secondary: [1024  | 9 ]
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ToggleCaseSensitiveCommand,
+    precondition: undefined,
+    handler: x => x.toggleCaseSensitive(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: ToggleCaseSensitiveKeybinding.primary,
+        mac: ToggleCaseSensitiveKeybinding.mac,
+        win: ToggleCaseSensitiveKeybinding.win,
+        linux: ToggleCaseSensitiveKeybinding.linux
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ToggleWholeWordCommand,
+    precondition: undefined,
+    handler: x => x.toggleWholeWords(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: ToggleWholeWordKeybinding.primary,
+        mac: ToggleWholeWordKeybinding.mac,
+        win: ToggleWholeWordKeybinding.win,
+        linux: ToggleWholeWordKeybinding.linux
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ToggleRegexCommand,
+    precondition: undefined,
+    handler: x => x.toggleRegex(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: ToggleRegexKeybinding.primary,
+        mac: ToggleRegexKeybinding.mac,
+        win: ToggleRegexKeybinding.win,
+        linux: ToggleRegexKeybinding.linux
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ToggleSearchScopeCommand,
+    precondition: undefined,
+    handler: x => x.toggleSearchScope(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: ToggleSearchScopeKeybinding.primary,
+        mac: ToggleSearchScopeKeybinding.mac,
+        win: ToggleSearchScopeKeybinding.win,
+        linux: ToggleSearchScopeKeybinding.linux
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.TogglePreserveCaseCommand,
+    precondition: undefined,
+    handler: x => x.togglePreserveCase(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: TogglePreserveCaseKeybinding.primary,
+        mac: TogglePreserveCaseKeybinding.mac,
+        win: TogglePreserveCaseKeybinding.win,
+        linux: TogglePreserveCaseKeybinding.linux
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ReplaceOneAction,
+    precondition: CONTEXT_FIND_WIDGET_VISIBLE,
+    handler: x => x.replace(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: 2048  | 1024  | 22
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ReplaceOneAction,
+    precondition: CONTEXT_FIND_WIDGET_VISIBLE,
+    handler: x => x.replace(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: ( ContextKeyExpr.and(EditorContextKeys.focus, CONTEXT_REPLACE_INPUT_FOCUSED)),
+        primary: 3
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ReplaceAllAction,
+    precondition: CONTEXT_FIND_WIDGET_VISIBLE,
+    handler: x => x.replaceAll(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: 2048  | 512  | 3
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.ReplaceAllAction,
+    precondition: CONTEXT_FIND_WIDGET_VISIBLE,
+    handler: x => x.replaceAll(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: ( ContextKeyExpr.and(EditorContextKeys.focus, CONTEXT_REPLACE_INPUT_FOCUSED)),
+        primary: undefined,
+        mac: {
+            primary: 2048  | 3 ,
+        }
+    }
+})));
+registerEditorCommand(( new FindCommand({
+    id: FIND_IDS.SelectAllMatchesAction,
+    precondition: CONTEXT_FIND_WIDGET_VISIBLE,
+    handler: x => x.selectAllMatches(),
+    kbOpts: {
+        weight: 100  + 5,
+        kbExpr: EditorContextKeys.focus,
+        primary: 512  | 3
+    }
+})));
+export { CommonFindController, FindController, MatchFindAction, MoveToMatchFindAction, NextMatchFindAction, NextSelectionMatchFindAction, PreviousMatchFindAction, PreviousSelectionMatchFindAction, SelectionMatchFindAction, StartFindAction, StartFindReplaceAction, StartFindWithArgsAction, StartFindWithSelectionAction, getSelectionSearchString };