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

package/dist/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel.js

@@ -0,0 +1,421 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { assertFn } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue, observableFromEvent, derived } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { basename, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { SaveSourceRegistry } from '../../../common/editor.js';
+import { EditorModel } from '../../../common/editor/editorModel.js';
+import { conflictMarkers } from './mergeMarkers/mergeMarkersController.js';
+import { MergeDiffComputer } from './model/diffComputer.js';
+import { MergeEditorModel } from './model/mergeEditorModel.js';
+import { StorageCloseWithConflicts } from '../common/mergeEditor.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+let TempFileMergeEditorModeFactory = class TempFileMergeEditorModeFactory {
+    constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, _modelService) {
+        this._mergeEditorTelemetry = _mergeEditorTelemetry;
+        this._instantiationService = _instantiationService;
+        this._textModelService = _textModelService;
+        this._modelService = _modelService;
+    }
+    async createInputModel(args) {
+        const store = ( new DisposableStore());
+        const [base, result, input1Data, input2Data,] = await Promise.all([
+            this._textModelService.createModelReference(args.base),
+            this._textModelService.createModelReference(args.result),
+            toInputData(args.input1, this._textModelService, store),
+            toInputData(args.input2, this._textModelService, store),
+        ]);
+        store.add(base);
+        store.add(result);
+        const tempResultUri = result.object.textEditorModel.uri.with({ scheme: 'merge-result' });
+        const temporaryResultModel = this._modelService.createModel('', {
+            languageId: result.object.textEditorModel.getLanguageId(),
+            onDidChange: Event.None,
+        }, tempResultUri);
+        store.add(temporaryResultModel);
+        const mergeDiffComputer = this._instantiationService.createInstance(MergeDiffComputer);
+        const model = this._instantiationService.createInstance(MergeEditorModel, base.object.textEditorModel, input1Data, input2Data, temporaryResultModel, mergeDiffComputer, {
+            resetResult: true,
+        }, this._mergeEditorTelemetry);
+        store.add(model);
+        await model.onInitialized;
+        return this._instantiationService.createInstance(TempFileMergeEditorInputModel, model, store, result.object, args.result);
+    }
+};
+TempFileMergeEditorModeFactory = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IModelService))
+], TempFileMergeEditorModeFactory));
+let TempFileMergeEditorInputModel = class TempFileMergeEditorInputModel extends EditorModel {
+    constructor(model, disposable, result, resultUri, textFileService, dialogService, editorService) {
+        super();
+        this.model = model;
+        this.disposable = disposable;
+        this.result = result;
+        this.resultUri = resultUri;
+        this.textFileService = textFileService;
+        this.dialogService = dialogService;
+        this.editorService = editorService;
+        this.savedAltVersionId = observableValue('initialAltVersionId', this.model.resultTextModel.getAlternativeVersionId());
+        this.altVersionId = observableFromEvent(e => this.model.resultTextModel.onDidChangeContent(e), () =>
+         this.model.resultTextModel.getAlternativeVersionId());
+        this.isDirty = derived('isDirty', (reader) => this.altVersionId.read(reader) !== this.savedAltVersionId.read(reader));
+        this.finished = false;
+    }
+    dispose() {
+        this.disposable.dispose();
+        super.dispose();
+    }
+    async accept() {
+        const value = await this.model.resultTextModel.getValue();
+        this.result.textEditorModel.setValue(value);
+        this.savedAltVersionId.set(this.model.resultTextModel.getAlternativeVersionId(), undefined);
+        await this.textFileService.save(this.result.textEditorModel.uri);
+        this.finished = true;
+    }
+    async _discard() {
+        await this.textFileService.revert(this.model.resultTextModel.uri);
+        this.savedAltVersionId.set(this.model.resultTextModel.getAlternativeVersionId(), undefined);
+        this.finished = true;
+    }
+    shouldConfirmClose() {
+        return true;
+    }
+    async confirmClose(inputModels) {
+        assertFn(() => ( inputModels.some((m) => m === this)));
+        const someDirty = ( inputModels.some((m) => m.isDirty.get()));
+        let choice;
+        if (someDirty) {
+            const isMany = inputModels.length > 1;
+            const message = isMany
+                ? ( localize(
+                'messageN',
+                'Do you want keep the merge result of {0} files?',
+                inputModels.length
+            ))
+                : ( localize(
+                'message1',
+                'Do you want keep the merge result of {0}?',
+                basename(inputModels[0].model.resultTextModel.uri)
+            ));
+            const hasUnhandledConflicts = ( inputModels.some((m) => m.model.hasUnhandledConflicts.get()));
+            const buttons = [
+                {
+                    label: hasUnhandledConflicts ?
+                        ( localize(
+                            { key: 'saveWithConflict', comment: ['&& denotes a mnemonic'] },
+                            "&&Save With Conflicts"
+                        )) :
+                        ( localize({ key: 'save', comment: ['&& denotes a mnemonic'] }, "&&Save")),
+                    run: () => 0
+                },
+                {
+                    label: ( localize({ key: 'discard', comment: ['&& denotes a mnemonic'] }, "Do&&n't Save")),
+                    run: () => 1
+                }
+            ];
+            choice = (await this.dialogService.prompt({
+                type: Severity.Info,
+                message,
+                detail: hasUnhandledConflicts
+                    ? isMany
+                        ? ( localize(
+                    'detailNConflicts',
+                    "The files contain unhandled conflicts. The merge results will be lost if you don't save them."
+                ))
+                        : ( localize(
+                    'detail1Conflicts',
+                    "The file contains unhandled conflicts. The merge result will be lost if you don't save it."
+                ))
+                    : isMany
+                        ? ( localize('detailN', "The merge results will be lost if you don't save them."))
+                        : ( localize('detail1', "The merge result will be lost if you don't save it.")),
+                buttons,
+                cancelButton: {
+                    run: () => 2
+                }
+            })).result;
+        }
+        else {
+            choice = 1 ;
+        }
+        if (choice === 0 ) {
+            await Promise.all(( inputModels.map(m => m.accept())));
+        }
+        else if (choice === 1 ) {
+            await Promise.all(( inputModels.map(m => m._discard())));
+        }
+        else ;
+        return choice;
+    }
+    async save(options) {
+        if (this.finished) {
+            return;
+        }
+        (async () => {
+            const { confirmed } = await this.dialogService.confirm({
+                message: ( localize('saveTempFile.message', "Do you want to accept the merge result?")),
+                detail: ( localize(
+                    'saveTempFile.detail',
+                    "This will write the merge result to the original file and close the merge editor."
+                )),
+                primaryButton: ( localize(
+                    { key: 'acceptMerge', comment: ['&& denotes a mnemonic'] },
+                    '&&Accept Merge'
+                ))
+            });
+            if (confirmed) {
+                await this.accept();
+                const editors = this.editorService.findEditors(this.resultUri).filter(e => e.editor.typeId === 'mergeEditor.Input');
+                await this.editorService.closeEditors(editors);
+            }
+        })();
+    }
+    async revert(options) {
+    }
+};
+TempFileMergeEditorInputModel = ( __decorate([
+    ( __param(4, ITextFileService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, IEditorService))
+], TempFileMergeEditorInputModel));
+let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
+    constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, textFileService) {
+        this._mergeEditorTelemetry = _mergeEditorTelemetry;
+        this._instantiationService = _instantiationService;
+        this._textModelService = _textModelService;
+        this.textFileService = textFileService;
+    }
+    async createInputModel(args) {
+        const store = ( new DisposableStore());
+        let resultTextFileModel = undefined;
+        const modelListener = store.add(( new DisposableStore()));
+        const handleDidCreate = (model) => {
+            if (isEqual(args.result, model.resource)) {
+                modelListener.clear();
+                resultTextFileModel = model;
+            }
+        };
+        modelListener.add(this.textFileService.files.onDidCreate(handleDidCreate));
+        this.textFileService.files.models.forEach(handleDidCreate);
+        const [base, result, input1Data, input2Data,] = await Promise.all([
+            this._textModelService.createModelReference(args.base),
+            this._textModelService.createModelReference(args.result),
+            toInputData(args.input1, this._textModelService, store),
+            toInputData(args.input2, this._textModelService, store),
+        ]);
+        store.add(base);
+        store.add(result);
+        if (!resultTextFileModel) {
+            throw new BugIndicatingError();
+        }
+        await resultTextFileModel.save({ source: WorkspaceMergeEditorModeFactory.FILE_SAVED_SOURCE });
+        const lines = resultTextFileModel.textEditorModel.getLinesContent();
+        const hasConflictMarkers = ( lines.some(l => l.startsWith(conflictMarkers.start)));
+        const resetResult = hasConflictMarkers;
+        const mergeDiffComputer = this._instantiationService.createInstance(MergeDiffComputer);
+        const model = this._instantiationService.createInstance(MergeEditorModel, base.object.textEditorModel, input1Data, input2Data, result.object.textEditorModel, mergeDiffComputer, {
+            resetResult
+        }, this._mergeEditorTelemetry);
+        store.add(model);
+        await model.onInitialized;
+        return this._instantiationService.createInstance(WorkspaceMergeEditorInputModel, model, store, resultTextFileModel, this._mergeEditorTelemetry);
+    }
+};
+WorkspaceMergeEditorModeFactory.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('merge-editor.source', ( localize('merge-editor.source', "Before Resolving Conflicts In Merge Editor")));
+WorkspaceMergeEditorModeFactory = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, ITextFileService))
+], WorkspaceMergeEditorModeFactory));
+let WorkspaceMergeEditorInputModel = class WorkspaceMergeEditorInputModel extends EditorModel {
+    constructor(model, disposableStore, resultTextFileModel, telemetry, _dialogService, _storageService) {
+        super();
+        this.model = model;
+        this.disposableStore = disposableStore;
+        this.resultTextFileModel = resultTextFileModel;
+        this.telemetry = telemetry;
+        this._dialogService = _dialogService;
+        this._storageService = _storageService;
+        this.isDirty = observableFromEvent(Event.any(this.resultTextFileModel.onDidChangeDirty, this.resultTextFileModel.onDidSaveError), () =>  this.resultTextFileModel.isDirty());
+        this.reported = false;
+        this.dateTimeOpened = ( new Date());
+    }
+    dispose() {
+        this.disposableStore.dispose();
+        super.dispose();
+        this.reportClose(false);
+    }
+    reportClose(accepted) {
+        if (!this.reported) {
+            const remainingConflictCount = this.model.unhandledConflictsCount.get();
+            const durationOpenedMs = ( new Date()).getTime() - this.dateTimeOpened.getTime();
+            this.telemetry.reportMergeEditorClosed({
+                durationOpenedSecs: durationOpenedMs / 1000,
+                remainingConflictCount,
+                accepted,
+                conflictCount: this.model.conflictCount,
+                combinableConflictCount: this.model.combinableConflictCount,
+                conflictsResolvedWithBase: this.model.conflictsResolvedWithBase,
+                conflictsResolvedWithInput1: this.model.conflictsResolvedWithInput1,
+                conflictsResolvedWithInput2: this.model.conflictsResolvedWithInput2,
+                conflictsResolvedWithSmartCombination: this.model.conflictsResolvedWithSmartCombination,
+                manuallySolvedConflictCountThatEqualNone: this.model.manuallySolvedConflictCountThatEqualNone,
+                manuallySolvedConflictCountThatEqualSmartCombine: this.model.manuallySolvedConflictCountThatEqualSmartCombine,
+                manuallySolvedConflictCountThatEqualInput1: this.model.manuallySolvedConflictCountThatEqualInput1,
+                manuallySolvedConflictCountThatEqualInput2: this.model.manuallySolvedConflictCountThatEqualInput2,
+                manuallySolvedConflictCountThatEqualNoneAndStartedWithBase: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBase,
+                manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput1,
+                manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithInput2,
+                manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothNonSmart,
+                manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart: this.model.manuallySolvedConflictCountThatEqualNoneAndStartedWithBothSmart,
+            });
+            this.reported = true;
+        }
+    }
+    async accept() {
+        this.reportClose(true);
+        await this.resultTextFileModel.save();
+    }
+    get resultUri() {
+        return this.resultTextFileModel.resource;
+    }
+    async save(options) {
+        await this.resultTextFileModel.save(options);
+    }
+    async revert(options) {
+        await this.resultTextFileModel.revert(options);
+    }
+    shouldConfirmClose() {
+        return true;
+    }
+    async confirmClose(inputModels) {
+        const isMany = inputModels.length > 1;
+        const someDirty = ( inputModels.some(m => m.isDirty.get()));
+        const someUnhandledConflicts = ( inputModels.some(m => m.model.hasUnhandledConflicts.get()));
+        if (someDirty) {
+            const message = isMany
+                ? ( localize(
+                'workspace.messageN',
+                'Do you want to save the changes you made to {0} files?',
+                inputModels.length
+            ))
+                : ( localize(
+                'workspace.message1',
+                'Do you want to save the changes you made to {0}?',
+                basename(inputModels[0].resultUri)
+            ));
+            const { result } = await this._dialogService.prompt({
+                type: Severity.Info,
+                message,
+                detail: someUnhandledConflicts ?
+                    isMany
+                        ? ( localize(
+                        'workspace.detailN.unhandled',
+                        "The files contain unhandled conflicts. Your changes will be lost if you don't save them."
+                    ))
+                        : ( localize(
+                        'workspace.detail1.unhandled',
+                        "The file contains unhandled conflicts. Your changes will be lost if you don't save them."
+                    ))
+                    : isMany
+                        ? ( localize(
+                    'workspace.detailN.handled',
+                    "Your changes will be lost if you don't save them."
+                ))
+                        : ( localize(
+                    'workspace.detail1.handled',
+                    "Your changes will be lost if you don't save them."
+                )),
+                buttons: [
+                    {
+                        label: someUnhandledConflicts
+                            ? ( localize(
+                            { key: 'workspace.saveWithConflict', comment: ['&& denotes a mnemonic'] },
+                            '&&Save with Conflicts'
+                        ))
+                            : ( localize({ key: 'workspace.save', comment: ['&& denotes a mnemonic'] }, '&&Save')),
+                        run: () => 0
+                    },
+                    {
+                        label: ( localize(
+                            { key: 'workspace.doNotSave', comment: ['&& denotes a mnemonic'] },
+                            "Do&&n't Save"
+                        )),
+                        run: () => 1
+                    }
+                ],
+                cancelButton: {
+                    run: () => 2
+                }
+            });
+            return result;
+        }
+        else if (someUnhandledConflicts && !this._storageService.getBoolean(StorageCloseWithConflicts, 0 , false)) {
+            const { confirmed, checkboxChecked } = await this._dialogService.confirm({
+                message: isMany
+                    ? ( localize(
+                    'workspace.messageN.nonDirty',
+                    'Do you want to close {0} merge editors?',
+                    inputModels.length
+                ))
+                    : ( localize(
+                    'workspace.message1.nonDirty',
+                    'Do you want to close the merge editor for {0}?',
+                    basename(inputModels[0].resultUri)
+                )),
+                detail: someUnhandledConflicts ?
+                    isMany
+                        ? ( localize(
+                        'workspace.detailN.unhandled.nonDirty',
+                        "The files contain unhandled conflicts."
+                    ))
+                        : ( localize(
+                        'workspace.detail1.unhandled.nonDirty',
+                        "The file contains unhandled conflicts."
+                    ))
+                    : undefined,
+                primaryButton: someUnhandledConflicts
+                    ? ( localize(
+                    { key: 'workspace.closeWithConflicts', comment: ['&& denotes a mnemonic'] },
+                    '&&Close with Conflicts'
+                ))
+                    : ( localize({ key: 'workspace.close', comment: ['&& denotes a mnemonic'] }, '&&Close')),
+                checkbox: { label: ( localize('noMoreWarn', "Don't ask again")) }
+            });
+            if (checkboxChecked) {
+                this._storageService.store(StorageCloseWithConflicts, true, 0 , 0 );
+            }
+            return confirmed ? 0  : 2 ;
+        }
+        else {
+            return 0 ;
+        }
+    }
+};
+WorkspaceMergeEditorInputModel = ( __decorate([
+    ( __param(4, IDialogService)),
+    ( __param(5, IStorageService))
+], WorkspaceMergeEditorInputModel));
+async function toInputData(data, textModelService, store) {
+    const ref = await textModelService.createModelReference(data.uri);
+    store.add(ref);
+    return {
+        textModel: ref.object.textEditorModel,
+        title: data.title,
+        description: data.description,
+        detail: data.detail,
+    };
+}
+export { TempFileMergeEditorModeFactory, WorkspaceMergeEditorModeFactory };

