@codingame/monaco-vscode-api 26.2.2 → 27.0.0

package/vscode/src/vs/editor/common/viewLayout/lineHeights.js

@@ -1,7 +1,15 @@
 
 import { binarySearch2 } from '../../../base/common/arrays.js';
 import { intersection } from '../../../base/common/collections.js';
+import { EditorOption } from '../config/editorOptions.js';
 
+var PendingChangeKind;
+(function(PendingChangeKind) {
+    PendingChangeKind[PendingChangeKind["InsertOrChange"] = 0] = "InsertOrChange";
+    PendingChangeKind[PendingChangeKind["Remove"] = 1] = "Remove";
+    PendingChangeKind[PendingChangeKind["LinesDeleted"] = 2] = "LinesDeleted";
+    PendingChangeKind[PendingChangeKind["LinesInserted"] = 3] = "LinesInserted";
+})(PendingChangeKind || (PendingChangeKind = {}));
 class CustomLine {
     constructor(decorationId, index, lineNumber, specialHeight, prefixSum) {
         this.decorationId = decorationId;
@@ -17,20 +25,17 @@ class LineHeightsManager {
     constructor(defaultLineHeight, customLineHeightData) {
         this._decorationIDToCustomLine = ( new ArrayMap());
         this._orderedCustomLines = [];
-        this._pendingSpecialLinesToInsert = [];
-        this._invalidIndex = 0;
+        this._pendingChanges = [];
+        this._invalidIndex = Infinity;
         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();
+        for (const data of customLineHeightData) {
+            this.insertOrChangeCustomLineHeight(
+                data.decorationId,
+                data.startLineNumber,
+                data.endLineNumber,
+                data.lineHeight
+            );
         }
     }
     set defaultLineHeight(defaultLineHeight) {
@@ -40,26 +45,24 @@ class LineHeightsManager {
         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._pendingChanges.push({
+            kind: PendingChangeKind.Remove,
+            decorationId: decorationID
+        });
         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._pendingChanges.push({
+            kind: PendingChangeKind.InsertOrChange,
+            decorationId,
+            startLineNumber,
+            endLineNumber,
+            lineHeight
+        });
         this._hasPending = true;
     }
     heightForLineNumber(lineNumber) {
+        this._commit();
         const searchIndex = this._binarySearchOverOrderedCustomLinesArray(lineNumber);
         if (searchIndex >= 0) {
             return this._orderedCustomLines[searchIndex].maximumSpecialHeight;
@@ -67,6 +70,7 @@ class LineHeightsManager {
         return this._defaultLineHeight;
     }
     getAccumulatedLineHeightsIncludingLineNumber(lineNumber) {
+        this._commit();
         const searchIndex = this._binarySearchOverOrderedCustomLinesArray(lineNumber);
         if (searchIndex >= 0) {
             return this._orderedCustomLines[searchIndex].prefixSum + this._orderedCustomLines[searchIndex].maximumSpecialHeight;
@@ -79,6 +83,137 @@ class LineHeightsManager {
         return previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (lineNumber - previousSpecialLine.lineNumber);
     }
     onLinesDeleted(fromLineNumber, toLineNumber) {
+        this._pendingChanges.push({
+            kind: PendingChangeKind.LinesDeleted,
+            fromLineNumber,
+            toLineNumber
+        });
+        this._hasPending = true;
+    }
+    onLinesInserted(fromLineNumber, toLineNumber) {
+        this._pendingChanges.push({
+            kind: PendingChangeKind.LinesInserted,
+            fromLineNumber,
+            toLineNumber
+        });
+        this._hasPending = true;
+    }
+    _commit() {
+        if (!this._hasPending) {
+            return;
+        }
+        const changes = this._pendingChanges;
+        this._pendingChanges = [];
+        this._hasPending = false;
+        const stagedInserts = [];
+        for (const change of changes) {
+            switch (change.kind) {
+            case PendingChangeKind.Remove:
+                this._doRemoveCustomLineHeight(change.decorationId, stagedInserts);
+                break;
+            case PendingChangeKind.InsertOrChange:
+                this._doInsertOrChangeCustomLineHeight(
+                    change.decorationId,
+                    change.startLineNumber,
+                    change.endLineNumber,
+                    change.lineHeight,
+                    stagedInserts
+                );
+                break;
+            case PendingChangeKind.LinesDeleted:
+                this._flushStagedDecorationChanges(stagedInserts);
+                this._doLinesDeleted(change.fromLineNumber, change.toLineNumber);
+                break;
+            case PendingChangeKind.LinesInserted:
+                this._flushStagedDecorationChanges(stagedInserts);
+                this._doLinesInserted(change.fromLineNumber, change.toLineNumber, stagedInserts);
+                break;
+            }
+        }
+        this._flushStagedDecorationChanges(stagedInserts);
+    }
+    _doRemoveCustomLineHeight(decorationID, stagedInserts) {
+        const customLines = this._decorationIDToCustomLine.get(decorationID);
+        if (customLines) {
+            this._decorationIDToCustomLine.delete(decorationID);
+            for (const customLine of customLines) {
+                customLine.deleted = true;
+                this._invalidIndex = Math.min(this._invalidIndex, customLine.index);
+            }
+        }
+        for (let i = stagedInserts.length - 1; i >= 0; i--) {
+            if (stagedInserts[i].decorationId === decorationID) {
+                stagedInserts.splice(i, 1);
+            }
+        }
+    }
+    _doInsertOrChangeCustomLineHeight(decorationId, startLineNumber, endLineNumber, lineHeight, stagedInserts) {
+        this._doRemoveCustomLineHeight(decorationId, stagedInserts);
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const customLine = ( new CustomLine(decorationId, -1, lineNumber, lineHeight, 0));
+            stagedInserts.push(customLine);
+        }
+    }
+    _flushStagedDecorationChanges(stagedInserts) {
+        if (stagedInserts.length === 0 && this._invalidIndex === Infinity) {
+            return;
+        }
+        for (const pendingChange of stagedInserts) {
+            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);
+        }
+        stagedInserts.length = 0;
+        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;
+    }
+    _doLinesDeleted(fromLineNumber, toLineNumber) {
         const deleteCount = toLineNumber - fromLineNumber + 1;
         const numberOfCustomLines = this._orderedCustomLines.length;
         const candidateStartIndexOfDeletion = this._binarySearchOverOrderedCustomLinesArray(fromLineNumber);
@@ -174,7 +309,7 @@ class LineHeightsManager {
             }
         }
     }
-    onLinesInserted(fromLineNumber, toLineNumber) {
+    _doLinesInserted(fromLineNumber, toLineNumber, stagedInserts) {
         const insertCount = toLineNumber - fromLineNumber + 1;
         const candidateStartIndexOfInsertion = this._binarySearchOverOrderedCustomLinesArray(fromLineNumber);
         let startIndexOfInsertion;
@@ -204,9 +339,10 @@ class LineHeightsManager {
             }
         }
         const decorationsWithGaps = intersection(decorationsImmediatelyBefore, decorationsImmediatelyAfter);
+        const prefixSumToAdd = insertCount * this._defaultLineHeight;
         for (let i = startIndexOfInsertion; i < this._orderedCustomLines.length; i++) {
             this._orderedCustomLines[i].lineNumber += insertCount;
-            this._orderedCustomLines[i].prefixSum += this._defaultLineHeight * insertCount;
+            this._orderedCustomLines[i].prefixSum += prefixSumToAdd;
         }
         if (decorationsWithGaps.size > 0) {
             for (const decorationId of decorationsWithGaps) {
@@ -224,70 +360,15 @@ class LineHeightsManager {
                 }
             }
             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;
+                this._doInsertOrChangeCustomLineHeight(
+                    dec.decorationId,
+                    dec.startLineNumber,
+                    dec.endLineNumber,
+                    dec.lineHeight,
+                    stagedInserts
+                );
             }
-            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 => {
@@ -302,6 +383,26 @@ class LineHeightsManager {
         });
     }
 }
+class CustomLineHeightData {
+    constructor(decorationId, startLineNumber, endLineNumber, lineHeight) {
+        this.decorationId = decorationId;
+        this.startLineNumber = startLineNumber;
+        this.endLineNumber = endLineNumber;
+        this.lineHeight = lineHeight;
+    }
+    static fromDecorations(decorations, coordinatesConverter, configuration) {
+        const defaultLineHeight = configuration.options.get(EditorOption.lineHeight);
+        return ( decorations.map(d => {
+            const viewRange = coordinatesConverter.convertModelRangeToViewRange(d.range);
+            return ( new CustomLineHeightData(
+                d.id,
+                viewRange.startLineNumber,
+                viewRange.endLineNumber,
+                d.options.lineHeight ? d.options.lineHeight * defaultLineHeight : 0
+            ));
+        }));
+    }
+}
 class ArrayMap {
     constructor() {
         this._map = ( new Map());
@@ -322,4 +423,4 @@ class ArrayMap {
     }
 }
 
-export { CustomLine, LineHeightsManager };
+export { CustomLine, CustomLineHeightData, LineHeightsManager };

package/vscode/src/vs/editor/common/viewLayout/linesLayout.d.ts

@@ -1,5 +1,5 @@
 import { IEditorWhitespace, IPartialViewLinesViewportData, ILineHeightChangeAccessor, IViewWhitespaceViewportData, IWhitespaceChangeAccessor } from "../viewModel.js";
-import { ICustomLineHeightData } from "./lineHeights.js";
+import { CustomLineHeightData } from "./lineHeights.js";
 interface IPendingChange {
     id: string;
     newAfterLineNumber: number;
@@ -35,7 +35,7 @@ export declare class LinesLayout {
     private _paddingTop;
     private _paddingBottom;
     private _lineHeightsManager;
-    constructor(lineCount: number, defaultLineHeight: number, paddingTop: number, paddingBottom: number, customLineHeightData: ICustomLineHeightData[]);
+    constructor(lineCount: number, defaultLineHeight: number, paddingTop: number, paddingBottom: number, customLineHeightData: CustomLineHeightData[]);
     /**
      * Find the insertion index for a new value inside a sorted array of values.
      * If the value is already present in the sorted array, the insertion index will be after the already existing value.
@@ -54,7 +54,7 @@ export declare class LinesLayout {
      *
      * @param lineCount New number of lines.
      */
-    onFlushed(lineCount: number, customLineHeightData: ICustomLineHeightData[]): void;
+    onFlushed(lineCount: number, customLineHeightData: CustomLineHeightData[]): void;
     changeLineHeights(callback: (accessor: ILineHeightChangeAccessor) => void): boolean;
     changeWhitespace(callback: (accessor: IWhitespaceChangeAccessor) => void): boolean;
     _commitPendingChanges(inserts: EditorWhitespace[], changes: IPendingChange[], removes: IPendingRemove[]): void;

package/vscode/src/vs/editor/common/viewLayout/linesLayout.js

@@ -99,21 +99,17 @@ class LinesLayout {
     }
     changeLineHeights(callback) {
         let hadAChange = false;
-        try {
-            const accessor = {
-                insertOrChangeCustomLineHeight: (decorationId, startLineNumber, endLineNumber, lineHeight) => {
-                    hadAChange = true;
-                    this._lineHeightsManager.insertOrChangeCustomLineHeight(decorationId, startLineNumber, endLineNumber, lineHeight);
-                },
-                removeCustomLineHeight: decorationId => {
-                    hadAChange = true;
-                    this._lineHeightsManager.removeCustomLineHeight(decorationId);
-                }
-            };
-            callback(accessor);
-        } finally {
-            this._lineHeightsManager.commit();
-        }
+        const accessor = {
+            insertOrChangeCustomLineHeight: (decorationId, startLineNumber, endLineNumber, lineHeight) => {
+                hadAChange = true;
+                this._lineHeightsManager.insertOrChangeCustomLineHeight(decorationId, startLineNumber, endLineNumber, lineHeight);
+            },
+            removeCustomLineHeight: decorationId => {
+                hadAChange = true;
+                this._lineHeightsManager.removeCustomLineHeight(decorationId);
+            }
+        };
+        callback(accessor);
         return hadAChange;
     }
     changeWhitespace(callback) {

package/vscode/src/vs/editor/common/viewLayout/viewLayout.d.ts

@@ -6,7 +6,7 @@ import { ScrollType } from "../editorCommon.js";
 import { IEditorConfiguration } from "../config/editorConfiguration.js";
 import { IEditorWhitespace, IPartialViewLinesViewportData, ILineHeightChangeAccessor, IViewLayout, IViewWhitespaceViewportData, IWhitespaceChangeAccessor, Viewport } from "../viewModel.js";
 import { ContentSizeChangedEvent } from "../viewModelEventDispatcher.js";
-import { ICustomLineHeightData } from "./lineHeights.js";
+import { CustomLineHeightData } from "./lineHeights.js";
 export declare class ViewLayout extends Disposable implements IViewLayout {
     private readonly _configuration;
     private readonly _linesLayout;
@@ -15,13 +15,13 @@ export declare class ViewLayout extends Disposable implements IViewLayout {
     private readonly _scrollable;
     readonly onDidScroll: Event<ScrollEvent>;
     readonly onDidContentSizeChange: Event<ContentSizeChangedEvent>;
-    constructor(configuration: IEditorConfiguration, lineCount: number, customLineHeightData: ICustomLineHeightData[], scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable);
+    constructor(configuration: IEditorConfiguration, lineCount: number, customLineHeightData: CustomLineHeightData[], scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable);
     dispose(): void;
     getScrollable(): Scrollable;
     onHeightMaybeChanged(): void;
     private _configureSmoothScrollDuration;
     onConfigurationChanged(e: ConfigurationChangedEvent): void;
-    onFlushed(lineCount: number, customLineHeightData: ICustomLineHeightData[]): void;
+    onFlushed(lineCount: number, customLineHeightData: CustomLineHeightData[]): void;
     onLinesDeleted(fromLineNumber: number, toLineNumber: number): void;
     onLinesInserted(fromLineNumber: number, toLineNumber: number): void;
     private _getHorizontalScrollbarHeight;

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.js

@@ -894,7 +894,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString("<span class=\"mtkoverflow\">");
-        sb.appendString(( localize(910, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(928, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString("</span>");
     }
     sb.appendString("</span>");
@@ -905,7 +905,7 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return localize(911, "{0} chars", n);
+        return localize(929, "{0} chars", n);
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

package/vscode/src/vs/editor/common/viewModel/inlineDecorations.d.ts

@@ -1,4 +1,7 @@
+import { IModelDecoration, InjectedTextOptions, ITextModel } from "../model.js";
 import { Range } from "../core/range.js";
+import { ICoordinatesConverter } from "../coordinatesConverter.js";
+import { ViewModelDecoration } from "./viewModelDecoration.js";
 export declare enum InlineDecorationType {
     Regular = 0,
     Before = 1,
@@ -11,11 +14,72 @@ export declare class InlineDecoration {
     readonly type: InlineDecorationType;
     constructor(range: Range, inlineClassName: string, type: InlineDecorationType);
 }
-export declare class SingleLineInlineDecoration {
-    readonly startOffset: number;
-    readonly endOffset: number;
-    readonly inlineClassName: string;
-    readonly inlineClassNameAffectsLetterSpacing: boolean;
-    constructor(startOffset: number, endOffset: number, inlineClassName: string, inlineClassNameAffectsLetterSpacing: boolean);
-    toInlineDecoration(lineNumber: number): InlineDecoration;
+/**
+ * A collection of decorations in a range of lines.
+ */
+export interface IViewDecorationsCollection {
+    /**
+     * decorations in the range of lines (ungrouped).
+     */
+    readonly decorations: ViewModelDecoration[];
+    /**
+     * inline decorations (grouped by each line in the range of lines).
+     */
+    readonly inlineDecorations: InlineDecoration[][];
+    /**
+     * Whether the decorations affect the fonts.
+     */
+    readonly hasVariableFonts: boolean[];
+}
+export interface IInlineDecorationsComputer {
+    /**
+     * Get the inline decorations for a specific model line number, split by view line number
+     */
+    getInlineDecorations(modelLineNumber: number): InlineDecoration[][];
+}
+export interface IInlineModelDecorationsComputerContext {
+    /**
+     * Get model decorations for a view range
+     */
+    getModelDecorations(viewRange: Range, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
+}
+export declare class InlineModelDecorationsComputer implements IInlineDecorationsComputer {
+    private readonly context;
+    private readonly model;
+    private readonly coordinatesConverter;
+    private _decorationsCache;
+    constructor(context: IInlineModelDecorationsComputerContext, model: ITextModel, coordinatesConverter: ICoordinatesConverter);
+    getInlineDecorations(modelLineNumber: number): InlineDecoration[][];
+    getDecorations(viewRange: Range, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IViewDecorationsCollection;
+    reset(): void;
+    onModelDecorationsChanged(): void;
+    onLineMappingChanged(): void;
+    private _getOrCreateViewModelDecoration;
+}
+export interface IInjectedTextInlineDecorationsComputerContext {
+    /**
+     * Get the injections options for a model line number
+     */
+    getInjectionOptions(modelLineNumber: number): InjectedTextOptions[] | null;
+    /**
+     * Get the injection offsets for a model line number
+     */
+    getInjectionOffsets(modelLineNumber: number): number[] | null;
+    /**
+     * Get the break offets for a model line number
+     */
+    getBreakOffsets(modelLineNumber: number): number[];
+    /**
+     * Get the wrapped text indent length for a model line number
+     */
+    getWrappedTextIndentLength(modelLineNumber: number): number;
+    /**
+     * Get the view line number for the first output line of a model line
+     */
+    getBaseViewLineNumber(modelLineNumber: number): number;
+}
+export declare class InjectedTextInlineDecorationsComputer implements IInlineDecorationsComputer {
+    private readonly context;
+    constructor(context: IInjectedTextInlineDecorationsComputerContext);
+    getInlineDecorations(modelLineNumber: number): InlineDecoration[][];
 }