@codingame/monaco-vscode-api 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadEditorTabs.js

@@ -1,473 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../common/editor.js';
-import { DiffEditorInput } from '../../common/editor/diffEditorInput.js';
-import { editorGroupToColumn, columnToEditorGroup } from '../../services/editor/common/editorGroupColumn.js';
-import { preferredSideBySideGroupDirection, IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
-import { SIDE_GROUP, IEditorService } from '../../services/editor/common/editorService.js';
-import { AbstractTextResourceEditorInput } from '../../common/editor/textResourceEditorInput.js';
-import { NotebookEditorInput } from '../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
-import { CustomEditorInput } from '../../contrib/customEditor/browser/customEditorInput.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { WebviewInput } from '../../contrib/webviewPanel/browser/webviewEditorInput.js';
-import { TerminalEditorInput } from '../../contrib/terminal/browser/terminalEditorInput.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { SideBySideEditorInput } from '../../common/editor/sideBySideEditorInput.js';
-import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { isGroupEditorMoveEvent } from '../../common/editor/editorGroupModel.js';
-import { InteractiveEditorInput } from '../../contrib/interactive/browser/interactiveEditorInput.js';
-import { MergeEditorInput } from '../../contrib/mergeEditor/browser/mergeEditorInput.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-let MainThreadEditorTabs = class MainThreadEditorTabs {
-    constructor(extHostContext, _editorGroupsService, _configurationService, _logService, editorService) {
-        this._editorGroupsService = _editorGroupsService;
-        this._configurationService = _configurationService;
-        this._logService = _logService;
-        this._dispoables = ( new DisposableStore());
-        this._tabGroupModel = [];
-        this._groupLookup = ( new Map());
-        this._tabInfoLookup = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditorTabs));
-        this._dispoables.add(editorService.onDidEditorsChange((event) => {
-            try {
-                this._updateTabsModel(event);
-            }
-            catch {
-                this._logService.error('Failed to update model, rebuilding');
-                this._createTabsModel();
-            }
-        }));
-        this._dispoables.add(this._editorGroupsService.onDidAddGroup(() => this._createTabsModel()));
-        this._dispoables.add(this._editorGroupsService.onDidRemoveGroup(() => this._createTabsModel()));
-        this._editorGroupsService.whenReady.then(() => this._createTabsModel());
-    }
-    dispose() {
-        this._groupLookup.clear();
-        this._tabInfoLookup.clear();
-        this._dispoables.dispose();
-    }
-    _buildTabObject(group, editor, editorIndex) {
-        const editorId = editor.editorId;
-        const tab = {
-            id: this._generateTabId(editor, group.id),
-            label: editor.getName(),
-            editorId,
-            input: this._editorInputToDto(editor),
-            isPinned: group.isSticky(editorIndex),
-            isPreview: !group.isPinned(editorIndex),
-            isActive: group.isActive(editor),
-            isDirty: editor.isDirty()
-        };
-        return tab;
-    }
-    _editorInputToDto(editor) {
-        if (editor instanceof MergeEditorInput) {
-            return {
-                kind: 3 ,
-                base: editor.base,
-                input1: editor.input1.uri,
-                input2: editor.input2.uri,
-                result: editor.resource
-            };
-        }
-        if (editor instanceof AbstractTextResourceEditorInput) {
-            return {
-                kind: 1 ,
-                uri: editor.resource
-            };
-        }
-        if (editor instanceof SideBySideEditorInput && !(editor instanceof DiffEditorInput)) {
-            const primaryResource = editor.primary.resource;
-            const secondaryResource = editor.secondary.resource;
-            if (editor.primary instanceof AbstractTextResourceEditorInput
-                && editor.secondary instanceof AbstractTextResourceEditorInput
-                && isEqual(primaryResource, secondaryResource)
-                && primaryResource
-                && secondaryResource) {
-                return {
-                    kind: 1 ,
-                    uri: primaryResource
-                };
-            }
-            return { kind: 0  };
-        }
-        if (editor instanceof NotebookEditorInput) {
-            return {
-                kind: 4 ,
-                notebookType: editor.viewType,
-                uri: editor.resource
-            };
-        }
-        if (editor instanceof CustomEditorInput) {
-            return {
-                kind: 6 ,
-                viewType: editor.viewType,
-                uri: editor.resource,
-            };
-        }
-        if (editor instanceof WebviewInput) {
-            return {
-                kind: 7 ,
-                viewType: editor.viewType
-            };
-        }
-        if (editor instanceof TerminalEditorInput) {
-            return {
-                kind: 8
-            };
-        }
-        if (editor instanceof DiffEditorInput) {
-            if (editor.modified instanceof AbstractTextResourceEditorInput && editor.original instanceof AbstractTextResourceEditorInput) {
-                return {
-                    kind: 2 ,
-                    modified: editor.modified.resource,
-                    original: editor.original.resource
-                };
-            }
-            if (editor.modified instanceof NotebookEditorInput && editor.original instanceof NotebookEditorInput) {
-                return {
-                    kind: 5 ,
-                    notebookType: editor.original.viewType,
-                    modified: editor.modified.resource,
-                    original: editor.original.resource
-                };
-            }
-        }
-        if (editor instanceof InteractiveEditorInput) {
-            return {
-                kind: 9 ,
-                uri: editor.resource,
-                inputBoxUri: editor.inputResource
-            };
-        }
-        return { kind: 0  };
-    }
-    _generateTabId(editor, groupId) {
-        let resourceString;
-        const resource = EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.BOTH });
-        if (resource instanceof URI) {
-            resourceString = ( resource.toString());
-        }
-        else {
-            resourceString = `${resource?.primary?.toString()}-${resource?.secondary?.toString()}`;
-        }
-        return `${groupId}~${editor.editorId}-${editor.typeId}-${resourceString} `;
-    }
-    _onDidGroupActivate() {
-        const activeGroupId = this._editorGroupsService.activeGroup.id;
-        const activeGroup = this._groupLookup.get(activeGroupId);
-        if (activeGroup) {
-            activeGroup.isActive = true;
-            this._proxy.$acceptTabGroupUpdate(activeGroup);
-        }
-    }
-    _onDidTabLabelChange(groupId, editorInput, editorIndex) {
-        const tabId = this._generateTabId(editorInput, groupId);
-        const tabInfo = this._tabInfoLookup.get(tabId);
-        if (tabInfo) {
-            tabInfo.tab.label = editorInput.getName();
-            this._proxy.$acceptTabOperation({
-                groupId,
-                index: editorIndex,
-                tabDto: tabInfo.tab,
-                kind: 2
-            });
-        }
-        else {
-            this._logService.error('Invalid model for label change, rebuilding');
-            this._createTabsModel();
-        }
-    }
-    _onDidTabOpen(groupId, editorInput, editorIndex) {
-        const group = this._editorGroupsService.getGroup(groupId);
-        const groupInModel = this._groupLookup.get(groupId) !== undefined;
-        if (!group || !groupInModel) {
-            this._createTabsModel();
-            return;
-        }
-        const tabs = this._groupLookup.get(groupId)?.tabs;
-        if (!tabs) {
-            return;
-        }
-        const tabObject = this._buildTabObject(group, editorInput, editorIndex);
-        tabs.splice(editorIndex, 0, tabObject);
-        this._tabInfoLookup.set(this._generateTabId(editorInput, groupId), { group, editorInput, tab: tabObject });
-        this._proxy.$acceptTabOperation({
-            groupId,
-            index: editorIndex,
-            tabDto: tabObject,
-            kind: 0
-        });
-    }
-    _onDidTabClose(groupId, editorIndex) {
-        const group = this._editorGroupsService.getGroup(groupId);
-        const tabs = this._groupLookup.get(groupId)?.tabs;
-        if (!group || !tabs) {
-            this._createTabsModel();
-            return;
-        }
-        const removedTab = tabs.splice(editorIndex, 1);
-        if (removedTab.length === 0) {
-            return;
-        }
-        this._tabInfoLookup.delete(removedTab[0]?.id ?? '');
-        this._proxy.$acceptTabOperation({
-            groupId,
-            index: editorIndex,
-            tabDto: removedTab[0],
-            kind: 1
-        });
-    }
-    _onDidTabActiveChange(groupId, editorIndex) {
-        const tabs = this._groupLookup.get(groupId)?.tabs;
-        if (!tabs) {
-            return;
-        }
-        const activeTab = tabs[editorIndex];
-        activeTab.isActive = true;
-        this._proxy.$acceptTabOperation({
-            groupId,
-            index: editorIndex,
-            tabDto: activeTab,
-            kind: 2
-        });
-    }
-    _onDidTabDirty(groupId, editorIndex, editor) {
-        const tabId = this._generateTabId(editor, groupId);
-        const tabInfo = this._tabInfoLookup.get(tabId);
-        if (!tabInfo) {
-            this._logService.error('Invalid model for dirty change, rebuilding');
-            this._createTabsModel();
-            return;
-        }
-        tabInfo.tab.isDirty = editor.isDirty();
-        this._proxy.$acceptTabOperation({
-            groupId,
-            index: editorIndex,
-            tabDto: tabInfo.tab,
-            kind: 2
-        });
-    }
-    _onDidTabPinChange(groupId, editorIndex, editor) {
-        const tabId = this._generateTabId(editor, groupId);
-        const tabInfo = this._tabInfoLookup.get(tabId);
-        const group = tabInfo?.group;
-        const tab = tabInfo?.tab;
-        if (!group || !tab) {
-            this._logService.error('Invalid model for sticky change, rebuilding');
-            this._createTabsModel();
-            return;
-        }
-        tab.isPinned = group.isSticky(editorIndex);
-        this._proxy.$acceptTabOperation({
-            groupId,
-            index: editorIndex,
-            tabDto: tab,
-            kind: 2
-        });
-    }
-    _onDidTabPreviewChange(groupId, editorIndex, editor) {
-        const tabId = this._generateTabId(editor, groupId);
-        const tabInfo = this._tabInfoLookup.get(tabId);
-        const group = tabInfo?.group;
-        const tab = tabInfo?.tab;
-        if (!group || !tab) {
-            this._logService.error('Invalid model for sticky change, rebuilding');
-            this._createTabsModel();
-            return;
-        }
-        tab.isPreview = !group.isPinned(editorIndex);
-        this._proxy.$acceptTabOperation({
-            kind: 2 ,
-            groupId,
-            tabDto: tab,
-            index: editorIndex
-        });
-    }
-    _onDidTabMove(groupId, editorIndex, oldEditorIndex, editor) {
-        const tabs = this._groupLookup.get(groupId)?.tabs;
-        if (!tabs) {
-            this._logService.error('Invalid model for move change, rebuilding');
-            this._createTabsModel();
-            return;
-        }
-        const removedTab = tabs.splice(oldEditorIndex, 1);
-        if (removedTab.length === 0) {
-            return;
-        }
-        tabs.splice(editorIndex, 0, removedTab[0]);
-        this._proxy.$acceptTabOperation({
-            kind: 3 ,
-            groupId,
-            tabDto: removedTab[0],
-            index: editorIndex,
-            oldIndex: oldEditorIndex
-        });
-    }
-    _createTabsModel() {
-        this._tabGroupModel = [];
-        this._groupLookup.clear();
-        this._tabInfoLookup.clear();
-        let tabs = [];
-        for (const group of this._editorGroupsService.groups) {
-            const currentTabGroupModel = {
-                groupId: group.id,
-                isActive: group.id === this._editorGroupsService.activeGroup.id,
-                viewColumn: editorGroupToColumn(this._editorGroupsService, group),
-                tabs: []
-            };
-            group.editors.forEach((editor, editorIndex) => {
-                const tab = this._buildTabObject(group, editor, editorIndex);
-                tabs.push(tab);
-                this._tabInfoLookup.set(this._generateTabId(editor, group.id), {
-                    group,
-                    tab,
-                    editorInput: editor
-                });
-            });
-            currentTabGroupModel.tabs = tabs;
-            this._tabGroupModel.push(currentTabGroupModel);
-            this._groupLookup.set(group.id, currentTabGroupModel);
-            tabs = [];
-        }
-        this._proxy.$acceptEditorTabModel(this._tabGroupModel);
-    }
-    _updateTabsModel(changeEvent) {
-        const event = changeEvent.event;
-        const groupId = changeEvent.groupId;
-        switch (event.kind) {
-            case 0 :
-                if (groupId === this._editorGroupsService.activeGroup.id) {
-                    this._onDidGroupActivate();
-                    break;
-                }
-                else {
-                    return;
-                }
-            case 7 :
-                if (event.editor !== undefined && event.editorIndex !== undefined) {
-                    this._onDidTabLabelChange(groupId, event.editor, event.editorIndex);
-                    break;
-                }
-            case 3 :
-                if (event.editor !== undefined && event.editorIndex !== undefined) {
-                    this._onDidTabOpen(groupId, event.editor, event.editorIndex);
-                    break;
-                }
-            case 4 :
-                if (event.editorIndex !== undefined) {
-                    this._onDidTabClose(groupId, event.editorIndex);
-                    break;
-                }
-            case 6 :
-                if (event.editorIndex !== undefined) {
-                    this._onDidTabActiveChange(groupId, event.editorIndex);
-                    break;
-                }
-            case 11 :
-                if (event.editorIndex !== undefined && event.editor !== undefined) {
-                    this._onDidTabDirty(groupId, event.editorIndex, event.editor);
-                    break;
-                }
-            case 10 :
-                if (event.editorIndex !== undefined && event.editor !== undefined) {
-                    this._onDidTabPinChange(groupId, event.editorIndex, event.editor);
-                    break;
-                }
-            case 9 :
-                if (event.editorIndex !== undefined && event.editor !== undefined) {
-                    this._onDidTabPreviewChange(groupId, event.editorIndex, event.editor);
-                    break;
-                }
-            case 5 :
-                if (isGroupEditorMoveEvent(event) && event.editor && event.editorIndex !== undefined && event.oldEditorIndex !== undefined) {
-                    this._onDidTabMove(groupId, event.editorIndex, event.oldEditorIndex, event.editor);
-                    break;
-                }
-            default:
-                this._createTabsModel();
-        }
-    }
-    $moveTab(tabId, index, viewColumn, preserveFocus) {
-        const groupId = columnToEditorGroup(this._editorGroupsService, this._configurationService, viewColumn);
-        const tabInfo = this._tabInfoLookup.get(tabId);
-        const tab = tabInfo?.tab;
-        if (!tab) {
-            throw new Error(`Attempted to close tab with id ${tabId} which does not exist`);
-        }
-        let targetGroup;
-        const sourceGroup = this._editorGroupsService.getGroup(tabInfo.group.id);
-        if (!sourceGroup) {
-            return;
-        }
-        if (this._groupLookup.get(groupId) === undefined) {
-            let direction = 3 ;
-            if (viewColumn === SIDE_GROUP) {
-                direction = preferredSideBySideGroupDirection(this._configurationService);
-            }
-            targetGroup = this._editorGroupsService.addGroup(this._editorGroupsService.groups[this._editorGroupsService.groups.length - 1], direction);
-        }
-        else {
-            targetGroup = this._editorGroupsService.getGroup(groupId);
-        }
-        if (!targetGroup) {
-            return;
-        }
-        if (index < 0 || index > targetGroup.editors.length) {
-            index = targetGroup.editors.length;
-        }
-        const editorInput = tabInfo?.editorInput;
-        if (!editorInput) {
-            return;
-        }
-        sourceGroup.moveEditor(editorInput, targetGroup, { index, preserveFocus });
-        return;
-    }
-    async $closeTab(tabIds, preserveFocus) {
-        const groups = ( new Map());
-        for (const tabId of tabIds) {
-            const tabInfo = this._tabInfoLookup.get(tabId);
-            const tab = tabInfo?.tab;
-            const group = tabInfo?.group;
-            const editorTab = tabInfo?.editorInput;
-            if (!group || !tab || !tabInfo || !editorTab) {
-                continue;
-            }
-            const groupEditors = groups.get(group);
-            if (!groupEditors) {
-                groups.set(group, [editorTab]);
-            }
-            else {
-                groupEditors.push(editorTab);
-            }
-        }
-        const results = [];
-        for (const [group, editors] of groups) {
-            results.push(await group.closeEditors(editors, { preserveFocus }));
-        }
-        return results.every(result => result);
-    }
-    async $closeGroup(groupIds, preserveFocus) {
-        const groupCloseResults = [];
-        for (const groupId of groupIds) {
-            const group = this._editorGroupsService.getGroup(groupId);
-            if (group) {
-                groupCloseResults.push(await group.closeAllEditors());
-                if (group.count === 0 && this._editorGroupsService.getGroup(group.id)) {
-                    this._editorGroupsService.removeGroup(group);
-                }
-            }
-        }
-        return groupCloseResults.every(result => result);
-    }
-};
-MainThreadEditorTabs = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadEditorTabs),
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IEditorService))
-], MainThreadEditorTabs);
-export { MainThreadEditorTabs };