package/dist/vscode/vs/workbench/contrib/mergeEditor/browser/mergeMarkers/mergeMarkersController.js

@@ -0,0 +1,5 @@
+const conflictMarkers = {
+    start: '<<<<<<<',
+    end: '>>>>>>>',
+};
+export { conflictMarkers };

package/dist/vscode/vs/workbench/contrib/mergeEditor/browser/model/diffComputer.js

@@ -0,0 +1,55 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { assertFn, checkAdjacentItems } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { LineRange } from './lineRange.js';
+import { DetailedLineRangeMapping, RangeMapping } from './mapping.js';
+import { observableConfigValue } from '../utils.js';
+let MergeDiffComputer = class MergeDiffComputer {
+    constructor(editorWorkerService, configurationService) {
+        this.editorWorkerService = editorWorkerService;
+        this.configurationService = configurationService;
+        this.mergeAlgorithm = ( observableConfigValue('mergeEditor.diffAlgorithm', 'advanced', this.configurationService)
+            .map(v => v === 'smart' ? 'legacy' : v === 'experimental' ? 'advanced' : v));
+    }
+    async computeDiff(textModel1, textModel2, reader) {
+        const diffAlgorithm = this.mergeAlgorithm.read(reader);
+        const result = await this.editorWorkerService.computeDiff(textModel1.uri, textModel2.uri, {
+            ignoreTrimWhitespace: false,
+            maxComputationTimeMs: 0,
+        }, diffAlgorithm);
+        if (!result) {
+            throw new Error('Diff computation failed');
+        }
+        if (textModel1.isDisposed() || textModel2.isDisposed()) {
+            return { diffs: null };
+        }
+        const changes = ( result.changes.map(c => ( new DetailedLineRangeMapping(
+            toLineRange(c.originalRange),
+            textModel1,
+            toLineRange(c.modifiedRange),
+            textModel2,
+            c.innerChanges?.map(ic => toRangeMapping(ic))
+        ))));
+        assertFn(() => {
+            return changes.length === 0 || (changes[0].inputRange.startLineNumber === changes[0].outputRange.startLineNumber &&
+                checkAdjacentItems(changes, (m1, m2) => m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive &&
+                    m1.inputRange.endLineNumberExclusive < m2.inputRange.startLineNumber &&
+                    m1.outputRange.endLineNumberExclusive < m2.outputRange.startLineNumber));
+        });
+        return {
+            diffs: changes
+        };
+    }
+};
+MergeDiffComputer = ( __decorate([
+    ( __param(0, IEditorWorkerService)),
+    ( __param(1, IConfigurationService))
+], MergeDiffComputer));
+function toLineRange(range) {
+    return ( new LineRange(range.startLineNumber, range.length));
+}
+function toRangeMapping(mapping) {
+    return ( new RangeMapping(mapping.originalRange, mapping.modifiedRange));
+}
+export { MergeDiffComputer, toLineRange, toRangeMapping };

