@umbraco-cms/backoffice 15.3.0 → 15.4.0-rc

package/dist-cms/monaco-editor/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeBase.js

@@ -0,0 +1,1452 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Position } from '../../core/position.js';
+import { Range } from '../../core/range.js';
+import { FindMatch } from '../../model.js';
+import { SENTINEL, TreeNode, fixInsert, leftest, rbDelete, righttest, updateTreeMetadata } from './rbTreeBase.js';
+import { Searcher, createFindMatch, isValidMatch } from '../textModelSearch.js';
+// const lfRegex = new RegExp(/\r\n|\r|\n/g);
+const AverageBufferSize = 65535;
+function createUintArray(arr) {
+    let r;
+    if (arr[arr.length - 1] < 65536) {
+        r = new Uint16Array(arr.length);
+    }
+    else {
+        r = new Uint32Array(arr.length);
+    }
+    r.set(arr, 0);
+    return r;
+}
+class LineStarts {
+    constructor(lineStarts, cr, lf, crlf, isBasicASCII) {
+        this.lineStarts = lineStarts;
+        this.cr = cr;
+        this.lf = lf;
+        this.crlf = crlf;
+        this.isBasicASCII = isBasicASCII;
+    }
+}
+export function createLineStartsFast(str, readonly = true) {
+    const r = [0];
+    let rLength = 1;
+    for (let i = 0, len = str.length; i < len; i++) {
+        const chr = str.charCodeAt(i);
+        if (chr === 13 /* CharCode.CarriageReturn */) {
+            if (i + 1 < len && str.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
+                // \r\n... case
+                r[rLength++] = i + 2;
+                i++; // skip \n
+            }
+            else {
+                // \r... case
+                r[rLength++] = i + 1;
+            }
+        }
+        else if (chr === 10 /* CharCode.LineFeed */) {
+            r[rLength++] = i + 1;
+        }
+    }
+    if (readonly) {
+        return createUintArray(r);
+    }
+    else {
+        return r;
+    }
+}
+export function createLineStarts(r, str) {
+    r.length = 0;
+    r[0] = 0;
+    let rLength = 1;
+    let cr = 0, lf = 0, crlf = 0;
+    let isBasicASCII = true;
+    for (let i = 0, len = str.length; i < len; i++) {
+        const chr = str.charCodeAt(i);
+        if (chr === 13 /* CharCode.CarriageReturn */) {
+            if (i + 1 < len && str.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
+                // \r\n... case
+                crlf++;
+                r[rLength++] = i + 2;
+                i++; // skip \n
+            }
+            else {
+                cr++;
+                // \r... case
+                r[rLength++] = i + 1;
+            }
+        }
+        else if (chr === 10 /* CharCode.LineFeed */) {
+            lf++;
+            r[rLength++] = i + 1;
+        }
+        else {
+            if (isBasicASCII) {
+                if (chr !== 9 /* CharCode.Tab */ && (chr < 32 || chr > 126)) {
+                    isBasicASCII = false;
+                }
+            }
+        }
+    }
+    const result = new LineStarts(createUintArray(r), cr, lf, crlf, isBasicASCII);
+    r.length = 0;
+    return result;
+}
+export class Piece {
+    constructor(bufferIndex, start, end, lineFeedCnt, length) {
+        this.bufferIndex = bufferIndex;
+        this.start = start;
+        this.end = end;
+        this.lineFeedCnt = lineFeedCnt;
+        this.length = length;
+    }
+}
+export class StringBuffer {
+    constructor(buffer, lineStarts) {
+        this.buffer = buffer;
+        this.lineStarts = lineStarts;
+    }
+}
+/**
+ * Readonly snapshot for piece tree.
+ * In a real multiple thread environment, to make snapshot reading always work correctly, we need to
+ * 1. Make TreeNode.piece immutable, then reading and writing can run in parallel.
+ * 2. TreeNode/Buffers normalization should not happen during snapshot reading.
+ */
+class PieceTreeSnapshot {
+    constructor(tree, BOM) {
+        this._pieces = [];
+        this._tree = tree;
+        this._BOM = BOM;
+        this._index = 0;
+        if (tree.root !== SENTINEL) {
+            tree.iterate(tree.root, node => {
+                if (node !== SENTINEL) {
+                    this._pieces.push(node.piece);
+                }
+                return true;
+            });
+        }
+    }
+    read() {
+        if (this._pieces.length === 0) {
+            if (this._index === 0) {
+                this._index++;
+                return this._BOM;
+            }
+            else {
+                return null;
+            }
+        }
+        if (this._index > this._pieces.length - 1) {
+            return null;
+        }
+        if (this._index === 0) {
+            return this._BOM + this._tree.getPieceContent(this._pieces[this._index++]);
+        }
+        return this._tree.getPieceContent(this._pieces[this._index++]);
+    }
+}
+class PieceTreeSearchCache {
+    constructor(limit) {
+        this._limit = limit;
+        this._cache = [];
+    }
+    get(offset) {
+        for (let i = this._cache.length - 1; i >= 0; i--) {
+            const nodePos = this._cache[i];
+            if (nodePos.nodeStartOffset <= offset && nodePos.nodeStartOffset + nodePos.node.piece.length >= offset) {
+                return nodePos;
+            }
+        }
+        return null;
+    }
+    get2(lineNumber) {
+        for (let i = this._cache.length - 1; i >= 0; i--) {
+            const nodePos = this._cache[i];
+            if (nodePos.nodeStartLineNumber && nodePos.nodeStartLineNumber < lineNumber && nodePos.nodeStartLineNumber + nodePos.node.piece.lineFeedCnt >= lineNumber) {
+                return nodePos;
+            }
+        }
+        return null;
+    }
+    set(nodePosition) {
+        if (this._cache.length >= this._limit) {
+            this._cache.shift();
+        }
+        this._cache.push(nodePosition);
+    }
+    validate(offset) {
+        let hasInvalidVal = false;
+        const tmp = this._cache;
+        for (let i = 0; i < tmp.length; i++) {
+            const nodePos = tmp[i];
+            if (nodePos.node.parent === null || nodePos.nodeStartOffset >= offset) {
+                tmp[i] = null;
+                hasInvalidVal = true;
+                continue;
+            }
+        }
+        if (hasInvalidVal) {
+            const newArr = [];
+            for (const entry of tmp) {
+                if (entry !== null) {
+                    newArr.push(entry);
+                }
+            }
+            this._cache = newArr;
+        }
+    }
+}
+export class PieceTreeBase {
+    constructor(chunks, eol, eolNormalized) {
+        this.create(chunks, eol, eolNormalized);
+    }
+    create(chunks, eol, eolNormalized) {
+        this._buffers = [
+            new StringBuffer('', [0])
+        ];
+        this._lastChangeBufferPos = { line: 0, column: 0 };
+        this.root = SENTINEL;
+        this._lineCnt = 1;
+        this._length = 0;
+        this._EOL = eol;
+        this._EOLLength = eol.length;
+        this._EOLNormalized = eolNormalized;
+        let lastNode = null;
+        for (let i = 0, len = chunks.length; i < len; i++) {
+            if (chunks[i].buffer.length > 0) {
+                if (!chunks[i].lineStarts) {
+                    chunks[i].lineStarts = createLineStartsFast(chunks[i].buffer);
+                }
+                const piece = new Piece(i + 1, { line: 0, column: 0 }, { line: chunks[i].lineStarts.length - 1, column: chunks[i].buffer.length - chunks[i].lineStarts[chunks[i].lineStarts.length - 1] }, chunks[i].lineStarts.length - 1, chunks[i].buffer.length);
+                this._buffers.push(chunks[i]);
+                lastNode = this.rbInsertRight(lastNode, piece);
+            }
+        }
+        this._searchCache = new PieceTreeSearchCache(1);
+        this._lastVisitedLine = { lineNumber: 0, value: '' };
+        this.computeBufferMetadata();
+    }
+    normalizeEOL(eol) {
+        const averageBufferSize = AverageBufferSize;
+        const min = averageBufferSize - Math.floor(averageBufferSize / 3);
+        const max = min * 2;
+        let tempChunk = '';
+        let tempChunkLen = 0;
+        const chunks = [];
+        this.iterate(this.root, node => {
+            const str = this.getNodeContent(node);
+            const len = str.length;
+            if (tempChunkLen <= min || tempChunkLen + len < max) {
+                tempChunk += str;
+                tempChunkLen += len;
+                return true;
+            }
+            // flush anyways
+            const text = tempChunk.replace(/\r\n|\r|\n/g, eol);
+            chunks.push(new StringBuffer(text, createLineStartsFast(text)));
+            tempChunk = str;
+            tempChunkLen = len;
+            return true;
+        });
+        if (tempChunkLen > 0) {
+            const text = tempChunk.replace(/\r\n|\r|\n/g, eol);
+            chunks.push(new StringBuffer(text, createLineStartsFast(text)));
+        }
+        this.create(chunks, eol, true);
+    }
+    // #region Buffer API
+    getEOL() {
+        return this._EOL;
+    }
+    setEOL(newEOL) {
+        this._EOL = newEOL;
+        this._EOLLength = this._EOL.length;
+        this.normalizeEOL(newEOL);
+    }
+    createSnapshot(BOM) {
+        return new PieceTreeSnapshot(this, BOM);
+    }
+    getOffsetAt(lineNumber, column) {
+        let leftLen = 0; // inorder
+        let x = this.root;
+        while (x !== SENTINEL) {
+            if (x.left !== SENTINEL && x.lf_left + 1 >= lineNumber) {
+                x = x.left;
+            }
+            else if (x.lf_left + x.piece.lineFeedCnt + 1 >= lineNumber) {
+                leftLen += x.size_left;
+                // lineNumber >= 2
+                const accumualtedValInCurrentIndex = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                return leftLen += accumualtedValInCurrentIndex + column - 1;
+            }
+            else {
+                lineNumber -= x.lf_left + x.piece.lineFeedCnt;
+                leftLen += x.size_left + x.piece.length;
+                x = x.right;
+            }
+        }
+        return leftLen;
+    }
+    getPositionAt(offset) {
+        offset = Math.floor(offset);
+        offset = Math.max(0, offset);
+        let x = this.root;
+        let lfCnt = 0;
+        const originalOffset = offset;
+        while (x !== SENTINEL) {
+            if (x.size_left !== 0 && x.size_left >= offset) {
+                x = x.left;
+            }
+            else if (x.size_left + x.piece.length >= offset) {
+                const out = this.getIndexOf(x, offset - x.size_left);
+                lfCnt += x.lf_left + out.index;
+                if (out.index === 0) {
+                    const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);
+                    const column = originalOffset - lineStartOffset;
+                    return new Position(lfCnt + 1, column + 1);
+                }
+                return new Position(lfCnt + 1, out.remainder + 1);
+            }
+            else {
+                offset -= x.size_left + x.piece.length;
+                lfCnt += x.lf_left + x.piece.lineFeedCnt;
+                if (x.right === SENTINEL) {
+                    // last node
+                    const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);
+                    const column = originalOffset - offset - lineStartOffset;
+                    return new Position(lfCnt + 1, column + 1);
+                }
+                else {
+                    x = x.right;
+                }
+            }
+        }
+        return new Position(1, 1);
+    }
+    getValueInRange(range, eol) {
+        if (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn) {
+            return '';
+        }
+        const startPosition = this.nodeAt2(range.startLineNumber, range.startColumn);
+        const endPosition = this.nodeAt2(range.endLineNumber, range.endColumn);
+        const value = this.getValueInRange2(startPosition, endPosition);
+        if (eol) {
+            if (eol !== this._EOL || !this._EOLNormalized) {
+                return value.replace(/\r\n|\r|\n/g, eol);
+            }
+            if (eol === this.getEOL() && this._EOLNormalized) {
+                if (eol === '\r\n') {
+                }
+                return value;
+            }
+            return value.replace(/\r\n|\r|\n/g, eol);
+        }
+        return value;
+    }
+    getValueInRange2(startPosition, endPosition) {
+        if (startPosition.node === endPosition.node) {
+            const node = startPosition.node;
+            const buffer = this._buffers[node.piece.bufferIndex].buffer;
+            const startOffset = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start);
+            return buffer.substring(startOffset + startPosition.remainder, startOffset + endPosition.remainder);
+        }
+        let x = startPosition.node;
+        const buffer = this._buffers[x.piece.bufferIndex].buffer;
+        const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+        let ret = buffer.substring(startOffset + startPosition.remainder, startOffset + x.piece.length);
+        x = x.next();
+        while (x !== SENTINEL) {
+            const buffer = this._buffers[x.piece.bufferIndex].buffer;
+            const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+            if (x === endPosition.node) {
+                ret += buffer.substring(startOffset, startOffset + endPosition.remainder);
+                break;
+            }
+            else {
+                ret += buffer.substr(startOffset, x.piece.length);
+            }
+            x = x.next();
+        }
+        return ret;
+    }
+    getLinesContent() {
+        const lines = [];
+        let linesLength = 0;
+        let currentLine = '';
+        let danglingCR = false;
+        this.iterate(this.root, node => {
+            if (node === SENTINEL) {
+                return true;
+            }
+            const piece = node.piece;
+            let pieceLength = piece.length;
+            if (pieceLength === 0) {
+                return true;
+            }
+            const buffer = this._buffers[piece.bufferIndex].buffer;
+            const lineStarts = this._buffers[piece.bufferIndex].lineStarts;
+            const pieceStartLine = piece.start.line;
+            const pieceEndLine = piece.end.line;
+            let pieceStartOffset = lineStarts[pieceStartLine] + piece.start.column;
+            if (danglingCR) {
+                if (buffer.charCodeAt(pieceStartOffset) === 10 /* CharCode.LineFeed */) {
+                    // pretend the \n was in the previous piece..
+                    pieceStartOffset++;
+                    pieceLength--;
+                }
+                lines[linesLength++] = currentLine;
+                currentLine = '';
+                danglingCR = false;
+                if (pieceLength === 0) {
+                    return true;
+                }
+            }
+            if (pieceStartLine === pieceEndLine) {
+                // this piece has no new lines
+                if (!this._EOLNormalized && buffer.charCodeAt(pieceStartOffset + pieceLength - 1) === 13 /* CharCode.CarriageReturn */) {
+                    danglingCR = true;
+                    currentLine += buffer.substr(pieceStartOffset, pieceLength - 1);
+                }
+                else {
+                    currentLine += buffer.substr(pieceStartOffset, pieceLength);
+                }
+                return true;
+            }
+            // add the text before the first line start in this piece
+            currentLine += (this._EOLNormalized
+                ? buffer.substring(pieceStartOffset, Math.max(pieceStartOffset, lineStarts[pieceStartLine + 1] - this._EOLLength))
+                : buffer.substring(pieceStartOffset, lineStarts[pieceStartLine + 1]).replace(/(\r\n|\r|\n)$/, ''));
+            lines[linesLength++] = currentLine;
+            for (let line = pieceStartLine + 1; line < pieceEndLine; line++) {
+                currentLine = (this._EOLNormalized
+                    ? buffer.substring(lineStarts[line], lineStarts[line + 1] - this._EOLLength)
+                    : buffer.substring(lineStarts[line], lineStarts[line + 1]).replace(/(\r\n|\r|\n)$/, ''));
+                lines[linesLength++] = currentLine;
+            }
+            if (!this._EOLNormalized && buffer.charCodeAt(lineStarts[pieceEndLine] + piece.end.column - 1) === 13 /* CharCode.CarriageReturn */) {
+                danglingCR = true;
+                if (piece.end.column === 0) {
+                    // The last line ended with a \r, let's undo the push, it will be pushed by next iteration
+                    linesLength--;
+                }
+                else {
+                    currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column - 1);
+                }
+            }
+            else {
+                currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column);
+            }
+            return true;
+        });
+        if (danglingCR) {
+            lines[linesLength++] = currentLine;
+            currentLine = '';
+        }
+        lines[linesLength++] = currentLine;
+        return lines;
+    }
+    getLength() {
+        return this._length;
+    }
+    getLineCount() {
+        return this._lineCnt;
+    }
+    getLineContent(lineNumber) {
+        if (this._lastVisitedLine.lineNumber === lineNumber) {
+            return this._lastVisitedLine.value;
+        }
+        this._lastVisitedLine.lineNumber = lineNumber;
+        if (lineNumber === this._lineCnt) {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber);
+        }
+        else if (this._EOLNormalized) {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber, this._EOLLength);
+        }
+        else {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber).replace(/(\r\n|\r|\n)$/, '');
+        }
+        return this._lastVisitedLine.value;
+    }
+    _getCharCode(nodePos) {
+        if (nodePos.remainder === nodePos.node.piece.length) {
+            // the char we want to fetch is at the head of next node.
+            const matchingNode = nodePos.node.next();
+            if (!matchingNode) {
+                return 0;
+            }
+            const buffer = this._buffers[matchingNode.piece.bufferIndex];
+            const startOffset = this.offsetInBuffer(matchingNode.piece.bufferIndex, matchingNode.piece.start);
+            return buffer.buffer.charCodeAt(startOffset);
+        }
+        else {
+            const buffer = this._buffers[nodePos.node.piece.bufferIndex];
+            const startOffset = this.offsetInBuffer(nodePos.node.piece.bufferIndex, nodePos.node.piece.start);
+            const targetOffset = startOffset + nodePos.remainder;
+            return buffer.buffer.charCodeAt(targetOffset);
+        }
+    }
+    getLineCharCode(lineNumber, index) {
+        const nodePos = this.nodeAt2(lineNumber, index + 1);
+        return this._getCharCode(nodePos);
+    }
+    getLineLength(lineNumber) {
+        if (lineNumber === this.getLineCount()) {
+            const startOffset = this.getOffsetAt(lineNumber, 1);
+            return this.getLength() - startOffset;
+        }
+        return this.getOffsetAt(lineNumber + 1, 1) - this.getOffsetAt(lineNumber, 1) - this._EOLLength;
+    }
+    findMatchesInNode(node, searcher, startLineNumber, startColumn, startCursor, endCursor, searchData, captureMatches, limitResultCount, resultLen, result) {
+        const buffer = this._buffers[node.piece.bufferIndex];
+        const startOffsetInBuffer = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start);
+        const start = this.offsetInBuffer(node.piece.bufferIndex, startCursor);
+        const end = this.offsetInBuffer(node.piece.bufferIndex, endCursor);
+        let m;
+        // Reset regex to search from the beginning
+        const ret = { line: 0, column: 0 };
+        let searchText;
+        let offsetInBuffer;
+        if (searcher._wordSeparators) {
+            searchText = buffer.buffer.substring(start, end);
+            offsetInBuffer = (offset) => offset + start;
+            searcher.reset(0);
+        }
+        else {
+            searchText = buffer.buffer;
+            offsetInBuffer = (offset) => offset;
+            searcher.reset(start);
+        }
+        do {
+            m = searcher.next(searchText);
+            if (m) {
+                if (offsetInBuffer(m.index) >= end) {
+                    return resultLen;
+                }
+                this.positionInBuffer(node, offsetInBuffer(m.index) - startOffsetInBuffer, ret);
+                const lineFeedCnt = this.getLineFeedCnt(node.piece.bufferIndex, startCursor, ret);
+                const retStartColumn = ret.line === startCursor.line ? ret.column - startCursor.column + startColumn : ret.column + 1;
+                const retEndColumn = retStartColumn + m[0].length;
+                result[resultLen++] = createFindMatch(new Range(startLineNumber + lineFeedCnt, retStartColumn, startLineNumber + lineFeedCnt, retEndColumn), m, captureMatches);
+                if (offsetInBuffer(m.index) + m[0].length >= end) {
+                    return resultLen;
+                }
+                if (resultLen >= limitResultCount) {
+                    return resultLen;
+                }
+            }
+        } while (m);
+        return resultLen;
+    }
+    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {
+        const result = [];
+        let resultLen = 0;
+        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);
+        let startPosition = this.nodeAt2(searchRange.startLineNumber, searchRange.startColumn);
+        if (startPosition === null) {
+            return [];
+        }
+        const endPosition = this.nodeAt2(searchRange.endLineNumber, searchRange.endColumn);
+        if (endPosition === null) {
+            return [];
+        }
+        let start = this.positionInBuffer(startPosition.node, startPosition.remainder);
+        const end = this.positionInBuffer(endPosition.node, endPosition.remainder);
+        if (startPosition.node === endPosition.node) {
+            this.findMatchesInNode(startPosition.node, searcher, searchRange.startLineNumber, searchRange.startColumn, start, end, searchData, captureMatches, limitResultCount, resultLen, result);
+            return result;
+        }
+        let startLineNumber = searchRange.startLineNumber;
+        let currentNode = startPosition.node;
+        while (currentNode !== endPosition.node) {
+            const lineBreakCnt = this.getLineFeedCnt(currentNode.piece.bufferIndex, start, currentNode.piece.end);
+            if (lineBreakCnt >= 1) {
+                // last line break position
+                const lineStarts = this._buffers[currentNode.piece.bufferIndex].lineStarts;
+                const startOffsetInBuffer = this.offsetInBuffer(currentNode.piece.bufferIndex, currentNode.piece.start);
+                const nextLineStartOffset = lineStarts[start.line + lineBreakCnt];
+                const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn : 1;
+                resultLen = this.findMatchesInNode(currentNode, searcher, startLineNumber, startColumn, start, this.positionInBuffer(currentNode, nextLineStartOffset - startOffsetInBuffer), searchData, captureMatches, limitResultCount, resultLen, result);
+                if (resultLen >= limitResultCount) {
+                    return result;
+                }
+                startLineNumber += lineBreakCnt;
+            }
+            const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;
+            // search for the remaining content
+            if (startLineNumber === searchRange.endLineNumber) {
+                const text = this.getLineContent(startLineNumber).substring(startColumn, searchRange.endColumn - 1);
+                resultLen = this._findMatchesInLine(searchData, searcher, text, searchRange.endLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);
+                return result;
+            }
+            resultLen = this._findMatchesInLine(searchData, searcher, this.getLineContent(startLineNumber).substr(startColumn), startLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);
+            if (resultLen >= limitResultCount) {
+                return result;
+            }
+            startLineNumber++;
+            startPosition = this.nodeAt2(startLineNumber, 1);
+            currentNode = startPosition.node;
+            start = this.positionInBuffer(startPosition.node, startPosition.remainder);
+        }
+        if (startLineNumber === searchRange.endLineNumber) {
+            const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;
+            const text = this.getLineContent(startLineNumber).substring(startColumn, searchRange.endColumn - 1);
+            resultLen = this._findMatchesInLine(searchData, searcher, text, searchRange.endLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);
+            return result;
+        }
+        const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn : 1;
+        resultLen = this.findMatchesInNode(endPosition.node, searcher, startLineNumber, startColumn, start, end, searchData, captureMatches, limitResultCount, resultLen, result);
+        return result;
+    }
+    _findMatchesInLine(searchData, searcher, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {
+        const wordSeparators = searchData.wordSeparators;
+        if (!captureMatches && searchData.simpleSearch) {
+            const searchString = searchData.simpleSearch;
+            const searchStringLen = searchString.length;
+            const textLength = text.length;
+            let lastMatchIndex = -searchStringLen;
+            while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {
+                if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {
+                    result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);
+                    if (resultLen >= limitResultCount) {
+                        return resultLen;
+                    }
+                }
+            }
+            return resultLen;
+        }
+        let m;
+        // Reset regex to search from the beginning
+        searcher.reset(0);
+        do {
+            m = searcher.next(text);
+            if (m) {
+                result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);
+                if (resultLen >= limitResultCount) {
+                    return resultLen;
+                }
+            }
+        } while (m);
+        return resultLen;
+    }
+    // #endregion
+    // #region Piece Table
+    insert(offset, value, eolNormalized = false) {
+        this._EOLNormalized = this._EOLNormalized && eolNormalized;
+        this._lastVisitedLine.lineNumber = 0;
+        this._lastVisitedLine.value = '';
+        if (this.root !== SENTINEL) {
+            const { node, remainder, nodeStartOffset } = this.nodeAt(offset);
+            const piece = node.piece;
+            const bufferIndex = piece.bufferIndex;
+            const insertPosInBuffer = this.positionInBuffer(node, remainder);
+            if (node.piece.bufferIndex === 0 &&
+                piece.end.line === this._lastChangeBufferPos.line &&
+                piece.end.column === this._lastChangeBufferPos.column &&
+                (nodeStartOffset + piece.length === offset) &&
+                value.length < AverageBufferSize) {
+                // changed buffer
+                this.appendToNode(node, value);
+                this.computeBufferMetadata();
+                return;
+            }
+            if (nodeStartOffset === offset) {
+                this.insertContentToNodeLeft(value, node);
+                this._searchCache.validate(offset);
+            }
+            else if (nodeStartOffset + node.piece.length > offset) {
+                // we are inserting into the middle of a node.
+                const nodesToDel = [];
+                let newRightPiece = new Piece(piece.bufferIndex, insertPosInBuffer, piece.end, this.getLineFeedCnt(piece.bufferIndex, insertPosInBuffer, piece.end), this.offsetInBuffer(bufferIndex, piece.end) - this.offsetInBuffer(bufferIndex, insertPosInBuffer));
+                if (this.shouldCheckCRLF() && this.endWithCR(value)) {
+                    const headOfRight = this.nodeCharCodeAt(node, remainder);
+                    if (headOfRight === 10 /** \n */) {
+                        const newStart = { line: newRightPiece.start.line + 1, column: 0 };
+                        newRightPiece = new Piece(newRightPiece.bufferIndex, newStart, newRightPiece.end, this.getLineFeedCnt(newRightPiece.bufferIndex, newStart, newRightPiece.end), newRightPiece.length - 1);
+                        value += '\n';
+                    }
+                }
+                // reuse node for content before insertion point.
+                if (this.shouldCheckCRLF() && this.startWithLF(value)) {
+                    const tailOfLeft = this.nodeCharCodeAt(node, remainder - 1);
+                    if (tailOfLeft === 13 /** \r */) {
+                        const previousPos = this.positionInBuffer(node, remainder - 1);
+                        this.deleteNodeTail(node, previousPos);
+                        value = '\r' + value;
+                        if (node.piece.length === 0) {
+                            nodesToDel.push(node);
+                        }
+                    }
+                    else {
+                        this.deleteNodeTail(node, insertPosInBuffer);
+                    }
+                }
+                else {
+                    this.deleteNodeTail(node, insertPosInBuffer);
+                }
+                const newPieces = this.createNewPieces(value);
+                if (newRightPiece.length > 0) {
+                    this.rbInsertRight(node, newRightPiece);
+                }
+                let tmpNode = node;
+                for (let k = 0; k < newPieces.length; k++) {
+                    tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);
+                }
+                this.deleteNodes(nodesToDel);
+            }
+            else {
+                this.insertContentToNodeRight(value, node);
+            }
+        }
+        else {
+            // insert new node
+            const pieces = this.createNewPieces(value);
+            let node = this.rbInsertLeft(null, pieces[0]);
+            for (let k = 1; k < pieces.length; k++) {
+                node = this.rbInsertRight(node, pieces[k]);
+            }
+        }
+        // todo, this is too brutal. Total line feed count should be updated the same way as lf_left.
+        this.computeBufferMetadata();
+    }
+    delete(offset, cnt) {
+        this._lastVisitedLine.lineNumber = 0;
+        this._lastVisitedLine.value = '';
+        if (cnt <= 0 || this.root === SENTINEL) {
+            return;
+        }
+        const startPosition = this.nodeAt(offset);
+        const endPosition = this.nodeAt(offset + cnt);
+        const startNode = startPosition.node;
+        const endNode = endPosition.node;
+        if (startNode === endNode) {
+            const startSplitPosInBuffer = this.positionInBuffer(startNode, startPosition.remainder);
+            const endSplitPosInBuffer = this.positionInBuffer(startNode, endPosition.remainder);
+            if (startPosition.nodeStartOffset === offset) {
+                if (cnt === startNode.piece.length) { // delete node
+                    const next = startNode.next();
+                    rbDelete(this, startNode);
+                    this.validateCRLFWithPrevNode(next);
+                    this.computeBufferMetadata();
+                    return;
+                }
+                this.deleteNodeHead(startNode, endSplitPosInBuffer);
+                this._searchCache.validate(offset);
+                this.validateCRLFWithPrevNode(startNode);
+                this.computeBufferMetadata();
+                return;
+            }
+            if (startPosition.nodeStartOffset + startNode.piece.length === offset + cnt) {
+                this.deleteNodeTail(startNode, startSplitPosInBuffer);
+                this.validateCRLFWithNextNode(startNode);
+                this.computeBufferMetadata();
+                return;
+            }
+            // delete content in the middle, this node will be splitted to nodes
+            this.shrinkNode(startNode, startSplitPosInBuffer, endSplitPosInBuffer);
+            this.computeBufferMetadata();
+            return;
+        }
+        const nodesToDel = [];
+        const startSplitPosInBuffer = this.positionInBuffer(startNode, startPosition.remainder);
+        this.deleteNodeTail(startNode, startSplitPosInBuffer);
+        this._searchCache.validate(offset);
+        if (startNode.piece.length === 0) {
+            nodesToDel.push(startNode);
+        }
+        // update last touched node
+        const endSplitPosInBuffer = this.positionInBuffer(endNode, endPosition.remainder);
+        this.deleteNodeHead(endNode, endSplitPosInBuffer);
+        if (endNode.piece.length === 0) {
+            nodesToDel.push(endNode);
+        }
+        // delete nodes in between
+        const secondNode = startNode.next();
+        for (let node = secondNode; node !== SENTINEL && node !== endNode; node = node.next()) {
+            nodesToDel.push(node);
+        }
+        const prev = startNode.piece.length === 0 ? startNode.prev() : startNode;
+        this.deleteNodes(nodesToDel);
+        this.validateCRLFWithNextNode(prev);
+        this.computeBufferMetadata();
+    }
+    insertContentToNodeLeft(value, node) {
+        // we are inserting content to the beginning of node
+        const nodesToDel = [];
+        if (this.shouldCheckCRLF() && this.endWithCR(value) && this.startWithLF(node)) {
+            // move `\n` to new node.
+            const piece = node.piece;
+            const newStart = { line: piece.start.line + 1, column: 0 };
+            const nPiece = new Piece(piece.bufferIndex, newStart, piece.end, this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end), piece.length - 1);
+            node.piece = nPiece;
+            value += '\n';
+            updateTreeMetadata(this, node, -1, -1);
+            if (node.piece.length === 0) {
+                nodesToDel.push(node);
+            }
+        }
+        const newPieces = this.createNewPieces(value);
+        let newNode = this.rbInsertLeft(node, newPieces[newPieces.length - 1]);
+        for (let k = newPieces.length - 2; k >= 0; k--) {
+            newNode = this.rbInsertLeft(newNode, newPieces[k]);
+        }
+        this.validateCRLFWithPrevNode(newNode);
+        this.deleteNodes(nodesToDel);
+    }
+    insertContentToNodeRight(value, node) {
+        // we are inserting to the right of this node.
+        if (this.adjustCarriageReturnFromNext(value, node)) {
+            // move \n to the new node.
+            value += '\n';
+        }
+        const newPieces = this.createNewPieces(value);
+        const newNode = this.rbInsertRight(node, newPieces[0]);
+        let tmpNode = newNode;
+        for (let k = 1; k < newPieces.length; k++) {
+            tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);
+        }
+        this.validateCRLFWithPrevNode(newNode);
+    }
+    positionInBuffer(node, remainder, ret) {
+        const piece = node.piece;
+        const bufferIndex = node.piece.bufferIndex;
+        const lineStarts = this._buffers[bufferIndex].lineStarts;
+        const startOffset = lineStarts[piece.start.line] + piece.start.column;
+        const offset = startOffset + remainder;
+        // binary search offset between startOffset and endOffset
+        let low = piece.start.line;
+        let high = piece.end.line;
+        let mid = 0;
+        let midStop = 0;
+        let midStart = 0;
+        while (low <= high) {
+            mid = low + ((high - low) / 2) | 0;
+            midStart = lineStarts[mid];
+            if (mid === high) {
+                break;
+            }
+            midStop = lineStarts[mid + 1];
+            if (offset < midStart) {
+                high = mid - 1;
+            }
+            else if (offset >= midStop) {
+                low = mid + 1;
+            }
+            else {
+                break;
+            }
+        }
+        if (ret) {
+            ret.line = mid;
+            ret.column = offset - midStart;
+            return null;
+        }
+        return {
+            line: mid,
+            column: offset - midStart
+        };
+    }
+    getLineFeedCnt(bufferIndex, start, end) {
+        // we don't need to worry about start: abc\r|\n, or abc|\r, or abc|\n, or abc|\r\n doesn't change the fact that, there is one line break after start.
+        // now let's take care of end: abc\r|\n, if end is in between \r and \n, we need to add line feed count by 1
+        if (end.column === 0) {
+            return end.line - start.line;
+        }
+        const lineStarts = this._buffers[bufferIndex].lineStarts;
+        if (end.line === lineStarts.length - 1) { // it means, there is no \n after end, otherwise, there will be one more lineStart.
+            return end.line - start.line;
+        }
+        const nextLineStartOffset = lineStarts[end.line + 1];
+        const endOffset = lineStarts[end.line] + end.column;
+        if (nextLineStartOffset > endOffset + 1) { // there are more than 1 character after end, which means it can't be \n
+            return end.line - start.line;
+        }
+        // endOffset + 1 === nextLineStartOffset
+        // character at endOffset is \n, so we check the character before first
+        // if character at endOffset is \r, end.column is 0 and we can't get here.
+        const previousCharOffset = endOffset - 1; // end.column > 0 so it's okay.
+        const buffer = this._buffers[bufferIndex].buffer;
+        if (buffer.charCodeAt(previousCharOffset) === 13) {
+            return end.line - start.line + 1;
+        }
+        else {
+            return end.line - start.line;
+        }
+    }
+    offsetInBuffer(bufferIndex, cursor) {
+        const lineStarts = this._buffers[bufferIndex].lineStarts;
+        return lineStarts[cursor.line] + cursor.column;
+    }
+    deleteNodes(nodes) {
+        for (let i = 0; i < nodes.length; i++) {
+            rbDelete(this, nodes[i]);
+        }
+    }
+    createNewPieces(text) {
+        if (text.length > AverageBufferSize) {
+            // the content is large, operations like substring, charCode becomes slow
+            // so here we split it into smaller chunks, just like what we did for CR/LF normalization
+            const newPieces = [];
+            while (text.length > AverageBufferSize) {
+                const lastChar = text.charCodeAt(AverageBufferSize - 1);
+                let splitText;
+                if (lastChar === 13 /* CharCode.CarriageReturn */ || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
+                    // last character is \r or a high surrogate => keep it back
+                    splitText = text.substring(0, AverageBufferSize - 1);
+                    text = text.substring(AverageBufferSize - 1);
+                }
+                else {
+                    splitText = text.substring(0, AverageBufferSize);
+                    text = text.substring(AverageBufferSize);
+                }
+                const lineStarts = createLineStartsFast(splitText);
+                newPieces.push(new Piece(this._buffers.length, /* buffer index */ { line: 0, column: 0 }, { line: lineStarts.length - 1, column: splitText.length - lineStarts[lineStarts.length - 1] }, lineStarts.length - 1, splitText.length));
+                this._buffers.push(new StringBuffer(splitText, lineStarts));
+            }
+            const lineStarts = createLineStartsFast(text);
+            newPieces.push(new Piece(this._buffers.length, /* buffer index */ { line: 0, column: 0 }, { line: lineStarts.length - 1, column: text.length - lineStarts[lineStarts.length - 1] }, lineStarts.length - 1, text.length));
+            this._buffers.push(new StringBuffer(text, lineStarts));
+            return newPieces;
+        }
+        let startOffset = this._buffers[0].buffer.length;
+        const lineStarts = createLineStartsFast(text, false);
+        let start = this._lastChangeBufferPos;
+        if (this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 1] === startOffset
+            && startOffset !== 0
+            && this.startWithLF(text)
+            && this.endWithCR(this._buffers[0].buffer) // todo, we can check this._lastChangeBufferPos's column as it's the last one
+        ) {
+            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line, column: this._lastChangeBufferPos.column + 1 };
+            start = this._lastChangeBufferPos;
+            for (let i = 0; i < lineStarts.length; i++) {
+                lineStarts[i] += startOffset + 1;
+            }
+            this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));
+            this._buffers[0].buffer += '_' + text;
+            startOffset += 1;
+        }
+        else {
+            if (startOffset !== 0) {
+                for (let i = 0; i < lineStarts.length; i++) {
+                    lineStarts[i] += startOffset;
+                }
+            }
+            this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));
+            this._buffers[0].buffer += text;
+        }
+        const endOffset = this._buffers[0].buffer.length;
+        const endIndex = this._buffers[0].lineStarts.length - 1;
+        const endColumn = endOffset - this._buffers[0].lineStarts[endIndex];
+        const endPos = { line: endIndex, column: endColumn };
+        const newPiece = new Piece(0, /** todo@peng */ start, endPos, this.getLineFeedCnt(0, start, endPos), endOffset - startOffset);
+        this._lastChangeBufferPos = endPos;
+        return [newPiece];
+    }
+    getLineRawContent(lineNumber, endOffset = 0) {
+        let x = this.root;
+        let ret = '';
+        const cache = this._searchCache.get2(lineNumber);
+        if (cache) {
+            x = cache.node;
+            const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber - 1);
+            const buffer = this._buffers[x.piece.bufferIndex].buffer;
+            const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+            if (cache.nodeStartLineNumber + x.piece.lineFeedCnt === lineNumber) {
+                ret = buffer.substring(startOffset + prevAccumulatedValue, startOffset + x.piece.length);
+            }
+            else {
+                const accumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber);
+                return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);
+            }
+        }
+        else {
+            let nodeStartOffset = 0;
+            const originalLineNumber = lineNumber;
+            while (x !== SENTINEL) {
+                if (x.left !== SENTINEL && x.lf_left >= lineNumber - 1) {
+                    x = x.left;
+                }
+                else if (x.lf_left + x.piece.lineFeedCnt > lineNumber - 1) {
+                    const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                    const accumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 1);
+                    const buffer = this._buffers[x.piece.bufferIndex].buffer;
+                    const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                    nodeStartOffset += x.size_left;
+                    this._searchCache.set({
+                        node: x,
+                        nodeStartOffset,
+                        nodeStartLineNumber: originalLineNumber - (lineNumber - 1 - x.lf_left)
+                    });
+                    return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);
+                }
+                else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {
+                    const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                    const buffer = this._buffers[x.piece.bufferIndex].buffer;
+                    const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                    ret = buffer.substring(startOffset + prevAccumulatedValue, startOffset + x.piece.length);
+                    break;
+                }
+                else {
+                    lineNumber -= x.lf_left + x.piece.lineFeedCnt;
+                    nodeStartOffset += x.size_left + x.piece.length;
+                    x = x.right;
+                }
+            }
+        }
+        // search in order, to find the node contains end column
+        x = x.next();
+        while (x !== SENTINEL) {
+            const buffer = this._buffers[x.piece.bufferIndex].buffer;
+            if (x.piece.lineFeedCnt > 0) {
+                const accumulatedValue = this.getAccumulatedValue(x, 0);
+                const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                ret += buffer.substring(startOffset, startOffset + accumulatedValue - endOffset);
+                return ret;
+            }
+            else {
+                const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                ret += buffer.substr(startOffset, x.piece.length);
+            }
+            x = x.next();
+        }
+        return ret;
+    }
+    computeBufferMetadata() {
+        let x = this.root;
+        let lfCnt = 1;
+        let len = 0;
+        while (x !== SENTINEL) {
+            lfCnt += x.lf_left + x.piece.lineFeedCnt;
+            len += x.size_left + x.piece.length;
+            x = x.right;
+        }
+        this._lineCnt = lfCnt;
+        this._length = len;
+        this._searchCache.validate(this._length);
+    }
+    // #region node operations
+    getIndexOf(node, accumulatedValue) {
+        const piece = node.piece;
+        const pos = this.positionInBuffer(node, accumulatedValue);
+        const lineCnt = pos.line - piece.start.line;
+        if (this.offsetInBuffer(piece.bufferIndex, piece.end) - this.offsetInBuffer(piece.bufferIndex, piece.start) === accumulatedValue) {
+            // we are checking the end of this node, so a CRLF check is necessary.
+            const realLineCnt = this.getLineFeedCnt(node.piece.bufferIndex, piece.start, pos);
+            if (realLineCnt !== lineCnt) {
+                // aha yes, CRLF
+                return { index: realLineCnt, remainder: 0 };
+            }
+        }
+        return { index: lineCnt, remainder: pos.column };
+    }
+    getAccumulatedValue(node, index) {
+        if (index < 0) {
+            return 0;
+        }
+        const piece = node.piece;
+        const lineStarts = this._buffers[piece.bufferIndex].lineStarts;
+        const expectedLineStartIndex = piece.start.line + index + 1;
+        if (expectedLineStartIndex > piece.end.line) {
+            return lineStarts[piece.end.line] + piece.end.column - lineStarts[piece.start.line] - piece.start.column;
+        }
+        else {
+            return lineStarts[expectedLineStartIndex] - lineStarts[piece.start.line] - piece.start.column;
+        }
+    }
+    deleteNodeTail(node, pos) {
+        const piece = node.piece;
+        const originalLFCnt = piece.lineFeedCnt;
+        const originalEndOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);
+        const newEnd = pos;
+        const newEndOffset = this.offsetInBuffer(piece.bufferIndex, newEnd);
+        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, piece.start, newEnd);
+        const lf_delta = newLineFeedCnt - originalLFCnt;
+        const size_delta = newEndOffset - originalEndOffset;
+        const newLength = piece.length + size_delta;
+        node.piece = new Piece(piece.bufferIndex, piece.start, newEnd, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, node, size_delta, lf_delta);
+    }
+    deleteNodeHead(node, pos) {
+        const piece = node.piece;
+        const originalLFCnt = piece.lineFeedCnt;
+        const originalStartOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);
+        const newStart = pos;
+        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end);
+        const newStartOffset = this.offsetInBuffer(piece.bufferIndex, newStart);
+        const lf_delta = newLineFeedCnt - originalLFCnt;
+        const size_delta = originalStartOffset - newStartOffset;
+        const newLength = piece.length + size_delta;
+        node.piece = new Piece(piece.bufferIndex, newStart, piece.end, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, node, size_delta, lf_delta);
+    }
+    shrinkNode(node, start, end) {
+        const piece = node.piece;
+        const originalStartPos = piece.start;
+        const originalEndPos = piece.end;
+        // old piece, originalStartPos, start
+        const oldLength = piece.length;
+        const oldLFCnt = piece.lineFeedCnt;
+        const newEnd = start;
+        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, piece.start, newEnd);
+        const newLength = this.offsetInBuffer(piece.bufferIndex, start) - this.offsetInBuffer(piece.bufferIndex, originalStartPos);
+        node.piece = new Piece(piece.bufferIndex, piece.start, newEnd, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, node, newLength - oldLength, newLineFeedCnt - oldLFCnt);
+        // new right piece, end, originalEndPos
+        const newPiece = new Piece(piece.bufferIndex, end, originalEndPos, this.getLineFeedCnt(piece.bufferIndex, end, originalEndPos), this.offsetInBuffer(piece.bufferIndex, originalEndPos) - this.offsetInBuffer(piece.bufferIndex, end));
+        const newNode = this.rbInsertRight(node, newPiece);
+        this.validateCRLFWithPrevNode(newNode);
+    }
+    appendToNode(node, value) {
+        if (this.adjustCarriageReturnFromNext(value, node)) {
+            value += '\n';
+        }
+        const hitCRLF = this.shouldCheckCRLF() && this.startWithLF(value) && this.endWithCR(node);
+        const startOffset = this._buffers[0].buffer.length;
+        this._buffers[0].buffer += value;
+        const lineStarts = createLineStartsFast(value, false);
+        for (let i = 0; i < lineStarts.length; i++) {
+            lineStarts[i] += startOffset;
+        }
+        if (hitCRLF) {
+            const prevStartOffset = this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 2];
+            this._buffers[0].lineStarts.pop();
+            // _lastChangeBufferPos is already wrong
+            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line - 1, column: startOffset - prevStartOffset };
+        }
+        this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));
+        const endIndex = this._buffers[0].lineStarts.length - 1;
+        const endColumn = this._buffers[0].buffer.length - this._buffers[0].lineStarts[endIndex];
+        const newEnd = { line: endIndex, column: endColumn };
+        const newLength = node.piece.length + value.length;
+        const oldLineFeedCnt = node.piece.lineFeedCnt;
+        const newLineFeedCnt = this.getLineFeedCnt(0, node.piece.start, newEnd);
+        const lf_delta = newLineFeedCnt - oldLineFeedCnt;
+        node.piece = new Piece(node.piece.bufferIndex, node.piece.start, newEnd, newLineFeedCnt, newLength);
+        this._lastChangeBufferPos = newEnd;
+        updateTreeMetadata(this, node, value.length, lf_delta);
+    }
+    nodeAt(offset) {
+        let x = this.root;
+        const cache = this._searchCache.get(offset);
+        if (cache) {
+            return {
+                node: cache.node,
+                nodeStartOffset: cache.nodeStartOffset,
+                remainder: offset - cache.nodeStartOffset
+            };
+        }
+        let nodeStartOffset = 0;
+        while (x !== SENTINEL) {
+            if (x.size_left > offset) {
+                x = x.left;
+            }
+            else if (x.size_left + x.piece.length >= offset) {
+                nodeStartOffset += x.size_left;
+                const ret = {
+                    node: x,
+                    remainder: offset - x.size_left,
+                    nodeStartOffset
+                };
+                this._searchCache.set(ret);
+                return ret;
+            }
+            else {
+                offset -= x.size_left + x.piece.length;
+                nodeStartOffset += x.size_left + x.piece.length;
+                x = x.right;
+            }
+        }
+        return null;
+    }
+    nodeAt2(lineNumber, column) {
+        let x = this.root;
+        let nodeStartOffset = 0;
+        while (x !== SENTINEL) {
+            if (x.left !== SENTINEL && x.lf_left >= lineNumber - 1) {
+                x = x.left;
+            }
+            else if (x.lf_left + x.piece.lineFeedCnt > lineNumber - 1) {
+                const prevAccumualtedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                const accumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 1);
+                nodeStartOffset += x.size_left;
+                return {
+                    node: x,
+                    remainder: Math.min(prevAccumualtedValue + column - 1, accumulatedValue),
+                    nodeStartOffset
+                };
+            }
+            else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {
+                const prevAccumualtedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                if (prevAccumualtedValue + column - 1 <= x.piece.length) {
+                    return {
+                        node: x,
+                        remainder: prevAccumualtedValue + column - 1,
+                        nodeStartOffset
+                    };
+                }
+                else {
+                    column -= x.piece.length - prevAccumualtedValue;
+                    break;
+                }
+            }
+            else {
+                lineNumber -= x.lf_left + x.piece.lineFeedCnt;
+                nodeStartOffset += x.size_left + x.piece.length;
+                x = x.right;
+            }
+        }
+        // search in order, to find the node contains position.column
+        x = x.next();
+        while (x !== SENTINEL) {
+            if (x.piece.lineFeedCnt > 0) {
+                const accumulatedValue = this.getAccumulatedValue(x, 0);
+                const nodeStartOffset = this.offsetOfNode(x);
+                return {
+                    node: x,
+                    remainder: Math.min(column - 1, accumulatedValue),
+                    nodeStartOffset
+                };
+            }
+            else {
+                if (x.piece.length >= column - 1) {
+                    const nodeStartOffset = this.offsetOfNode(x);
+                    return {
+                        node: x,
+                        remainder: column - 1,
+                        nodeStartOffset
+                    };
+                }
+                else {
+                    column -= x.piece.length;
+                }
+            }
+            x = x.next();
+        }
+        return null;
+    }
+    nodeCharCodeAt(node, offset) {
+        if (node.piece.lineFeedCnt < 1) {
+            return -1;
+        }
+        const buffer = this._buffers[node.piece.bufferIndex];
+        const newOffset = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start) + offset;
+        return buffer.buffer.charCodeAt(newOffset);
+    }
+    offsetOfNode(node) {
+        if (!node) {
+            return 0;
+        }
+        let pos = node.size_left;
+        while (node !== this.root) {
+            if (node.parent.right === node) {
+                pos += node.parent.size_left + node.parent.piece.length;
+            }
+            node = node.parent;
+        }
+        return pos;
+    }
+    // #endregion
+    // #region CRLF
+    shouldCheckCRLF() {
+        return !(this._EOLNormalized && this._EOL === '\n');
+    }
+    startWithLF(val) {
+        if (typeof val === 'string') {
+            return val.charCodeAt(0) === 10;
+        }
+        if (val === SENTINEL || val.piece.lineFeedCnt === 0) {
+            return false;
+        }
+        const piece = val.piece;
+        const lineStarts = this._buffers[piece.bufferIndex].lineStarts;
+        const line = piece.start.line;
+        const startOffset = lineStarts[line] + piece.start.column;
+        if (line === lineStarts.length - 1) {
+            // last line, so there is no line feed at the end of this line
+            return false;
+        }
+        const nextLineOffset = lineStarts[line + 1];
+        if (nextLineOffset > startOffset + 1) {
+            return false;
+        }
+        return this._buffers[piece.bufferIndex].buffer.charCodeAt(startOffset) === 10;
+    }
+    endWithCR(val) {
+        if (typeof val === 'string') {
+            return val.charCodeAt(val.length - 1) === 13;
+        }
+        if (val === SENTINEL || val.piece.lineFeedCnt === 0) {
+            return false;
+        }
+        return this.nodeCharCodeAt(val, val.piece.length - 1) === 13;
+    }
+    validateCRLFWithPrevNode(nextNode) {
+        if (this.shouldCheckCRLF() && this.startWithLF(nextNode)) {
+            const node = nextNode.prev();
+            if (this.endWithCR(node)) {
+                this.fixCRLF(node, nextNode);
+            }
+        }
+    }
+    validateCRLFWithNextNode(node) {
+        if (this.shouldCheckCRLF() && this.endWithCR(node)) {
+            const nextNode = node.next();
+            if (this.startWithLF(nextNode)) {
+                this.fixCRLF(node, nextNode);
+            }
+        }
+    }
+    fixCRLF(prev, next) {
+        const nodesToDel = [];
+        // update node
+        const lineStarts = this._buffers[prev.piece.bufferIndex].lineStarts;
+        let newEnd;
+        if (prev.piece.end.column === 0) {
+            // it means, last line ends with \r, not \r\n
+            newEnd = { line: prev.piece.end.line - 1, column: lineStarts[prev.piece.end.line] - lineStarts[prev.piece.end.line - 1] - 1 };
+        }
+        else {
+            // \r\n
+            newEnd = { line: prev.piece.end.line, column: prev.piece.end.column - 1 };
+        }
+        const prevNewLength = prev.piece.length - 1;
+        const prevNewLFCnt = prev.piece.lineFeedCnt - 1;
+        prev.piece = new Piece(prev.piece.bufferIndex, prev.piece.start, newEnd, prevNewLFCnt, prevNewLength);
+        updateTreeMetadata(this, prev, -1, -1);
+        if (prev.piece.length === 0) {
+            nodesToDel.push(prev);
+        }
+        // update nextNode
+        const newStart = { line: next.piece.start.line + 1, column: 0 };
+        const newLength = next.piece.length - 1;
+        const newLineFeedCnt = this.getLineFeedCnt(next.piece.bufferIndex, newStart, next.piece.end);
+        next.piece = new Piece(next.piece.bufferIndex, newStart, next.piece.end, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, next, -1, -1);
+        if (next.piece.length === 0) {
+            nodesToDel.push(next);
+        }
+        // create new piece which contains \r\n
+        const pieces = this.createNewPieces('\r\n');
+        this.rbInsertRight(prev, pieces[0]);
+        // delete empty nodes
+        for (let i = 0; i < nodesToDel.length; i++) {
+            rbDelete(this, nodesToDel[i]);
+        }
+    }
+    adjustCarriageReturnFromNext(value, node) {
+        if (this.shouldCheckCRLF() && this.endWithCR(value)) {
+            const nextNode = node.next();
+            if (this.startWithLF(nextNode)) {
+                // move `\n` forward
+                value += '\n';
+                if (nextNode.piece.length === 1) {
+                    rbDelete(this, nextNode);
+                }
+                else {
+                    const piece = nextNode.piece;
+                    const newStart = { line: piece.start.line + 1, column: 0 };
+                    const newLength = piece.length - 1;
+                    const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end);
+                    nextNode.piece = new Piece(piece.bufferIndex, newStart, piece.end, newLineFeedCnt, newLength);
+                    updateTreeMetadata(this, nextNode, -1, -1);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    // #endregion
+    // #endregion
+    // #region Tree operations
+    iterate(node, callback) {
+        if (node === SENTINEL) {
+            return callback(SENTINEL);
+        }
+        const leftRet = this.iterate(node.left, callback);
+        if (!leftRet) {
+            return leftRet;
+        }
+        return callback(node) && this.iterate(node.right, callback);
+    }
+    getNodeContent(node) {
+        if (node === SENTINEL) {
+            return '';
+        }
+        const buffer = this._buffers[node.piece.bufferIndex];
+        const piece = node.piece;
+        const startOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);
+        const endOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);
+        const currentContent = buffer.buffer.substring(startOffset, endOffset);
+        return currentContent;
+    }
+    getPieceContent(piece) {
+        const buffer = this._buffers[piece.bufferIndex];
+        const startOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);
+        const endOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);
+        const currentContent = buffer.buffer.substring(startOffset, endOffset);
+        return currentContent;
+    }
+    /**
+     *      node              node
+     *     /  \              /  \
+     *    a   b    <----   a    b
+     *                         /
+     *                        z
+     */
+    rbInsertRight(node, p) {
+        const z = new TreeNode(p, 1 /* NodeColor.Red */);
+        z.left = SENTINEL;
+        z.right = SENTINEL;
+        z.parent = SENTINEL;
+        z.size_left = 0;
+        z.lf_left = 0;
+        const x = this.root;
+        if (x === SENTINEL) {
+            this.root = z;
+            z.color = 0 /* NodeColor.Black */;
+        }
+        else if (node.right === SENTINEL) {
+            node.right = z;
+            z.parent = node;
+        }
+        else {
+            const nextNode = leftest(node.right);
+            nextNode.left = z;
+            z.parent = nextNode;
+        }
+        fixInsert(this, z);
+        return z;
+    }
+    /**
+     *      node              node
+     *     /  \              /  \
+     *    a   b     ---->   a    b
+     *                       \
+     *                        z
+     */
+    rbInsertLeft(node, p) {
+        const z = new TreeNode(p, 1 /* NodeColor.Red */);
+        z.left = SENTINEL;
+        z.right = SENTINEL;
+        z.parent = SENTINEL;
+        z.size_left = 0;
+        z.lf_left = 0;
+        if (this.root === SENTINEL) {
+            this.root = z;
+            z.color = 0 /* NodeColor.Black */;
+        }
+        else if (node.left === SENTINEL) {
+            node.left = z;
+            z.parent = node;
+        }
+        else {
+            const prevNode = righttest(node.left); // a
+            prevNode.right = z;
+            z.parent = prevNode;
+        }
+        fixInsert(this, z);
+        return z;
+    }
+}