monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/lineCommentCommand.js

@@ -0,0 +1,328 @@
+import { firstNonWhitespaceIndex } from '../../../../base/common/strings.js';
+import { EditOperation } from '../../../common/core/editOperation.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+import { BlockCommentCommand } from './blockCommentCommand.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class LineCommentCommand {
+    constructor(languageConfigurationService, selection, indentSize, type, insertSpace, ignoreEmptyLines, ignoreFirstLine) {
+        this.languageConfigurationService = languageConfigurationService;
+        this._selection = selection;
+        this._indentSize = indentSize;
+        this._type = type;
+        this._insertSpace = insertSpace;
+        this._selectionId = null;
+        this._deltaColumn = 0;
+        this._moveEndPositionDown = false;
+        this._ignoreEmptyLines = ignoreEmptyLines;
+        this._ignoreFirstLine = ignoreFirstLine || false;
+    }
+    /**
+     * Do an initial pass over the lines and gather info about the line comment string.
+     * Returns null if any of the lines doesn't support a line comment string.
+     */
+    static _gatherPreflightCommentStrings(model, startLineNumber, endLineNumber, languageConfigurationService) {
+        model.tokenization.tokenizeIfCheap(startLineNumber);
+        const languageId = model.getLanguageIdAtPosition(startLineNumber, 1);
+        const config = languageConfigurationService.getLanguageConfiguration(languageId).comments;
+        const commentStr = (config ? config.lineCommentToken : null);
+        if (!commentStr) {
+            // Mode does not support line comments
+            return null;
+        }
+        const lines = [];
+        for (let i = 0, lineCount = endLineNumber - startLineNumber + 1; i < lineCount; i++) {
+            lines[i] = {
+                ignore: false,
+                commentStr: commentStr,
+                commentStrOffset: 0,
+                commentStrLength: commentStr.length
+            };
+        }
+        return lines;
+    }
+    /**
+     * Analyze lines and decide which lines are relevant and what the toggle should do.
+     * Also, build up several offsets and lengths useful in the generation of editor operations.
+     */
+    static _analyzeLines(type, insertSpace, model, lines, startLineNumber, ignoreEmptyLines, ignoreFirstLine, languageConfigurationService, languageId) {
+        let onlyWhitespaceLines = true;
+        const config = languageConfigurationService.getLanguageConfiguration(languageId).comments;
+        const lineCommentNoIndent = config?.lineCommentNoIndent ?? false;
+        let shouldRemoveComments;
+        if (type === 0 /* Type.Toggle */) {
+            shouldRemoveComments = true;
+        }
+        else if (type === 1 /* Type.ForceAdd */) {
+            shouldRemoveComments = false;
+        }
+        else {
+            shouldRemoveComments = true;
+        }
+        for (let i = 0, lineCount = lines.length; i < lineCount; i++) {
+            const lineData = lines[i];
+            const lineNumber = startLineNumber + i;
+            if (lineNumber === startLineNumber && ignoreFirstLine) {
+                // first line ignored
+                lineData.ignore = true;
+                continue;
+            }
+            const lineContent = model.getLineContent(lineNumber);
+            const lineContentStartOffset = firstNonWhitespaceIndex(lineContent);
+            if (lineContentStartOffset === -1) {
+                // Empty or whitespace only line
+                lineData.ignore = ignoreEmptyLines;
+                lineData.commentStrOffset = lineCommentNoIndent ? 0 : lineContent.length;
+                continue;
+            }
+            onlyWhitespaceLines = false;
+            const offset = lineCommentNoIndent ? 0 : lineContentStartOffset;
+            lineData.ignore = false;
+            lineData.commentStrOffset = offset;
+            if (shouldRemoveComments && !BlockCommentCommand._haystackHasNeedleAtOffset(lineContent, lineData.commentStr, offset)) {
+                if (type === 0 /* Type.Toggle */) {
+                    // Every line so far has been a line comment, but this one is not
+                    shouldRemoveComments = false;
+                }
+                else if (type === 1 /* Type.ForceAdd */) ;
+                else {
+                    lineData.ignore = true;
+                }
+            }
+            if (shouldRemoveComments && insertSpace) {
+                // Remove a following space if present
+                const commentStrEndOffset = lineContentStartOffset + lineData.commentStrLength;
+                if (commentStrEndOffset < lineContent.length && lineContent.charCodeAt(commentStrEndOffset) === 32 /* CharCode.Space */) {
+                    lineData.commentStrLength += 1;
+                }
+            }
+        }
+        if (type === 0 /* Type.Toggle */ && onlyWhitespaceLines) {
+            // For only whitespace lines, we insert comments
+            shouldRemoveComments = false;
+            // Also, no longer ignore them
+            for (let i = 0, lineCount = lines.length; i < lineCount; i++) {
+                lines[i].ignore = false;
+            }
+        }
+        return {
+            supported: true,
+            shouldRemoveComments: shouldRemoveComments,
+            lines: lines
+        };
+    }
+    /**
+     * Analyze all lines and decide exactly what to do => not supported | insert line comments | remove line comments
+     */
+    static _gatherPreflightData(type, insertSpace, model, startLineNumber, endLineNumber, ignoreEmptyLines, ignoreFirstLine, languageConfigurationService) {
+        const lines = LineCommentCommand._gatherPreflightCommentStrings(model, startLineNumber, endLineNumber, languageConfigurationService);
+        const languageId = model.getLanguageIdAtPosition(startLineNumber, 1);
+        if (lines === null) {
+            return {
+                supported: false
+            };
+        }
+        return LineCommentCommand._analyzeLines(type, insertSpace, model, lines, startLineNumber, ignoreEmptyLines, ignoreFirstLine, languageConfigurationService, languageId);
+    }
+    /**
+     * Given a successful analysis, execute either insert line comments, either remove line comments
+     */
+    _executeLineComments(model, builder, data, s) {
+        let ops;
+        if (data.shouldRemoveComments) {
+            ops = LineCommentCommand._createRemoveLineCommentsOperations(data.lines, s.startLineNumber);
+        }
+        else {
+            LineCommentCommand._normalizeInsertionPoint(model, data.lines, s.startLineNumber, this._indentSize);
+            ops = this._createAddLineCommentsOperations(data.lines, s.startLineNumber);
+        }
+        const cursorPosition = new Position(s.positionLineNumber, s.positionColumn);
+        for (let i = 0, len = ops.length; i < len; i++) {
+            builder.addEditOperation(ops[i].range, ops[i].text);
+            if (Range.isEmpty(ops[i].range) && Range.getStartPosition(ops[i].range).equals(cursorPosition)) {
+                const lineContent = model.getLineContent(cursorPosition.lineNumber);
+                if (lineContent.length + 1 === cursorPosition.column) {
+                    this._deltaColumn = (ops[i].text || '').length;
+                }
+            }
+        }
+        this._selectionId = builder.trackSelection(s);
+    }
+    _attemptRemoveBlockComment(model, s, startToken, endToken) {
+        let startLineNumber = s.startLineNumber;
+        let endLineNumber = s.endLineNumber;
+        const startTokenAllowedBeforeColumn = endToken.length + Math.max(model.getLineFirstNonWhitespaceColumn(s.startLineNumber), s.startColumn);
+        let startTokenIndex = model.getLineContent(startLineNumber).lastIndexOf(startToken, startTokenAllowedBeforeColumn - 1);
+        let endTokenIndex = model.getLineContent(endLineNumber).indexOf(endToken, s.endColumn - 1 - startToken.length);
+        if (startTokenIndex !== -1 && endTokenIndex === -1) {
+            endTokenIndex = model.getLineContent(startLineNumber).indexOf(endToken, startTokenIndex + startToken.length);
+            endLineNumber = startLineNumber;
+        }
+        if (startTokenIndex === -1 && endTokenIndex !== -1) {
+            startTokenIndex = model.getLineContent(endLineNumber).lastIndexOf(startToken, endTokenIndex);
+            startLineNumber = endLineNumber;
+        }
+        if (s.isEmpty() && (startTokenIndex === -1 || endTokenIndex === -1)) {
+            startTokenIndex = model.getLineContent(startLineNumber).indexOf(startToken);
+            if (startTokenIndex !== -1) {
+                endTokenIndex = model.getLineContent(startLineNumber).indexOf(endToken, startTokenIndex + startToken.length);
+            }
+        }
+        // We have to adjust to possible inner white space.
+        // For Space after startToken, add Space to startToken - range math will work out.
+        if (startTokenIndex !== -1 && model.getLineContent(startLineNumber).charCodeAt(startTokenIndex + startToken.length) === 32 /* CharCode.Space */) {
+            startToken += ' ';
+        }
+        // For Space before endToken, add Space before endToken and shift index one left.
+        if (endTokenIndex !== -1 && model.getLineContent(endLineNumber).charCodeAt(endTokenIndex - 1) === 32 /* CharCode.Space */) {
+            endToken = ' ' + endToken;
+            endTokenIndex -= 1;
+        }
+        if (startTokenIndex !== -1 && endTokenIndex !== -1) {
+            return BlockCommentCommand._createRemoveBlockCommentOperations(new Range(startLineNumber, startTokenIndex + startToken.length + 1, endLineNumber, endTokenIndex + 1), startToken, endToken);
+        }
+        return null;
+    }
+    /**
+     * Given an unsuccessful analysis, delegate to the block comment command
+     */
+    _executeBlockComment(model, builder, s) {
+        model.tokenization.tokenizeIfCheap(s.startLineNumber);
+        const languageId = model.getLanguageIdAtPosition(s.startLineNumber, 1);
+        const config = this.languageConfigurationService.getLanguageConfiguration(languageId).comments;
+        if (!config || !config.blockCommentStartToken || !config.blockCommentEndToken) {
+            // Mode does not support block comments
+            return;
+        }
+        const startToken = config.blockCommentStartToken;
+        const endToken = config.blockCommentEndToken;
+        let ops = this._attemptRemoveBlockComment(model, s, startToken, endToken);
+        if (!ops) {
+            if (s.isEmpty()) {
+                const lineContent = model.getLineContent(s.startLineNumber);
+                let firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineContent);
+                if (firstNonWhitespaceIndex$1 === -1) {
+                    // Line is empty or contains only whitespace
+                    firstNonWhitespaceIndex$1 = lineContent.length;
+                }
+                ops = BlockCommentCommand._createAddBlockCommentOperations(new Range(s.startLineNumber, firstNonWhitespaceIndex$1 + 1, s.startLineNumber, lineContent.length + 1), startToken, endToken, this._insertSpace);
+            }
+            else {
+                ops = BlockCommentCommand._createAddBlockCommentOperations(new Range(s.startLineNumber, model.getLineFirstNonWhitespaceColumn(s.startLineNumber), s.endLineNumber, model.getLineMaxColumn(s.endLineNumber)), startToken, endToken, this._insertSpace);
+            }
+            if (ops.length === 1) {
+                // Leave cursor after token and Space
+                this._deltaColumn = startToken.length + 1;
+            }
+        }
+        this._selectionId = builder.trackSelection(s);
+        for (const op of ops) {
+            builder.addEditOperation(op.range, op.text);
+        }
+    }
+    getEditOperations(model, builder) {
+        let s = this._selection;
+        this._moveEndPositionDown = false;
+        if (s.startLineNumber === s.endLineNumber && this._ignoreFirstLine) {
+            builder.addEditOperation(new Range(s.startLineNumber, model.getLineMaxColumn(s.startLineNumber), s.startLineNumber + 1, 1), s.startLineNumber === model.getLineCount() ? '' : '\n');
+            this._selectionId = builder.trackSelection(s);
+            return;
+        }
+        if (s.startLineNumber < s.endLineNumber && s.endColumn === 1) {
+            this._moveEndPositionDown = true;
+            s = s.setEndPosition(s.endLineNumber - 1, model.getLineMaxColumn(s.endLineNumber - 1));
+        }
+        const data = LineCommentCommand._gatherPreflightData(this._type, this._insertSpace, model, s.startLineNumber, s.endLineNumber, this._ignoreEmptyLines, this._ignoreFirstLine, this.languageConfigurationService);
+        if (data.supported) {
+            return this._executeLineComments(model, builder, data, s);
+        }
+        return this._executeBlockComment(model, builder, s);
+    }
+    computeCursorState(model, helper) {
+        let result = helper.getTrackedSelection(this._selectionId);
+        if (this._moveEndPositionDown) {
+            result = result.setEndPosition(result.endLineNumber + 1, 1);
+        }
+        return new Selection(result.selectionStartLineNumber, result.selectionStartColumn + this._deltaColumn, result.positionLineNumber, result.positionColumn + this._deltaColumn);
+    }
+    /**
+     * Generate edit operations in the remove line comment case
+     */
+    static _createRemoveLineCommentsOperations(lines, startLineNumber) {
+        const res = [];
+        for (let i = 0, len = lines.length; i < len; i++) {
+            const lineData = lines[i];
+            if (lineData.ignore) {
+                continue;
+            }
+            res.push(EditOperation.delete(new Range(startLineNumber + i, lineData.commentStrOffset + 1, startLineNumber + i, lineData.commentStrOffset + lineData.commentStrLength + 1)));
+        }
+        return res;
+    }
+    /**
+     * Generate edit operations in the add line comment case
+     */
+    _createAddLineCommentsOperations(lines, startLineNumber) {
+        const res = [];
+        const afterCommentStr = this._insertSpace ? ' ' : '';
+        for (let i = 0, len = lines.length; i < len; i++) {
+            const lineData = lines[i];
+            if (lineData.ignore) {
+                continue;
+            }
+            res.push(EditOperation.insert(new Position(startLineNumber + i, lineData.commentStrOffset + 1), lineData.commentStr + afterCommentStr));
+        }
+        return res;
+    }
+    static nextVisibleColumn(currentVisibleColumn, indentSize, isTab, columnSize) {
+        if (isTab) {
+            return currentVisibleColumn + (indentSize - (currentVisibleColumn % indentSize));
+        }
+        return currentVisibleColumn + columnSize;
+    }
+    /**
+     * Adjust insertion points to have them vertically aligned in the add line comment case
+     */
+    static _normalizeInsertionPoint(model, lines, startLineNumber, indentSize) {
+        let minVisibleColumn = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;
+        let j;
+        let lenJ;
+        for (let i = 0, len = lines.length; i < len; i++) {
+            if (lines[i].ignore) {
+                continue;
+            }
+            const lineContent = model.getLineContent(startLineNumber + i);
+            let currentVisibleColumn = 0;
+            for (let j = 0, lenJ = lines[i].commentStrOffset; currentVisibleColumn < minVisibleColumn && j < lenJ; j++) {
+                currentVisibleColumn = LineCommentCommand.nextVisibleColumn(currentVisibleColumn, indentSize, lineContent.charCodeAt(j) === 9 /* CharCode.Tab */, 1);
+            }
+            if (currentVisibleColumn < minVisibleColumn) {
+                minVisibleColumn = currentVisibleColumn;
+            }
+        }
+        minVisibleColumn = Math.floor(minVisibleColumn / indentSize) * indentSize;
+        for (let i = 0, len = lines.length; i < len; i++) {
+            if (lines[i].ignore) {
+                continue;
+            }
+            const lineContent = model.getLineContent(startLineNumber + i);
+            let currentVisibleColumn = 0;
+            for (j = 0, lenJ = lines[i].commentStrOffset; currentVisibleColumn < minVisibleColumn && j < lenJ; j++) {
+                currentVisibleColumn = LineCommentCommand.nextVisibleColumn(currentVisibleColumn, indentSize, lineContent.charCodeAt(j) === 9 /* CharCode.Tab */, 1);
+            }
+            if (currentVisibleColumn > minVisibleColumn) {
+                lines[i].commentStrOffset = j - 1;
+            }
+            else {
+                lines[i].commentStrOffset = j;
+            }
+        }
+    }
+}
+
+export { LineCommentCommand };

