monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/textAreaEditContextState.js

@@ -0,0 +1,160 @@
+import { commonPrefixLength, commonSuffixLength } 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 TextAreaState {
+    static { this.EMPTY = new TextAreaState('', 0, 0, null, undefined); }
+    constructor(value, 
+    /** the offset where selection starts inside `value` */
+    selectionStart, 
+    /** the offset where selection ends inside `value` */
+    selectionEnd, 
+    /** the editor range in the view coordinate system that matches the selection inside `value` */
+    selection, 
+    /** the visible line count (wrapped, not necessarily matching \n characters) for the text in `value` before `selectionStart` */
+    newlineCountBeforeSelection) {
+        this.value = value;
+        this.selectionStart = selectionStart;
+        this.selectionEnd = selectionEnd;
+        this.selection = selection;
+        this.newlineCountBeforeSelection = newlineCountBeforeSelection;
+    }
+    toString() {
+        return `[ <${this.value}>, selectionStart: ${this.selectionStart}, selectionEnd: ${this.selectionEnd}]`;
+    }
+    static readFromTextArea(textArea, previousState) {
+        const value = textArea.getValue();
+        const selectionStart = textArea.getSelectionStart();
+        const selectionEnd = textArea.getSelectionEnd();
+        let newlineCountBeforeSelection = undefined;
+        if (previousState) {
+            const valueBeforeSelectionStart = value.substring(0, selectionStart);
+            const previousValueBeforeSelectionStart = previousState.value.substring(0, previousState.selectionStart);
+            if (valueBeforeSelectionStart === previousValueBeforeSelectionStart) {
+                newlineCountBeforeSelection = previousState.newlineCountBeforeSelection;
+            }
+        }
+        return new TextAreaState(value, selectionStart, selectionEnd, null, newlineCountBeforeSelection);
+    }
+    collapseSelection() {
+        if (this.selectionStart === this.value.length) {
+            return this;
+        }
+        return new TextAreaState(this.value, this.value.length, this.value.length, null, undefined);
+    }
+    isWrittenToTextArea(textArea, select) {
+        const valuesEqual = this.value === textArea.getValue();
+        if (!select) {
+            return valuesEqual;
+        }
+        const selectionsEqual = this.selectionStart === textArea.getSelectionStart() && this.selectionEnd === textArea.getSelectionEnd();
+        return selectionsEqual && valuesEqual;
+    }
+    writeToTextArea(reason, textArea, select) {
+        textArea.setValue(reason, this.value);
+        if (select) {
+            textArea.setSelectionRange(reason, this.selectionStart, this.selectionEnd);
+        }
+    }
+    deduceEditorPosition(offset) {
+        if (offset <= this.selectionStart) {
+            const str = this.value.substring(offset, this.selectionStart);
+            return this._finishDeduceEditorPosition(this.selection?.getStartPosition() ?? null, str, -1);
+        }
+        if (offset >= this.selectionEnd) {
+            const str = this.value.substring(this.selectionEnd, offset);
+            return this._finishDeduceEditorPosition(this.selection?.getEndPosition() ?? null, str, 1);
+        }
+        const str1 = this.value.substring(this.selectionStart, offset);
+        if (str1.indexOf(String.fromCharCode(8230)) === -1) {
+            return this._finishDeduceEditorPosition(this.selection?.getStartPosition() ?? null, str1, 1);
+        }
+        const str2 = this.value.substring(offset, this.selectionEnd);
+        return this._finishDeduceEditorPosition(this.selection?.getEndPosition() ?? null, str2, -1);
+    }
+    _finishDeduceEditorPosition(anchor, deltaText, signum) {
+        let lineFeedCnt = 0;
+        let lastLineFeedIndex = -1;
+        while ((lastLineFeedIndex = deltaText.indexOf('\n', lastLineFeedIndex + 1)) !== -1) {
+            lineFeedCnt++;
+        }
+        return [anchor, signum * deltaText.length, lineFeedCnt];
+    }
+    static deduceInput(previousState, currentState, couldBeEmojiInput) {
+        if (!previousState) {
+            // This is the EMPTY state
+            return {
+                text: '',
+                replacePrevCharCnt: 0,
+                replaceNextCharCnt: 0,
+                positionDelta: 0
+            };
+        }
+        const prefixLength = Math.min(commonPrefixLength(previousState.value, currentState.value), previousState.selectionStart, currentState.selectionStart);
+        const suffixLength = Math.min(commonSuffixLength(previousState.value, currentState.value), previousState.value.length - previousState.selectionEnd, currentState.value.length - currentState.selectionEnd);
+        previousState.value.substring(prefixLength, previousState.value.length - suffixLength);
+        const currentValue = currentState.value.substring(prefixLength, currentState.value.length - suffixLength);
+        const previousSelectionStart = previousState.selectionStart - prefixLength;
+        const previousSelectionEnd = previousState.selectionEnd - prefixLength;
+        const currentSelectionStart = currentState.selectionStart - prefixLength;
+        const currentSelectionEnd = currentState.selectionEnd - prefixLength;
+        if (currentSelectionStart === currentSelectionEnd) {
+            // no current selection
+            const replacePreviousCharacters = (previousState.selectionStart - prefixLength);
+            return {
+                text: currentValue,
+                replacePrevCharCnt: replacePreviousCharacters,
+                replaceNextCharCnt: 0,
+                positionDelta: 0
+            };
+        }
+        // there is a current selection => composition case
+        const replacePreviousCharacters = previousSelectionEnd - previousSelectionStart;
+        return {
+            text: currentValue,
+            replacePrevCharCnt: replacePreviousCharacters,
+            replaceNextCharCnt: 0,
+            positionDelta: 0
+        };
+    }
+    static deduceAndroidCompositionInput(previousState, currentState) {
+        if (!previousState) {
+            // This is the EMPTY state
+            return {
+                text: '',
+                replacePrevCharCnt: 0,
+                replaceNextCharCnt: 0,
+                positionDelta: 0
+            };
+        }
+        if (previousState.value === currentState.value) {
+            return {
+                text: '',
+                replacePrevCharCnt: 0,
+                replaceNextCharCnt: 0,
+                positionDelta: currentState.selectionEnd - previousState.selectionEnd
+            };
+        }
+        const prefixLength = Math.min(commonPrefixLength(previousState.value, currentState.value), previousState.selectionEnd);
+        const suffixLength = Math.min(commonSuffixLength(previousState.value, currentState.value), previousState.value.length - previousState.selectionEnd);
+        const previousValue = previousState.value.substring(prefixLength, previousState.value.length - suffixLength);
+        const currentValue = currentState.value.substring(prefixLength, currentState.value.length - suffixLength);
+        previousState.selectionStart - prefixLength;
+        const previousSelectionEnd = previousState.selectionEnd - prefixLength;
+        currentState.selectionStart - prefixLength;
+        const currentSelectionEnd = currentState.selectionEnd - prefixLength;
+        return {
+            text: currentValue,
+            replacePrevCharCnt: previousSelectionEnd,
+            replaceNextCharCnt: previousValue.length - previousSelectionEnd,
+            positionDelta: currentSelectionEnd - currentValue.length
+        };
+    }
+    static fromScreenReaderContentState(screenReaderContentState) {
+        return new TextAreaState(screenReaderContentState.value, screenReaderContentState.selectionStart, screenReaderContentState.selectionEnd, screenReaderContentState.selection, screenReaderContentState.newlineCountBeforeSelection);
+    }
+}
+
+export { TextAreaState };

