monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,461 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-import { isHighSurrogate, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isBasicASCII, containsRTL, containsUnusualLineTerminators } from '../../../../base/common/strings.js';
-import { Range } from '../../core/range.js';
-import { ApplyEditsResult } from '../../model.js';
-import { PieceTreeBase } from './pieceTreeBase.js';
-import { countEOL } from '../../core/misc/eolCounter.js';
-import { TextChange } from '../../core/textChange.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class PieceTreeTextBuffer extends Disposable {
-    constructor(chunks, BOM, eol, containsRTL, containsUnusualLineTerminators, isBasicASCII, eolNormalized) {
-        super();
-        this._onDidChangeContent = this._register(new Emitter());
-        this._BOM = BOM;
-        this._mightContainNonBasicASCII = !isBasicASCII;
-        this._mightContainRTL = containsRTL;
-        this._mightContainUnusualLineTerminators = containsUnusualLineTerminators;
-        this._pieceTree = new PieceTreeBase(chunks, eol, eolNormalized);
-    }
-    mightContainRTL() {
-        return this._mightContainRTL;
-    }
-    mightContainUnusualLineTerminators() {
-        return this._mightContainUnusualLineTerminators;
-    }
-    resetMightContainUnusualLineTerminators() {
-        this._mightContainUnusualLineTerminators = false;
-    }
-    mightContainNonBasicASCII() {
-        return this._mightContainNonBasicASCII;
-    }
-    getBOM() {
-        return this._BOM;
-    }
-    getEOL() {
-        return this._pieceTree.getEOL();
-    }
-    createSnapshot(preserveBOM) {
-        return this._pieceTree.createSnapshot(preserveBOM ? this._BOM : '');
-    }
-    getOffsetAt(lineNumber, column) {
-        return this._pieceTree.getOffsetAt(lineNumber, column);
-    }
-    getPositionAt(offset) {
-        return this._pieceTree.getPositionAt(offset);
-    }
-    getRangeAt(start, length) {
-        const end = start + length;
-        const startPosition = this.getPositionAt(start);
-        const endPosition = this.getPositionAt(end);
-        return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);
-    }
-    getValueInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {
-        if (range.isEmpty()) {
-            return '';
-        }
-        const lineEnding = this._getEndOfLine(eol);
-        return this._pieceTree.getValueInRange(range, lineEnding);
-    }
-    getValueLengthInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {
-        if (range.isEmpty()) {
-            return 0;
-        }
-        if (range.startLineNumber === range.endLineNumber) {
-            return (range.endColumn - range.startColumn);
-        }
-        const startOffset = this.getOffsetAt(range.startLineNumber, range.startColumn);
-        const endOffset = this.getOffsetAt(range.endLineNumber, range.endColumn);
-        // offsets use the text EOL, so we need to compensate for length differences
-        // if the requested EOL doesn't match the text EOL
-        let eolOffsetCompensation = 0;
-        const desiredEOL = this._getEndOfLine(eol);
-        const actualEOL = this.getEOL();
-        if (desiredEOL.length !== actualEOL.length) {
-            const delta = desiredEOL.length - actualEOL.length;
-            const eolCount = range.endLineNumber - range.startLineNumber;
-            eolOffsetCompensation = delta * eolCount;
-        }
-        return endOffset - startOffset + eolOffsetCompensation;
-    }
-    getCharacterCountInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {
-        if (this._mightContainNonBasicASCII) {
-            // we must count by iterating
-            let result = 0;
-            const fromLineNumber = range.startLineNumber;
-            const toLineNumber = range.endLineNumber;
-            for (let lineNumber = fromLineNumber; lineNumber <= toLineNumber; lineNumber++) {
-                const lineContent = this.getLineContent(lineNumber);
-                const fromOffset = (lineNumber === fromLineNumber ? range.startColumn - 1 : 0);
-                const toOffset = (lineNumber === toLineNumber ? range.endColumn - 1 : lineContent.length);
-                for (let offset = fromOffset; offset < toOffset; offset++) {
-                    if (isHighSurrogate(lineContent.charCodeAt(offset))) {
-                        result = result + 1;
-                        offset = offset + 1;
-                    }
-                    else {
-                        result = result + 1;
-                    }
-                }
-            }
-            result += this._getEndOfLine(eol).length * (toLineNumber - fromLineNumber);
-            return result;
-        }
-        return this.getValueLengthInRange(range, eol);
-    }
-    getNearestChunk(offset) {
-        return this._pieceTree.getNearestChunk(offset);
-    }
-    getLength() {
-        return this._pieceTree.getLength();
-    }
-    getLineCount() {
-        return this._pieceTree.getLineCount();
-    }
-    getLinesContent() {
-        return this._pieceTree.getLinesContent();
-    }
-    getLineContent(lineNumber) {
-        return this._pieceTree.getLineContent(lineNumber);
-    }
-    getLineCharCode(lineNumber, index) {
-        return this._pieceTree.getLineCharCode(lineNumber, index);
-    }
-    getLineLength(lineNumber) {
-        return this._pieceTree.getLineLength(lineNumber);
-    }
-    getLineFirstNonWhitespaceColumn(lineNumber) {
-        const result = firstNonWhitespaceIndex(this.getLineContent(lineNumber));
-        if (result === -1) {
-            return 0;
-        }
-        return result + 1;
-    }
-    getLineLastNonWhitespaceColumn(lineNumber) {
-        const result = lastNonWhitespaceIndex(this.getLineContent(lineNumber));
-        if (result === -1) {
-            return 0;
-        }
-        return result + 2;
-    }
-    _getEndOfLine(eol) {
-        switch (eol) {
-            case 1 /* EndOfLinePreference.LF */:
-                return '\n';
-            case 2 /* EndOfLinePreference.CRLF */:
-                return '\r\n';
-            case 0 /* EndOfLinePreference.TextDefined */:
-                return this.getEOL();
-            default:
-                throw new Error('Unknown EOL preference');
-        }
-    }
-    setEOL(newEOL) {
-        this._pieceTree.setEOL(newEOL);
-    }
-    applyEdits(rawOperations, recordTrimAutoWhitespace, computeUndoEdits) {
-        let mightContainRTL = this._mightContainRTL;
-        let mightContainUnusualLineTerminators = this._mightContainUnusualLineTerminators;
-        let mightContainNonBasicASCII = this._mightContainNonBasicASCII;
-        let canReduceOperations = true;
-        let operations = [];
-        for (let i = 0; i < rawOperations.length; i++) {
-            const op = rawOperations[i];
-            if (canReduceOperations && op._isTracked) {
-                canReduceOperations = false;
-            }
-            const validatedRange = op.range;
-            if (op.text) {
-                let textMightContainNonBasicASCII = true;
-                if (!mightContainNonBasicASCII) {
-                    textMightContainNonBasicASCII = !isBasicASCII(op.text);
-                    mightContainNonBasicASCII = textMightContainNonBasicASCII;
-                }
-                if (!mightContainRTL && textMightContainNonBasicASCII) {
-                    // check if the new inserted text contains RTL
-                    mightContainRTL = containsRTL(op.text);
-                }
-                if (!mightContainUnusualLineTerminators && textMightContainNonBasicASCII) {
-                    // check if the new inserted text contains unusual line terminators
-                    mightContainUnusualLineTerminators = containsUnusualLineTerminators(op.text);
-                }
-            }
-            let validText = '';
-            let eolCount = 0;
-            let firstLineLength = 0;
-            let lastLineLength = 0;
-            if (op.text) {
-                let strEOL;
-                [eolCount, firstLineLength, lastLineLength, strEOL] = countEOL(op.text);
-                const bufferEOL = this.getEOL();
-                const expectedStrEOL = (bufferEOL === '\r\n' ? 2 /* StringEOL.CRLF */ : 1 /* StringEOL.LF */);
-                if (strEOL === 0 /* StringEOL.Unknown */ || strEOL === expectedStrEOL) {
-                    validText = op.text;
-                }
-                else {
-                    validText = op.text.replace(/\r\n|\r|\n/g, bufferEOL);
-                }
-            }
-            operations[i] = {
-                sortIndex: i,
-                identifier: op.identifier || null,
-                range: validatedRange,
-                rangeOffset: this.getOffsetAt(validatedRange.startLineNumber, validatedRange.startColumn),
-                rangeLength: this.getValueLengthInRange(validatedRange),
-                text: validText,
-                eolCount: eolCount,
-                firstLineLength: firstLineLength,
-                lastLineLength: lastLineLength,
-                forceMoveMarkers: Boolean(op.forceMoveMarkers),
-                isAutoWhitespaceEdit: op.isAutoWhitespaceEdit || false
-            };
-        }
-        // Sort operations ascending
-        operations.sort(PieceTreeTextBuffer._sortOpsAscending);
-        let hasTouchingRanges = false;
-        for (let i = 0, count = operations.length - 1; i < count; i++) {
-            const rangeEnd = operations[i].range.getEndPosition();
-            const nextRangeStart = operations[i + 1].range.getStartPosition();
-            if (nextRangeStart.isBeforeOrEqual(rangeEnd)) {
-                if (nextRangeStart.isBefore(rangeEnd)) {
-                    // overlapping ranges
-                    throw new Error('Overlapping ranges are not allowed!');
-                }
-                hasTouchingRanges = true;
-            }
-        }
-        if (canReduceOperations) {
-            operations = this._reduceOperations(operations);
-        }
-        // Delta encode operations
-        const reverseRanges = (computeUndoEdits || recordTrimAutoWhitespace ? PieceTreeTextBuffer._getInverseEditRanges(operations) : []);
-        const newTrimAutoWhitespaceCandidates = [];
-        if (recordTrimAutoWhitespace) {
-            for (let i = 0; i < operations.length; i++) {
-                const op = operations[i];
-                const reverseRange = reverseRanges[i];
-                if (op.isAutoWhitespaceEdit && op.range.isEmpty()) {
-                    // Record already the future line numbers that might be auto whitespace removal candidates on next edit
-                    for (let lineNumber = reverseRange.startLineNumber; lineNumber <= reverseRange.endLineNumber; lineNumber++) {
-                        let currentLineContent = '';
-                        if (lineNumber === reverseRange.startLineNumber) {
-                            currentLineContent = this.getLineContent(op.range.startLineNumber);
-                            if (firstNonWhitespaceIndex(currentLineContent) !== -1) {
-                                continue;
-                            }
-                        }
-                        newTrimAutoWhitespaceCandidates.push({ lineNumber: lineNumber, oldContent: currentLineContent });
-                    }
-                }
-            }
-        }
-        let reverseOperations = null;
-        if (computeUndoEdits) {
-            let reverseRangeDeltaOffset = 0;
-            reverseOperations = [];
-            for (let i = 0; i < operations.length; i++) {
-                const op = operations[i];
-                const reverseRange = reverseRanges[i];
-                const bufferText = this.getValueInRange(op.range);
-                const reverseRangeOffset = op.rangeOffset + reverseRangeDeltaOffset;
-                reverseRangeDeltaOffset += (op.text.length - bufferText.length);
-                reverseOperations[i] = {
-                    sortIndex: op.sortIndex,
-                    identifier: op.identifier,
-                    range: reverseRange,
-                    text: bufferText,
-                    textChange: new TextChange(op.rangeOffset, bufferText, reverseRangeOffset, op.text)
-                };
-            }
-            // Can only sort reverse operations when the order is not significant
-            if (!hasTouchingRanges) {
-                reverseOperations.sort((a, b) => a.sortIndex - b.sortIndex);
-            }
-        }
-        this._mightContainRTL = mightContainRTL;
-        this._mightContainUnusualLineTerminators = mightContainUnusualLineTerminators;
-        this._mightContainNonBasicASCII = mightContainNonBasicASCII;
-        const contentChanges = this._doApplyEdits(operations);
-        let trimAutoWhitespaceLineNumbers = null;
-        if (recordTrimAutoWhitespace && newTrimAutoWhitespaceCandidates.length > 0) {
-            // sort line numbers auto whitespace removal candidates for next edit descending
-            newTrimAutoWhitespaceCandidates.sort((a, b) => b.lineNumber - a.lineNumber);
-            trimAutoWhitespaceLineNumbers = [];
-            for (let i = 0, len = newTrimAutoWhitespaceCandidates.length; i < len; i++) {
-                const lineNumber = newTrimAutoWhitespaceCandidates[i].lineNumber;
-                if (i > 0 && newTrimAutoWhitespaceCandidates[i - 1].lineNumber === lineNumber) {
-                    // Do not have the same line number twice
-                    continue;
-                }
-                const prevContent = newTrimAutoWhitespaceCandidates[i].oldContent;
-                const lineContent = this.getLineContent(lineNumber);
-                if (lineContent.length === 0 || lineContent === prevContent || firstNonWhitespaceIndex(lineContent) !== -1) {
-                    continue;
-                }
-                trimAutoWhitespaceLineNumbers.push(lineNumber);
-            }
-        }
-        this._onDidChangeContent.fire();
-        return new ApplyEditsResult(reverseOperations, contentChanges, trimAutoWhitespaceLineNumbers);
-    }
-    /**
-     * Transform operations such that they represent the same logic edit,
-     * but that they also do not cause OOM crashes.
-     */
-    _reduceOperations(operations) {
-        if (operations.length < 1000) {
-            // We know from empirical testing that a thousand edits work fine regardless of their shape.
-            return operations;
-        }
-        // At one point, due to how events are emitted and how each operation is handled,
-        // some operations can trigger a high amount of temporary string allocations,
-        // that will immediately get edited again.
-        // e.g. a formatter inserting ridiculous ammounts of \n on a model with a single line
-        // Therefore, the strategy is to collapse all the operations into a huge single edit operation
-        return [this._toSingleEditOperation(operations)];
-    }
-    _toSingleEditOperation(operations) {
-        let forceMoveMarkers = false;
-        const firstEditRange = operations[0].range;
-        const lastEditRange = operations[operations.length - 1].range;
-        const entireEditRange = new Range(firstEditRange.startLineNumber, firstEditRange.startColumn, lastEditRange.endLineNumber, lastEditRange.endColumn);
-        let lastEndLineNumber = firstEditRange.startLineNumber;
-        let lastEndColumn = firstEditRange.startColumn;
-        const result = [];
-        for (let i = 0, len = operations.length; i < len; i++) {
-            const operation = operations[i];
-            const range = operation.range;
-            forceMoveMarkers = forceMoveMarkers || operation.forceMoveMarkers;
-            // (1) -- Push old text
-            result.push(this.getValueInRange(new Range(lastEndLineNumber, lastEndColumn, range.startLineNumber, range.startColumn)));
-            // (2) -- Push new text
-            if (operation.text.length > 0) {
-                result.push(operation.text);
-            }
-            lastEndLineNumber = range.endLineNumber;
-            lastEndColumn = range.endColumn;
-        }
-        const text = result.join('');
-        const [eolCount, firstLineLength, lastLineLength] = countEOL(text);
-        return {
-            sortIndex: 0,
-            identifier: operations[0].identifier,
-            range: entireEditRange,
-            rangeOffset: this.getOffsetAt(entireEditRange.startLineNumber, entireEditRange.startColumn),
-            rangeLength: this.getValueLengthInRange(entireEditRange, 0 /* EndOfLinePreference.TextDefined */),
-            text: text,
-            eolCount: eolCount,
-            firstLineLength: firstLineLength,
-            lastLineLength: lastLineLength,
-            forceMoveMarkers: forceMoveMarkers,
-            isAutoWhitespaceEdit: false
-        };
-    }
-    _doApplyEdits(operations) {
-        operations.sort(PieceTreeTextBuffer._sortOpsDescending);
-        const contentChanges = [];
-        // operations are from bottom to top
-        for (let i = 0; i < operations.length; i++) {
-            const op = operations[i];
-            const startLineNumber = op.range.startLineNumber;
-            const startColumn = op.range.startColumn;
-            const endLineNumber = op.range.endLineNumber;
-            const endColumn = op.range.endColumn;
-            if (startLineNumber === endLineNumber && startColumn === endColumn && op.text.length === 0) {
-                // no-op
-                continue;
-            }
-            if (op.text) {
-                // replacement
-                this._pieceTree.delete(op.rangeOffset, op.rangeLength);
-                this._pieceTree.insert(op.rangeOffset, op.text, true);
-            }
-            else {
-                // deletion
-                this._pieceTree.delete(op.rangeOffset, op.rangeLength);
-            }
-            const contentChangeRange = new Range(startLineNumber, startColumn, endLineNumber, endColumn);
-            contentChanges.push({
-                range: contentChangeRange,
-                rangeLength: op.rangeLength,
-                text: op.text,
-                rangeOffset: op.rangeOffset,
-                forceMoveMarkers: op.forceMoveMarkers
-            });
-        }
-        return contentChanges;
-    }
-    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {
-        return this._pieceTree.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);
-    }
-    /**
-     * Assumes `operations` are validated and sorted ascending
-     */
-    static _getInverseEditRanges(operations) {
-        const result = [];
-        let prevOpEndLineNumber = 0;
-        let prevOpEndColumn = 0;
-        let prevOp = null;
-        for (let i = 0, len = operations.length; i < len; i++) {
-            const op = operations[i];
-            let startLineNumber;
-            let startColumn;
-            if (prevOp) {
-                if (prevOp.range.endLineNumber === op.range.startLineNumber) {
-                    startLineNumber = prevOpEndLineNumber;
-                    startColumn = prevOpEndColumn + (op.range.startColumn - prevOp.range.endColumn);
-                }
-                else {
-                    startLineNumber = prevOpEndLineNumber + (op.range.startLineNumber - prevOp.range.endLineNumber);
-                    startColumn = op.range.startColumn;
-                }
-            }
-            else {
-                startLineNumber = op.range.startLineNumber;
-                startColumn = op.range.startColumn;
-            }
-            let resultRange;
-            if (op.text.length > 0) {
-                // the operation inserts something
-                const lineCount = op.eolCount + 1;
-                if (lineCount === 1) {
-                    // single line insert
-                    resultRange = new Range(startLineNumber, startColumn, startLineNumber, startColumn + op.firstLineLength);
-                }
-                else {
-                    // multi line insert
-                    resultRange = new Range(startLineNumber, startColumn, startLineNumber + lineCount - 1, op.lastLineLength + 1);
-                }
-            }
-            else {
-                // There is nothing to insert
-                resultRange = new Range(startLineNumber, startColumn, startLineNumber, startColumn);
-            }
-            prevOpEndLineNumber = resultRange.endLineNumber;
-            prevOpEndColumn = resultRange.endColumn;
-            result.push(resultRange);
-            prevOp = op;
-        }
-        return result;
-    }
-    static _sortOpsAscending(a, b) {
-        const r = Range.compareRangesUsingEnds(a.range, b.range);
-        if (r === 0) {
-            return a.sortIndex - b.sortIndex;
-        }
-        return r;
-    }
-    static _sortOpsDescending(a, b) {
-        const r = Range.compareRangesUsingEnds(a.range, b.range);
-        if (r === 0) {
-            return b.sortIndex - a.sortIndex;
-        }
-        return -r;
-    }
-}
-
-export { PieceTreeTextBuffer };

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