package/dist/vscode/vs/workbench/contrib/mergeEditor/browser/model/editing.js

@@ -0,0 +1,54 @@
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+class LineRangeEdit {
+    constructor(range, newLines) {
+        this.range = range;
+        this.newLines = newLines;
+    }
+    equals(other) {
+        return this.range.equals(other.range) && equals(this.newLines, other.newLines);
+    }
+    toEdits(modelLineCount) {
+        return ( new LineEdits([this])).toEdits(modelLineCount);
+    }
+}
+class RangeEdit {
+    constructor(range, newText) {
+        this.range = range;
+        this.newText = newText;
+    }
+    equals(other) {
+        return Range.equalsRange(this.range, other.range) && this.newText === other.newText;
+    }
+}
+class LineEdits {
+    constructor(edits) {
+        this.edits = edits;
+    }
+    toEdits(modelLineCount) {
+        return ( this.edits.map((e) => {
+            if (e.range.endLineNumberExclusive <= modelLineCount) {
+                return {
+                    range: ( new Range(e.range.startLineNumber, 1, e.range.endLineNumberExclusive, 1)),
+                    text: ( e.newLines.map(s => s + '\n')).join(''),
+                };
+            }
+            if (e.range.startLineNumber === 1) {
+                return {
+                    range: ( new Range(1, 1, modelLineCount, Number.MAX_SAFE_INTEGER)),
+                    text: e.newLines.join('\n'),
+                };
+            }
+            return {
+                range: ( new Range(
+                    e.range.startLineNumber - 1,
+                    Number.MAX_SAFE_INTEGER,
+                    modelLineCount,
+                    Number.MAX_SAFE_INTEGER
+                )),
+                text: ( e.newLines.map(s => '\n' + s)).join(''),
+            };
+        }));
+    }
+}
+export { LineEdits, LineRangeEdit, RangeEdit };