package/dist/workers/textChange.js

@@ -0,0 +1,248 @@
+import { writeUInt32BE, writeUInt16LE, readUInt32BE } from '../../../base/common/buffer.js';
+import { decodeUTF16LE } from './stringBuilder.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function escapeNewLine(str) {
+    return (str
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r'));
+}
+class TextChange {
+    get oldLength() {
+        return this.oldText.length;
+    }
+    get oldEnd() {
+        return this.oldPosition + this.oldText.length;
+    }
+    get newLength() {
+        return this.newText.length;
+    }
+    get newEnd() {
+        return this.newPosition + this.newText.length;
+    }
+    constructor(oldPosition, oldText, newPosition, newText) {
+        this.oldPosition = oldPosition;
+        this.oldText = oldText;
+        this.newPosition = newPosition;
+        this.newText = newText;
+    }
+    toString() {
+        if (this.oldText.length === 0) {
+            return `(insert@${this.oldPosition} "${escapeNewLine(this.newText)}")`;
+        }
+        if (this.newText.length === 0) {
+            return `(delete@${this.oldPosition} "${escapeNewLine(this.oldText)}")`;
+        }
+        return `(replace@${this.oldPosition} "${escapeNewLine(this.oldText)}" with "${escapeNewLine(this.newText)}")`;
+    }
+    static _writeStringSize(str) {
+        return (4 + 2 * str.length);
+    }
+    static _writeString(b, str, offset) {
+        const len = str.length;
+        writeUInt32BE(b, len, offset);
+        offset += 4;
+        for (let i = 0; i < len; i++) {
+            writeUInt16LE(b, str.charCodeAt(i), offset);
+            offset += 2;
+        }
+        return offset;
+    }
+    static _readString(b, offset) {
+        const len = readUInt32BE(b, offset);
+        offset += 4;
+        return decodeUTF16LE(b, offset, len);
+    }
+    writeSize() {
+        return (4 // oldPosition
+            + 4 // newPosition
+            + TextChange._writeStringSize(this.oldText)
+            + TextChange._writeStringSize(this.newText));
+    }
+    write(b, offset) {
+        writeUInt32BE(b, this.oldPosition, offset);
+        offset += 4;
+        writeUInt32BE(b, this.newPosition, offset);
+        offset += 4;
+        offset = TextChange._writeString(b, this.oldText, offset);
+        offset = TextChange._writeString(b, this.newText, offset);
+        return offset;
+    }
+    static read(b, offset, dest) {
+        const oldPosition = readUInt32BE(b, offset);
+        offset += 4;
+        const newPosition = readUInt32BE(b, offset);
+        offset += 4;
+        const oldText = TextChange._readString(b, offset);
+        offset += TextChange._writeStringSize(oldText);
+        const newText = TextChange._readString(b, offset);
+        offset += TextChange._writeStringSize(newText);
+        dest.push(new TextChange(oldPosition, oldText, newPosition, newText));
+        return offset;
+    }
+}
+function compressConsecutiveTextChanges(prevEdits, currEdits) {
+    if (prevEdits === null || prevEdits.length === 0) {
+        return currEdits;
+    }
+    const compressor = new TextChangeCompressor(prevEdits, currEdits);
+    return compressor.compress();
+}
+class TextChangeCompressor {
+    constructor(prevEdits, currEdits) {
+        this._prevEdits = prevEdits;
+        this._currEdits = currEdits;
+        this._result = [];
+        this._resultLen = 0;
+        this._prevLen = this._prevEdits.length;
+        this._prevDeltaOffset = 0;
+        this._currLen = this._currEdits.length;
+        this._currDeltaOffset = 0;
+    }
+    compress() {
+        let prevIndex = 0;
+        let currIndex = 0;
+        let prevEdit = this._getPrev(prevIndex);
+        let currEdit = this._getCurr(currIndex);
+        while (prevIndex < this._prevLen || currIndex < this._currLen) {
+            if (prevEdit === null) {
+                this._acceptCurr(currEdit);
+                currEdit = this._getCurr(++currIndex);
+                continue;
+            }
+            if (currEdit === null) {
+                this._acceptPrev(prevEdit);
+                prevEdit = this._getPrev(++prevIndex);
+                continue;
+            }
+            if (currEdit.oldEnd <= prevEdit.newPosition) {
+                this._acceptCurr(currEdit);
+                currEdit = this._getCurr(++currIndex);
+                continue;
+            }
+            if (prevEdit.newEnd <= currEdit.oldPosition) {
+                this._acceptPrev(prevEdit);
+                prevEdit = this._getPrev(++prevIndex);
+                continue;
+            }
+            if (currEdit.oldPosition < prevEdit.newPosition) {
+                const [e1, e2] = TextChangeCompressor._splitCurr(currEdit, prevEdit.newPosition - currEdit.oldPosition);
+                this._acceptCurr(e1);
+                currEdit = e2;
+                continue;
+            }
+            if (prevEdit.newPosition < currEdit.oldPosition) {
+                const [e1, e2] = TextChangeCompressor._splitPrev(prevEdit, currEdit.oldPosition - prevEdit.newPosition);
+                this._acceptPrev(e1);
+                prevEdit = e2;
+                continue;
+            }
+            // At this point, currEdit.oldPosition === prevEdit.newPosition
+            let mergePrev;
+            let mergeCurr;
+            if (currEdit.oldEnd === prevEdit.newEnd) {
+                mergePrev = prevEdit;
+                mergeCurr = currEdit;
+                prevEdit = this._getPrev(++prevIndex);
+                currEdit = this._getCurr(++currIndex);
+            }
+            else if (currEdit.oldEnd < prevEdit.newEnd) {
+                const [e1, e2] = TextChangeCompressor._splitPrev(prevEdit, currEdit.oldLength);
+                mergePrev = e1;
+                mergeCurr = currEdit;
+                prevEdit = e2;
+                currEdit = this._getCurr(++currIndex);
+            }
+            else {
+                const [e1, e2] = TextChangeCompressor._splitCurr(currEdit, prevEdit.newLength);
+                mergePrev = prevEdit;
+                mergeCurr = e1;
+                prevEdit = this._getPrev(++prevIndex);
+                currEdit = e2;
+            }
+            this._result[this._resultLen++] = new TextChange(mergePrev.oldPosition, mergePrev.oldText, mergeCurr.newPosition, mergeCurr.newText);
+            this._prevDeltaOffset += mergePrev.newLength - mergePrev.oldLength;
+            this._currDeltaOffset += mergeCurr.newLength - mergeCurr.oldLength;
+        }
+        const merged = TextChangeCompressor._merge(this._result);
+        const cleaned = TextChangeCompressor._removeNoOps(merged);
+        return cleaned;
+    }
+    _acceptCurr(currEdit) {
+        this._result[this._resultLen++] = TextChangeCompressor._rebaseCurr(this._prevDeltaOffset, currEdit);
+        this._currDeltaOffset += currEdit.newLength - currEdit.oldLength;
+    }
+    _getCurr(currIndex) {
+        return (currIndex < this._currLen ? this._currEdits[currIndex] : null);
+    }
+    _acceptPrev(prevEdit) {
+        this._result[this._resultLen++] = TextChangeCompressor._rebasePrev(this._currDeltaOffset, prevEdit);
+        this._prevDeltaOffset += prevEdit.newLength - prevEdit.oldLength;
+    }
+    _getPrev(prevIndex) {
+        return (prevIndex < this._prevLen ? this._prevEdits[prevIndex] : null);
+    }
+    static _rebaseCurr(prevDeltaOffset, currEdit) {
+        return new TextChange(currEdit.oldPosition - prevDeltaOffset, currEdit.oldText, currEdit.newPosition, currEdit.newText);
+    }
+    static _rebasePrev(currDeltaOffset, prevEdit) {
+        return new TextChange(prevEdit.oldPosition, prevEdit.oldText, prevEdit.newPosition + currDeltaOffset, prevEdit.newText);
+    }
+    static _splitPrev(edit, offset) {
+        const preText = edit.newText.substr(0, offset);
+        const postText = edit.newText.substr(offset);
+        return [
+            new TextChange(edit.oldPosition, edit.oldText, edit.newPosition, preText),
+            new TextChange(edit.oldEnd, '', edit.newPosition + offset, postText)
+        ];
+    }
+    static _splitCurr(edit, offset) {
+        const preText = edit.oldText.substr(0, offset);
+        const postText = edit.oldText.substr(offset);
+        return [
+            new TextChange(edit.oldPosition, preText, edit.newPosition, edit.newText),
+            new TextChange(edit.oldPosition + offset, postText, edit.newEnd, '')
+        ];
+    }
+    static _merge(edits) {
+        if (edits.length === 0) {
+            return edits;
+        }
+        const result = [];
+        let resultLen = 0;
+        let prev = edits[0];
+        for (let i = 1; i < edits.length; i++) {
+            const curr = edits[i];
+            if (prev.oldEnd === curr.oldPosition) {
+                // Merge into `prev`
+                prev = new TextChange(prev.oldPosition, prev.oldText + curr.oldText, prev.newPosition, prev.newText + curr.newText);
+            }
+            else {
+                result[resultLen++] = prev;
+                prev = curr;
+            }
+        }
+        result[resultLen++] = prev;
+        return result;
+    }
+    static _removeNoOps(edits) {
+        if (edits.length === 0) {
+            return edits;
+        }
+        const result = [];
+        let resultLen = 0;
+        for (let i = 0; i < edits.length; i++) {
+            const edit = edits[i];
+            if (edit.oldText === edit.newText) {
+                continue;
+            }
+            result[resultLen++] = edit;
+        }
+        return result;
+    }
+}
+
+export { TextChange, compressConsecutiveTextChanges };

