@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeBase.js

@@ -11,8 +11,7 @@ function createUintArray(arr) {
     let r;
     if (arr[arr.length - 1] < 65536) {
         r = ( new Uint16Array(arr.length));
-    }
-    else {
+    } else {
         r = ( new Uint32Array(arr.length));
     }
     r.set(arr, 0);
@@ -36,19 +35,16 @@ function createLineStartsFast(str, readonly = true) {
             if (i + 1 < len && str.charCodeAt(i + 1) === CharCode.LineFeed) {
                 r[rLength++] = i + 2;
                 i++;
-            }
-            else {
+            } else {
                 r[rLength++] = i + 1;
             }
-        }
-        else if (chr === CharCode.LineFeed) {
+        } else if (chr === CharCode.LineFeed) {
             r[rLength++] = i + 1;
         }
     }
     if (readonly) {
         return createUintArray(r);
-    }
-    else {
+    } else {
         return r;
     }
 }
@@ -65,17 +61,14 @@ function createLineStarts(r, str) {
                 crlf++;
                 r[rLength++] = i + 2;
                 i++;
-            }
-            else {
+            } else {
                 cr++;
                 r[rLength++] = i + 1;
             }
-        }
-        else if (chr === CharCode.LineFeed) {
+        } else if (chr === CharCode.LineFeed) {
             lf++;
             r[rLength++] = i + 1;
-        }
-        else {
+        } else {
             if (isBasicASCII) {
                 if (chr !== CharCode.Tab && (chr < 32 || chr > 126)) {
                     isBasicASCII = false;
@@ -122,8 +115,7 @@ class PieceTreeSnapshot {
             if (this._index === 0) {
                 this._index++;
                 return this._BOM;
-            }
-            else {
+            } else {
                 return null;
             }
         }
@@ -192,10 +184,11 @@ class PieceTreeBase {
         this.create(chunks, eol, eolNormalized);
     }
     create(chunks, eol, eolNormalized) {
-        this._buffers = [
-            ( new StringBuffer('', [0]))
-        ];
-        this._lastChangeBufferPos = { line: 0, column: 0 };
+        this._buffers = [( new StringBuffer("", [0]))];
+        this._lastChangeBufferPos = {
+            line: 0,
+            column: 0
+        };
         this.root = SENTINEL;
         this._lineCnt = 1;
         this._length = 0;
@@ -208,26 +201,29 @@ class PieceTreeBase {
                 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
-                ));
+                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._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 tempChunk = "";
         let tempChunkLen = 0;
         const chunks = [];
         this.iterate(this.root, node => {
@@ -289,13 +285,11 @@ class PieceTreeBase {
         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) {
+            } else if (x.lf_left + x.piece.lineFeedCnt + 1 >= lineNumber) {
                 leftLen += x.size_left;
                 const accumualtedValInCurrentIndex = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
                 return leftLen += accumualtedValInCurrentIndex + column - 1;
-            }
-            else {
+            } else {
                 lineNumber -= x.lf_left + x.piece.lineFeedCnt;
                 leftLen += x.size_left + x.piece.length;
                 x = x.right;
@@ -312,8 +306,7 @@ class PieceTreeBase {
         while (x !== SENTINEL) {
             if (x.size_left !== 0 && x.size_left >= offset) {
                 x = x.left;
-            }
-            else if (x.size_left + x.piece.length >= offset) {
+            } 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) {
@@ -322,16 +315,14 @@ class PieceTreeBase {
                     return ( new Position(lfCnt + 1, column + 1));
                 }
                 return ( new Position(lfCnt + 1, out.remainder + 1));
-            }
-            else {
+            } else {
                 offset -= x.size_left + x.piece.length;
                 lfCnt += x.lf_left + x.piece.lineFeedCnt;
                 if (x.right === SENTINEL) {
                     const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);
                     const column = originalOffset - offset - lineStartOffset;
                     return ( new Position(lfCnt + 1, column + 1));
-                }
-                else {
+                } else {
                     x = x.right;
                 }
             }
@@ -340,7 +331,7 @@ class PieceTreeBase {
     }
     getValueInRange(range, eol) {
         if (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn) {
-            return '';
+            return "";
         }
         const startPosition = this.nodeAt2(range.startLineNumber, range.startColumn);
         const endPosition = this.nodeAt2(range.endLineNumber, range.endColumn);
@@ -374,8 +365,7 @@ class PieceTreeBase {
             if (x === endPosition.node) {
                 ret += buffer.substring(startOffset, startOffset + endPosition.remainder);
                 break;
-            }
-            else {
+            } else {
                 ret += buffer.substr(startOffset, x.piece.length);
             }
             x = x.next();
@@ -385,7 +375,7 @@ class PieceTreeBase {
     getLinesContent() {
         const lines = [];
         let linesLength = 0;
-        let currentLine = '';
+        let currentLine = "";
         let danglingCR = false;
         this.iterate(this.root, node => {
             if (node === SENTINEL) {
@@ -407,7 +397,7 @@ class PieceTreeBase {
                     pieceLength--;
                 }
                 lines[linesLength++] = currentLine;
-                currentLine = '';
+                currentLine = "";
                 danglingCR = false;
                 if (pieceLength === 0) {
                     return true;
@@ -417,39 +407,35 @@ class PieceTreeBase {
                 if (!this._EOLNormalized && buffer.charCodeAt(pieceStartOffset + pieceLength - 1) === CharCode.CarriageReturn) {
                     danglingCR = true;
                     currentLine += buffer.substr(pieceStartOffset, pieceLength - 1);
-                }
-                else {
+                } else {
                     currentLine += buffer.substr(pieceStartOffset, pieceLength);
                 }
                 return true;
             }
-            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)$/, ''));
+            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)$/, ''));
+                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) === CharCode.CarriageReturn) {
                 danglingCR = true;
                 if (piece.end.column === 0) {
                     linesLength--;
-                }
-                else {
+                } else {
                     currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column - 1);
                 }
-            }
-            else {
+            } else {
                 currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column);
             }
             return true;
         });
         if (danglingCR) {
             lines[linesLength++] = currentLine;
-            currentLine = '';
+            currentLine = "";
         }
         lines[linesLength++] = currentLine;
         return lines;
@@ -467,12 +453,10 @@ class PieceTreeBase {
         this._lastVisitedLine.lineNumber = lineNumber;
         if (lineNumber === this._lineCnt) {
             this._lastVisitedLine.value = this.getLineRawContent(lineNumber);
-        }
-        else if (this._EOLNormalized) {
+        } else if (this._EOLNormalized) {
             this._lastVisitedLine.value = this.getLineRawContent(lineNumber, this._EOLLength);
-        }
-        else {
-            this._lastVisitedLine.value = this.getLineRawContent(lineNumber).replace(/(\r\n|\r|\n)$/, '');
+        } else {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber).replace(/(\r\n|\r|\n)$/, "");
         }
         return this._lastVisitedLine.value;
     }
@@ -485,8 +469,7 @@ class PieceTreeBase {
             const buffer = this._buffers[matchingNode.piece.bufferIndex];
             const startOffset = this.offsetInBuffer(matchingNode.piece.bufferIndex, matchingNode.piece.start);
             return buffer.buffer.charCodeAt(startOffset);
-        }
-        else {
+        } 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;
@@ -513,13 +496,12 @@ class PieceTreeBase {
         if (nodePos.remainder === nodePos.node.piece.length) {
             const matchingNode = nodePos.node.next();
             if (!matchingNode || matchingNode === SENTINEL) {
-                return '';
+                return "";
             }
             const buffer = this._buffers[matchingNode.piece.bufferIndex];
             const startOffset = this.offsetInBuffer(matchingNode.piece.bufferIndex, matchingNode.piece.start);
             return buffer.buffer.substring(startOffset, startOffset + matchingNode.piece.length);
-        }
-        else {
+        } 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;
@@ -527,23 +509,37 @@ class PieceTreeBase {
             return buffer.buffer.substring(targetOffset, targetEnd);
         }
     }
-    findMatchesInNode(node, searcher, startLineNumber, startColumn, startCursor, endCursor, searchData, captureMatches, limitResultCount, resultLen, result) {
+    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;
-        const ret = { line: 0, column: 0 };
+        const ret = {
+            line: 0,
+            column: 0
+        };
         let searchText;
         let offsetInBuffer;
         if (searcher._wordSeparators) {
             searchText = buffer.buffer.substring(start, end);
-            offsetInBuffer = (offset) => offset + start;
+            offsetInBuffer = offset => offset + start;
             searcher.reset(0);
-        }
-        else {
+        } else {
             searchText = buffer.buffer;
-            offsetInBuffer = (offset) => offset;
+            offsetInBuffer = offset => offset;
             searcher.reset(start);
         }
         do {
@@ -587,7 +583,19 @@ class PieceTreeBase {
         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);
+            this.findMatchesInNode(
+                startPosition.node,
+                searcher,
+                searchRange.startLineNumber,
+                searchRange.startColumn,
+                start,
+                end,
+                searchData,
+                captureMatches,
+                limitResultCount,
+                resultLen,
+                result
+            );
             return result;
         }
         let startLineNumber = searchRange.startLineNumber;
@@ -599,7 +607,19 @@ class PieceTreeBase {
                 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);
+                resultLen = this.findMatchesInNode(
+                    currentNode,
+                    searcher,
+                    startLineNumber,
+                    startColumn,
+                    start,
+                    this.positionInBuffer(currentNode, nextLineStartOffset - startOffsetInBuffer),
+                    searchData,
+                    captureMatches,
+                    limitResultCount,
+                    resultLen,
+                    result
+                );
                 if (resultLen >= limitResultCount) {
                     return result;
                 }
@@ -608,10 +628,30 @@ class PieceTreeBase {
             const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;
             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);
+                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);
+            resultLen = this._findMatchesInLine(
+                searchData,
+                searcher,
+                this.getLineContent(startLineNumber).substr(startColumn),
+                startLineNumber,
+                startColumn,
+                resultLen,
+                result,
+                captureMatches,
+                limitResultCount
+            );
             if (resultLen >= limitResultCount) {
                 return result;
             }
@@ -623,14 +663,46 @@ class PieceTreeBase {
         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);
+            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);
+        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) {
+    _findMatchesInLine(
+        searchData,
+        searcher,
+        text,
+        lineNumber,
+        deltaOffset,
+        resultLen,
+        result,
+        captureMatches,
+        limitResultCount
+    ) {
         const wordSeparators = searchData.wordSeparators;
         if (!captureMatches && searchData.simpleSearch) {
             const searchString = searchData.simpleSearch;
@@ -673,17 +745,17 @@ class PieceTreeBase {
     insert(offset, value, eolNormalized = false) {
         this._EOLNormalized = this._EOLNormalized && eolNormalized;
         this._lastVisitedLine.lineNumber = 0;
-        this._lastVisitedLine.value = '';
+        this._lastVisitedLine.value = "";
         if (this.root !== SENTINEL) {
-            const { node, remainder, nodeStartOffset } = this.nodeAt(offset);
+            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) {
+            if (node.piece.bufferIndex === 0 && piece.end.line === this._lastChangeBufferPos.line && piece.end.column === this._lastChangeBufferPos.column && (nodeStartOffset + piece.length === offset) && value.length < AverageBufferSize) {
                 this.appendToNode(node, value);
                 this.computeBufferMetadata();
                 return;
@@ -691,8 +763,7 @@ class PieceTreeBase {
             if (nodeStartOffset === offset) {
                 this.insertContentToNodeLeft(value, node);
                 this._searchCache.validate(offset);
-            }
-            else if (nodeStartOffset + node.piece.length > offset) {
+            } else if (nodeStartOffset + node.piece.length > offset) {
                 const nodesToDel = [];
                 let newRightPiece = ( new Piece(
                     piece.bufferIndex,
@@ -704,7 +775,10 @@ class PieceTreeBase {
                 if (this.shouldCheckCRLF() && this.endWithCR(value)) {
                     const headOfRight = this.nodeCharCodeAt(node, remainder);
                     if (headOfRight === 10 ) {
-                        const newStart = { line: newRightPiece.start.line + 1, column: 0 };
+                        const newStart = {
+                            line: newRightPiece.start.line + 1,
+                            column: 0
+                        };
                         newRightPiece = ( new Piece(
                             newRightPiece.bufferIndex,
                             newStart,
@@ -712,7 +786,7 @@ class PieceTreeBase {
                             this.getLineFeedCnt(newRightPiece.bufferIndex, newStart, newRightPiece.end),
                             newRightPiece.length - 1
                         ));
-                        value += '\n';
+                        value += "\n";
                     }
                 }
                 if (this.shouldCheckCRLF() && this.startWithLF(value)) {
@@ -720,16 +794,14 @@ class PieceTreeBase {
                     if (tailOfLeft === 13 ) {
                         const previousPos = this.positionInBuffer(node, remainder - 1);
                         this.deleteNodeTail(node, previousPos);
-                        value = '\r' + value;
+                        value = "\r" + value;
                         if (node.piece.length === 0) {
                             nodesToDel.push(node);
                         }
-                    }
-                    else {
+                    } else {
                         this.deleteNodeTail(node, insertPosInBuffer);
                     }
-                }
-                else {
+                } else {
                     this.deleteNodeTail(node, insertPosInBuffer);
                 }
                 const newPieces = this.createNewPieces(value);
@@ -741,12 +813,10 @@ class PieceTreeBase {
                     tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);
                 }
                 this.deleteNodes(nodesToDel);
-            }
-            else {
+            } else {
                 this.insertContentToNodeRight(value, node);
             }
-        }
-        else {
+        } else {
             const pieces = this.createNewPieces(value);
             let node = this.rbInsertLeft(null, pieces[0]);
             for (let k = 1; k < pieces.length; k++) {
@@ -757,7 +827,7 @@ class PieceTreeBase {
     }
     delete(offset, cnt) {
         this._lastVisitedLine.lineNumber = 0;
-        this._lastVisitedLine.value = '';
+        this._lastVisitedLine.value = "";
         if (cnt <= 0 || this.root === SENTINEL) {
             return;
         }
@@ -817,7 +887,10 @@ class PieceTreeBase {
         const nodesToDel = [];
         if (this.shouldCheckCRLF() && this.endWithCR(value) && this.startWithLF(node)) {
             const piece = node.piece;
-            const newStart = { line: piece.start.line + 1, column: 0 };
+            const newStart = {
+                line: piece.start.line + 1,
+                column: 0
+            };
             const nPiece = ( new Piece(
                 piece.bufferIndex,
                 newStart,
@@ -826,7 +899,7 @@ class PieceTreeBase {
                 piece.length - 1
             ));
             node.piece = nPiece;
-            value += '\n';
+            value += "\n";
             updateTreeMetadata(this, node, -1, -1);
             if (node.piece.length === 0) {
                 nodesToDel.push(node);
@@ -842,7 +915,7 @@ class PieceTreeBase {
     }
     insertContentToNodeRight(value, node) {
         if (this.adjustCarriageReturnFromNext(value, node)) {
-            value += '\n';
+            value += "\n";
         }
         const newPieces = this.createNewPieces(value);
         const newNode = this.rbInsertRight(node, newPieces[0]);
@@ -872,11 +945,9 @@ class PieceTreeBase {
             midStop = lineStarts[mid + 1];
             if (offset < midStart) {
                 high = mid - 1;
-            }
-            else if (offset >= midStop) {
+            } else if (offset >= midStop) {
                 low = mid + 1;
-            }
-            else {
+            } else {
                 break;
             }
         }
@@ -907,8 +978,7 @@ class PieceTreeBase {
         const buffer = this._buffers[bufferIndex].buffer;
         if (buffer.charCodeAt(previousCharOffset) === 13) {
             return end.line - start.line + 1;
-        }
-        else {
+        } else {
             return end.line - start.line;
         }
     }
@@ -930,50 +1000,48 @@ class PieceTreeBase {
                 if (lastChar === CharCode.CarriageReturn || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
                     splitText = text.substring(0, AverageBufferSize - 1);
                     text = text.substring(AverageBufferSize - 1);
-                }
-                else {
+                } else {
                     splitText = text.substring(0, AverageBufferSize);
                     text = text.substring(AverageBufferSize);
                 }
                 const lineStarts = createLineStartsFast(splitText);
-                newPieces.push(( new Piece(
-                    this._buffers.length,
-                     { line: 0, column: 0 },
-                    { line: lineStarts.length - 1, column: splitText.length - lineStarts[lineStarts.length - 1] },
-                    lineStarts.length - 1,
-                    splitText.length
-                )));
+                newPieces.push(( new Piece(this._buffers.length,  {
+                    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,
-                 { line: 0, column: 0 },
-                { line: lineStarts.length - 1, column: text.length - lineStarts[lineStarts.length - 1] },
-                lineStarts.length - 1,
-                text.length
-            )));
+            newPieces.push(( new Piece(this._buffers.length,  {
+                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)
-        ) {
-            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line, column: this._lastChangeBufferPos.column + 1 };
+        if (
+        this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 1] === startOffset && startOffset !== 0 && this.startWithLF(text) && this.endWithCR(this._buffers[0].buffer)) {
+            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;
+            this._buffers[0].buffer += "_" + text;
             startOffset += 1;
-        }
-        else {
+        } else {
             if (startOffset !== 0) {
                 for (let i = 0; i < lineStarts.length; i++) {
                     lineStarts[i] += startOffset;
@@ -985,7 +1053,10 @@ class PieceTreeBase {
         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 endPos = {
+            line: endIndex,
+            column: endColumn
+        };
         const newPiece = ( new Piece(
             0,
              start,
@@ -1001,7 +1072,7 @@ class PieceTreeBase {
     }
     getLineRawContent(lineNumber, endOffset = 0) {
         let x = this.root;
-        let ret = '';
+        let ret = "";
         const cache = this._searchCache.get2(lineNumber);
         if (cache) {
             x = cache.node;
@@ -1010,20 +1081,20 @@ class PieceTreeBase {
             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 {
+            } else {
                 const accumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber);
-                return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);
+                return buffer.substring(
+                    startOffset + prevAccumulatedValue,
+                    startOffset + accumulatedValue - endOffset
+                );
             }
-        }
-        else {
+        } 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) {
+                } 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;
@@ -1034,16 +1105,17 @@ class PieceTreeBase {
                         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) {
+                    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 {
+                } else {
                     lineNumber -= x.lf_left + x.piece.lineFeedCnt;
                     nodeStartOffset += x.size_left + x.piece.length;
                     x = x.right;
@@ -1058,8 +1130,7 @@ class PieceTreeBase {
                 const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
                 ret += buffer.substring(startOffset, startOffset + accumulatedValue - endOffset);
                 return ret;
-            }
-            else {
+            } else {
                 const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
                 ret += buffer.substr(startOffset, x.piece.length);
             }
@@ -1087,10 +1158,16 @@ class PieceTreeBase {
         if (this.offsetInBuffer(piece.bufferIndex, piece.end) - this.offsetInBuffer(piece.bufferIndex, piece.start) === accumulatedValue) {
             const realLineCnt = this.getLineFeedCnt(node.piece.bufferIndex, piece.start, pos);
             if (realLineCnt !== lineCnt) {
-                return { index: realLineCnt, remainder: 0 };
+                return {
+                    index: realLineCnt,
+                    remainder: 0
+                };
             }
         }
-        return { index: lineCnt, remainder: pos.column };
+        return {
+            index: lineCnt,
+            remainder: pos.column
+        };
     }
     getAccumulatedValue(node, index) {
         if (index < 0) {
@@ -1101,8 +1178,7 @@ class PieceTreeBase {
         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 {
+        } else {
             return lineStarts[expectedLineStartIndex] - lineStarts[piece.start.line] - piece.start.column;
         }
     }
@@ -1155,7 +1231,7 @@ class PieceTreeBase {
     }
     appendToNode(node, value) {
         if (this.adjustCarriageReturnFromNext(value, node)) {
-            value += '\n';
+            value += "\n";
         }
         const hitCRLF = this.shouldCheckCRLF() && this.startWithLF(value) && this.endWithCR(node);
         const startOffset = this._buffers[0].buffer.length;
@@ -1167,12 +1243,18 @@ class PieceTreeBase {
         if (hitCRLF) {
             const prevStartOffset = this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 2];
             this._buffers[0].lineStarts.pop();
-            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line - 1, column: startOffset - prevStartOffset };
+            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 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);
@@ -1201,8 +1283,7 @@ class PieceTreeBase {
         while (x !== SENTINEL) {
             if (x.size_left > offset) {
                 x = x.left;
-            }
-            else if (x.size_left + x.piece.length >= offset) {
+            } else if (x.size_left + x.piece.length >= offset) {
                 nodeStartOffset += x.size_left;
                 const ret = {
                     node: x,
@@ -1211,8 +1292,7 @@ class PieceTreeBase {
                 };
                 this._searchCache.set(ret);
                 return ret;
-            }
-            else {
+            } else {
                 offset -= x.size_left + x.piece.length;
                 nodeStartOffset += x.size_left + x.piece.length;
                 x = x.right;
@@ -1226,8 +1306,7 @@ class PieceTreeBase {
         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) {
+            } 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;
@@ -1236,8 +1315,7 @@ class PieceTreeBase {
                     remainder: Math.min(prevAccumualtedValue + column - 1, accumulatedValue),
                     nodeStartOffset
                 };
-            }
-            else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {
+            } 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 {
@@ -1245,13 +1323,11 @@ class PieceTreeBase {
                         remainder: prevAccumualtedValue + column - 1,
                         nodeStartOffset
                     };
-                }
-                else {
+                } else {
                     column -= x.piece.length - prevAccumualtedValue;
                     break;
                 }
-            }
-            else {
+            } else {
                 lineNumber -= x.lf_left + x.piece.lineFeedCnt;
                 nodeStartOffset += x.size_left + x.piece.length;
                 x = x.right;
@@ -1267,8 +1343,7 @@ class PieceTreeBase {
                     remainder: Math.min(column - 1, accumulatedValue),
                     nodeStartOffset
                 };
-            }
-            else {
+            } else {
                 if (x.piece.length >= column - 1) {
                     const nodeStartOffset = this.offsetOfNode(x);
                     return {
@@ -1276,8 +1351,7 @@ class PieceTreeBase {
                         remainder: column - 1,
                         nodeStartOffset
                     };
-                }
-                else {
+                } else {
                     column -= x.piece.length;
                 }
             }
@@ -1307,10 +1381,10 @@ class PieceTreeBase {
         return pos;
     }
     shouldCheckCRLF() {
-        return !(this._EOLNormalized && this._EOL === '\n');
+        return !(this._EOLNormalized && this._EOL === "\n");
     }
     startWithLF(val) {
-        if (typeof val === 'string') {
+        if (typeof val === "string") {
             return val.charCodeAt(0) === 10;
         }
         if (val === SENTINEL || val.piece.lineFeedCnt === 0) {
@@ -1330,7 +1404,7 @@ class PieceTreeBase {
         return this._buffers[piece.bufferIndex].buffer.charCodeAt(startOffset) === 10;
     }
     endWithCR(val) {
-        if (typeof val === 'string') {
+        if (typeof val === "string") {
             return val.charCodeAt(val.length - 1) === 13;
         }
         if (val === SENTINEL || val.piece.lineFeedCnt === 0) {
@@ -1359,10 +1433,15 @@ class PieceTreeBase {
         const lineStarts = this._buffers[prev.piece.bufferIndex].lineStarts;
         let newEnd;
         if (prev.piece.end.column === 0) {
-            newEnd = { line: prev.piece.end.line - 1, column: lineStarts[prev.piece.end.line] - lineStarts[prev.piece.end.line - 1] - 1 };
-        }
-        else {
-            newEnd = { line: prev.piece.end.line, column: prev.piece.end.column - 1 };
+            newEnd = {
+                line: prev.piece.end.line - 1,
+                column: lineStarts[prev.piece.end.line] - lineStarts[prev.piece.end.line - 1] - 1
+            };
+        } else {
+            newEnd = {
+                line: prev.piece.end.line,
+                column: prev.piece.end.column - 1
+            };
         }
         const prevNewLength = prev.piece.length - 1;
         const prevNewLFCnt = prev.piece.lineFeedCnt - 1;
@@ -1377,7 +1456,10 @@ class PieceTreeBase {
         if (prev.piece.length === 0) {
             nodesToDel.push(prev);
         }
-        const newStart = { line: next.piece.start.line + 1, column: 0 };
+        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(
@@ -1391,7 +1473,7 @@ class PieceTreeBase {
         if (next.piece.length === 0) {
             nodesToDel.push(next);
         }
-        const pieces = this.createNewPieces('\r\n');
+        const pieces = this.createNewPieces("\r\n");
         this.rbInsertRight(prev, pieces[0]);
         for (let i = 0; i < nodesToDel.length; i++) {
             rbDelete(this, nodesToDel[i]);
@@ -1401,13 +1483,15 @@ class PieceTreeBase {
         if (this.shouldCheckCRLF() && this.endWithCR(value)) {
             const nextNode = node.next();
             if (this.startWithLF(nextNode)) {
-                value += '\n';
+                value += "\n";
                 if (nextNode.piece.length === 1) {
                     rbDelete(this, nextNode);
-                }
-                else {
+                } else {
                     const piece = nextNode.piece;
-                    const newStart = { line: piece.start.line + 1, column: 0 };
+                    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));
@@ -1430,7 +1514,7 @@ class PieceTreeBase {
     }
     getNodeContent(node) {
         if (node === SENTINEL) {
-            return '';
+            return "";
         }
         const buffer = this._buffers[node.piece.bufferIndex];
         const piece = node.piece;
@@ -1457,12 +1541,10 @@ class PieceTreeBase {
         if (x === SENTINEL) {
             this.root = z;
             z.color = NodeColor.Black;
-        }
-        else if (node.right === SENTINEL) {
+        } else if (node.right === SENTINEL) {
             node.right = z;
             z.parent = node;
-        }
-        else {
+        } else {
             const nextNode = leftest(node.right);
             nextNode.left = z;
             z.parent = nextNode;
@@ -1480,12 +1562,10 @@ class PieceTreeBase {
         if (this.root === SENTINEL) {
             this.root = z;
             z.color = NodeColor.Black;
-        }
-        else if (node.left === SENTINEL) {
+        } else if (node.left === SENTINEL) {
             node.left = z;
             z.parent = node;
-        }
-        else {
+        } else {
             const prevNode = righttest(node.left);
             prevNode.right = z;
             z.parent = prevNode;
@@ -1494,7 +1574,7 @@ class PieceTreeBase {
         return z;
     }
     getContentOfSubTree(node) {
-        let str = '';
+        let str = "";
         this.iterate(node, node => {
             str += this.getNodeContent(node);
             return true;