@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/browser/parts/editor/textCodeEditor.js

@@ -0,0 +1,79 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { withNullAsUndefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { AbstractTextEditor } from './textEditor.js';
+class AbstractTextCodeEditor extends AbstractTextEditor {
+    constructor() {
+        super(...arguments);
+        this.editorControl = undefined;
+    }
+    get scopedContextKeyService() {
+        return this.editorControl?.invokeWithinContext(accessor => accessor.get(IContextKeyService));
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return ( localize('textEditor', "Text Editor"));
+    }
+    createEditorControl(parent, initialOptions) {
+        this.editorControl = this._register(this.instantiationService.createInstance(CodeEditorWidget, parent, initialOptions, this.getCodeEditorWidgetOptions()));
+    }
+    getCodeEditorWidgetOptions() {
+        return Object.create(null);
+    }
+    updateEditorControlOptions(options) {
+        this.editorControl?.updateOptions(options);
+    }
+    getMainControl() {
+        return this.editorControl;
+    }
+    getControl() {
+        return this.editorControl;
+    }
+    computeEditorViewState(resource) {
+        if (!this.editorControl) {
+            return undefined;
+        }
+        const model = this.editorControl.getModel();
+        if (!model) {
+            return undefined;
+        }
+        const modelUri = model.uri;
+        if (!modelUri) {
+            return undefined;
+        }
+        if (!isEqual(modelUri, resource)) {
+            return undefined;
+        }
+        return withNullAsUndefined(this.editorControl.saveViewState());
+    }
+    setOptions(options) {
+        super.setOptions(options);
+        if (options) {
+            applyTextEditorOptions(options, assertIsDefined(this.editorControl), 0 );
+        }
+    }
+    focus() {
+        this.editorControl?.focus();
+    }
+    hasFocus() {
+        return this.editorControl?.hasTextFocus() || super.hasFocus();
+    }
+    setEditorVisible(visible, group) {
+        super.setEditorVisible(visible, group);
+        if (visible) {
+            this.editorControl?.onVisible();
+        }
+        else {
+            this.editorControl?.onHide();
+        }
+    }
+    layout(dimension) {
+        this.editorControl?.layout(dimension);
+    }
+}
+export { AbstractTextCodeEditor };

package/dist/vscode/vs/workbench/browser/parts/editor/textDiffEditor.js

@@ -0,0 +1,304 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { assertIsDefined, withUndefinedAsNull, isObject, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { AbstractTextEditor } from './textEditor.js';
+import { TEXT_DIFF_EDITOR_ID, isTextEditorViewState, createTooLargeFileError, EditorExtensions, isEditorInput } from '../../../common/editor.js';
+import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';
+import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { DiffNavigator } from 'monaco-editor/esm/vs/editor/browser/widget/diffNavigator.js';
+import { DiffEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditorWidget.js';
+import { TextDiffEditorModel } from '../../../common/editor/textDiffEditorModel.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { multibyteAwareBtoa } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { TooLargeFileOperationError, ByteSize, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
+    get scopedContextKeyService() {
+        if (!this.diffEditorControl) {
+            return undefined;
+        }
+        const originalEditor = this.diffEditorControl.getOriginalEditor();
+        const modifiedEditor = this.diffEditorControl.getModifiedEditor();
+        return (originalEditor.hasTextFocus() ? originalEditor : modifiedEditor).invokeWithinContext(accessor => accessor.get(IContextKeyService));
+    }
+    constructor(telemetryService, instantiationService, storageService, configurationService, editorService, themeService, editorGroupService, fileService, preferencesService) {
+        super(TextDiffEditor.ID, telemetryService, instantiationService, storageService, configurationService, themeService, editorService, editorGroupService, fileService);
+        this.preferencesService = preferencesService;
+        this.diffEditorControl = undefined;
+        this.diffNavigatorDisposables = this._register(( (new DisposableStore())));
+        this.inputLifecycleStopWatch = undefined;
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return (
+             (localize('textDiffEditor', "Text Diff Editor"))
+        );
+    }
+    createEditorControl(parent, configuration) {
+        this.diffEditorControl = this._register(this.instantiationService.createInstance(DiffEditorWidget, parent, configuration, {}));
+    }
+    updateEditorControlOptions(options) {
+        this.diffEditorControl?.updateOptions(options);
+    }
+    getMainControl() {
+        return this.diffEditorControl?.getModifiedEditor();
+    }
+    async setInput(input, options, context, token) {
+        this.inputLifecycleStopWatch = undefined;
+        this.diffNavigatorDisposables.clear();
+        await super.setInput(input, options, context, token);
+        try {
+            const resolvedModel = await input.resolve(options);
+            if (token.isCancellationRequested) {
+                return undefined;
+            }
+            if (!(resolvedModel instanceof TextDiffEditorModel)) {
+                this.openAsBinary(input, options);
+                return undefined;
+            }
+            const control = assertIsDefined(this.diffEditorControl);
+            const resolvedDiffEditorModel = resolvedModel;
+            control.setModel(withUndefinedAsNull(resolvedDiffEditorModel.textDiffEditorModel));
+            let hasPreviousViewState = false;
+            if (!isTextEditorViewState(options?.viewState)) {
+                hasPreviousViewState = this.restoreTextDiffEditorViewState(input, options, context, control);
+            }
+            let optionsGotApplied = false;
+            if (options) {
+                optionsGotApplied = applyTextEditorOptions(options, control, 1 );
+            }
+            this.diffNavigator = this.instantiationService.createInstance(DiffNavigator, control, {
+                alwaysRevealFirst: !optionsGotApplied && !hasPreviousViewState,
+                findResultLoop: this.getMainControl()?.getOption(39 ).loop
+            });
+            this.diffNavigatorDisposables.add(this.diffNavigator);
+            control.updateOptions({
+                readOnly: resolvedDiffEditorModel.modifiedModel?.isReadonly(),
+                originalEditable: !resolvedDiffEditorModel.originalModel?.isReadonly()
+            });
+            this.inputLifecycleStopWatch = ( (new StopWatch(false)));
+        }
+        catch (error) {
+            await this.handleSetInputError(error, input, options);
+        }
+    }
+    async handleSetInputError(error, input, options) {
+        if (this.isFileBinaryError(error)) {
+            return this.openAsBinary(input, options);
+        }
+        if (error.fileOperationResult === 7  && this.group) {
+            let message;
+            if (error instanceof TooLargeFileOperationError) {
+                message = ( (localize(
+                    'fileTooLargeForHeapErrorWithSize',
+                    "At least one file is not displayed in the text compare editor because it is very large ({0}).",
+                    ByteSize.formatSize(error.size)
+                )));
+            }
+            else {
+                message = ( (localize(
+                    'fileTooLargeForHeapErrorWithoutSize',
+                    "At least one file is not displayed in the text compare editor because it is very large."
+                )));
+            }
+            throw createTooLargeFileError(this.group, input, options, message, this.preferencesService);
+        }
+        throw error;
+    }
+    restoreTextDiffEditorViewState(editor, options, context, control) {
+        const editorViewState = this.loadEditorViewState(editor, context);
+        if (editorViewState) {
+            if (options?.selection && editorViewState.modified) {
+                editorViewState.modified.cursorState = [];
+            }
+            control.restoreViewState(editorViewState);
+            return true;
+        }
+        return false;
+    }
+    openAsBinary(input, options) {
+        const original = input.original;
+        const modified = input.modified;
+        const binaryDiffInput = this.instantiationService.createInstance(DiffEditorInput, input.getName(), input.getDescription(), original, modified, true);
+        const fileEditorFactory = ( (Registry.as(EditorExtensions.EditorFactory))).getFileEditorFactory();
+        if (fileEditorFactory.isFileEditor(original)) {
+            original.setForceOpenAsBinary();
+        }
+        if (fileEditorFactory.isFileEditor(modified)) {
+            modified.setForceOpenAsBinary();
+        }
+        (this.group ?? this.editorGroupService.activeGroup).replaceEditors([{
+                editor: input,
+                replacement: binaryDiffInput,
+                options: {
+                    ...options,
+                    activation: EditorActivation.PRESERVE,
+                    pinned: this.group?.isPinned(input),
+                    sticky: this.group?.isSticky(input)
+                }
+            }]);
+    }
+    setOptions(options) {
+        super.setOptions(options);
+        if (options) {
+            applyTextEditorOptions(options, assertIsDefined(this.diffEditorControl), 0 );
+        }
+    }
+    shouldHandleConfigurationChangeEvent(e, resource) {
+        if (super.shouldHandleConfigurationChangeEvent(e, resource)) {
+            return true;
+        }
+        return e.affectsConfiguration(resource, 'diffEditor');
+    }
+    computeConfiguration(configuration) {
+        const editorConfiguration = super.computeConfiguration(configuration);
+        if (isObject(configuration.diffEditor)) {
+            const diffEditorConfiguration = deepClone(configuration.diffEditor);
+            diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+            delete diffEditorConfiguration.codeLens;
+            diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+            delete diffEditorConfiguration.wordWrap;
+            Object.assign(editorConfiguration, diffEditorConfiguration);
+        }
+        return editorConfiguration;
+    }
+    getConfigurationOverrides() {
+        const readOnly = this.input instanceof DiffEditorInput && this.input.modified.hasCapability(2 );
+        return {
+            ...super.getConfigurationOverrides(),
+            readOnly,
+            originalEditable: this.input instanceof DiffEditorInput && !this.input.original.hasCapability(2 ),
+            lineDecorationsWidth: '2ch'
+        };
+    }
+    updateReadonly(input) {
+        if (input instanceof DiffEditorInput) {
+            this.diffEditorControl?.updateOptions({
+                readOnly: input.hasCapability(2 ),
+                originalEditable: !input.original.hasCapability(2 ),
+            });
+        }
+        else {
+            super.updateReadonly(input);
+        }
+    }
+    isFileBinaryError(error) {
+        if (Array.isArray(error)) {
+            const errors = error;
+            return (
+                 (errors.some(error => this.isFileBinaryError(error)))
+            );
+        }
+        return error.textFileOperationResult === 0 ;
+    }
+    clearInput() {
+        super.clearInput();
+        const inputLifecycleElapsed = this.inputLifecycleStopWatch?.elapsed();
+        this.inputLifecycleStopWatch = undefined;
+        if (typeof inputLifecycleElapsed === 'number') {
+            this.logInputLifecycleTelemetry(inputLifecycleElapsed, this.getControl()?.getModel()?.modified?.getLanguageId());
+        }
+        this.diffNavigatorDisposables.clear();
+        this.diffEditorControl?.setModel(null);
+    }
+    logInputLifecycleTelemetry(duration, languageId) {
+        this.telemetryService.publicLog2('diffEditor.editorVisibleTime', {
+            editorVisibleTimeMs: duration,
+            languageId: languageId ?? '',
+        });
+    }
+    getDiffNavigator() {
+        return this.diffNavigator;
+    }
+    getControl() {
+        return this.diffEditorControl;
+    }
+    focus() {
+        this.diffEditorControl?.focus();
+    }
+    hasFocus() {
+        return this.diffEditorControl?.hasTextFocus() || super.hasFocus();
+    }
+    setEditorVisible(visible, group) {
+        super.setEditorVisible(visible, group);
+        if (visible) {
+            this.diffEditorControl?.onVisible();
+        }
+        else {
+            this.diffEditorControl?.onHide();
+        }
+    }
+    layout(dimension) {
+        this.diffEditorControl?.layout(dimension);
+    }
+    setBoundarySashes(sashes) {
+        this.diffEditorControl?.setBoundarySashes(sashes);
+    }
+    tracksEditorViewState(input) {
+        return input instanceof DiffEditorInput;
+    }
+    computeEditorViewState(resource) {
+        if (!this.diffEditorControl) {
+            return undefined;
+        }
+        const model = this.diffEditorControl.getModel();
+        if (!model || !model.modified || !model.original) {
+            return undefined;
+        }
+        const modelUri = this.toEditorViewStateResource(model);
+        if (!modelUri) {
+            return undefined;
+        }
+        if (!isEqual(modelUri, resource)) {
+            return undefined;
+        }
+        return withNullAsUndefined(this.diffEditorControl.saveViewState());
+    }
+    toEditorViewStateResource(modelOrInput) {
+        let original;
+        let modified;
+        if (modelOrInput instanceof DiffEditorInput) {
+            original = modelOrInput.original.resource;
+            modified = modelOrInput.modified.resource;
+        }
+        else if (!isEditorInput(modelOrInput)) {
+            original = modelOrInput.original.uri;
+            modified = modelOrInput.modified.uri;
+        }
+        if (!original || !modified) {
+            return undefined;
+        }
+        return (
+             (URI.from({ scheme: 'diff', path: `${multibyteAwareBtoa(( ( original.toString())))}${multibyteAwareBtoa(( ( modified.toString())))}` }))
+        );
+    }
+};
+TextDiffEditor.ID = TEXT_DIFF_EDITOR_ID;
+TextDiffEditor = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IStorageService))),
+    ( (__param(3, ITextResourceConfigurationService))),
+    ( (__param(4, IEditorService))),
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IEditorGroupsService))),
+    ( (__param(7, IFileService))),
+    ( (__param(8, IPreferencesService)))
+], TextDiffEditor)));
+export { TextDiffEditor };