package/dist/workers/textEdit.js

@@ -0,0 +1,269 @@
+import { compareBy } from '../../../../base/common/arrays.js';
+import { assertFn, checkAdjacentItems } from '../../../../base/common/assert.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { commonPrefixLength, commonSuffixLength } from '../../../../base/common/strings.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+import { TextLength } from '../text/textLength.js';
+import { StringText } from '../text/abstractText.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class TextEdit {
+    static fromStringEdit(edit, initialState) {
+        const edits = edit.replacements.map(e => TextReplacement.fromStringReplacement(e, initialState));
+        return new TextEdit(edits);
+    }
+    static fromParallelReplacementsUnsorted(replacements) {
+        const r = replacements.slice().sort(compareBy(i => i.range, Range.compareRangesUsingStarts));
+        return new TextEdit(r);
+    }
+    constructor(replacements) {
+        this.replacements = replacements;
+        assertFn(() => checkAdjacentItems(replacements, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
+    }
+    mapPosition(position) {
+        let lineDelta = 0;
+        let curLine = 0;
+        let columnDeltaInCurLine = 0;
+        for (const replacement of this.replacements) {
+            const start = replacement.range.getStartPosition();
+            if (position.isBeforeOrEqual(start)) {
+                break;
+            }
+            const end = replacement.range.getEndPosition();
+            const len = TextLength.ofText(replacement.text);
+            if (position.isBefore(end)) {
+                const startPos = new Position(start.lineNumber + lineDelta, start.column + (start.lineNumber + lineDelta === curLine ? columnDeltaInCurLine : 0));
+                const endPos = len.addToPosition(startPos);
+                return rangeFromPositions(startPos, endPos);
+            }
+            if (start.lineNumber + lineDelta !== curLine) {
+                columnDeltaInCurLine = 0;
+            }
+            lineDelta += len.lineCount - (replacement.range.endLineNumber - replacement.range.startLineNumber);
+            if (len.lineCount === 0) {
+                if (end.lineNumber !== start.lineNumber) {
+                    columnDeltaInCurLine += len.columnCount - (end.column - 1);
+                }
+                else {
+                    columnDeltaInCurLine += len.columnCount - (end.column - start.column);
+                }
+            }
+            else {
+                columnDeltaInCurLine = len.columnCount;
+            }
+            curLine = end.lineNumber + lineDelta;
+        }
+        return new Position(position.lineNumber + lineDelta, position.column + (position.lineNumber + lineDelta === curLine ? columnDeltaInCurLine : 0));
+    }
+    mapRange(range) {
+        function getStart(p) {
+            return p instanceof Position ? p : p.getStartPosition();
+        }
+        function getEnd(p) {
+            return p instanceof Position ? p : p.getEndPosition();
+        }
+        const start = getStart(this.mapPosition(range.getStartPosition()));
+        const end = getEnd(this.mapPosition(range.getEndPosition()));
+        return rangeFromPositions(start, end);
+    }
+    apply(text) {
+        let result = '';
+        let lastEditEnd = new Position(1, 1);
+        for (const replacement of this.replacements) {
+            const editRange = replacement.range;
+            const editStart = editRange.getStartPosition();
+            const editEnd = editRange.getEndPosition();
+            const r = rangeFromPositions(lastEditEnd, editStart);
+            if (!r.isEmpty()) {
+                result += text.getValueOfRange(r);
+            }
+            result += replacement.text;
+            lastEditEnd = editEnd;
+        }
+        const r = rangeFromPositions(lastEditEnd, text.endPositionExclusive);
+        if (!r.isEmpty()) {
+            result += text.getValueOfRange(r);
+        }
+        return result;
+    }
+    applyToString(str) {
+        const strText = new StringText(str);
+        return this.apply(strText);
+    }
+    getNewRanges() {
+        const newRanges = [];
+        let previousEditEndLineNumber = 0;
+        let lineOffset = 0;
+        let columnOffset = 0;
+        for (const replacement of this.replacements) {
+            const textLength = TextLength.ofText(replacement.text);
+            const newRangeStart = Position.lift({
+                lineNumber: replacement.range.startLineNumber + lineOffset,
+                column: replacement.range.startColumn + (replacement.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
+            });
+            const newRange = textLength.createRange(newRangeStart);
+            newRanges.push(newRange);
+            lineOffset = newRange.endLineNumber - replacement.range.endLineNumber;
+            columnOffset = newRange.endColumn - replacement.range.endColumn;
+            previousEditEndLineNumber = replacement.range.endLineNumber;
+        }
+        return newRanges;
+    }
+    toReplacement(text) {
+        if (this.replacements.length === 0) {
+            throw new BugIndicatingError();
+        }
+        if (this.replacements.length === 1) {
+            return this.replacements[0];
+        }
+        const startPos = this.replacements[0].range.getStartPosition();
+        const endPos = this.replacements[this.replacements.length - 1].range.getEndPosition();
+        let newText = '';
+        for (let i = 0; i < this.replacements.length; i++) {
+            const curEdit = this.replacements[i];
+            newText += curEdit.text;
+            if (i < this.replacements.length - 1) {
+                const nextEdit = this.replacements[i + 1];
+                const gapRange = Range.fromPositions(curEdit.range.getEndPosition(), nextEdit.range.getStartPosition());
+                const gapText = text.getValueOfRange(gapRange);
+                newText += gapText;
+            }
+        }
+        return new TextReplacement(Range.fromPositions(startPos, endPos), newText);
+    }
+    toString(text) {
+        if (text === undefined) {
+            return this.replacements.map(edit => edit.toString()).join('\n');
+        }
+        if (typeof text === 'string') {
+            return this.toString(new StringText(text));
+        }
+        if (this.replacements.length === 0) {
+            return '';
+        }
+        return this.replacements.map(r => {
+            const maxLength = 10;
+            const originalText = text.getValueOfRange(r.range);
+            // Get text before the edit
+            const beforeRange = Range.fromPositions(new Position(Math.max(1, r.range.startLineNumber - 1), 1), r.range.getStartPosition());
+            let beforeText = text.getValueOfRange(beforeRange);
+            if (beforeText.length > maxLength) {
+                beforeText = '...' + beforeText.substring(beforeText.length - maxLength);
+            }
+            // Get text after the edit
+            const afterRange = Range.fromPositions(r.range.getEndPosition(), new Position(r.range.endLineNumber + 1, 1));
+            let afterText = text.getValueOfRange(afterRange);
+            if (afterText.length > maxLength) {
+                afterText = afterText.substring(0, maxLength) + '...';
+            }
+            // Format the replaced text
+            let replacedText = originalText;
+            if (replacedText.length > maxLength) {
+                const halfMax = Math.floor(maxLength / 2);
+                replacedText = replacedText.substring(0, halfMax) + '...' +
+                    replacedText.substring(replacedText.length - halfMax);
+            }
+            // Format the new text
+            let newText = r.text;
+            if (newText.length > maxLength) {
+                const halfMax = Math.floor(maxLength / 2);
+                newText = newText.substring(0, halfMax) + '...' +
+                    newText.substring(newText.length - halfMax);
+            }
+            if (replacedText.length === 0) {
+                // allow-any-unicode-next-line
+                return `${beforeText}❰${newText}❱${afterText}`;
+            }
+            // allow-any-unicode-next-line
+            return `${beforeText}❰${replacedText}↦${newText}❱${afterText}`;
+        }).join('\n');
+    }
+}
+class TextReplacement {
+    static joinReplacements(replacements, initialValue) {
+        if (replacements.length === 0) {
+            throw new BugIndicatingError();
+        }
+        if (replacements.length === 1) {
+            return replacements[0];
+        }
+        const startPos = replacements[0].range.getStartPosition();
+        const endPos = replacements[replacements.length - 1].range.getEndPosition();
+        let newText = '';
+        for (let i = 0; i < replacements.length; i++) {
+            const curEdit = replacements[i];
+            newText += curEdit.text;
+            if (i < replacements.length - 1) {
+                const nextEdit = replacements[i + 1];
+                const gapRange = Range.fromPositions(curEdit.range.getEndPosition(), nextEdit.range.getStartPosition());
+                const gapText = initialValue.getValueOfRange(gapRange);
+                newText += gapText;
+            }
+        }
+        return new TextReplacement(Range.fromPositions(startPos, endPos), newText);
+    }
+    static fromStringReplacement(replacement, initialState) {
+        return new TextReplacement(initialState.getTransformer().getRange(replacement.replaceRange), replacement.newText);
+    }
+    static delete(range) {
+        return new TextReplacement(range, '');
+    }
+    constructor(range, text) {
+        this.range = range;
+        this.text = text;
+    }
+    get isEmpty() {
+        return this.range.isEmpty() && this.text.length === 0;
+    }
+    static equals(first, second) {
+        return first.range.equalsRange(second.range) && first.text === second.text;
+    }
+    equals(other) {
+        return TextReplacement.equals(this, other);
+    }
+    removeCommonPrefixAndSuffix(text) {
+        const prefix = this.removeCommonPrefix(text);
+        const suffix = prefix.removeCommonSuffix(text);
+        return suffix;
+    }
+    removeCommonPrefix(text) {
+        const normalizedOriginalText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
+        const normalizedModifiedText = this.text.replaceAll('\r\n', '\n');
+        const commonPrefixLen = commonPrefixLength(normalizedOriginalText, normalizedModifiedText);
+        const start = TextLength.ofText(normalizedOriginalText.substring(0, commonPrefixLen))
+            .addToPosition(this.range.getStartPosition());
+        const newText = normalizedModifiedText.substring(commonPrefixLen);
+        const range = Range.fromPositions(start, this.range.getEndPosition());
+        return new TextReplacement(range, newText);
+    }
+    removeCommonSuffix(text) {
+        const normalizedOriginalText = text.getValueOfRange(this.range).replaceAll('\r\n', '\n');
+        const normalizedModifiedText = this.text.replaceAll('\r\n', '\n');
+        const commonSuffixLen = commonSuffixLength(normalizedOriginalText, normalizedModifiedText);
+        const end = TextLength.ofText(normalizedOriginalText.substring(0, normalizedOriginalText.length - commonSuffixLen))
+            .addToPosition(this.range.getStartPosition());
+        const newText = normalizedModifiedText.substring(0, normalizedModifiedText.length - commonSuffixLen);
+        const range = Range.fromPositions(this.range.getStartPosition(), end);
+        return new TextReplacement(range, newText);
+    }
+    toString() {
+        const start = this.range.getStartPosition();
+        const end = this.range.getEndPosition();
+        return `(${start.lineNumber},${start.column} -> ${end.lineNumber},${end.column}): "${this.text}"`;
+    }
+}
+function rangeFromPositions(start, end) {
+    if (start.lineNumber === end.lineNumber && start.column === Number.MAX_SAFE_INTEGER) {
+        return Range.fromPositions(end, end);
+    }
+    else if (!start.isBeforeOrEqual(end)) {
+        throw new BugIndicatingError('start must be before end');
+    }
+    return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
+}
+
+export { TextEdit, TextReplacement };