package/vscode/src/vs/workbench/api/browser/mainThreadEditors.js

@@ -1,225 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { illegalArgument } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { EditorActivation, EditorResolution } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
-import { ExtHostContext } from '../common/extHost.protocol.js';
-import { editorGroupToColumn, columnToEditorGroup } from '../../services/editor/common/editorGroupColumn.js';
-import { IEditorService } from '../../services/editor/common/editorService.js';
-import { IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IWorkingCopyService } from '../../services/workingCopy/common/workingCopyService.js';
-import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-var MainThreadTextEditors_1;
-let MainThreadTextEditors = class MainThreadTextEditors {
-    static { MainThreadTextEditors_1 = this; }
-    static { this.INSTANCE_COUNT = 0; }
-    constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService, _configurationService) {
-        this._editorLocator = _editorLocator;
-        this._codeEditorService = _codeEditorService;
-        this._editorService = _editorService;
-        this._editorGroupService = _editorGroupService;
-        this._configurationService = _configurationService;
-        this._toDispose = ( new DisposableStore());
-        this._instanceId = String(++MainThreadTextEditors_1.INSTANCE_COUNT);
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditors));
-        this._textEditorsListenersMap = Object.create(null);
-        this._editorPositionData = null;
-        this._toDispose.add(this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors()));
-        this._toDispose.add(this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors()));
-        this._toDispose.add(this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors()));
-        this._registeredDecorationTypes = Object.create(null);
-    }
-    dispose() {
-        ( Object.keys(this._textEditorsListenersMap)).forEach((editorId) => {
-            dispose(this._textEditorsListenersMap[editorId]);
-        });
-        this._textEditorsListenersMap = Object.create(null);
-        this._toDispose.dispose();
-        for (const decorationType in this._registeredDecorationTypes) {
-            this._codeEditorService.removeDecorationType(decorationType);
-        }
-        this._registeredDecorationTypes = Object.create(null);
-    }
-    handleTextEditorAdded(textEditor) {
-        const id = textEditor.getId();
-        const toDispose = [];
-        toDispose.push(textEditor.onPropertiesChanged((data) => {
-            this._proxy.$acceptEditorPropertiesChanged(id, data);
-        }));
-        this._textEditorsListenersMap[id] = toDispose;
-    }
-    handleTextEditorRemoved(id) {
-        dispose(this._textEditorsListenersMap[id]);
-        delete this._textEditorsListenersMap[id];
-    }
-    _updateActiveAndVisibleTextEditors() {
-        const editorPositionData = this._getTextEditorPositionData();
-        if (!equals(this._editorPositionData, editorPositionData)) {
-            this._editorPositionData = editorPositionData;
-            this._proxy.$acceptEditorPositionData(this._editorPositionData);
-        }
-    }
-    _getTextEditorPositionData() {
-        const result = Object.create(null);
-        for (const editorPane of this._editorService.visibleEditorPanes) {
-            const id = this._editorLocator.findTextEditorIdFor(editorPane);
-            if (id) {
-                result[id] = editorGroupToColumn(this._editorGroupService, editorPane.group);
-            }
-        }
-        return result;
-    }
-    async $tryShowTextDocument(resource, options) {
-        const uri = URI.revive(resource);
-        const editorOptions = {
-            preserveFocus: options.preserveFocus,
-            pinned: options.pinned,
-            selection: options.selection,
-            activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
-            override: EditorResolution.EXCLUSIVE_ONLY
-        };
-        const input = {
-            resource: uri,
-            options: editorOptions
-        };
-        const editor = await this._editorService.openEditor(input, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
-        if (!editor) {
-            return undefined;
-        }
-        const editorControl = editor.getControl();
-        const codeEditor = getCodeEditor(editorControl);
-        return codeEditor ? this._editorLocator.getIdOfCodeEditor(codeEditor) : undefined;
-    }
-    async $tryShowEditor(id, position) {
-        const mainThreadEditor = this._editorLocator.getEditor(id);
-        if (mainThreadEditor) {
-            const model = mainThreadEditor.getModel();
-            await this._editorService.openEditor({
-                resource: model.uri,
-                options: { preserveFocus: false }
-            }, columnToEditorGroup(this._editorGroupService, this._configurationService, position));
-            return;
-        }
-    }
-    async $tryHideEditor(id) {
-        const mainThreadEditor = this._editorLocator.getEditor(id);
-        if (mainThreadEditor) {
-            const editorPanes = this._editorService.visibleEditorPanes;
-            for (const editorPane of editorPanes) {
-                if (mainThreadEditor.matches(editorPane)) {
-                    await editorPane.group.closeEditor(editorPane.input);
-                    return;
-                }
-            }
-        }
-    }
-    $trySetSelections(id, selections) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setSelections(selections);
-        return Promise.resolve(undefined);
-    }
-    $trySetDecorations(id, key, ranges) {
-        key = `${this._instanceId}-${key}`;
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setDecorations(key, ranges);
-        return Promise.resolve(undefined);
-    }
-    $trySetDecorationsFast(id, key, ranges) {
-        key = `${this._instanceId}-${key}`;
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setDecorationsFast(key, ranges);
-        return Promise.resolve(undefined);
-    }
-    $tryRevealRange(id, range, revealType) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.revealRange(range, revealType);
-        return Promise.resolve();
-    }
-    $trySetOptions(id, options) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        editor.setConfiguration(options);
-        return Promise.resolve(undefined);
-    }
-    $tryApplyEdits(id, modelVersionId, edits, opts) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        return Promise.resolve(editor.applyEdits(modelVersionId, edits, opts));
-    }
-    $tryInsertSnippet(id, modelVersionId, template, ranges, opts) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(illegalArgument(`TextEditor(${id})`));
-        }
-        return Promise.resolve(editor.insertSnippet(modelVersionId, template, ranges, opts));
-    }
-    $registerTextEditorDecorationType(extensionId, key, options) {
-        key = `${this._instanceId}-${key}`;
-        this._registeredDecorationTypes[key] = true;
-        this._codeEditorService.registerDecorationType(`exthost-api-${extensionId}`, key, options);
-    }
-    $removeTextEditorDecorationType(key) {
-        key = `${this._instanceId}-${key}`;
-        delete this._registeredDecorationTypes[key];
-        this._codeEditorService.removeDecorationType(key);
-    }
-    $getDiffInformation(id) {
-        const editor = this._editorLocator.getEditor(id);
-        if (!editor) {
-            return Promise.reject(( new Error('No such TextEditor')));
-        }
-        const codeEditor = editor.getCodeEditor();
-        if (!codeEditor) {
-            return Promise.reject(( new Error('No such CodeEditor')));
-        }
-        const codeEditorId = codeEditor.getId();
-        const diffEditors = this._codeEditorService.listDiffEditors();
-        const [diffEditor] = diffEditors.filter(d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId);
-        if (diffEditor) {
-            return Promise.resolve(diffEditor.getLineChanges() || []);
-        }
-        const dirtyDiffContribution = codeEditor.getContribution('editor.contrib.dirtydiff');
-        if (dirtyDiffContribution) {
-            return Promise.resolve(dirtyDiffContribution.getChanges());
-        }
-        return Promise.resolve([]);
-    }
-};
-MainThreadTextEditors = MainThreadTextEditors_1 = ( __decorate([
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IEditorGroupsService)),
-    ( __param(5, IConfigurationService))
-], MainThreadTextEditors));
-CommandsRegistry.registerCommand('_workbench.revertAllDirty', async function (accessor) {
-    const environmentService = accessor.get(IEnvironmentService);
-    if (!environmentService.extensionTestsLocationURI) {
-        throw new Error('Command is only available when running extension tests.');
-    }
-    const workingCopyService = accessor.get(IWorkingCopyService);
-    for (const workingCopy of workingCopyService.dirtyWorkingCopies) {
-        await workingCopy.revert({ soft: true });
-    }
-});
-export { MainThreadTextEditors };