package/dist/workers/lineDecorations.js

@@ -0,0 +1,208 @@
+import { isHighSurrogate } from '../../../base/common/strings.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class LineDecoration {
+    constructor(startColumn, endColumn, className, type) {
+        this.startColumn = startColumn;
+        this.endColumn = endColumn;
+        this.className = className;
+        this.type = type;
+        this._lineDecorationBrand = undefined;
+    }
+    static _equals(a, b) {
+        return (a.startColumn === b.startColumn
+            && a.endColumn === b.endColumn
+            && a.className === b.className
+            && a.type === b.type);
+    }
+    static equalsArr(a, b) {
+        const aLen = a.length;
+        const bLen = b.length;
+        if (aLen !== bLen) {
+            return false;
+        }
+        for (let i = 0; i < aLen; i++) {
+            if (!LineDecoration._equals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static extractWrapped(arr, startOffset, endOffset) {
+        if (arr.length === 0) {
+            return arr;
+        }
+        const startColumn = startOffset + 1;
+        const endColumn = endOffset + 1;
+        const lineLength = endOffset - startOffset;
+        const r = [];
+        let rLength = 0;
+        for (const dec of arr) {
+            if (dec.endColumn <= startColumn || dec.startColumn >= endColumn) {
+                continue;
+            }
+            r[rLength++] = new LineDecoration(Math.max(1, dec.startColumn - startColumn + 1), Math.min(lineLength + 1, dec.endColumn - startColumn + 1), dec.className, dec.type);
+        }
+        return r;
+    }
+    static filter(lineDecorations, lineNumber, minLineColumn, maxLineColumn) {
+        if (lineDecorations.length === 0) {
+            return [];
+        }
+        const result = [];
+        let resultLen = 0;
+        for (let i = 0, len = lineDecorations.length; i < len; i++) {
+            const d = lineDecorations[i];
+            const range = d.range;
+            if (range.endLineNumber < lineNumber || range.startLineNumber > lineNumber) {
+                // Ignore decorations that sit outside this line
+                continue;
+            }
+            if (range.isEmpty() && (d.type === 0 /* InlineDecorationType.Regular */ || d.type === 3 /* InlineDecorationType.RegularAffectingLetterSpacing */)) {
+                // Ignore empty range decorations
+                continue;
+            }
+            const startColumn = (range.startLineNumber === lineNumber ? range.startColumn : minLineColumn);
+            const endColumn = (range.endLineNumber === lineNumber ? range.endColumn : maxLineColumn);
+            result[resultLen++] = new LineDecoration(startColumn, endColumn, d.inlineClassName, d.type);
+        }
+        return result;
+    }
+    static _typeCompare(a, b) {
+        const ORDER = [2, 0, 1, 3];
+        return ORDER[a] - ORDER[b];
+    }
+    static compare(a, b) {
+        if (a.startColumn !== b.startColumn) {
+            return a.startColumn - b.startColumn;
+        }
+        if (a.endColumn !== b.endColumn) {
+            return a.endColumn - b.endColumn;
+        }
+        const typeCmp = LineDecoration._typeCompare(a.type, b.type);
+        if (typeCmp !== 0) {
+            return typeCmp;
+        }
+        if (a.className !== b.className) {
+            return a.className < b.className ? -1 : 1;
+        }
+        return 0;
+    }
+}
+class DecorationSegment {
+    constructor(startOffset, endOffset, className, metadata) {
+        this.startOffset = startOffset;
+        this.endOffset = endOffset;
+        this.className = className;
+        this.metadata = metadata;
+    }
+}
+class Stack {
+    constructor() {
+        this.stopOffsets = [];
+        this.classNames = [];
+        this.metadata = [];
+        this.count = 0;
+    }
+    static _metadata(metadata) {
+        let result = 0;
+        for (let i = 0, len = metadata.length; i < len; i++) {
+            result |= metadata[i];
+        }
+        return result;
+    }
+    consumeLowerThan(maxStopOffset, nextStartOffset, result) {
+        while (this.count > 0 && this.stopOffsets[0] < maxStopOffset) {
+            let i = 0;
+            // Take all equal stopping offsets
+            while (i + 1 < this.count && this.stopOffsets[i] === this.stopOffsets[i + 1]) {
+                i++;
+            }
+            // Basically we are consuming the first i + 1 elements of the stack
+            result.push(new DecorationSegment(nextStartOffset, this.stopOffsets[i], this.classNames.join(' '), Stack._metadata(this.metadata)));
+            nextStartOffset = this.stopOffsets[i] + 1;
+            // Consume them
+            this.stopOffsets.splice(0, i + 1);
+            this.classNames.splice(0, i + 1);
+            this.metadata.splice(0, i + 1);
+            this.count -= (i + 1);
+        }
+        if (this.count > 0 && nextStartOffset < maxStopOffset) {
+            result.push(new DecorationSegment(nextStartOffset, maxStopOffset - 1, this.classNames.join(' '), Stack._metadata(this.metadata)));
+            nextStartOffset = maxStopOffset;
+        }
+        return nextStartOffset;
+    }
+    insert(stopOffset, className, metadata) {
+        if (this.count === 0 || this.stopOffsets[this.count - 1] <= stopOffset) {
+            // Insert at the end
+            this.stopOffsets.push(stopOffset);
+            this.classNames.push(className);
+            this.metadata.push(metadata);
+        }
+        else {
+            // Find the insertion position for `stopOffset`
+            for (let i = 0; i < this.count; i++) {
+                if (this.stopOffsets[i] >= stopOffset) {
+                    this.stopOffsets.splice(i, 0, stopOffset);
+                    this.classNames.splice(i, 0, className);
+                    this.metadata.splice(i, 0, metadata);
+                    break;
+                }
+            }
+        }
+        this.count++;
+        return;
+    }
+}
+class LineDecorationsNormalizer {
+    /**
+     * Normalize line decorations. Overlapping decorations will generate multiple segments
+     */
+    static normalize(lineContent, lineDecorations) {
+        if (lineDecorations.length === 0) {
+            return [];
+        }
+        const result = [];
+        const stack = new Stack();
+        let nextStartOffset = 0;
+        for (let i = 0, len = lineDecorations.length; i < len; i++) {
+            const d = lineDecorations[i];
+            let startColumn = d.startColumn;
+            let endColumn = d.endColumn;
+            const className = d.className;
+            const metadata = (d.type === 1 /* InlineDecorationType.Before */
+                ? 2 /* LinePartMetadata.PSEUDO_BEFORE */
+                : d.type === 2 /* InlineDecorationType.After */
+                    ? 4 /* LinePartMetadata.PSEUDO_AFTER */
+                    : 0);
+            // If the position would end up in the middle of a high-low surrogate pair, we move it to before the pair
+            if (startColumn > 1) {
+                const charCodeBefore = lineContent.charCodeAt(startColumn - 2);
+                if (isHighSurrogate(charCodeBefore)) {
+                    startColumn--;
+                }
+            }
+            if (endColumn > 1) {
+                const charCodeBefore = lineContent.charCodeAt(endColumn - 2);
+                if (isHighSurrogate(charCodeBefore)) {
+                    endColumn--;
+                }
+            }
+            const currentStartOffset = startColumn - 1;
+            const currentEndOffset = endColumn - 2;
+            nextStartOffset = stack.consumeLowerThan(currentStartOffset, nextStartOffset, result);
+            if (stack.count === 0) {
+                nextStartOffset = currentStartOffset;
+            }
+            stack.insert(currentEndOffset, className, metadata);
+        }
+        stack.consumeLowerThan(1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, nextStartOffset, result);
+        return result;
+    }
+}
+
+export { DecorationSegment, LineDecoration, LineDecorationsNormalizer };

package/dist/workers/lineEdit.js

@@ -0,0 +1,75 @@
+import { assert, checkAdjacentItems } from '../../../../base/common/assert.js';
+import { splitLines } from '../../../../base/common/strings.js';
+import { LineRange } from '../ranges/lineRange.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+
+class LineEdit {
+    static { this.empty = new LineEdit([]); }
+    constructor(
+    /**
+     * Have to be sorted by start line number and non-intersecting.
+    */
+    replacements) {
+        this.replacements = replacements;
+        assert(checkAdjacentItems(replacements, (i1, i2) => i1.lineRange.endLineNumberExclusive <= i2.lineRange.startLineNumber));
+    }
+    toString() {
+        return this.replacements.map(e => e.toString()).join(',');
+    }
+    getNewLineRanges() {
+        const ranges = [];
+        let offset = 0;
+        for (const e of this.replacements) {
+            ranges.push(LineRange.ofLength(e.lineRange.startLineNumber + offset, e.newLines.length));
+            offset += e.newLines.length - e.lineRange.length;
+        }
+        return ranges;
+    }
+}
+class LineReplacement {
+    static fromSingleTextEdit(edit, initialValue) {
+        // 1: ab[cde
+        // 2: fghijk
+        // 3: lmn]opq
+        // replaced with
+        // 1n: 123
+        // 2n: 456
+        // 3n: 789
+        // simple solution: replace [1..4) with [1n..4n)
+        const newLines = splitLines(edit.text);
+        let startLineNumber = edit.range.startLineNumber;
+        const survivingFirstLineText = initialValue.getValueOfRange(Range.fromPositions(new Position(edit.range.startLineNumber, 1), edit.range.getStartPosition()));
+        newLines[0] = survivingFirstLineText + newLines[0];
+        let endLineNumberEx = edit.range.endLineNumber + 1;
+        const editEndLineNumberMaxColumn = initialValue.getTransformer().getLineLength(edit.range.endLineNumber) + 1;
+        const survivingEndLineText = initialValue.getValueOfRange(Range.fromPositions(edit.range.getEndPosition(), new Position(edit.range.endLineNumber, editEndLineNumberMaxColumn)));
+        newLines[newLines.length - 1] = newLines[newLines.length - 1] + survivingEndLineText;
+        // Replacing [startLineNumber, endLineNumberEx) with newLines would be correct, however it might not be minimal.
+        const startBeforeNewLine = edit.range.startColumn === initialValue.getTransformer().getLineLength(edit.range.startLineNumber) + 1;
+        const endAfterNewLine = edit.range.endColumn === 1;
+        if (startBeforeNewLine && newLines[0].length === survivingFirstLineText.length) {
+            // the replacement would not delete any text on the first line
+            startLineNumber++;
+            newLines.shift();
+        }
+        if (newLines.length > 0 && startLineNumber < endLineNumberEx && endAfterNewLine && newLines[newLines.length - 1].length === survivingEndLineText.length) {
+            // the replacement would not delete any text on the last line
+            endLineNumberEx--;
+            newLines.pop();
+        }
+        return new LineReplacement(new LineRange(startLineNumber, endLineNumberEx), newLines);
+    }
+    constructor(lineRange, newLines) {
+        this.lineRange = lineRange;
+        this.newLines = newLines;
+    }
+    toString() {
+        return `${this.lineRange}->${JSON.stringify(this.newLines)}`;
+    }
+    toLineEdit() {
+        return new LineEdit([this]);
+    }
+}
+
+export { LineEdit, LineReplacement };