@codingame/monaco-vscode-api 16.1.1 → 17.1.0

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

@@ -1,5 +1,6 @@
 
 import { singleLetterHash } from '../../../base/common/strings.js';
+import { LineHeightsManager } from './lineHeights.js';
 
 class PendingChanges {
     constructor() {
@@ -20,9 +21,6 @@ class PendingChanges {
         this._hasPending = true;
         this._removes.push(x);
     }
-    mustCommit() {
-        return this._hasPending;
-    }
     commit(linesLayout) {
         if (!this._hasPending) {
             return;
@@ -49,7 +47,7 @@ class EditorWhitespace {
 }
 class LinesLayout {
     static { this.INSTANCE_COUNT = 0; }
-    constructor(lineCount, lineHeight, paddingTop, paddingBottom) {
+    constructor(lineCount, defaultLineHeight, paddingTop, paddingBottom, customLineHeightData) {
         this._instanceId = singleLetterHash(++LinesLayout.INSTANCE_COUNT);
         this._pendingChanges = ( new PendingChanges());
         this._lastWhitespaceId = 0;
@@ -57,9 +55,9 @@ class LinesLayout {
         this._prefixSumValidIndex = -1;
         this._minWidth = -1;
         this._lineCount = lineCount;
-        this._lineHeight = lineHeight;
         this._paddingTop = paddingTop;
         this._paddingBottom = paddingBottom;
+        this._lineHeightsManager = ( new LineHeightsManager(defaultLineHeight, customLineHeightData));
     }
     static findInsertionIndex(arr, afterLineNumber, ordinal) {
         let low = 0;
@@ -83,17 +81,36 @@ class LinesLayout {
         }
         return low;
     }
-    setLineHeight(lineHeight) {
-        this._checkPendingChanges();
-        this._lineHeight = lineHeight;
+    setDefaultLineHeight(lineHeight) {
+        this._lineHeightsManager.defaultLineHeight = lineHeight;
     }
     setPadding(paddingTop, paddingBottom) {
         this._paddingTop = paddingTop;
         this._paddingBottom = paddingBottom;
     }
-    onFlushed(lineCount) {
-        this._checkPendingChanges();
+    onFlushed(lineCount, customLineHeightData) {
         this._lineCount = lineCount;
+        this._lineHeightsManager = ( new LineHeightsManager(this._lineHeightsManager.defaultLineHeight, customLineHeightData));
+    }
+    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();
+        }
+        return hadAChange;
     }
     changeWhitespace(callback) {
         let hadAChange = false;
@@ -180,11 +197,6 @@ class LinesLayout {
         this._arr = result;
         this._prefixSumValidIndex = -1;
     }
-    _checkPendingChanges() {
-        if (this._pendingChanges.mustCommit()) {
-            this._pendingChanges.commit(this);
-        }
-    }
     _insertWhitespace(whitespace) {
         const insertIndex = LinesLayout.findInsertionIndex(this._arr, whitespace.afterLineNumber, whitespace.ordinal);
         this._arr.splice(insertIndex, 0, whitespace);
@@ -220,7 +232,6 @@ class LinesLayout {
         this._prefixSumValidIndex = Math.min(this._prefixSumValidIndex, removeIndex - 1);
     }
     onLinesDeleted(fromLineNumber, toLineNumber) {
-        this._checkPendingChanges();
         fromLineNumber = fromLineNumber | 0;
         toLineNumber = toLineNumber | 0;
         this._lineCount -= (toLineNumber - fromLineNumber + 1);
@@ -233,9 +244,9 @@ class LinesLayout {
                 this._arr[i].afterLineNumber -= (toLineNumber - fromLineNumber + 1);
             }
         }
+        this._lineHeightsManager.onLinesDeleted(fromLineNumber, toLineNumber);
     }
     onLinesInserted(fromLineNumber, toLineNumber) {
-        this._checkPendingChanges();
         fromLineNumber = fromLineNumber | 0;
         toLineNumber = toLineNumber | 0;
         this._lineCount += (toLineNumber - fromLineNumber + 1);
@@ -245,16 +256,15 @@ class LinesLayout {
                 this._arr[i].afterLineNumber += (toLineNumber - fromLineNumber + 1);
             }
         }
+        this._lineHeightsManager.onLinesInserted(fromLineNumber, toLineNumber);
     }
     getWhitespacesTotalHeight() {
-        this._checkPendingChanges();
         if (this._arr.length === 0) {
             return 0;
         }
         return this.getWhitespacesAccumulatedHeight(this._arr.length - 1);
     }
     getWhitespacesAccumulatedHeight(index) {
-        this._checkPendingChanges();
         index = index | 0;
         let startIndex = Math.max(0, this._prefixSumValidIndex + 1);
         if (startIndex === 0) {
@@ -268,13 +278,11 @@ class LinesLayout {
         return this._arr[index].prefixSum;
     }
     getLinesTotalHeight() {
-        this._checkPendingChanges();
-        const linesHeight = this._lineHeight * this._lineCount;
+        const linesHeight = this._lineHeightsManager.getAccumulatedLineHeightsIncludingLineNumber(this._lineCount);
         const whitespacesHeight = this.getWhitespacesTotalHeight();
         return linesHeight + whitespacesHeight + this._paddingTop + this._paddingBottom;
     }
     getWhitespaceAccumulatedHeightBeforeLineNumber(lineNumber) {
-        this._checkPendingChanges();
         lineNumber = lineNumber | 0;
         const lastWhitespaceBeforeLineNumber = this._findLastWhitespaceBeforeLineNumber(lineNumber);
         if (lastWhitespaceBeforeLineNumber === -1) {
@@ -315,16 +323,14 @@ class LinesLayout {
         return -1;
     }
     getFirstWhitespaceIndexAfterLineNumber(lineNumber) {
-        this._checkPendingChanges();
         lineNumber = lineNumber | 0;
         return this._findFirstWhitespaceAfterLineNumber(lineNumber);
     }
     getVerticalOffsetForLineNumber(lineNumber, includeViewZones = false) {
-        this._checkPendingChanges();
         lineNumber = lineNumber | 0;
         let previousLinesHeight;
         if (lineNumber > 1) {
-            previousLinesHeight = this._lineHeight * (lineNumber - 1);
+            previousLinesHeight = this._lineHeightsManager.getAccumulatedLineHeightsIncludingLineNumber(lineNumber - 1);
         }
         else {
             previousLinesHeight = 0;
@@ -332,19 +338,19 @@ class LinesLayout {
         const previousWhitespacesHeight = this.getWhitespaceAccumulatedHeightBeforeLineNumber(lineNumber - (includeViewZones ? 1 : 0));
         return previousLinesHeight + previousWhitespacesHeight + this._paddingTop;
     }
+    getLineHeightForLineNumber(lineNumber) {
+        return this._lineHeightsManager.heightForLineNumber(lineNumber);
+    }
     getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones = false) {
-        this._checkPendingChanges();
         lineNumber = lineNumber | 0;
-        const previousLinesHeight = this._lineHeight * lineNumber;
+        const previousLinesHeight = this._lineHeightsManager.getAccumulatedLineHeightsIncludingLineNumber(lineNumber);
         const previousWhitespacesHeight = this.getWhitespaceAccumulatedHeightBeforeLineNumber(lineNumber + (includeViewZones ? 1 : 0));
         return previousLinesHeight + previousWhitespacesHeight + this._paddingTop;
     }
     hasWhitespace() {
-        this._checkPendingChanges();
         return this.getWhitespacesCount() > 0;
     }
     getWhitespaceMinWidth() {
-        this._checkPendingChanges();
         if (this._minWidth === -1) {
             let minWidth = 0;
             for (let i = 0, len = this._arr.length; i < len; i++) {
@@ -355,7 +361,6 @@ class LinesLayout {
         return this._minWidth;
     }
     isAfterLines(verticalOffset) {
-        this._checkPendingChanges();
         const totalHeight = this.getLinesTotalHeight();
         return verticalOffset > totalHeight;
     }
@@ -363,29 +368,26 @@ class LinesLayout {
         if (this._paddingTop === 0) {
             return false;
         }
-        this._checkPendingChanges();
         return (verticalOffset < this._paddingTop);
     }
     isInBottomPadding(verticalOffset) {
         if (this._paddingBottom === 0) {
             return false;
         }
-        this._checkPendingChanges();
         const totalHeight = this.getLinesTotalHeight();
         return (verticalOffset >= totalHeight - this._paddingBottom);
     }
     getLineNumberAtOrAfterVerticalOffset(verticalOffset) {
-        this._checkPendingChanges();
         verticalOffset = verticalOffset | 0;
         if (verticalOffset < 0) {
             return 1;
         }
         const linesCount = this._lineCount | 0;
-        const lineHeight = this._lineHeight;
         let minLineNumber = 1;
         let maxLineNumber = linesCount;
         while (minLineNumber < maxLineNumber) {
             const midLineNumber = ((minLineNumber + maxLineNumber) / 2) | 0;
+            const lineHeight = this.getLineHeightForLineNumber(midLineNumber);
             const midLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(midLineNumber) | 0;
             if (verticalOffset >= midLineNumberVerticalOffset + lineHeight) {
                 minLineNumber = midLineNumber + 1;
@@ -403,10 +405,8 @@ class LinesLayout {
         return minLineNumber;
     }
     getLinesViewportData(verticalOffset1, verticalOffset2) {
-        this._checkPendingChanges();
         verticalOffset1 = verticalOffset1 | 0;
         verticalOffset2 = verticalOffset2 | 0;
-        const lineHeight = this._lineHeight;
         const startLineNumber = this.getLineNumberAtOrAfterVerticalOffset(verticalOffset1) | 0;
         const startLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(startLineNumber) | 0;
         let endLineNumber = this._lineCount | 0;
@@ -429,13 +429,14 @@ class LinesLayout {
         let bigNumbersDelta = 0;
         if (startLineNumberVerticalOffset >= STEP_SIZE) {
             bigNumbersDelta = Math.floor(startLineNumberVerticalOffset / STEP_SIZE) * STEP_SIZE;
-            bigNumbersDelta = Math.floor(bigNumbersDelta / lineHeight) * lineHeight;
+            bigNumbersDelta = Math.floor(bigNumbersDelta / this._lineHeightsManager.defaultLineHeight) * this._lineHeightsManager.defaultLineHeight;
             currentLineRelativeOffset -= bigNumbersDelta;
         }
         const linesOffsets = [];
         const verticalCenter = verticalOffset1 + (verticalOffset2 - verticalOffset1) / 2;
         let centeredLineNumber = -1;
         for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const lineHeight = this.getLineHeightForLineNumber(lineNumber);
             if (centeredLineNumber === -1) {
                 const currentLineTop = currentVerticalOffset;
                 const currentLineBottom = currentVerticalOffset + lineHeight;
@@ -475,7 +476,8 @@ class LinesLayout {
             }
         }
         if (completelyVisibleStartLineNumber < completelyVisibleEndLineNumber) {
-            if (endLineNumberVerticalOffset + lineHeight > verticalOffset2) {
+            const endLineHeight = this.getLineHeightForLineNumber(endLineNumber);
+            if (endLineNumberVerticalOffset + endLineHeight > verticalOffset2) {
                 completelyVisibleEndLineNumber--;
             }
         }
@@ -487,16 +489,15 @@ class LinesLayout {
             centeredLineNumber: centeredLineNumber,
             completelyVisibleStartLineNumber: completelyVisibleStartLineNumber,
             completelyVisibleEndLineNumber: completelyVisibleEndLineNumber,
-            lineHeight: this._lineHeight,
+            lineHeight: this._lineHeightsManager.defaultLineHeight,
         };
     }
     getVerticalOffsetForWhitespaceIndex(whitespaceIndex) {
-        this._checkPendingChanges();
         whitespaceIndex = whitespaceIndex | 0;
         const afterLineNumber = this.getAfterLineNumberForWhitespaceIndex(whitespaceIndex);
         let previousLinesHeight;
         if (afterLineNumber >= 1) {
-            previousLinesHeight = this._lineHeight * afterLineNumber;
+            previousLinesHeight = this._lineHeightsManager.getAccumulatedLineHeightsIncludingLineNumber(afterLineNumber);
         }
         else {
             previousLinesHeight = 0;
@@ -511,7 +512,6 @@ class LinesLayout {
         return previousLinesHeight + previousWhitespacesHeight + this._paddingTop;
     }
     getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset) {
-        this._checkPendingChanges();
         verticalOffset = verticalOffset | 0;
         let minWhitespaceIndex = 0;
         let maxWhitespaceIndex = this.getWhitespacesCount() - 1;
@@ -540,7 +540,6 @@ class LinesLayout {
         return minWhitespaceIndex;
     }
     getWhitespaceAtVerticalOffset(verticalOffset) {
-        this._checkPendingChanges();
         verticalOffset = verticalOffset | 0;
         const candidateIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset);
         if (candidateIndex < 0) {
@@ -564,7 +563,6 @@ class LinesLayout {
         };
     }
     getWhitespaceViewportData(verticalOffset1, verticalOffset2) {
-        this._checkPendingChanges();
         verticalOffset1 = verticalOffset1 | 0;
         verticalOffset2 = verticalOffset2 | 0;
         const startIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset1);
@@ -589,25 +587,20 @@ class LinesLayout {
         return result;
     }
     getWhitespaces() {
-        this._checkPendingChanges();
         return this._arr.slice(0);
     }
     getWhitespacesCount() {
-        this._checkPendingChanges();
         return this._arr.length;
     }
     getIdForWhitespaceIndex(index) {
-        this._checkPendingChanges();
         index = index | 0;
         return this._arr[index].id;
     }
     getAfterLineNumberForWhitespaceIndex(index) {
-        this._checkPendingChanges();
         index = index | 0;
         return this._arr[index].afterLineNumber;
     }
     getHeightForWhitespaceIndex(index) {
-        this._checkPendingChanges();
         index = index | 0;
         return this._arr[index].height;
     }

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

@@ -4,8 +4,9 @@ import { IScrollPosition, ScrollEvent, Scrollable, INewScrollPosition } from "..
 import { ConfigurationChangedEvent } from "../config/editorOptions.js";
 import { ScrollType } from "../editorCommon.js";
 import { IEditorConfiguration } from "../config/editorConfiguration.js";
-import { IEditorWhitespace, IPartialViewLinesViewportData, IViewLayout, IViewWhitespaceViewportData, IWhitespaceChangeAccessor, Viewport } from "../viewModel.js";
+import { IEditorWhitespace, IPartialViewLinesViewportData, ILineHeightChangeAccessor, IViewLayout, IViewWhitespaceViewportData, IWhitespaceChangeAccessor, Viewport } from "../viewModel.js";
 import { ContentSizeChangedEvent } from "../viewModelEventDispatcher.js";
+import { ICustomLineHeightData } from "./lineHeights.js";
 export declare class ViewLayout extends Disposable implements IViewLayout {
     private readonly _configuration;
     private readonly _linesLayout;
@@ -14,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, scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable);
+    constructor(configuration: IEditorConfiguration, lineCount: number, customLineHeightData: ICustomLineHeightData[], scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable);
     dispose(): void;
     getScrollable(): Scrollable;
     onHeightMaybeChanged(): void;
     private _configureSmoothScrollDuration;
     onConfigurationChanged(e: ConfigurationChangedEvent): void;
-    onFlushed(lineCount: number): void;
+    onFlushed(lineCount: number, customLineHeightData: ICustomLineHeightData[]): void;
     onLinesDeleted(fromLineNumber: number, toLineNumber: number): void;
     onLinesInserted(fromLineNumber: number, toLineNumber: number): void;
     private _getHorizontalScrollbarHeight;
@@ -38,8 +39,10 @@ export declare class ViewLayout extends Disposable implements IViewLayout {
         scrollLeft: number;
     };
     changeWhitespace(callback: (accessor: IWhitespaceChangeAccessor) => void): boolean;
+    changeSpecialLineHeights(callback: (accessor: ILineHeightChangeAccessor) => void): boolean;
     getVerticalOffsetForLineNumber(lineNumber: number, includeViewZones?: boolean): number;
     getVerticalOffsetAfterLineNumber(lineNumber: number, includeViewZones?: boolean): number;
+    getLineHeightForLineNumber(lineNumber: number): number;
     isAfterLines(verticalOffset: number): boolean;
     isInTopPadding(verticalOffset: number): boolean;
     isInBottomPadding(verticalOffset: number): boolean;

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

@@ -106,7 +106,7 @@ class EditorScrollable extends Disposable {
     }
 }
 class ViewLayout extends Disposable {
-    constructor(configuration, lineCount, scheduleAtNextAnimationFrame) {
+    constructor(configuration, lineCount, customLineHeightData, scheduleAtNextAnimationFrame) {
         super();
         this._configuration = configuration;
         const options = this._configuration.options;
@@ -116,7 +116,8 @@ class ViewLayout extends Disposable {
             lineCount,
             options.get(EditorOption.lineHeight),
             padding.top,
-            padding.bottom
+            padding.bottom,
+            customLineHeightData
         ));
         this._maxLineWidth = 0;
         this._overlayWidgetsMinWidth = 0;
@@ -142,7 +143,7 @@ class ViewLayout extends Disposable {
     onConfigurationChanged(e) {
         const options = this._configuration.options;
         if (e.hasChanged(EditorOption.lineHeight)) {
-            this._linesLayout.setLineHeight(options.get(EditorOption.lineHeight));
+            this._linesLayout.setDefaultLineHeight(options.get(EditorOption.lineHeight));
         }
         if (e.hasChanged(EditorOption.padding)) {
             const padding = options.get(EditorOption.padding);
@@ -168,8 +169,8 @@ class ViewLayout extends Disposable {
             this._configureSmoothScrollDuration();
         }
     }
-    onFlushed(lineCount) {
-        this._linesLayout.onFlushed(lineCount);
+    onFlushed(lineCount, customLineHeightData) {
+        this._linesLayout.onFlushed(lineCount, customLineHeightData);
     }
     onLinesDeleted(fromLineNumber, toLineNumber) {
         this._linesLayout.onLinesDeleted(fromLineNumber, toLineNumber);
@@ -288,12 +289,22 @@ class ViewLayout extends Disposable {
         }
         return hadAChange;
     }
+    changeSpecialLineHeights(callback) {
+        const hadAChange = this._linesLayout.changeLineHeights(callback);
+        if (hadAChange) {
+            this.onHeightMaybeChanged();
+        }
+        return hadAChange;
+    }
     getVerticalOffsetForLineNumber(lineNumber, includeViewZones = false) {
         return this._linesLayout.getVerticalOffsetForLineNumber(lineNumber, includeViewZones);
     }
     getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones = false) {
         return this._linesLayout.getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones);
     }
+    getLineHeightForLineNumber(lineNumber) {
+        return this._linesLayout.getLineHeightForLineNumber(lineNumber);
+    }
     isAfterLines(verticalOffset) {
         return this._linesLayout.isAfterLines(verticalOffset);
     }

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

@@ -43,6 +43,7 @@ export declare class ViewModel extends Disposable implements IViewModel {
     createLineBreaksComputer(): ILineBreaksComputer;
     addViewEventHandler(eventHandler: ViewEventHandler): void;
     removeViewEventHandler(eventHandler: ViewEventHandler): void;
+    private _getCustomLineHeights;
     private _updateConfigurationViewLineCountNow;
     private getModelVisibleRanges;
     visibleLinesStabilized(): void;

package/vscode/src/vs/editor/common/viewModel/viewModelImpl.js

@@ -13,7 +13,7 @@ import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { ScrollType } from '../editorCommon.js';
 import { EndOfLinePreference, TrackedRangeStickiness } from '../model.js';
-import { InternalModelContentChangeEvent, RawContentChangedType } from '../textModelEvents.js';
+import { InternalModelContentChangeEvent, RawContentChangedType, ModelLineHeightChangedEvent } from '../textModelEvents.js';
 import { TokenizationRegistry } from '../languages.js';
 import { ColorId } from '../encodedTokenAttributes.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
@@ -23,7 +23,7 @@ import { ViewLayout } from '../viewLayout/viewLayout.js';
 import { MinimapTokensColorTracker } from './minimapTokensColorTracker.js';
 import { ViewLineRenderingData, MinimapLinesRenderingData, OverviewRulerDecorationsGroup } from '../viewModel.js';
 import { ViewModelDecorations } from './viewModelDecorations.js';
-import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, WidgetFocusChangedEvent, ModelContentChangedEvent, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
+import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, WidgetFocusChangedEvent, ModelContentChangedEvent, ModelLineHeightChangedEvent as ModelLineHeightChangedEvent$1, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
 import { ViewModelLinesFromModelAsIs, ViewModelLinesFromProjectedModel } from './viewModelLines.js';
 import { GlyphMarginLanesModel } from './glyphLanesModel.js';
 
@@ -76,7 +76,12 @@ class ViewModel extends Disposable {
         }
         this.coordinatesConverter = this._lines.createCoordinatesConverter();
         this._cursor = this._register(( new CursorsController(model, this, this.coordinatesConverter, this.cursorConfig)));
-        this.viewLayout = this._register(( new ViewLayout(this._configuration, this.getLineCount(), scheduleAtNextAnimationFrame)));
+        this.viewLayout = this._register(( new ViewLayout(
+            this._configuration,
+            this.getLineCount(),
+            this._getCustomLineHeights(),
+            scheduleAtNextAnimationFrame
+        )));
         this._register(this.viewLayout.onDidScroll((e) => {
             if (e.scrollTopChanged) {
                 this._handleVisibleLinesChanged();
@@ -141,6 +146,19 @@ class ViewModel extends Disposable {
     removeViewEventHandler(eventHandler) {
         this._eventDispatcher.removeViewEventHandler(eventHandler);
     }
+    _getCustomLineHeights() {
+        const decorations = this.model.getCustomLineHeightsDecorations(this._editorId);
+        return ( decorations.map((d) => {
+            const lineNumber = d.range.startLineNumber;
+            const viewRange = this.coordinatesConverter.convertModelRangeToViewRange(( new Range(lineNumber, 1, lineNumber, this.model.getLineMaxColumn(lineNumber))));
+            return {
+                decorationId: d.id,
+                startLineNumber: viewRange.startLineNumber,
+                endLineNumber: viewRange.endLineNumber,
+                lineHeight: d.options.lineHeight || 0
+            };
+        }));
+    }
     _updateConfigurationViewLineCountNow() {
         this._configuration.setViewLineCount(this._lines.getViewLineCount());
     }
@@ -203,7 +221,7 @@ class ViewModel extends Disposable {
             eventsCollector.emitViewEvent(new ViewDecorationsChangedEvent(null));
             this._cursor.onLineMappingChanged(eventsCollector);
             this._decorations.onLineMappingChanged();
-            this.viewLayout.onFlushed(this.getLineCount());
+            this.viewLayout.onFlushed(this.getLineCount(), this._getCustomLineHeights());
             this._updateConfigurationViewLineCount.schedule();
         }
         if (e.hasChanged(EditorOption.readOnly)) {
@@ -267,7 +285,7 @@ class ViewModel extends Disposable {
                             this._lines.onModelFlushed();
                             eventsCollector.emitViewEvent(new ViewFlushedEvent());
                             this._decorations.reset();
-                            this.viewLayout.onFlushed(this.getLineCount());
+                            this.viewLayout.onFlushed(this.getLineCount(), this._getCustomLineHeights());
                             hadOtherModelChange = true;
                             break;
                         }
@@ -350,6 +368,25 @@ class ViewModel extends Disposable {
             }
             this._handleVisibleLinesChanged();
         }));
+        this._register(this.model.onDidChangeLineHeight((e) => {
+            const filteredChanges = e.changes.filter((change) => change.ownerId === this._editorId || change.ownerId === 0);
+            this.viewLayout.changeSpecialLineHeights((accessor) => {
+                for (const change of filteredChanges) {
+                    const { decorationId, lineNumber, lineHeight } = change;
+                    const viewRange = this.coordinatesConverter.convertModelRangeToViewRange(( new Range(lineNumber, 1, lineNumber, this.model.getLineMaxColumn(lineNumber))));
+                    if (lineHeight !== null) {
+                        accessor.insertOrChangeCustomLineHeight(decorationId, viewRange.startLineNumber, viewRange.endLineNumber, lineHeight);
+                    }
+                    else {
+                        accessor.removeCustomLineHeight(decorationId);
+                    }
+                }
+            });
+            if (filteredChanges.length > 0) {
+                const filteredEvent = new ModelLineHeightChangedEvent(filteredChanges);
+                this._eventDispatcher.emitOutgoingEvent(( new ModelLineHeightChangedEvent$1(filteredEvent)));
+            }
+        }));
         this._register(this.model.onDidChangeTokens((e) => {
             const viewRanges = [];
             for (let j = 0, lenJ = e.ranges.length; j < lenJ; j++) {
@@ -397,7 +434,7 @@ class ViewModel extends Disposable {
                     eventsCollector.emitViewEvent(new ViewDecorationsChangedEvent(null));
                     this._cursor.onLineMappingChanged(eventsCollector);
                     this._decorations.onLineMappingChanged();
-                    this.viewLayout.onFlushed(this.getLineCount());
+                    this.viewLayout.onFlushed(this.getLineCount(), this._getCustomLineHeights());
                 }
                 finally {
                     this._eventDispatcher.endEmitViewEvents();
@@ -437,7 +474,7 @@ class ViewModel extends Disposable {
                 eventsCollector.emitViewEvent(new ViewDecorationsChangedEvent(null));
                 this._cursor.onLineMappingChanged(eventsCollector);
                 this._decorations.onLineMappingChanged();
-                this.viewLayout.onFlushed(this.getLineCount());
+                this.viewLayout.onFlushed(this.getLineCount(), this._getCustomLineHeights());
                 this.viewLayout.onHeightMaybeChanged();
             }
             const firstModelLineInViewPort = stableViewport.viewportStartModelPosition?.lineNumber;

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

@@ -95,6 +95,7 @@ export interface IViewLayout {
     getLineNumberAtVerticalOffset(verticalOffset: number): number;
     getVerticalOffsetForLineNumber(lineNumber: number, includeViewZones?: boolean): number;
     getVerticalOffsetAfterLineNumber(lineNumber: number, includeViewZones?: boolean): number;
+    getLineHeightForLineNumber(lineNumber: number): number;
     getWhitespaceAtVerticalOffset(verticalOffset: number): IViewWhitespaceViewportData | null;
     getWhitespaceViewportData(): IViewWhitespaceViewportData[];
 }
@@ -108,6 +109,10 @@ export interface IWhitespaceChangeAccessor {
     changeOneWhitespace(id: string, newAfterLineNumber: number, newHeight: number): void;
     removeWhitespace(id: string): void;
 }
+export interface ILineHeightChangeAccessor {
+    insertOrChangeCustomLineHeight(decorationId: string, startLineNumber: number, endLineNumber: number, lineHeight: number): void;
+    removeCustomLineHeight(decorationId: string): void;
+}
 export interface IPartialViewLinesViewportData {
     readonly bigNumbersDelta: number;
     readonly startLineNumber: number;

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

@@ -4,7 +4,7 @@ import { IContentSizeChangedEvent } from "./editorCommon.js";
 import { Selection } from "./core/selection.js";
 import { Disposable } from "../../base/common/lifecycle.js";
 import { CursorChangeReason } from "./cursorEvents.js";
-import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent } from "./textModelEvents.js";
+import { ModelLineHeightChangedEvent as OriginalModelLineHeightChangedEvent, IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent } from "./textModelEvents.js";
 export declare class ViewModelEventDispatcher extends Disposable {
     private readonly _onEvent;
     readonly onEvent: import("../../base/common/event.js").Event<OutgoingViewModelEvent>;
@@ -34,7 +34,7 @@ export declare class ViewModelEventsCollector {
     emitViewEvent(event: ViewEvent): void;
     emitOutgoingEvent(e: OutgoingViewModelEvent): void;
 }
-export type OutgoingViewModelEvent = (ContentSizeChangedEvent | FocusChangedEvent | WidgetFocusChangedEvent | ScrollChangedEvent | ViewZonesChangedEvent | HiddenAreasChangedEvent | ReadOnlyEditAttemptEvent | CursorStateChangedEvent | ModelDecorationsChangedEvent | ModelLanguageChangedEvent | ModelLanguageConfigurationChangedEvent | ModelContentChangedEvent | ModelOptionsChangedEvent | ModelTokensChangedEvent);
+export type OutgoingViewModelEvent = (ContentSizeChangedEvent | FocusChangedEvent | WidgetFocusChangedEvent | ScrollChangedEvent | ViewZonesChangedEvent | HiddenAreasChangedEvent | ReadOnlyEditAttemptEvent | CursorStateChangedEvent | ModelDecorationsChangedEvent | ModelLanguageChangedEvent | ModelLanguageConfigurationChangedEvent | ModelContentChangedEvent | ModelOptionsChangedEvent | ModelTokensChangedEvent | ModelLineHeightChangedEvent);
 export declare enum OutgoingViewModelEventKind {
     ContentSizeChanged = 0,
     FocusChanged = 1,
@@ -49,7 +49,8 @@ export declare enum OutgoingViewModelEventKind {
     ModelLanguageConfigurationChanged = 10,
     ModelContentChanged = 11,
     ModelOptionsChanged = 12,
-    ModelTokensChanged = 13
+    ModelTokensChanged = 13,
+    ModelLineHeightChanged = 14
 }
 export declare class ContentSizeChangedEvent implements IContentSizeChangedEvent {
     readonly kind = OutgoingViewModelEventKind.ContentSizeChanged;
@@ -171,3 +172,10 @@ export declare class ModelTokensChangedEvent {
     isNoOp(): boolean;
     attemptToMerge(other: OutgoingViewModelEvent): OutgoingViewModelEvent | null;
 }
+export declare class ModelLineHeightChangedEvent {
+    readonly event: OriginalModelLineHeightChangedEvent;
+    readonly kind = OutgoingViewModelEventKind.ModelLineHeightChanged;
+    constructor(event: OriginalModelLineHeightChangedEvent);
+    isNoOp(): boolean;
+    attemptToMerge(other: OutgoingViewModelEvent): OutgoingViewModelEvent | null;
+}

package/vscode/src/vs/editor/common/viewModelEventDispatcher.js

@@ -146,6 +146,7 @@ var OutgoingViewModelEventKind;
     OutgoingViewModelEventKind[OutgoingViewModelEventKind["ModelContentChanged"] = 11] = "ModelContentChanged";
     OutgoingViewModelEventKind[OutgoingViewModelEventKind["ModelOptionsChanged"] = 12] = "ModelOptionsChanged";
     OutgoingViewModelEventKind[OutgoingViewModelEventKind["ModelTokensChanged"] = 13] = "ModelTokensChanged";
+    OutgoingViewModelEventKind[OutgoingViewModelEventKind["ModelLineHeightChanged"] = 14] = "ModelLineHeightChanged";
 })(OutgoingViewModelEventKind || (OutgoingViewModelEventKind = {}));
 class ContentSizeChangedEvent {
     constructor(oldContentWidth, oldContentHeight, contentWidth, contentHeight) {
@@ -402,5 +403,17 @@ class ModelTokensChangedEvent {
         return null;
     }
 }
+class ModelLineHeightChangedEvent {
+    constructor(event) {
+        this.event = event;
+        this.kind = OutgoingViewModelEventKind.ModelLineHeightChanged;
+    }
+    isNoOp() {
+        return false;
+    }
+    attemptToMerge(other) {
+        return null;
+    }
+}
 
-export { ContentSizeChangedEvent, CursorStateChangedEvent, FocusChangedEvent, HiddenAreasChangedEvent, ModelContentChangedEvent, ModelDecorationsChangedEvent, ModelLanguageChangedEvent, ModelLanguageConfigurationChangedEvent, ModelOptionsChangedEvent, ModelTokensChangedEvent, OutgoingViewModelEventKind, ReadOnlyEditAttemptEvent, ScrollChangedEvent, ViewModelEventDispatcher, ViewModelEventsCollector, ViewZonesChangedEvent, WidgetFocusChangedEvent };
+export { ContentSizeChangedEvent, CursorStateChangedEvent, FocusChangedEvent, HiddenAreasChangedEvent, ModelContentChangedEvent, ModelDecorationsChangedEvent, ModelLanguageChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLineHeightChangedEvent, ModelOptionsChangedEvent, ModelTokensChangedEvent, OutgoingViewModelEventKind, ReadOnlyEditAttemptEvent, ScrollChangedEvent, ViewModelEventDispatcher, ViewModelEventsCollector, ViewZonesChangedEvent, WidgetFocusChangedEvent };