monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,208 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,370 +0,0 @@
-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

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