monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,208 @@
+import { isHighSurrogate } from '../../../base/common/strings.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class LineDecoration {
+    constructor(startColumn, endColumn, className, type) {
+        this.startColumn = startColumn;
+        this.endColumn = endColumn;
+        this.className = className;
+        this.type = type;
+        this._lineDecorationBrand = undefined;
+    }
+    static _equals(a, b) {
+        return (a.startColumn === b.startColumn
+            && a.endColumn === b.endColumn
+            && a.className === b.className
+            && a.type === b.type);
+    }
+    static equalsArr(a, b) {
+        const aLen = a.length;
+        const bLen = b.length;
+        if (aLen !== bLen) {
+            return false;
+        }
+        for (let i = 0; i < aLen; i++) {
+            if (!LineDecoration._equals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static extractWrapped(arr, startOffset, endOffset) {
+        if (arr.length === 0) {
+            return arr;
+        }
+        const startColumn = startOffset + 1;
+        const endColumn = endOffset + 1;
+        const lineLength = endOffset - startOffset;
+        const r = [];
+        let rLength = 0;
+        for (const dec of arr) {
+            if (dec.endColumn <= startColumn || dec.startColumn >= endColumn) {
+                continue;
+            }
+            r[rLength++] = new LineDecoration(Math.max(1, dec.startColumn - startColumn + 1), Math.min(lineLength + 1, dec.endColumn - startColumn + 1), dec.className, dec.type);
+        }
+        return r;
+    }
+    static filter(lineDecorations, lineNumber, minLineColumn, maxLineColumn) {
+        if (lineDecorations.length === 0) {
+            return [];
+        }
+        const result = [];
+        let resultLen = 0;
+        for (let i = 0, len = lineDecorations.length; i < len; i++) {
+            const d = lineDecorations[i];
+            const range = d.range;
+            if (range.endLineNumber < lineNumber || range.startLineNumber > lineNumber) {
+                // Ignore decorations that sit outside this line
+                continue;
+            }
+            if (range.isEmpty() && (d.type === 0 /* InlineDecorationType.Regular */ || d.type === 3 /* InlineDecorationType.RegularAffectingLetterSpacing */)) {
+                // Ignore empty range decorations
+                continue;
+            }
+            const startColumn = (range.startLineNumber === lineNumber ? range.startColumn : minLineColumn);
+            const endColumn = (range.endLineNumber === lineNumber ? range.endColumn : maxLineColumn);
+            result[resultLen++] = new LineDecoration(startColumn, endColumn, d.inlineClassName, d.type);
+        }
+        return result;
+    }
+    static _typeCompare(a, b) {
+        const ORDER = [2, 0, 1, 3];
+        return ORDER[a] - ORDER[b];
+    }
+    static compare(a, b) {
+        if (a.startColumn !== b.startColumn) {
+            return a.startColumn - b.startColumn;
+        }
+        if (a.endColumn !== b.endColumn) {
+            return a.endColumn - b.endColumn;
+        }
+        const typeCmp = LineDecoration._typeCompare(a.type, b.type);
+        if (typeCmp !== 0) {
+            return typeCmp;
+        }
+        if (a.className !== b.className) {
+            return a.className < b.className ? -1 : 1;
+        }
+        return 0;
+    }
+}
+class DecorationSegment {
+    constructor(startOffset, endOffset, className, metadata) {
+        this.startOffset = startOffset;
+        this.endOffset = endOffset;
+        this.className = className;
+        this.metadata = metadata;
+    }
+}
+class Stack {
+    constructor() {
+        this.stopOffsets = [];
+        this.classNames = [];
+        this.metadata = [];
+        this.count = 0;
+    }
+    static _metadata(metadata) {
+        let result = 0;
+        for (let i = 0, len = metadata.length; i < len; i++) {
+            result |= metadata[i];
+        }
+        return result;
+    }
+    consumeLowerThan(maxStopOffset, nextStartOffset, result) {
+        while (this.count > 0 && this.stopOffsets[0] < maxStopOffset) {
+            let i = 0;
+            // Take all equal stopping offsets
+            while (i + 1 < this.count && this.stopOffsets[i] === this.stopOffsets[i + 1]) {
+                i++;
+            }
+            // Basically we are consuming the first i + 1 elements of the stack
+            result.push(new DecorationSegment(nextStartOffset, this.stopOffsets[i], this.classNames.join(' '), Stack._metadata(this.metadata)));
+            nextStartOffset = this.stopOffsets[i] + 1;
+            // Consume them
+            this.stopOffsets.splice(0, i + 1);
+            this.classNames.splice(0, i + 1);
+            this.metadata.splice(0, i + 1);
+            this.count -= (i + 1);
+        }
+        if (this.count > 0 && nextStartOffset < maxStopOffset) {
+            result.push(new DecorationSegment(nextStartOffset, maxStopOffset - 1, this.classNames.join(' '), Stack._metadata(this.metadata)));
+            nextStartOffset = maxStopOffset;
+        }
+        return nextStartOffset;
+    }
+    insert(stopOffset, className, metadata) {
+        if (this.count === 0 || this.stopOffsets[this.count - 1] <= stopOffset) {
+            // Insert at the end
+            this.stopOffsets.push(stopOffset);
+            this.classNames.push(className);
+            this.metadata.push(metadata);
+        }
+        else {
+            // Find the insertion position for `stopOffset`
+            for (let i = 0; i < this.count; i++) {
+                if (this.stopOffsets[i] >= stopOffset) {
+                    this.stopOffsets.splice(i, 0, stopOffset);
+                    this.classNames.splice(i, 0, className);
+                    this.metadata.splice(i, 0, metadata);
+                    break;
+                }
+            }
+        }
+        this.count++;
+        return;
+    }
+}
+class LineDecorationsNormalizer {
+    /**
+     * Normalize line decorations. Overlapping decorations will generate multiple segments
+     */
+    static normalize(lineContent, lineDecorations) {
+        if (lineDecorations.length === 0) {
+            return [];
+        }
+        const result = [];
+        const stack = new Stack();
+        let nextStartOffset = 0;
+        for (let i = 0, len = lineDecorations.length; i < len; i++) {
+            const d = lineDecorations[i];
+            let startColumn = d.startColumn;
+            let endColumn = d.endColumn;
+            const className = d.className;
+            const metadata = (d.type === 1 /* InlineDecorationType.Before */
+                ? 2 /* LinePartMetadata.PSEUDO_BEFORE */
+                : d.type === 2 /* InlineDecorationType.After */
+                    ? 4 /* LinePartMetadata.PSEUDO_AFTER */
+                    : 0);
+            // If the position would end up in the middle of a high-low surrogate pair, we move it to before the pair
+            if (startColumn > 1) {
+                const charCodeBefore = lineContent.charCodeAt(startColumn - 2);
+                if (isHighSurrogate(charCodeBefore)) {
+                    startColumn--;
+                }
+            }
+            if (endColumn > 1) {
+                const charCodeBefore = lineContent.charCodeAt(endColumn - 2);
+                if (isHighSurrogate(charCodeBefore)) {
+                    endColumn--;
+                }
+            }
+            const currentStartOffset = startColumn - 1;
+            const currentEndOffset = endColumn - 2;
+            nextStartOffset = stack.consumeLowerThan(currentStartOffset, nextStartOffset, result);
+            if (stack.count === 0) {
+                nextStartOffset = currentStartOffset;
+            }
+            stack.insert(currentEndOffset, className, metadata);
+        }
+        stack.consumeLowerThan(1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, nextStartOffset, result);
+        return result;
+    }
+}
+
+export { DecorationSegment, LineDecoration, LineDecorationsNormalizer };

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

@@ -0,0 +1,75 @@
+import { assert, checkAdjacentItems } from '../../../../base/common/assert.js';
+import { splitLines } from '../../../../base/common/strings.js';
+import { LineRange } from '../ranges/lineRange.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+
+class LineEdit {
+    static { this.empty = new LineEdit([]); }
+    constructor(
+    /**
+     * Have to be sorted by start line number and non-intersecting.
+    */
+    replacements) {
+        this.replacements = replacements;
+        assert(checkAdjacentItems(replacements, (i1, i2) => i1.lineRange.endLineNumberExclusive <= i2.lineRange.startLineNumber));
+    }
+    toString() {
+        return this.replacements.map(e => e.toString()).join(',');
+    }
+    getNewLineRanges() {
+        const ranges = [];
+        let offset = 0;
+        for (const e of this.replacements) {
+            ranges.push(LineRange.ofLength(e.lineRange.startLineNumber + offset, e.newLines.length));
+            offset += e.newLines.length - e.lineRange.length;
+        }
+        return ranges;
+    }
+}
+class LineReplacement {
+    static fromSingleTextEdit(edit, initialValue) {
+        // 1: ab[cde
+        // 2: fghijk
+        // 3: lmn]opq
+        // replaced with
+        // 1n: 123
+        // 2n: 456
+        // 3n: 789
+        // simple solution: replace [1..4) with [1n..4n)
+        const newLines = splitLines(edit.text);
+        let startLineNumber = edit.range.startLineNumber;
+        const survivingFirstLineText = initialValue.getValueOfRange(Range.fromPositions(new Position(edit.range.startLineNumber, 1), edit.range.getStartPosition()));
+        newLines[0] = survivingFirstLineText + newLines[0];
+        let endLineNumberEx = edit.range.endLineNumber + 1;
+        const editEndLineNumberMaxColumn = initialValue.getTransformer().getLineLength(edit.range.endLineNumber) + 1;
+        const survivingEndLineText = initialValue.getValueOfRange(Range.fromPositions(edit.range.getEndPosition(), new Position(edit.range.endLineNumber, editEndLineNumberMaxColumn)));
+        newLines[newLines.length - 1] = newLines[newLines.length - 1] + survivingEndLineText;
+        // Replacing [startLineNumber, endLineNumberEx) with newLines would be correct, however it might not be minimal.
+        const startBeforeNewLine = edit.range.startColumn === initialValue.getTransformer().getLineLength(edit.range.startLineNumber) + 1;
+        const endAfterNewLine = edit.range.endColumn === 1;
+        if (startBeforeNewLine && newLines[0].length === survivingFirstLineText.length) {
+            // the replacement would not delete any text on the first line
+            startLineNumber++;
+            newLines.shift();
+        }
+        if (newLines.length > 0 && startLineNumber < endLineNumberEx && endAfterNewLine && newLines[newLines.length - 1].length === survivingEndLineText.length) {
+            // the replacement would not delete any text on the last line
+            endLineNumberEx--;
+            newLines.pop();
+        }
+        return new LineReplacement(new LineRange(startLineNumber, endLineNumberEx), newLines);
+    }
+    constructor(lineRange, newLines) {
+        this.lineRange = lineRange;
+        this.newLines = newLines;
+    }
+    toString() {
+        return `${this.lineRange}->${JSON.stringify(this.newLines)}`;
+    }
+    toLineEdit() {
+        return new LineEdit([this]);
+    }
+}
+
+export { LineEdit, LineReplacement };

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

@@ -0,0 +1,370 @@
+import { binarySearch2 } from '../../../base/common/arrays.js';
+import { intersection } from '../../../base/common/collections.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class CustomLine {
+    constructor(decorationId, index, lineNumber, specialHeight, prefixSum) {
+        this.decorationId = decorationId;
+        this.index = index;
+        this.lineNumber = lineNumber;
+        this.specialHeight = specialHeight;
+        this.prefixSum = prefixSum;
+        this.maximumSpecialHeight = specialHeight;
+        this.deleted = false;
+    }
+}
+/**
+ * Manages line heights in the editor with support for custom line heights from decorations.
+ *
+ * This class maintains an ordered collection of line heights, where each line can have either
+ * the default height or a custom height specified by decorations. It supports efficient querying
+ * of individual line heights as well as accumulated heights up to a specific line.
+ *
+ * Line heights are stored in a sorted array for efficient binary search operations. Each line
+ * with custom height is represented by a {@link CustomLine} object which tracks its special height,
+ * accumulated height prefix sum, and associated decoration ID.
+ *
+ * The class optimizes performance by:
+ * - Using binary search to locate lines in the ordered array
+ * - Batching updates through a pending changes mechanism
+ * - Computing prefix sums for O(1) accumulated height lookup
+ * - Tracking maximum height for lines with multiple decorations
+ * - Efficiently handling document changes (line insertions and deletions)
+ *
+ * When lines are inserted or deleted, the manager updates line numbers and prefix sums
+ * for all affected lines. It also handles special cases like decorations that span
+ * the insertion/deletion points by re-applying those decorations appropriately.
+ *
+ * All query operations automatically commit pending changes to ensure consistent results.
+ * Clients can modify line heights by adding or removing custom line height decorations,
+ * which are tracked by their unique decoration IDs.
+ */
+class LineHeightsManager {
+    constructor(defaultLineHeight, customLineHeightData) {
+        this._decorationIDToCustomLine = new ArrayMap();
+        this._orderedCustomLines = [];
+        this._pendingSpecialLinesToInsert = [];
+        this._invalidIndex = 0;
+        this._hasPending = false;
+        this._defaultLineHeight = defaultLineHeight;
+        if (customLineHeightData.length > 0) {
+            for (const data of customLineHeightData) {
+                this.insertOrChangeCustomLineHeight(data.decorationId, data.startLineNumber, data.endLineNumber, data.lineHeight);
+            }
+            this.commit();
+        }
+    }
+    set defaultLineHeight(defaultLineHeight) {
+        this._defaultLineHeight = defaultLineHeight;
+    }
+    get defaultLineHeight() {
+        return this._defaultLineHeight;
+    }
+    removeCustomLineHeight(decorationID) {
+        const customLines = this._decorationIDToCustomLine.get(decorationID);
+        if (!customLines) {
+            return;
+        }
+        this._decorationIDToCustomLine.delete(decorationID);
+        for (const customLine of customLines) {
+            customLine.deleted = true;
+            this._invalidIndex = Math.min(this._invalidIndex, customLine.index);
+        }
+        this._hasPending = true;
+    }
+    insertOrChangeCustomLineHeight(decorationId, startLineNumber, endLineNumber, lineHeight) {
+        this.removeCustomLineHeight(decorationId);
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const customLine = new CustomLine(decorationId, -1, lineNumber, lineHeight, 0);
+            this._pendingSpecialLinesToInsert.push(customLine);
+        }
+        this._hasPending = true;
+    }
+    heightForLineNumber(lineNumber) {
+        const searchIndex = this._binarySearchOverOrderedCustomLinesArray(lineNumber);
+        if (searchIndex >= 0) {
+            return this._orderedCustomLines[searchIndex].maximumSpecialHeight;
+        }
+        return this._defaultLineHeight;
+    }
+    getAccumulatedLineHeightsIncludingLineNumber(lineNumber) {
+        const searchIndex = this._binarySearchOverOrderedCustomLinesArray(lineNumber);
+        if (searchIndex >= 0) {
+            return this._orderedCustomLines[searchIndex].prefixSum + this._orderedCustomLines[searchIndex].maximumSpecialHeight;
+        }
+        if (searchIndex === -1) {
+            return this._defaultLineHeight * lineNumber;
+        }
+        const modifiedIndex = -(searchIndex + 1);
+        const previousSpecialLine = this._orderedCustomLines[modifiedIndex - 1];
+        return previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (lineNumber - previousSpecialLine.lineNumber);
+    }
+    onLinesDeleted(fromLineNumber, toLineNumber) {
+        const deleteCount = toLineNumber - fromLineNumber + 1;
+        const numberOfCustomLines = this._orderedCustomLines.length;
+        const candidateStartIndexOfDeletion = this._binarySearchOverOrderedCustomLinesArray(fromLineNumber);
+        let startIndexOfDeletion;
+        if (candidateStartIndexOfDeletion >= 0) {
+            startIndexOfDeletion = candidateStartIndexOfDeletion;
+            for (let i = candidateStartIndexOfDeletion - 1; i >= 0; i--) {
+                if (this._orderedCustomLines[i].lineNumber === fromLineNumber) {
+                    startIndexOfDeletion--;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            startIndexOfDeletion = candidateStartIndexOfDeletion === -(numberOfCustomLines + 1) && candidateStartIndexOfDeletion !== -1 ? numberOfCustomLines - 1 : -(candidateStartIndexOfDeletion + 1);
+        }
+        const candidateEndIndexOfDeletion = this._binarySearchOverOrderedCustomLinesArray(toLineNumber);
+        let endIndexOfDeletion;
+        if (candidateEndIndexOfDeletion >= 0) {
+            endIndexOfDeletion = candidateEndIndexOfDeletion;
+            for (let i = candidateEndIndexOfDeletion + 1; i < numberOfCustomLines; i++) {
+                if (this._orderedCustomLines[i].lineNumber === toLineNumber) {
+                    endIndexOfDeletion++;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            endIndexOfDeletion = candidateEndIndexOfDeletion === -(numberOfCustomLines + 1) && candidateEndIndexOfDeletion !== -1 ? numberOfCustomLines - 1 : -(candidateEndIndexOfDeletion + 1);
+        }
+        const isEndIndexBiggerThanStartIndex = endIndexOfDeletion > startIndexOfDeletion;
+        const isEndIndexEqualToStartIndexAndCoversCustomLine = endIndexOfDeletion === startIndexOfDeletion
+            && this._orderedCustomLines[startIndexOfDeletion]
+            && this._orderedCustomLines[startIndexOfDeletion].lineNumber >= fromLineNumber
+            && this._orderedCustomLines[startIndexOfDeletion].lineNumber <= toLineNumber;
+        if (isEndIndexBiggerThanStartIndex || isEndIndexEqualToStartIndexAndCoversCustomLine) {
+            let maximumSpecialHeightOnDeletedInterval = 0;
+            for (let i = startIndexOfDeletion; i <= endIndexOfDeletion; i++) {
+                maximumSpecialHeightOnDeletedInterval = Math.max(maximumSpecialHeightOnDeletedInterval, this._orderedCustomLines[i].maximumSpecialHeight);
+            }
+            let prefixSumOnDeletedInterval = 0;
+            if (startIndexOfDeletion > 0) {
+                const previousSpecialLine = this._orderedCustomLines[startIndexOfDeletion - 1];
+                prefixSumOnDeletedInterval = previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (fromLineNumber - previousSpecialLine.lineNumber - 1);
+            }
+            else {
+                prefixSumOnDeletedInterval = fromLineNumber > 0 ? (fromLineNumber - 1) * this._defaultLineHeight : 0;
+            }
+            const firstSpecialLineDeleted = this._orderedCustomLines[startIndexOfDeletion];
+            const lastSpecialLineDeleted = this._orderedCustomLines[endIndexOfDeletion];
+            const firstSpecialLineAfterDeletion = this._orderedCustomLines[endIndexOfDeletion + 1];
+            const heightOfFirstLineAfterDeletion = firstSpecialLineAfterDeletion && firstSpecialLineAfterDeletion.lineNumber === toLineNumber + 1 ? firstSpecialLineAfterDeletion.maximumSpecialHeight : this._defaultLineHeight;
+            const totalHeightDeleted = lastSpecialLineDeleted.prefixSum
+                + lastSpecialLineDeleted.maximumSpecialHeight
+                - firstSpecialLineDeleted.prefixSum
+                + this._defaultLineHeight * (toLineNumber - lastSpecialLineDeleted.lineNumber)
+                + this._defaultLineHeight * (firstSpecialLineDeleted.lineNumber - fromLineNumber)
+                + heightOfFirstLineAfterDeletion - maximumSpecialHeightOnDeletedInterval;
+            const decorationIdsSeen = new Set();
+            const newOrderedCustomLines = [];
+            const newDecorationIDToSpecialLine = new ArrayMap();
+            let numberOfDeletions = 0;
+            for (let i = 0; i < this._orderedCustomLines.length; i++) {
+                const customLine = this._orderedCustomLines[i];
+                if (i < startIndexOfDeletion) {
+                    newOrderedCustomLines.push(customLine);
+                    newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+                }
+                else if (i >= startIndexOfDeletion && i <= endIndexOfDeletion) {
+                    const decorationId = customLine.decorationId;
+                    if (!decorationIdsSeen.has(decorationId)) {
+                        customLine.index -= numberOfDeletions;
+                        customLine.lineNumber = fromLineNumber;
+                        customLine.prefixSum = prefixSumOnDeletedInterval;
+                        customLine.maximumSpecialHeight = maximumSpecialHeightOnDeletedInterval;
+                        newOrderedCustomLines.push(customLine);
+                        newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+                    }
+                    else {
+                        numberOfDeletions++;
+                    }
+                }
+                else if (i > endIndexOfDeletion) {
+                    customLine.index -= numberOfDeletions;
+                    customLine.lineNumber -= deleteCount;
+                    customLine.prefixSum -= totalHeightDeleted;
+                    newOrderedCustomLines.push(customLine);
+                    newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+                }
+                decorationIdsSeen.add(customLine.decorationId);
+            }
+            this._orderedCustomLines = newOrderedCustomLines;
+            this._decorationIDToCustomLine = newDecorationIDToSpecialLine;
+        }
+        else {
+            const totalHeightDeleted = deleteCount * this._defaultLineHeight;
+            for (let i = endIndexOfDeletion; i < this._orderedCustomLines.length; i++) {
+                const customLine = this._orderedCustomLines[i];
+                if (customLine.lineNumber > toLineNumber) {
+                    customLine.lineNumber -= deleteCount;
+                    customLine.prefixSum -= totalHeightDeleted;
+                }
+            }
+        }
+    }
+    onLinesInserted(fromLineNumber, toLineNumber) {
+        const insertCount = toLineNumber - fromLineNumber + 1;
+        const candidateStartIndexOfInsertion = this._binarySearchOverOrderedCustomLinesArray(fromLineNumber);
+        let startIndexOfInsertion;
+        if (candidateStartIndexOfInsertion >= 0) {
+            startIndexOfInsertion = candidateStartIndexOfInsertion;
+            for (let i = candidateStartIndexOfInsertion - 1; i >= 0; i--) {
+                if (this._orderedCustomLines[i].lineNumber === fromLineNumber) {
+                    startIndexOfInsertion--;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            startIndexOfInsertion = -(candidateStartIndexOfInsertion + 1);
+        }
+        const toReAdd = [];
+        const decorationsImmediatelyAfter = new Set();
+        for (let i = startIndexOfInsertion; i < this._orderedCustomLines.length; i++) {
+            if (this._orderedCustomLines[i].lineNumber === fromLineNumber) {
+                decorationsImmediatelyAfter.add(this._orderedCustomLines[i].decorationId);
+            }
+        }
+        const decorationsImmediatelyBefore = new Set();
+        for (let i = startIndexOfInsertion - 1; i >= 0; i--) {
+            if (this._orderedCustomLines[i].lineNumber === fromLineNumber - 1) {
+                decorationsImmediatelyBefore.add(this._orderedCustomLines[i].decorationId);
+            }
+        }
+        const decorationsWithGaps = intersection(decorationsImmediatelyBefore, decorationsImmediatelyAfter);
+        for (let i = startIndexOfInsertion; i < this._orderedCustomLines.length; i++) {
+            this._orderedCustomLines[i].lineNumber += insertCount;
+            this._orderedCustomLines[i].prefixSum += this._defaultLineHeight * insertCount;
+        }
+        if (decorationsWithGaps.size > 0) {
+            for (const decorationId of decorationsWithGaps) {
+                const decoration = this._decorationIDToCustomLine.get(decorationId);
+                if (decoration) {
+                    const startLineNumber = decoration.reduce((min, l) => Math.min(min, l.lineNumber), fromLineNumber); // min
+                    const endLineNumber = decoration.reduce((max, l) => Math.max(max, l.lineNumber), fromLineNumber); // max
+                    const lineHeight = decoration.reduce((max, l) => Math.max(max, l.specialHeight), 0);
+                    toReAdd.push({
+                        decorationId,
+                        startLineNumber,
+                        endLineNumber,
+                        lineHeight
+                    });
+                }
+            }
+            for (const dec of toReAdd) {
+                this.insertOrChangeCustomLineHeight(dec.decorationId, dec.startLineNumber, dec.endLineNumber, dec.lineHeight);
+            }
+            this.commit();
+        }
+    }
+    commit() {
+        if (!this._hasPending) {
+            return;
+        }
+        for (const pendingChange of this._pendingSpecialLinesToInsert) {
+            const candidateInsertionIndex = this._binarySearchOverOrderedCustomLinesArray(pendingChange.lineNumber);
+            const insertionIndex = candidateInsertionIndex >= 0 ? candidateInsertionIndex : -(candidateInsertionIndex + 1);
+            this._orderedCustomLines.splice(insertionIndex, 0, pendingChange);
+            this._invalidIndex = Math.min(this._invalidIndex, insertionIndex);
+        }
+        this._pendingSpecialLinesToInsert = [];
+        const newDecorationIDToSpecialLine = new ArrayMap();
+        const newOrderedSpecialLines = [];
+        for (let i = 0; i < this._invalidIndex; i++) {
+            const customLine = this._orderedCustomLines[i];
+            newOrderedSpecialLines.push(customLine);
+            newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+        }
+        let numberOfDeletions = 0;
+        let previousSpecialLine = (this._invalidIndex > 0) ? newOrderedSpecialLines[this._invalidIndex - 1] : undefined;
+        for (let i = this._invalidIndex; i < this._orderedCustomLines.length; i++) {
+            const customLine = this._orderedCustomLines[i];
+            if (customLine.deleted) {
+                numberOfDeletions++;
+                continue;
+            }
+            customLine.index = i - numberOfDeletions;
+            if (previousSpecialLine && previousSpecialLine.lineNumber === customLine.lineNumber) {
+                customLine.maximumSpecialHeight = previousSpecialLine.maximumSpecialHeight;
+                customLine.prefixSum = previousSpecialLine.prefixSum;
+            }
+            else {
+                let maximumSpecialHeight = customLine.specialHeight;
+                for (let j = i; j < this._orderedCustomLines.length; j++) {
+                    const nextSpecialLine = this._orderedCustomLines[j];
+                    if (nextSpecialLine.deleted) {
+                        continue;
+                    }
+                    if (nextSpecialLine.lineNumber !== customLine.lineNumber) {
+                        break;
+                    }
+                    maximumSpecialHeight = Math.max(maximumSpecialHeight, nextSpecialLine.specialHeight);
+                }
+                customLine.maximumSpecialHeight = maximumSpecialHeight;
+                let prefixSum;
+                if (previousSpecialLine) {
+                    prefixSum = previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (customLine.lineNumber - previousSpecialLine.lineNumber - 1);
+                }
+                else {
+                    prefixSum = this._defaultLineHeight * (customLine.lineNumber - 1);
+                }
+                customLine.prefixSum = prefixSum;
+            }
+            previousSpecialLine = customLine;
+            newOrderedSpecialLines.push(customLine);
+            newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+        }
+        this._orderedCustomLines = newOrderedSpecialLines;
+        this._decorationIDToCustomLine = newDecorationIDToSpecialLine;
+        this._invalidIndex = Infinity;
+        this._hasPending = false;
+    }
+    _binarySearchOverOrderedCustomLinesArray(lineNumber) {
+        return binarySearch2(this._orderedCustomLines.length, (index) => {
+            const line = this._orderedCustomLines[index];
+            if (line.lineNumber === lineNumber) {
+                return 0;
+            }
+            else if (line.lineNumber < lineNumber) {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        });
+    }
+}
+class ArrayMap {
+    constructor() {
+        this._map = new Map();
+    }
+    add(key, value) {
+        const array = this._map.get(key);
+        if (!array) {
+            this._map.set(key, [value]);
+        }
+        else {
+            array.push(value);
+        }
+    }
+    get(key) {
+        return this._map.get(key);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+}
+
+export { CustomLine, LineHeightsManager };

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

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class LinePart {
+    constructor(
+    /**
+     * last char index of this token (not inclusive).
+     */
+    endIndex, type, metadata, containsRTL) {
+        this.endIndex = endIndex;
+        this.type = type;
+        this.metadata = metadata;
+        this.containsRTL = containsRTL;
+        this._linePartBrand = undefined;
+    }
+    isWhitespace() {
+        return (this.metadata & 1 /* LinePartMetadata.IS_WHITESPACE_MASK */ ? true : false);
+    }
+    isPseudoAfter() {
+        return (this.metadata & 4 /* LinePartMetadata.PSEUDO_AFTER_MASK */ ? true : false);
+    }
+}
+
+export { LinePart };