@codingame/monaco-vscode-api 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess.js

@@ -0,0 +1,339 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { ResourceSet } from '../../../../../base/common/map.js';
+import { basenameOrAuthority, dirname } from '../../../../../base/common/resources.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ILabelService } from '../../../../../platform/label/common/label.js';
+import { getSelectionKeyboardEvent } from '../../../../../platform/list/browser/listService.js';
+import { PickerQuickAccessProvider, TriggerAction } from '../../../../../platform/quickinput/browser/pickerQuickAccess.js';
+import { DefaultQuickAccessFilterValue } from '../../../../../platform/quickinput/common/quickAccess.js';
+import { QuickInputHideReason } from '../../../../../platform/quickinput/common/quickInput.js';
+import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.js';
+import { searchDetailsIcon, searchOpenInFileIcon, searchActivityBarIcon } from '../searchIcons.js';
+import { SearchModel, SearchModelLocation, searchComparer } from '../searchModel.js';
+import { getEditorSelectionFromMatch } from '../searchView.js';
+import { getOutOfWorkspaceEditorResources } from '../../common/search.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../../../../services/editor/common/editorService.js';
+import { QueryBuilder } from '../../../../services/search/common/queryBuilder.js';
+import { VIEW_ID } from '../../../../services/search/common/search.js';
+import { Event } from '../../../../../base/common/event.js';
+import { PickerEditorState } from '../../../../browser/quickaccess.js';
+import { IViewsService } from '../../../../services/views/common/viewsService.js';
+import { Sequencer } from '../../../../../base/common/async.js';
+const TEXT_SEARCH_QUICK_ACCESS_PREFIX = '%';
+const DEFAULT_TEXT_QUERY_BUILDER_OPTIONS = {
+    _reason: 'quickAccessSearch',
+    disregardIgnoreFiles: false,
+    disregardExcludeSettings: false,
+    onlyOpenEditors: false,
+    expandPatterns: true
+};
+const MAX_FILES_SHOWN = 30;
+const MAX_RESULTS_PER_FILE = 10;
+const DEBOUNCE_DELAY = 75;
+let TextSearchQuickAccess = class TextSearchQuickAccess extends PickerQuickAccessProvider {
+    _getTextQueryBuilderOptions(charsPerLine) {
+        return {
+            ...DEFAULT_TEXT_QUERY_BUILDER_OPTIONS,
+            ...{
+                extraFileResources: this._instantiationService.invokeFunction(getOutOfWorkspaceEditorResources),
+                maxResults: this.configuration.maxResults ?? undefined,
+                isSmartCase: this.configuration.smartCase,
+            },
+            previewOptions: {
+                matchLines: 1,
+                charsPerLine
+            }
+        };
+    }
+    constructor(_instantiationService, _contextService, _editorService, _labelService, _viewsService, _configurationService) {
+        super(TEXT_SEARCH_QUICK_ACCESS_PREFIX, { canAcceptInBackground: true, shouldSkipTrimPickFilter: true });
+        this._instantiationService = _instantiationService;
+        this._contextService = _contextService;
+        this._editorService = _editorService;
+        this._labelService = _labelService;
+        this._viewsService = _viewsService;
+        this._configurationService = _configurationService;
+        this.currentAsyncSearch = Promise.resolve({
+            results: [],
+            messages: []
+        });
+        this.queryBuilder = this._instantiationService.createInstance(QueryBuilder);
+        this.searchModel = this._register(this._instantiationService.createInstance(SearchModel));
+        this.editorViewState = this._register(this._instantiationService.createInstance(PickerEditorState));
+        this.searchModel.location = SearchModelLocation.QUICK_ACCESS;
+        this.editorSequencer = ( new Sequencer());
+    }
+    dispose() {
+        this.searchModel.dispose();
+        super.dispose();
+    }
+    provide(picker, token, runOptions) {
+        const disposables = ( new DisposableStore());
+        if (TEXT_SEARCH_QUICK_ACCESS_PREFIX.length < picker.value.length) {
+            picker.valueSelection = [TEXT_SEARCH_QUICK_ACCESS_PREFIX.length, picker.value.length];
+        }
+        picker.customButton = true;
+        picker.customLabel = '$(link-external)';
+        this.editorViewState.reset();
+        disposables.add(picker.onDidCustom(() => {
+            if (this.searchModel.searchResult.count() > 0) {
+                this.moveToSearchViewlet(undefined);
+            }
+            else {
+                this._viewsService.openView(VIEW_ID, true);
+            }
+            picker.hide();
+        }));
+        const onDidChangeActive = () => {
+            const [item] = picker.activeItems;
+            if (item?.match) {
+                this.editorViewState.set();
+                const itemMatch = item.match;
+                this.editorSequencer.queue(async () => {
+                    await this.editorViewState.openTransientEditor({
+                        resource: itemMatch.parent().resource,
+                        options: { preserveFocus: true, revealIfOpened: true, ignoreError: true, selection: itemMatch.range() }
+                    });
+                });
+            }
+        };
+        disposables.add(Event.debounce(picker.onDidChangeActive, (last, event) => event, DEBOUNCE_DELAY, true)(onDidChangeActive));
+        disposables.add(Event.once(picker.onWillHide)(({ reason }) => {
+            if (reason === QuickInputHideReason.Gesture) {
+                this.editorViewState.restore();
+            }
+        }));
+        disposables.add(Event.once(picker.onDidHide)(({ reason }) => {
+            this.searchModel.searchResult.toggleHighlights(false);
+        }));
+        disposables.add(super.provide(picker, token, runOptions));
+        disposables.add(picker.onDidAccept(() => this.searchModel.searchResult.toggleHighlights(false)));
+        return disposables;
+    }
+    get configuration() {
+        const editorConfig = this._configurationService.getValue().workbench?.editor;
+        const searchConfig = this._configurationService.getValue().search;
+        return {
+            openEditorPinned: !editorConfig?.enablePreviewFromQuickOpen || !editorConfig?.enablePreview,
+            preserveInput: searchConfig.experimental.quickAccess.preserveInput,
+            maxResults: searchConfig.maxResults,
+            smartCase: searchConfig.smartCase,
+        };
+    }
+    get defaultFilterValue() {
+        if (this.configuration.preserveInput) {
+            return DefaultQuickAccessFilterValue.LAST;
+        }
+        return undefined;
+    }
+    doSearch(contentPattern, token) {
+        if (contentPattern === '') {
+            return undefined;
+        }
+        const folderResources = this._contextService.getWorkspace().folders;
+        const content = {
+            pattern: contentPattern,
+        };
+        this.searchModel.searchResult.toggleHighlights(false);
+        const charsPerLine = content.isRegExp ? 10000 : 1000;
+        const query = this.queryBuilder.text(content, ( folderResources.map(folder => folder.uri)), this._getTextQueryBuilderOptions(charsPerLine));
+        const result = this.searchModel.search(query, undefined, token);
+        const getAsyncResults = async () => {
+            this.currentAsyncSearch = result.asyncResults;
+            await result.asyncResults;
+            const syncResultURIs = ( new ResourceSet(( result.syncResults.map(e => e.resource))));
+            return this.searchModel.searchResult.matches().filter(e => !( syncResultURIs.has(e.resource)));
+        };
+        return {
+            syncResults: this.searchModel.searchResult.matches(),
+            asyncResults: getAsyncResults()
+        };
+    }
+    moveToSearchViewlet(currentElem) {
+        this._viewsService.openView(VIEW_ID, false);
+        const viewlet = this._viewsService.getActiveViewWithId(VIEW_ID);
+        viewlet.replaceSearchModel(this.searchModel, this.currentAsyncSearch);
+        this.searchModel = this._instantiationService.createInstance(SearchModel);
+        this.searchModel.location = SearchModelLocation.QUICK_ACCESS;
+        const viewer = viewlet?.getControl();
+        if (currentElem) {
+            viewer.setFocus([currentElem], getSelectionKeyboardEvent());
+            viewer.setSelection([currentElem], getSelectionKeyboardEvent());
+            viewer.reveal(currentElem);
+        }
+        else {
+            viewlet.searchAndReplaceWidget.focus();
+        }
+    }
+    _getPicksFromMatches(matches, limit) {
+        matches = matches.sort(searchComparer);
+        const files = matches.length > limit ? matches.slice(0, limit) : matches;
+        const picks = [];
+        for (let fileIndex = 0; fileIndex < matches.length; fileIndex++) {
+            if (fileIndex === limit) {
+                picks.push({
+                    type: 'separator',
+                });
+                picks.push({
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess',
+                        'QuickSearchSeeMoreFiles',
+                        "See More Files"
+                    )),
+                    iconClass: ThemeIcon.asClassName(searchDetailsIcon),
+                    accept: async () => {
+                        this.moveToSearchViewlet(matches[limit]);
+                    }
+                });
+                break;
+            }
+            const fileMatch = files[fileIndex];
+            const label = basenameOrAuthority(fileMatch.resource);
+            const description = this._labelService.getUriLabel(dirname(fileMatch.resource), { relative: true });
+            picks.push({
+                label,
+                type: 'separator',
+                description,
+                buttons: [{
+                        iconClass: ThemeIcon.asClassName(searchOpenInFileIcon),
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess',
+                            'QuickSearchOpenInFile',
+                            "Open File"
+                        ))
+                    }],
+                trigger: async () => {
+                    await this.handleAccept(fileMatch, {});
+                    return TriggerAction.CLOSE_PICKER;
+                },
+            });
+            const results = fileMatch.matches() ?? [];
+            for (let matchIndex = 0; matchIndex < results.length; matchIndex++) {
+                const element = results[matchIndex];
+                if (matchIndex === MAX_RESULTS_PER_FILE) {
+                    picks.push({
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess',
+                            'QuickSearchMore',
+                            "More"
+                        )),
+                        iconClass: ThemeIcon.asClassName(searchDetailsIcon),
+                        accept: async () => {
+                            this.moveToSearchViewlet(element);
+                        }
+                    });
+                    break;
+                }
+                const preview = element.preview();
+                const previewText = (preview.before + preview.inside + preview.after).trim().substring(0, 999);
+                const match = [{
+                        start: preview.before.length,
+                        end: preview.before.length + preview.inside.length
+                    }];
+                picks.push({
+                    label: `${previewText}`,
+                    highlights: {
+                        label: match
+                    },
+                    buttons: [{
+                            iconClass: ThemeIcon.asClassName(searchActivityBarIcon),
+                            tooltip: ( localizeWithPath(
+                                'vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess',
+                                'showMore',
+                                "See in Search Panel"
+                            )),
+                        }],
+                    ariaLabel: `Match at location ${element.range().startLineNumber}:${element.range().startColumn} - ${previewText}`,
+                    accept: async (keyMods, event) => {
+                        await this.handleAccept(fileMatch, {
+                            keyMods,
+                            selection: getEditorSelectionFromMatch(element, this.searchModel),
+                            preserveFocus: event.inBackground,
+                            forcePinned: event.inBackground
+                        });
+                    },
+                    trigger: () => {
+                        this.moveToSearchViewlet(element);
+                        return TriggerAction.CLOSE_PICKER;
+                    },
+                    match: element
+                });
+            }
+        }
+        return picks;
+    }
+    async handleAccept(fileMatch, options) {
+        const editorOptions = {
+            preserveFocus: options.preserveFocus,
+            pinned: options.keyMods?.ctrlCmd || options.forcePinned || this.configuration.openEditorPinned,
+            selection: options.selection
+        };
+        const targetGroup = options.keyMods?.alt || (this.configuration.openEditorPinned && options.keyMods?.ctrlCmd) || options.forceOpenSideBySide ? SIDE_GROUP : ACTIVE_GROUP;
+        await this._editorService.openEditor({
+            resource: fileMatch.resource,
+            options: editorOptions
+        }, targetGroup);
+    }
+    _getPicks(contentPattern, disposables, token) {
+        const searchModelAtTimeOfSearch = this.searchModel;
+        if (contentPattern === '') {
+            this.searchModel.searchResult.clear();
+            return [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess',
+                        'enterSearchTerm',
+                        "Enter a term to search for across your files."
+                    ))
+                }];
+        }
+        const conditionalTokenCts = disposables.add(( new CancellationTokenSource()));
+        disposables.add(token.onCancellationRequested(() => {
+            if (searchModelAtTimeOfSearch.location === SearchModelLocation.QUICK_ACCESS) {
+                conditionalTokenCts.cancel();
+            }
+        }));
+        const allMatches = this.doSearch(contentPattern, conditionalTokenCts.token);
+        if (!allMatches) {
+            return null;
+        }
+        const matches = allMatches.syncResults;
+        const syncResult = this._getPicksFromMatches(matches, MAX_FILES_SHOWN);
+        if (syncResult.length > 0) {
+            this.searchModel.searchResult.toggleHighlights(true);
+        }
+        if (matches.length >= MAX_FILES_SHOWN) {
+            return syncResult;
+        }
+        return {
+            picks: syncResult,
+            additionalPicks: allMatches.asyncResults
+                .then(asyncResults => (asyncResults.length + syncResult.length === 0) ? [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/quickTextSearch/textSearchQuickAccess',
+                        'noAnythingResults',
+                        "No matching results"
+                    ))
+                }] : this._getPicksFromMatches(asyncResults, MAX_FILES_SHOWN - matches.length))
+                .then(picks => {
+                if (picks.length > 0) {
+                    this.searchModel.searchResult.toggleHighlights(true);
+                }
+                return picks;
+            })
+        };
+    }
+};
+TextSearchQuickAccess = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IViewsService)),
+    ( __param(5, IConfigurationService))
+], TextSearchQuickAccess));
+export { TEXT_SEARCH_QUICK_ACCESS_PREFIX, TextSearchQuickAccess };

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

