monaco-editor11 1.0.9 → 1.1.0

package/dist/workers/editor/common/standaloneStrings.js

@@ -1,42 +0,0 @@
-import { localize } from '../../nls.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var InspectTokensNLS;
-(function (InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = localize(786, "Developer: Inspect Tokens");
-})(InspectTokensNLS || (InspectTokensNLS = {}));
-var GoToLineNLS;
-(function (GoToLineNLS) {
-    GoToLineNLS.gotoLineActionLabel = localize(787, "Go to Line/Column...");
-})(GoToLineNLS || (GoToLineNLS = {}));
-var QuickHelpNLS;
-(function (QuickHelpNLS) {
-    QuickHelpNLS.helpQuickAccessActionLabel = localize(788, "Show all Quick Access Providers");
-})(QuickHelpNLS || (QuickHelpNLS = {}));
-var QuickCommandNLS;
-(function (QuickCommandNLS) {
-    QuickCommandNLS.quickCommandActionLabel = localize(789, "Command Palette");
-    QuickCommandNLS.quickCommandHelp = localize(790, "Show And Run Commands");
-})(QuickCommandNLS || (QuickCommandNLS = {}));
-var QuickOutlineNLS;
-(function (QuickOutlineNLS) {
-    QuickOutlineNLS.quickOutlineActionLabel = localize(791, "Go to Symbol...");
-    QuickOutlineNLS.quickOutlineByCategoryActionLabel = localize(792, "Go to Symbol by Category...");
-})(QuickOutlineNLS || (QuickOutlineNLS = {}));
-var StandaloneCodeEditorNLS;
-(function (StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = localize(793, "Editor content");
-})(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}));
-var ToggleHighContrastNLS;
-(function (ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = localize(794, "Toggle High Contrast Theme");
-})(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}));
-var StandaloneServicesNLS;
-(function (StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = localize(795, "Made {0} edits in {1} files");
-})(StandaloneServicesNLS || (StandaloneServicesNLS = {}));
-
-export { GoToLineNLS, InspectTokensNLS, QuickCommandNLS, QuickHelpNLS, QuickOutlineNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/dist/workers/editor/common/stringBuilder.js

@@ -1,122 +0,0 @@
-import { isHighSurrogate } from '../../../base/common/strings.js';
-import { isLittleEndian } from '../../../base/common/platform.js';
-import { readUInt16LE } from '../../../base/common/buffer.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-let _utf16LE_TextDecoder;
-function getUTF16LE_TextDecoder() {
-    if (!_utf16LE_TextDecoder) {
-        _utf16LE_TextDecoder = new TextDecoder('UTF-16LE');
-    }
-    return _utf16LE_TextDecoder;
-}
-let _utf16BE_TextDecoder;
-function getUTF16BE_TextDecoder() {
-    if (!_utf16BE_TextDecoder) {
-        _utf16BE_TextDecoder = new TextDecoder('UTF-16BE');
-    }
-    return _utf16BE_TextDecoder;
-}
-let _platformTextDecoder;
-function getPlatformTextDecoder() {
-    if (!_platformTextDecoder) {
-        _platformTextDecoder = isLittleEndian() ? getUTF16LE_TextDecoder() : getUTF16BE_TextDecoder();
-    }
-    return _platformTextDecoder;
-}
-function decodeUTF16LE(source, offset, len) {
-    const view = new Uint16Array(source.buffer, offset, len);
-    if (len > 0 && (view[0] === 0xFEFF || view[0] === 0xFFFE)) {
-        // UTF16 sometimes starts with a BOM https://de.wikipedia.org/wiki/Byte_Order_Mark
-        // It looks like TextDecoder.decode will eat up a leading BOM (0xFEFF or 0xFFFE)
-        // We don't want that behavior because we know the string is UTF16LE and the BOM should be maintained
-        // So we use the manual decoder
-        return compatDecodeUTF16LE(source, offset, len);
-    }
-    return getUTF16LE_TextDecoder().decode(view);
-}
-function compatDecodeUTF16LE(source, offset, len) {
-    const result = [];
-    let resultLen = 0;
-    for (let i = 0; i < len; i++) {
-        const charCode = readUInt16LE(source, offset);
-        offset += 2;
-        result[resultLen++] = String.fromCharCode(charCode);
-    }
-    return result.join('');
-}
-class StringBuilder {
-    constructor(capacity) {
-        this._capacity = capacity | 0;
-        this._buffer = new Uint16Array(this._capacity);
-        this._completedStrings = null;
-        this._bufferLength = 0;
-    }
-    reset() {
-        this._completedStrings = null;
-        this._bufferLength = 0;
-    }
-    build() {
-        if (this._completedStrings !== null) {
-            this._flushBuffer();
-            return this._completedStrings.join('');
-        }
-        return this._buildBuffer();
-    }
-    _buildBuffer() {
-        if (this._bufferLength === 0) {
-            return '';
-        }
-        const view = new Uint16Array(this._buffer.buffer, 0, this._bufferLength);
-        return getPlatformTextDecoder().decode(view);
-    }
-    _flushBuffer() {
-        const bufferString = this._buildBuffer();
-        this._bufferLength = 0;
-        if (this._completedStrings === null) {
-            this._completedStrings = [bufferString];
-        }
-        else {
-            this._completedStrings[this._completedStrings.length] = bufferString;
-        }
-    }
-    /**
-     * Append a char code (<2^16)
-     */
-    appendCharCode(charCode) {
-        const remainingSpace = this._capacity - this._bufferLength;
-        if (remainingSpace <= 1) {
-            if (remainingSpace === 0 || isHighSurrogate(charCode)) {
-                this._flushBuffer();
-            }
-        }
-        this._buffer[this._bufferLength++] = charCode;
-    }
-    /**
-     * Append an ASCII char code (<2^8)
-     */
-    appendASCIICharCode(charCode) {
-        if (this._bufferLength === this._capacity) {
-            // buffer is full
-            this._flushBuffer();
-        }
-        this._buffer[this._bufferLength++] = charCode;
-    }
-    appendString(str) {
-        const strLen = str.length;
-        if (this._bufferLength + strLen >= this._capacity) {
-            // This string does not fit in the remaining buffer space
-            this._flushBuffer();
-            this._completedStrings[this._completedStrings.length] = str;
-            return;
-        }
-        for (let i = 0; i < strLen; i++) {
-            this._buffer[this._bufferLength++] = str.charCodeAt(i);
-        }
-    }
-}
-
-export { StringBuilder, decodeUTF16LE, getPlatformTextDecoder };

package/dist/workers/editor/common/stringEdit.js

@@ -1,165 +0,0 @@
-import { commonPrefixLength, commonSuffixLength } from '../../../../base/common/strings.js';
-import { OffsetRange } from '../ranges/offsetRange.js';
-import { BaseEdit, BaseReplacement } from './edit.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-class BaseStringEdit extends BaseEdit {
-    apply(base) {
-        const resultText = [];
-        let pos = 0;
-        for (const edit of this.replacements) {
-            resultText.push(base.substring(pos, edit.replaceRange.start));
-            resultText.push(edit.newText);
-            pos = edit.replaceRange.endExclusive;
-        }
-        resultText.push(base.substring(pos));
-        return resultText.join('');
-    }
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-class BaseStringReplacement extends BaseReplacement {
-    constructor(range, newText) {
-        super(range);
-        this.newText = newText;
-    }
-    getNewLength() { return this.newText.length; }
-    toString() {
-        return `${this.replaceRange} -> ${JSON.stringify(this.newText)}`;
-    }
-    replace(str) {
-        return str.substring(0, this.replaceRange.start) + this.newText + str.substring(this.replaceRange.endExclusive);
-    }
-    removeCommonSuffixPrefix(originalText) {
-        const oldText = originalText.substring(this.replaceRange.start, this.replaceRange.endExclusive);
-        const prefixLen = commonPrefixLength(oldText, this.newText);
-        const suffixLen = Math.min(oldText.length - prefixLen, this.newText.length - prefixLen, commonSuffixLength(oldText, this.newText));
-        const replaceRange = new OffsetRange(this.replaceRange.start + prefixLen, this.replaceRange.endExclusive - suffixLen);
-        const newText = this.newText.substring(prefixLen, this.newText.length - suffixLen);
-        return new StringReplacement(replaceRange, newText);
-    }
-    removeCommonSuffixAndPrefix(source) {
-        return this.removeCommonSuffix(source).removeCommonPrefix(source);
-    }
-    removeCommonPrefix(source) {
-        const oldText = this.replaceRange.substring(source);
-        const prefixLen = commonPrefixLength(oldText, this.newText);
-        if (prefixLen === 0) {
-            return this;
-        }
-        return this.slice(this.replaceRange.deltaStart(prefixLen), new OffsetRange(prefixLen, this.newText.length));
-    }
-    removeCommonSuffix(source) {
-        const oldText = this.replaceRange.substring(source);
-        const suffixLen = commonSuffixLength(oldText, this.newText);
-        if (suffixLen === 0) {
-            return this;
-        }
-        return this.slice(this.replaceRange.deltaEnd(-suffixLen), new OffsetRange(0, this.newText.length - suffixLen));
-    }
-    toJson() {
-        return ({
-            txt: this.newText,
-            pos: this.replaceRange.start,
-            len: this.replaceRange.length,
-        });
-    }
-}
-/**
- * Represents a set of replacements to a string.
- * All these replacements are applied at once.
-*/
-class StringEdit extends BaseStringEdit {
-    static { this.empty = new StringEdit([]); }
-    static compose(edits) {
-        if (edits.length === 0) {
-            return StringEdit.empty;
-        }
-        let result = edits[0];
-        for (let i = 1; i < edits.length; i++) {
-            result = result.compose(edits[i]);
-        }
-        return result;
-    }
-    constructor(replacements) {
-        super(replacements);
-    }
-    _createNew(replacements) {
-        return new StringEdit(replacements);
-    }
-}
-class StringReplacement extends BaseStringReplacement {
-    static insert(offset, text) {
-        return new StringReplacement(OffsetRange.emptyAt(offset), text);
-    }
-    static replace(range, text) {
-        return new StringReplacement(range, text);
-    }
-    equals(other) {
-        return this.replaceRange.equals(other.replaceRange) && this.newText === other.newText;
-    }
-    tryJoinTouching(other) {
-        return new StringReplacement(this.replaceRange.joinRightTouching(other.replaceRange), this.newText + other.newText);
-    }
-    slice(range, rangeInReplacement) {
-        return new StringReplacement(range, rangeInReplacement ? rangeInReplacement.substring(this.newText) : this.newText);
-    }
-}
-function applyEditsToRanges(sortedRanges, edit) {
-    sortedRanges = sortedRanges.slice();
-    // treat edits as deletion of the replace range and then as insertion that extends the first range
-    const result = [];
-    let offset = 0;
-    for (const e of edit.replacements) {
-        while (true) {
-            // ranges before the current edit
-            const r = sortedRanges[0];
-            if (!r || r.endExclusive >= e.replaceRange.start) {
-                break;
-            }
-            sortedRanges.shift();
-            result.push(r.delta(offset));
-        }
-        const intersecting = [];
-        while (true) {
-            const r = sortedRanges[0];
-            if (!r || !r.intersectsOrTouches(e.replaceRange)) {
-                break;
-            }
-            sortedRanges.shift();
-            intersecting.push(r);
-        }
-        for (let i = intersecting.length - 1; i >= 0; i--) {
-            let r = intersecting[i];
-            const overlap = r.intersect(e.replaceRange).length;
-            r = r.deltaEnd(-overlap + (i === 0 ? e.newText.length : 0));
-            const rangeAheadOfReplaceRange = r.start - e.replaceRange.start;
-            if (rangeAheadOfReplaceRange > 0) {
-                r = r.delta(-rangeAheadOfReplaceRange);
-            }
-            if (i !== 0) {
-                r = r.delta(e.newText.length);
-            }
-            // We already took our offset into account.
-            // Because we add r back to the queue (which then adds offset again),
-            // we have to remove it here.
-            r = r.delta(-(e.newText.length - e.replaceRange.length));
-            sortedRanges.unshift(r);
-        }
-        offset += e.newText.length - e.replaceRange.length;
-    }
-    while (true) {
-        const r = sortedRanges[0];
-        if (!r) {
-            break;
-        }
-        sortedRanges.shift();
-        result.push(r.delta(offset));
-    }
-    return result;
-}
-
-export { BaseStringEdit, BaseStringReplacement, StringEdit, StringReplacement, applyEditsToRanges };

package/dist/workers/editor/common/supports.js

@@ -1,58 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function createScopedLineTokens(context, offset) {
-    const tokenCount = context.getCount();
-    const tokenIndex = context.findTokenIndexAtOffset(offset);
-    const desiredLanguageId = context.getLanguageId(tokenIndex);
-    let lastTokenIndex = tokenIndex;
-    while (lastTokenIndex + 1 < tokenCount && context.getLanguageId(lastTokenIndex + 1) === desiredLanguageId) {
-        lastTokenIndex++;
-    }
-    let firstTokenIndex = tokenIndex;
-    while (firstTokenIndex > 0 && context.getLanguageId(firstTokenIndex - 1) === desiredLanguageId) {
-        firstTokenIndex--;
-    }
-    return new ScopedLineTokens(context, desiredLanguageId, firstTokenIndex, lastTokenIndex + 1, context.getStartOffset(firstTokenIndex), context.getEndOffset(lastTokenIndex));
-}
-class ScopedLineTokens {
-    constructor(actual, languageId, firstTokenIndex, lastTokenIndex, firstCharOffset, lastCharOffset) {
-        this._scopedLineTokensBrand = undefined;
-        this._actual = actual;
-        this.languageId = languageId;
-        this._firstTokenIndex = firstTokenIndex;
-        this._lastTokenIndex = lastTokenIndex;
-        this.firstCharOffset = firstCharOffset;
-        this._lastCharOffset = lastCharOffset;
-        this.languageIdCodec = actual.languageIdCodec;
-    }
-    getLineContent() {
-        const actualLineContent = this._actual.getLineContent();
-        return actualLineContent.substring(this.firstCharOffset, this._lastCharOffset);
-    }
-    getLineLength() {
-        return this._lastCharOffset - this.firstCharOffset;
-    }
-    getActualLineContentBefore(offset) {
-        const actualLineContent = this._actual.getLineContent();
-        return actualLineContent.substring(0, this.firstCharOffset + offset);
-    }
-    getTokenCount() {
-        return this._lastTokenIndex - this._firstTokenIndex;
-    }
-    findTokenIndexAtOffset(offset) {
-        return this._actual.findTokenIndexAtOffset(offset + this.firstCharOffset) - this._firstTokenIndex;
-    }
-    getStandardTokenType(tokenIndex) {
-        return this._actual.getStandardTokenType(tokenIndex + this._firstTokenIndex);
-    }
-    toIViewLineTokens() {
-        return this._actual.sliceAndInflate(this.firstCharOffset, this._lastCharOffset, 0);
-    }
-}
-function ignoreBracketsInToken(standardTokenType) {
-    return (standardTokenType & 3 /* IgnoreBracketsInTokens.value */) !== 0;
-}
-
-export { ScopedLineTokens, createScopedLineTokens, ignoreBracketsInToken };

package/dist/workers/editor/common/surroundSelectionCommand.js

@@ -1,44 +0,0 @@
-import { Range } from '../core/range.js';
-import { Selection } from '../core/selection.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class SurroundSelectionCommand {
-    constructor(range, charBeforeSelection, charAfterSelection) {
-        this._range = range;
-        this._charBeforeSelection = charBeforeSelection;
-        this._charAfterSelection = charAfterSelection;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(new Range(this._range.startLineNumber, this._range.startColumn, this._range.startLineNumber, this._range.startColumn), this._charBeforeSelection);
-        builder.addTrackedEditOperation(new Range(this._range.endLineNumber, this._range.endColumn, this._range.endLineNumber, this._range.endColumn), this._charAfterSelection || null); // addTrackedEditOperation() ignores us if the text == ''. Causing a chain of errors in computeCursorState()
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const firstOperationRange = inverseEditOperations[0].range;
-        const secondOperationRange = inverseEditOperations[1].range;
-        return new Selection(firstOperationRange.endLineNumber, firstOperationRange.endColumn, secondOperationRange.endLineNumber, secondOperationRange.endColumn - this._charAfterSelection.length);
-    }
-}
-/**
- * A surround selection command that runs after composition finished.
- */
-class CompositionSurroundSelectionCommand {
-    constructor(_position, _text, _charAfter) {
-        this._position = _position;
-        this._text = _text;
-        this._charAfter = _charAfter;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(new Range(this._position.lineNumber, this._position.column, this._position.lineNumber, this._position.column), this._text + this._charAfter);
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const opRange = inverseEditOperations[0].range;
-        return new Selection(opRange.endLineNumber, opRange.startColumn, opRange.endLineNumber, opRange.endColumn - this._charAfter.length);
-    }
-}
-
-export { CompositionSurroundSelectionCommand, SurroundSelectionCommand };

package/dist/workers/editor/common/textChange.js

@@ -1,248 +0,0 @@
-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 };