@@ -1,140 +0,0 @@
-import { startsWithUTF8BOM, UTF8_BOM_CHARACTER, containsRTL, containsUnusualLineTerminators } from '../../../../base/common/strings.js';
-import { createLineStarts, StringBuffer, createLineStartsFast } from './pieceTreeBase.js';
-import { PieceTreeTextBuffer } from './pieceTreeTextBuffer.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class PieceTreeTextBufferFactory {
-    constructor(_chunks, _bom, _cr, _lf, _crlf, _containsRTL, _containsUnusualLineTerminators, _isBasicASCII, _normalizeEOL) {
-        this._chunks = _chunks;
-        this._bom = _bom;
-        this._cr = _cr;
-        this._lf = _lf;
-        this._crlf = _crlf;
-        this._containsRTL = _containsRTL;
-        this._containsUnusualLineTerminators = _containsUnusualLineTerminators;
-        this._isBasicASCII = _isBasicASCII;
-        this._normalizeEOL = _normalizeEOL;
-    }
-    _getEOL(defaultEOL) {
-        const totalEOLCount = this._cr + this._lf + this._crlf;
-        const totalCRCount = this._cr + this._crlf;
-        if (totalEOLCount === 0) {
-            // This is an empty file or a file with precisely one line
-            return (defaultEOL === 1 /* DefaultEndOfLine.LF */ ? '\n' : '\r\n');
-        }
-        if (totalCRCount > totalEOLCount / 2) {
-            // More than half of the file contains \r\n ending lines
-            return '\r\n';
-        }
-        // At least one line more ends in \n
-        return '\n';
-    }
-    create(defaultEOL) {
-        const eol = this._getEOL(defaultEOL);
-        const chunks = this._chunks;
-        if (this._normalizeEOL &&
-            ((eol === '\r\n' && (this._cr > 0 || this._lf > 0))
-                || (eol === '\n' && (this._cr > 0 || this._crlf > 0)))) {
-            // Normalize pieces
-            for (let i = 0, len = chunks.length; i < len; i++) {
-                const str = chunks[i].buffer.replace(/\r\n|\r|\n/g, eol);
-                const newLineStart = createLineStartsFast(str);
-                chunks[i] = new StringBuffer(str, newLineStart);
-            }
-        }
-        const textBuffer = new PieceTreeTextBuffer(chunks, this._bom, eol, this._containsRTL, this._containsUnusualLineTerminators, this._isBasicASCII, this._normalizeEOL);
-        return { textBuffer: textBuffer, disposable: textBuffer };
-    }
-}
-class PieceTreeTextBufferBuilder {
-    constructor() {
-        this.chunks = [];
-        this.BOM = '';
-        this._hasPreviousChar = false;
-        this._previousChar = 0;
-        this._tmpLineStarts = [];
-        this.cr = 0;
-        this.lf = 0;
-        this.crlf = 0;
-        this.containsRTL = false;
-        this.containsUnusualLineTerminators = false;
-        this.isBasicASCII = true;
-    }
-    acceptChunk(chunk) {
-        if (chunk.length === 0) {
-            return;
-        }
-        if (this.chunks.length === 0) {
-            if (startsWithUTF8BOM(chunk)) {
-                this.BOM = UTF8_BOM_CHARACTER;
-                chunk = chunk.substr(1);
-            }
-        }
-        const lastChar = chunk.charCodeAt(chunk.length - 1);
-        if (lastChar === 13 /* CharCode.CarriageReturn */ || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
-            // last character is \r or a high surrogate => keep it back
-            this._acceptChunk1(chunk.substr(0, chunk.length - 1), false);
-            this._hasPreviousChar = true;
-            this._previousChar = lastChar;
-        }
-        else {
-            this._acceptChunk1(chunk, false);
-            this._hasPreviousChar = false;
-            this._previousChar = lastChar;
-        }
-    }
-    _acceptChunk1(chunk, allowEmptyStrings) {
-        if (!allowEmptyStrings && chunk.length === 0) {
-            // Nothing to do
-            return;
-        }
-        if (this._hasPreviousChar) {
-            this._acceptChunk2(String.fromCharCode(this._previousChar) + chunk);
-        }
-        else {
-            this._acceptChunk2(chunk);
-        }
-    }
-    _acceptChunk2(chunk) {
-        const lineStarts = createLineStarts(this._tmpLineStarts, chunk);
-        this.chunks.push(new StringBuffer(chunk, lineStarts.lineStarts));
-        this.cr += lineStarts.cr;
-        this.lf += lineStarts.lf;
-        this.crlf += lineStarts.crlf;
-        if (!lineStarts.isBasicASCII) {
-            // this chunk contains non basic ASCII characters
-            this.isBasicASCII = false;
-            if (!this.containsRTL) {
-                this.containsRTL = containsRTL(chunk);
-            }
-            if (!this.containsUnusualLineTerminators) {
-                this.containsUnusualLineTerminators = containsUnusualLineTerminators(chunk);
-            }
-        }
-    }
-    finish(normalizeEOL = true) {
-        this._finish();
-        return new PieceTreeTextBufferFactory(this.chunks, this.BOM, this.cr, this.lf, this.crlf, this.containsRTL, this.containsUnusualLineTerminators, this.isBasicASCII, normalizeEOL);
-    }
-    _finish() {
-        if (this.chunks.length === 0) {
-            this._acceptChunk1('', true);
-        }
-        if (this._hasPreviousChar) {
-            this._hasPreviousChar = false;
-            // recreate last chunk
-            const lastChunk = this.chunks[this.chunks.length - 1];
-            lastChunk.buffer += String.fromCharCode(this._previousChar);
-            const newLineStarts = createLineStartsFast(lastChunk.buffer);
-            lastChunk.lineStarts = newLineStarts;
-            if (this._previousChar === 13 /* CharCode.CarriageReturn */) {
-                this.cr++;
-            }
-        }
-    }
-}
-
-export { PieceTreeTextBufferBuilder };

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

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class Point {
-    static equals(a, b) {
-        return a.x === b.x && a.y === b.y;
-    }
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-    }
-    add(other) {
-        return new Point(this.x + other.x, this.y + other.y);
-    }
-    deltaX(delta) {
-        return new Point(this.x + delta, this.y);
-    }
-    deltaY(delta) {
-        return new Point(this.x, this.y + delta);
-    }
-    toString() {
-        return `(${this.x},${this.y})`;
-    }
-    subtract(other) {
-        return new Point(this.x - other.x, this.y - other.y);
-    }
-    scale(factor) {
-        return new Point(this.x * factor, this.y * factor);
-    }
-    mapComponents(map) {
-        return new Point(map(this.x), map(this.y));
-    }
-    isZero() {
-        return this.x === 0 && this.y === 0;
-    }
-    withThreshold(threshold) {
-        return this.mapComponents(axisVal => {
-            if (axisVal > threshold) {
-                return axisVal - threshold;
-            }
-            else if (axisVal < -threshold) {
-                return axisVal + threshold;
-            }
-            return 0;
-        });
-    }
-}
-
-export { Point };