package/dist/vscode/vs/workbench/browser/parts/editor/textEditor.js

@@ -0,0 +1,220 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { deepClone, distinct } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { isObject, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { computeEditorAriaLabel } from '../../editor.js';
+import { AbstractEditorWithViewState } from './editorWithViewState.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithViewState {
+    constructor(id, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService) {
+        super(id, AbstractTextEditor.VIEW_STATE_PREFERENCE_KEY, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);
+        this.fileService = fileService;
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this.inputListener = this._register(( new MutableDisposable()));
+        this._register(this.textResourceConfigurationService.onDidChangeConfiguration(e => this.handleConfigurationChangeEvent(e)));
+        this._register(Event.any(this.editorGroupService.onDidAddGroup, this.editorGroupService.onDidRemoveGroup)(() => {
+            const ariaLabel = this.computeAriaLabel();
+            this.editorContainer?.setAttribute('aria-label', ariaLabel);
+            this.updateEditorControlOptions({ ariaLabel });
+        }));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProvider(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProvider(e.scheme)));
+    }
+    handleConfigurationChangeEvent(e) {
+        const resource = this.getActiveResource();
+        if (!this.shouldHandleConfigurationChangeEvent(e, resource)) {
+            return;
+        }
+        if (this.isVisible()) {
+            this.updateEditorConfiguration(resource);
+        }
+        else {
+            this.hasPendingConfigurationChange = true;
+        }
+    }
+    shouldHandleConfigurationChangeEvent(e, resource) {
+        return e.affectsConfiguration(resource, 'editor');
+    }
+    consumePendingConfigurationChangeEvent() {
+        if (this.hasPendingConfigurationChange) {
+            this.updateEditorConfiguration();
+            this.hasPendingConfigurationChange = false;
+        }
+    }
+    computeConfiguration(configuration) {
+        const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
+        Object.assign(editorConfiguration, this.getConfigurationOverrides());
+        editorConfiguration.ariaLabel = this.computeAriaLabel();
+        return editorConfiguration;
+    }
+    computeAriaLabel() {
+        return this._input ? computeEditorAriaLabel(this._input, undefined, this.group, this.editorGroupService.count) : ( localize('editor', "Editor"));
+    }
+    onDidChangeFileSystemProvider(scheme) {
+        if (!this.input) {
+            return;
+        }
+        if (this.getActiveResource()?.scheme === scheme) {
+            this.updateReadonly(this.input);
+        }
+    }
+    onDidChangeInputCapabilities(input) {
+        if (this.input === input) {
+            this.updateReadonly(input);
+        }
+    }
+    updateReadonly(input) {
+        const readOnly = input.hasCapability(2 );
+        this.updateEditorControlOptions({ readOnly });
+    }
+    getConfigurationOverrides() {
+        const readOnly = this.input?.hasCapability(2 );
+        return {
+            overviewRulerLanes: 3,
+            lineNumbersMinChars: 3,
+            fixedOverflowWidgets: true,
+            readOnly,
+            renderValidationDecorations: 'on'
+        };
+    }
+    createEditor(parent) {
+        this.editorContainer = parent;
+        this.createEditorControl(parent, this.computeConfiguration(this.textResourceConfigurationService.getValue(this.getActiveResource())));
+        this.registerCodeEditorListeners();
+    }
+    registerCodeEditorListeners() {
+        const mainControl = this.getMainControl();
+        if (mainControl) {
+            this._register(mainControl.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+            this._register(mainControl.onDidChangeModel(() => this.updateEditorConfiguration()));
+            this._register(mainControl.onDidChangeCursorPosition(e => this._onDidChangeSelection.fire({ reason: this.toEditorPaneSelectionChangeReason(e) })));
+            this._register(mainControl.onDidChangeModelContent(() => this._onDidChangeSelection.fire({ reason: 3  })));
+        }
+    }
+    toEditorPaneSelectionChangeReason(e) {
+        switch (e.source) {
+            case "api" : return 1 ;
+            case "code.navigation" : return 4 ;
+            case "code.jump" : return 5 ;
+            default: return 2 ;
+        }
+    }
+    getSelection() {
+        const mainControl = this.getMainControl();
+        if (mainControl) {
+            const selection = mainControl.getSelection();
+            if (selection) {
+                return ( new TextEditorPaneSelection(selection));
+            }
+        }
+        return undefined;
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        this.inputListener.value = input.onDidChangeCapabilities(() => this.onDidChangeInputCapabilities(input));
+        this.updateEditorConfiguration();
+        const editorContainer = assertIsDefined(this.editorContainer);
+        editorContainer.setAttribute('aria-label', this.computeAriaLabel());
+    }
+    clearInput() {
+        this.inputListener.clear();
+        super.clearInput();
+    }
+    setEditorVisible(visible, group) {
+        if (visible) {
+            this.consumePendingConfigurationChangeEvent();
+        }
+        super.setEditorVisible(visible, group);
+    }
+    toEditorViewStateResource(input) {
+        return input.resource;
+    }
+    updateEditorConfiguration(resource = this.getActiveResource()) {
+        let configuration = undefined;
+        if (resource) {
+            configuration = this.textResourceConfigurationService.getValue(resource);
+        }
+        if (!configuration) {
+            return;
+        }
+        const editorConfiguration = this.computeConfiguration(configuration);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (( Object.keys(editorSettingsToApply)).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            this.updateEditorControlOptions(editorSettingsToApply);
+        }
+    }
+    getActiveResource() {
+        const mainControl = this.getMainControl();
+        if (mainControl) {
+            const model = mainControl.getModel();
+            if (model) {
+                return model.uri;
+            }
+        }
+        if (this.input) {
+            return this.input.resource;
+        }
+        return undefined;
+    }
+    dispose() {
+        this.lastAppliedEditorOptions = undefined;
+        super.dispose();
+    }
+};
+AbstractTextEditor.VIEW_STATE_PREFERENCE_KEY = 'textEditorViewState';
+AbstractTextEditor = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, ITextResourceConfigurationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IFileService))
+], AbstractTextEditor));
+class TextEditorPaneSelection {
+    constructor(textSelection) {
+        this.textSelection = textSelection;
+    }
+    compare(other) {
+        if (!(other instanceof TextEditorPaneSelection)) {
+            return 3 ;
+        }
+        const thisLineNumber = Math.min(this.textSelection.selectionStartLineNumber, this.textSelection.positionLineNumber);
+        const otherLineNumber = Math.min(other.textSelection.selectionStartLineNumber, other.textSelection.positionLineNumber);
+        if (thisLineNumber === otherLineNumber) {
+            return 1 ;
+        }
+        if (Math.abs(thisLineNumber - otherLineNumber) < TextEditorPaneSelection.TEXT_EDITOR_SELECTION_THRESHOLD) {
+            return 2 ;
+        }
+        return 3 ;
+    }
+    restore(options) {
+        const textEditorOptions = {
+            ...options,
+            selection: this.textSelection,
+            selectionRevealType: 1
+        };
+        return textEditorOptions;
+    }
+    log() {
+        return `line: ${this.textSelection.startLineNumber}-${this.textSelection.endLineNumber}, col:  ${this.textSelection.startColumn}-${this.textSelection.endColumn}`;
+    }
+}
+TextEditorPaneSelection.TEXT_EDITOR_SELECTION_THRESHOLD = 10;
+export { AbstractTextEditor, TextEditorPaneSelection };