@@ -0,0 +1,7 @@
+import '../../../../platform/instantiation/common/instantiation.js';
+import { ReplacePreviewContentProvider } from './replaceService.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
+function registerContributions() {
+    registerWorkbenchContribution2(ReplacePreviewContentProvider.ID, ReplacePreviewContentProvider, 1 );
+}
+export { registerContributions };

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

@@ -0,0 +1,230 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IReplaceService } from './replace.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { Match, MatchInNotebook, FileMatch, ISearchViewModelWorkbenchService } from './searchModel.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { createTextBufferFactoryFromSnapshot } from '../../../../editor/common/model/textModel.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { ResourceTextEdit, IBulkEditService } from '../../../../editor/browser/services/bulkEditService.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { EditOperation } from '../../../../editor/common/core/editOperation.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { dirname } from '../../../../base/common/resources.js';
+import { Promises } from '../../../../base/common/async.js';
+import { SaveSourceRegistry } from '../../../common/editor.js';
+import { CellUri } from '../../notebook/common/notebookCommon.js';
+import { INotebookEditorModelResolverService } from '../../notebook/common/notebookEditorModelResolverService.js';
+var ReplaceService_1;
+const REPLACE_PREVIEW = 'replacePreview';
+const toReplaceResource = (fileResource) => {
+    return fileResource.with({ scheme: Schemas.internal, fragment: REPLACE_PREVIEW, query: JSON.stringify({ scheme: fileResource.scheme }) });
+};
+const toFileResource = (replaceResource) => {
+    return replaceResource.with({ scheme: JSON.parse(replaceResource.query)['scheme'], fragment: '', query: '' });
+};
+let ReplacePreviewContentProvider = class ReplacePreviewContentProvider {
+    static { this.ID = 'workbench.contrib.replacePreviewContentProvider'; }
+    constructor(instantiationService, textModelResolverService) {
+        this.instantiationService = instantiationService;
+        this.textModelResolverService = textModelResolverService;
+        this.textModelResolverService.registerTextModelContentProvider(Schemas.internal, this);
+    }
+    provideTextContent(uri) {
+        if (uri.fragment === REPLACE_PREVIEW) {
+            return this.instantiationService.createInstance(ReplacePreviewModel).resolve(uri);
+        }
+        return null;
+    }
+};
+ReplacePreviewContentProvider = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextModelService))
+], ReplacePreviewContentProvider));
+let ReplacePreviewModel = class ReplacePreviewModel extends Disposable {
+    constructor(modelService, languageService, textModelResolverService, replaceService, searchWorkbenchService) {
+        super();
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.textModelResolverService = textModelResolverService;
+        this.replaceService = replaceService;
+        this.searchWorkbenchService = searchWorkbenchService;
+    }
+    async resolve(replacePreviewUri) {
+        const fileResource = toFileResource(replacePreviewUri);
+        const fileMatch = this.searchWorkbenchService.searchModel.searchResult.matches().filter(match => ( match.resource.toString()) === ( fileResource.toString()))[0];
+        const ref = this._register(await this.textModelResolverService.createModelReference(fileResource));
+        const sourceModel = ref.object.textEditorModel;
+        const sourceModelLanguageId = sourceModel.getLanguageId();
+        const replacePreviewModel = this.modelService.createModel(createTextBufferFactoryFromSnapshot(sourceModel.createSnapshot()), this.languageService.createById(sourceModelLanguageId), replacePreviewUri);
+        this._register(fileMatch.onChange(({ forceUpdateModel }) => this.update(sourceModel, replacePreviewModel, fileMatch, forceUpdateModel)));
+        this._register(this.searchWorkbenchService.searchModel.onReplaceTermChanged(() => this.update(sourceModel, replacePreviewModel, fileMatch)));
+        this._register(fileMatch.onDispose(() => replacePreviewModel.dispose()));
+        this._register(replacePreviewModel.onWillDispose(() => this.dispose()));
+        this._register(sourceModel.onWillDispose(() => this.dispose()));
+        return replacePreviewModel;
+    }
+    update(sourceModel, replacePreviewModel, fileMatch, override = false) {
+        if (!sourceModel.isDisposed() && !replacePreviewModel.isDisposed()) {
+            this.replaceService.updateReplacePreview(fileMatch, override);
+        }
+    }
+};
+ReplacePreviewModel = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IReplaceService)),
+    ( __param(4, ISearchViewModelWorkbenchService))
+], ReplacePreviewModel));
+let ReplaceService = class ReplaceService {
+    static { ReplaceService_1 = this; }
+    static { this.REPLACE_SAVE_SOURCE = SaveSourceRegistry.registerSource('searchReplace.source', ( localizeWithPath(
+        'vs/workbench/contrib/search/browser/replaceService',
+        'searchReplace.source',
+        "Search and Replace"
+    ))); }
+    constructor(textFileService, editorService, textModelResolverService, bulkEditorService, labelService, notebookEditorModelResolverService) {
+        this.textFileService = textFileService;
+        this.editorService = editorService;
+        this.textModelResolverService = textModelResolverService;
+        this.bulkEditorService = bulkEditorService;
+        this.labelService = labelService;
+        this.notebookEditorModelResolverService = notebookEditorModelResolverService;
+    }
+    async replace(arg, progress = undefined, resource = null) {
+        const edits = this.createEdits(arg, resource);
+        await this.bulkEditorService.apply(edits, { progress });
+        const rawTextPromises = ( edits.map(async (e) => {
+            if (e.resource.scheme === Schemas.vscodeNotebookCell) {
+                const notebookResource = CellUri.parse(e.resource)?.notebook;
+                if (notebookResource) {
+                    let ref;
+                    try {
+                        ref = await this.notebookEditorModelResolverService.resolve(notebookResource);
+                        await ref.object.save({ source: ReplaceService_1.REPLACE_SAVE_SOURCE });
+                    }
+                    finally {
+                        ref?.dispose();
+                    }
+                }
+                return;
+            }
+            else {
+                return this.textFileService.files.get(e.resource)?.save({ source: ReplaceService_1.REPLACE_SAVE_SOURCE });
+            }
+        }));
+        return Promises.settled(rawTextPromises);
+    }
+    async openReplacePreview(element, preserveFocus, sideBySide, pinned) {
+        const fileMatch = element instanceof Match ? element.parent() : element;
+        const editor = await this.editorService.openEditor({
+            original: { resource: fileMatch.resource },
+            modified: { resource: toReplaceResource(fileMatch.resource) },
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/replaceService',
+                'fileReplaceChanges',
+                "{0} ↔ {1} (Replace Preview)",
+                fileMatch.name(),
+                fileMatch.name()
+            )),
+            description: this.labelService.getUriLabel(dirname(fileMatch.resource), { relative: true }),
+            options: {
+                preserveFocus,
+                pinned,
+                revealIfVisible: true
+            }
+        });
+        const input = editor?.input;
+        const disposable = fileMatch.onDispose(() => {
+            input?.dispose();
+            disposable.dispose();
+        });
+        await this.updateReplacePreview(fileMatch);
+        if (editor) {
+            const editorControl = editor.getControl();
+            if (element instanceof Match && editorControl) {
+                editorControl.revealLineInCenter(element.range().startLineNumber, 1 );
+            }
+        }
+    }
+    async updateReplacePreview(fileMatch, override = false) {
+        const replacePreviewUri = toReplaceResource(fileMatch.resource);
+        const [sourceModelRef, replaceModelRef] = await Promise.all([this.textModelResolverService.createModelReference(fileMatch.resource), this.textModelResolverService.createModelReference(replacePreviewUri)]);
+        const sourceModel = sourceModelRef.object.textEditorModel;
+        const replaceModel = replaceModelRef.object.textEditorModel;
+        try {
+            if (sourceModel && replaceModel) {
+                if (override) {
+                    replaceModel.setValue(sourceModel.getValue());
+                }
+                else {
+                    replaceModel.undo();
+                }
+                this.applyEditsToPreview(fileMatch, replaceModel);
+            }
+        }
+        finally {
+            sourceModelRef.dispose();
+            replaceModelRef.dispose();
+        }
+    }
+    applyEditsToPreview(fileMatch, replaceModel) {
+        const resourceEdits = this.createEdits(fileMatch, replaceModel.uri);
+        const modelEdits = [];
+        for (const resourceEdit of resourceEdits) {
+            modelEdits.push(EditOperation.replaceMove(Range.lift(resourceEdit.textEdit.range), resourceEdit.textEdit.text));
+        }
+        replaceModel.pushEditOperations([], modelEdits.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range)), () => []);
+    }
+    createEdits(arg, resource = null) {
+        const edits = [];
+        if (arg instanceof Match) {
+            if (arg instanceof MatchInNotebook) {
+                if (!arg.isReadonly()) {
+                    const match = arg;
+                    edits.push(this.createEdit(match, match.replaceString, match.cell?.uri));
+                }
+            }
+            else {
+                const match = arg;
+                edits.push(this.createEdit(match, match.replaceString, resource));
+            }
+        }
+        if (arg instanceof FileMatch) {
+            arg = [arg];
+        }
+        if (arg instanceof Array) {
+            arg.forEach(element => {
+                const fileMatch = element;
+                if (fileMatch.count() > 0) {
+                    edits.push(...fileMatch.matches().flatMap(match => this.createEdits(match, resource)));
+                }
+            });
+        }
+        return edits;
+    }
+    createEdit(match, text, resource = null) {
+        const fileMatch = match.parent();
+        return ( new ResourceTextEdit(
+            resource ?? fileMatch.resource,
+            { range: match.range(), text },
+            undefined,
+            undefined
+        ));
+    }
+};
+ReplaceService = ReplaceService_1 = ( __decorate([
+    ( __param(0, ITextFileService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, INotebookEditorModelResolverService))
+], ReplaceService));
+export { ReplacePreviewContentProvider, ReplaceService };