package/dist/vscode/vs/workbench/contrib/mergeEditor/browser/model/lineRange.js

@@ -0,0 +1,108 @@
+import { compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+class LineRange {
+    static join(ranges) {
+        if (ranges.length === 0) {
+            return undefined;
+        }
+        let startLineNumber = Number.MAX_SAFE_INTEGER;
+        let endLineNumber = 0;
+        for (const range of ranges) {
+            startLineNumber = Math.min(startLineNumber, range.startLineNumber);
+            endLineNumber = Math.max(endLineNumber, range.startLineNumber + range.lineCount);
+        }
+        return ( new LineRange(startLineNumber, endLineNumber - startLineNumber));
+    }
+    static fromLineNumbers(startLineNumber, endExclusiveLineNumber) {
+        return ( new LineRange(startLineNumber, endExclusiveLineNumber - startLineNumber));
+    }
+    constructor(startLineNumber, lineCount) {
+        this.startLineNumber = startLineNumber;
+        this.lineCount = lineCount;
+        if (lineCount < 0) {
+            throw new BugIndicatingError();
+        }
+    }
+    join(other) {
+        return ( new LineRange(
+            Math.min(this.startLineNumber, other.startLineNumber),
+            Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive) - this.startLineNumber
+        ));
+    }
+    get endLineNumberExclusive() {
+        return this.startLineNumber + this.lineCount;
+    }
+    get isEmpty() {
+        return this.lineCount === 0;
+    }
+    touches(other) {
+        return (this.endLineNumberExclusive >= other.startLineNumber &&
+            other.endLineNumberExclusive >= this.startLineNumber);
+    }
+    isAfter(range) {
+        return this.startLineNumber >= range.endLineNumberExclusive;
+    }
+    isBefore(range) {
+        return range.startLineNumber >= this.endLineNumberExclusive;
+    }
+    delta(lineDelta) {
+        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount));
+    }
+    toString() {
+        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
+    }
+    equals(originalRange) {
+        return this.startLineNumber === originalRange.startLineNumber && this.lineCount === originalRange.lineCount;
+    }
+    contains(lineNumber) {
+        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
+    }
+    deltaEnd(delta) {
+        return ( new LineRange(this.startLineNumber, this.lineCount + delta));
+    }
+    deltaStart(lineDelta) {
+        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount - lineDelta));
+    }
+    getLines(model) {
+        const result = ( new Array(this.lineCount));
+        for (let i = 0; i < this.lineCount; i++) {
+            result[i] = model.getLineContent(this.startLineNumber + i);
+        }
+        return result;
+    }
+    containsRange(range) {
+        return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
+    }
+    toRange() {
+        return ( new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1));
+    }
+    toInclusiveRange() {
+        if (this.isEmpty) {
+            return undefined;
+        }
+        return ( new Range(
+            this.startLineNumber,
+            1,
+            this.endLineNumberExclusive - 1,
+            1073741824
+        ));
+    }
+    toInclusiveRangeOrEmpty() {
+        if (this.isEmpty) {
+            return ( new Range(this.startLineNumber, 1, this.startLineNumber, 1));
+        }
+        return ( new Range(
+            this.startLineNumber,
+            1,
+            this.endLineNumberExclusive - 1,
+            1073741824
+        ));
+    }
+    intersects(lineRange) {
+        return this.startLineNumber <= lineRange.endLineNumberExclusive
+            && lineRange.startLineNumber <= this.endLineNumberExclusive;
+    }
+}
+LineRange.compareByStart = compareBy(l => l.startLineNumber, numberComparator);
+export { LineRange };