@codingame/monaco-vscode-api 13.1.7 → 14.0.1

package/vscode/src/vs/editor/browser/gpu/renderStrategy/viewportRenderStrategy.js

@@ -0,0 +1,287 @@
+
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { Color } from '../../../../base/common/color.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { CursorColumns } from '../../../common/core/cursorColumns.js';
+import { createContentSegmenter } from '../contentSegmenter.js';
+import { BindingId } from '../gpu.js';
+import { GPULifecycle } from '../gpuDisposable.js';
+import { quadVertices } from '../gpuUtils.js';
+import { ViewGpuContext } from '../viewGpuContext.js';
+import { BaseRenderStrategy } from './baseRenderStrategy.js';
+import { fullFileRenderStrategyWgsl } from './fullFileRenderStrategy.wgsl.js';
+
+var Constants;
+(function (Constants) {
+    Constants[Constants["IndicesPerCell"] = 6] = "IndicesPerCell";
+    Constants[Constants["CellBindBufferCapacityIncrement"] = 32] = "CellBindBufferCapacityIncrement";
+    Constants[Constants["CellBindBufferInitialCapacity"] = 63] = "CellBindBufferInitialCapacity";
+})(Constants || (Constants = {}));
+var CellBufferInfo;
+(function (CellBufferInfo) {
+    CellBufferInfo[CellBufferInfo["FloatsPerEntry"] = 6] = "FloatsPerEntry";
+    CellBufferInfo[CellBufferInfo["BytesPerEntry"] = 24] = "BytesPerEntry";
+    CellBufferInfo[CellBufferInfo["Offset_X"] = 0] = "Offset_X";
+    CellBufferInfo[CellBufferInfo["Offset_Y"] = 1] = "Offset_Y";
+    CellBufferInfo[CellBufferInfo["Offset_Unused1"] = 2] = "Offset_Unused1";
+    CellBufferInfo[CellBufferInfo["Offset_Unused2"] = 3] = "Offset_Unused2";
+    CellBufferInfo[CellBufferInfo["GlyphIndex"] = 4] = "GlyphIndex";
+    CellBufferInfo[CellBufferInfo["TextureIndex"] = 5] = "TextureIndex";
+})(CellBufferInfo || (CellBufferInfo = {}));
+class ViewportRenderStrategy extends BaseRenderStrategy {
+    static { this.maxSupportedColumns = 2000; }
+    get bindGroupEntries() {
+        return [
+            { binding: BindingId.Cells, resource: { buffer: this._cellBindBuffer } },
+            { binding: BindingId.ScrollOffset, resource: { buffer: this._scrollOffsetBindBuffer } }
+        ];
+    }
+    constructor(context, viewGpuContext, device, glyphRasterizer) {
+        super(context, viewGpuContext, device, glyphRasterizer);
+        this.type = 'viewport';
+        this.wgsl = fullFileRenderStrategyWgsl;
+        this._cellBindBufferLineCapacity = Constants.CellBindBufferInitialCapacity;
+        this._activeDoubleBufferIndex = 0;
+        this._visibleObjectCount = 0;
+        this._scrollInitialized = false;
+        this._onDidChangeBindGroupEntries = this._register(( new Emitter()));
+        this.onDidChangeBindGroupEntries = this._onDidChangeBindGroupEntries.event;
+        this._rebuildCellBuffer(this._cellBindBufferLineCapacity);
+        const scrollOffsetBufferSize = 2;
+        this._scrollOffsetBindBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco scroll offset buffer',
+            size: scrollOffsetBufferSize * Float32Array.BYTES_PER_ELEMENT,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._scrollOffsetValueBuffer = ( new Float32Array(scrollOffsetBufferSize));
+    }
+    _rebuildCellBuffer(lineCount) {
+        this._cellBindBuffer?.destroy();
+        const lineCountWithIncrement = (Math.floor(lineCount / Constants.CellBindBufferCapacityIncrement) + 1) * Constants.CellBindBufferCapacityIncrement;
+        const bufferSize = lineCountWithIncrement * ViewportRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell * Float32Array.BYTES_PER_ELEMENT;
+        this._cellBindBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco full file cell buffer',
+            size: bufferSize,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._cellValueBuffers = [
+            ( new ArrayBuffer(bufferSize)),
+            ( new ArrayBuffer(bufferSize)),
+        ];
+        this._cellBindBufferLineCapacity = lineCountWithIncrement;
+        this._onDidChangeBindGroupEntries.fire();
+    }
+    onConfigurationChanged(e) {
+        return true;
+    }
+    onDecorationsChanged(e) {
+        return true;
+    }
+    onTokensChanged(e) {
+        return true;
+    }
+    onLinesDeleted(e) {
+        return true;
+    }
+    onLinesInserted(e) {
+        return true;
+    }
+    onLinesChanged(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        const dpr = getActiveWindow().devicePixelRatio;
+        this._scrollOffsetValueBuffer[0] = (e?.scrollLeft ?? this._context.viewLayout.getCurrentScrollLeft()) * dpr;
+        this._scrollOffsetValueBuffer[1] = (e?.scrollTop ?? this._context.viewLayout.getCurrentScrollTop()) * dpr;
+        this._device.queue.writeBuffer(this._scrollOffsetBindBuffer, 0, this._scrollOffsetValueBuffer);
+        return true;
+    }
+    onThemeChanged(e) {
+        return true;
+    }
+    onLineMappingChanged(e) {
+        return true;
+    }
+    onZonesChanged(e) {
+        return true;
+    }
+    reset() {
+        for (const bufferIndex of [0, 1]) {
+            const buffer = ( new Float32Array(this._cellValueBuffers[bufferIndex]));
+            buffer.fill(0, 0, buffer.length);
+            this._device.queue.writeBuffer(this._cellBindBuffer, 0, buffer.buffer, 0, buffer.byteLength);
+        }
+    }
+    update(viewportData, viewLineOptions) {
+        let chars = '';
+        let segment;
+        let charWidth = 0;
+        let y = 0;
+        let x = 0;
+        let absoluteOffsetX = 0;
+        let absoluteOffsetY = 0;
+        let tabXOffset = 0;
+        let glyph;
+        let cellIndex = 0;
+        let tokenStartIndex = 0;
+        let tokenEndIndex = 0;
+        let tokenMetadata = 0;
+        let decorationStyleSetBold;
+        let decorationStyleSetColor;
+        let decorationStyleSetOpacity;
+        let lineData;
+        let decoration;
+        let fillStartIndex = 0;
+        let fillEndIndex = 0;
+        let tokens;
+        const dpr = getActiveWindow().devicePixelRatio;
+        let contentSegmenter;
+        if (!this._scrollInitialized) {
+            this.onScrollChanged();
+            this._scrollInitialized = true;
+        }
+        if (this._cellBindBufferLineCapacity < viewportData.endLineNumber - viewportData.startLineNumber + 1) {
+            this._rebuildCellBuffer(viewportData.endLineNumber - viewportData.startLineNumber + 1);
+        }
+        const cellBuffer = ( new Float32Array(this._cellValueBuffers[this._activeDoubleBufferIndex]));
+        cellBuffer.fill(0);
+        const lineIndexCount = ViewportRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell;
+        for (y = viewportData.startLineNumber; y <= viewportData.endLineNumber; y++) {
+            if (!this._viewGpuContext.canRender(viewLineOptions, viewportData, y)) {
+                continue;
+            }
+            lineData = viewportData.getViewLineRenderingData(y);
+            tabXOffset = 0;
+            contentSegmenter = createContentSegmenter(lineData, viewLineOptions);
+            charWidth = viewLineOptions.spaceWidth * dpr;
+            absoluteOffsetX = 0;
+            tokens = lineData.tokens;
+            tokenStartIndex = lineData.minColumn - 1;
+            tokenEndIndex = 0;
+            for (let tokenIndex = 0, tokensLen = tokens.getCount(); tokenIndex < tokensLen; tokenIndex++) {
+                tokenEndIndex = tokens.getEndOffset(tokenIndex);
+                if (tokenEndIndex <= tokenStartIndex) {
+                    continue;
+                }
+                tokenMetadata = tokens.getMetadata(tokenIndex);
+                for (x = tokenStartIndex; x < tokenEndIndex; x++) {
+                    if (x > ViewportRenderStrategy.maxSupportedColumns) {
+                        break;
+                    }
+                    segment = contentSegmenter.getSegmentAtIndex(x);
+                    if (segment === undefined) {
+                        continue;
+                    }
+                    chars = segment;
+                    if (!(lineData.isBasicASCII && viewLineOptions.useMonospaceOptimizations)) {
+                        charWidth = this.glyphRasterizer.getTextMetrics(chars).width;
+                    }
+                    decorationStyleSetColor = undefined;
+                    decorationStyleSetBold = undefined;
+                    decorationStyleSetOpacity = undefined;
+                    for (decoration of lineData.inlineDecorations) {
+                        if ((y < decoration.range.startLineNumber || y > decoration.range.endLineNumber) ||
+                            (y === decoration.range.startLineNumber && x < decoration.range.startColumn - 1) ||
+                            (y === decoration.range.endLineNumber && x >= decoration.range.endColumn - 1)) {
+                            continue;
+                        }
+                        const rules = ViewGpuContext.decorationCssRuleExtractor.getStyleRules(this._viewGpuContext.canvas.domNode, decoration.inlineClassName);
+                        for (const rule of rules) {
+                            for (const r of rule.style) {
+                                const value = rule.styleMap.get(r)?.toString() ?? '';
+                                switch (r) {
+                                    case 'color': {
+                                        const parsedColor = Color.Format.CSS.parse(value);
+                                        if (!parsedColor) {
+                                            throw ( new BugIndicatingError('Invalid color format ' + value));
+                                        }
+                                        decorationStyleSetColor = parsedColor.toNumber32Bit();
+                                        break;
+                                    }
+                                    case 'font-weight': {
+                                        const parsedValue = parseCssFontWeight(value);
+                                        if (parsedValue >= 400) {
+                                            decorationStyleSetBold = true;
+                                        }
+                                        else {
+                                            decorationStyleSetBold = false;
+                                        }
+                                        break;
+                                    }
+                                    case 'opacity': {
+                                        const parsedValue = parseCssOpacity(value);
+                                        decorationStyleSetOpacity = parsedValue;
+                                        break;
+                                    }
+                                    default: throw ( new BugIndicatingError('Unexpected inline decoration style'));
+                                }
+                            }
+                        }
+                    }
+                    if (chars === ' ' || chars === '\t') {
+                        cellIndex = ((y - 1) * ViewportRenderStrategy.maxSupportedColumns + x) * Constants.IndicesPerCell;
+                        cellBuffer.fill(0, cellIndex, cellIndex + CellBufferInfo.FloatsPerEntry);
+                        if (chars === '\t') {
+                            const offsetBefore = x + tabXOffset;
+                            tabXOffset = CursorColumns.nextRenderTabStop(x + tabXOffset, lineData.tabSize);
+                            absoluteOffsetX += charWidth * (tabXOffset - offsetBefore);
+                            tabXOffset -= x + 1;
+                        }
+                        else {
+                            absoluteOffsetX += charWidth;
+                        }
+                        continue;
+                    }
+                    const decorationStyleSetId = ViewGpuContext.decorationStyleCache.getOrCreateEntry(decorationStyleSetColor, decorationStyleSetBold, decorationStyleSetOpacity);
+                    glyph = this._viewGpuContext.atlas.getGlyph(this.glyphRasterizer, chars, tokenMetadata, decorationStyleSetId, absoluteOffsetX);
+                    absoluteOffsetY = Math.round(
+                    viewportData.relativeVerticalOffset[y - viewportData.startLineNumber] * dpr +
+                        Math.floor((viewportData.lineHeight * dpr - (glyph.fontBoundingBoxAscent + glyph.fontBoundingBoxDescent)) / 2) +
+                        glyph.fontBoundingBoxAscent);
+                    cellIndex = ((y - viewportData.startLineNumber) * ViewportRenderStrategy.maxSupportedColumns + x) * Constants.IndicesPerCell;
+                    cellBuffer[cellIndex + CellBufferInfo.Offset_X] = Math.floor(absoluteOffsetX);
+                    cellBuffer[cellIndex + CellBufferInfo.Offset_Y] = absoluteOffsetY;
+                    cellBuffer[cellIndex + CellBufferInfo.GlyphIndex] = glyph.glyphIndex;
+                    cellBuffer[cellIndex + CellBufferInfo.TextureIndex] = glyph.pageIndex;
+                    absoluteOffsetX += charWidth;
+                }
+                tokenStartIndex = tokenEndIndex;
+            }
+            fillStartIndex = ((y - viewportData.startLineNumber) * ViewportRenderStrategy.maxSupportedColumns + tokenEndIndex) * Constants.IndicesPerCell;
+            fillEndIndex = ((y - viewportData.startLineNumber) * ViewportRenderStrategy.maxSupportedColumns) * Constants.IndicesPerCell;
+            cellBuffer.fill(0, fillStartIndex, fillEndIndex);
+        }
+        const visibleObjectCount = (viewportData.endLineNumber - viewportData.startLineNumber + 1) * lineIndexCount;
+        this._device.queue.writeBuffer(this._cellBindBuffer, 0, cellBuffer.buffer, 0, (viewportData.endLineNumber - viewportData.startLineNumber) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT);
+        this._activeDoubleBufferIndex = this._activeDoubleBufferIndex ? 0 : 1;
+        this._visibleObjectCount = visibleObjectCount;
+        return visibleObjectCount;
+    }
+    draw(pass, viewportData) {
+        if (this._visibleObjectCount <= 0) {
+            throw ( new BugIndicatingError('Attempt to draw 0 objects'));
+        }
+        pass.draw(quadVertices.length / 2, this._visibleObjectCount);
+    }
+}
+function parseCssFontWeight(value) {
+    switch (value) {
+        case 'lighter':
+        case 'normal': return 400;
+        case 'bolder':
+        case 'bold': return 700;
+    }
+    return parseInt(value);
+}
+function parseCssOpacity(value) {
+    if (value.endsWith('%')) {
+        return parseFloat(value.substring(0, value.length - 1)) / 100;
+    }
+    if (value.match(/^\d+(?:\.\d*)/)) {
+        return parseFloat(value);
+    }
+    return 1;
+}
+
+export { ViewportRenderStrategy };

package/vscode/src/vs/editor/browser/gpu/taskQueue.d.ts

@@ -1,5 +1,5 @@
-import { Disposable } from "../../../base/common/lifecycle.js";
-interface ITaskQueue {
+import { Disposable, type IDisposable } from "../../../base/common/lifecycle.js";
+export interface ITaskQueue extends IDisposable {
     enqueue(task: () => boolean | void): void;
     flush(): void;
     clear(): void;
@@ -26,10 +26,11 @@ export declare class PriorityTaskQueue extends TaskQueue {
     protected _cancelCallback(identifier: number): void;
     private _createDeadline;
 }
-export declare class IdleTaskQueue extends TaskQueue {
+declare class IdleTaskQueueInternal extends TaskQueue {
     protected _requestCallback(callback: IdleRequestCallback): number;
     protected _cancelCallback(identifier: number): void;
 }
+export declare const IdleTaskQueue: typeof PriorityTaskQueue | typeof IdleTaskQueueInternal;
 export declare class DebouncedIdleTask {
     private _queue;
     constructor();

package/vscode/src/vs/editor/browser/gpu/taskQueue.js

@@ -60,7 +60,21 @@ class TaskQueue extends Disposable {
         this.clear();
     }
 }
-class IdleTaskQueue extends TaskQueue {
+class PriorityTaskQueue extends TaskQueue {
+    _requestCallback(callback) {
+        return getActiveWindow().setTimeout(() => callback(this._createDeadline(16)));
+    }
+    _cancelCallback(identifier) {
+        getActiveWindow().clearTimeout(identifier);
+    }
+    _createDeadline(duration) {
+        const end = Date.now() + duration;
+        return {
+            timeRemaining: () => Math.max(0, end - Date.now())
+        };
+    }
+}
+class IdleTaskQueueInternal extends TaskQueue {
     _requestCallback(callback) {
         return getActiveWindow().requestIdleCallback(callback);
     }
@@ -68,5 +82,6 @@ class IdleTaskQueue extends TaskQueue {
         getActiveWindow().cancelIdleCallback(identifier);
     }
 }
+const IdleTaskQueue = ('requestIdleCallback' in getActiveWindow()) ? IdleTaskQueueInternal : PriorityTaskQueue;
 
-export { IdleTaskQueue };
+export { IdleTaskQueue, PriorityTaskQueue };

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.d.ts

@@ -9,23 +9,22 @@ import { IConfigurationService } from "../../../platform/configuration/common/co
 import { INotificationService } from "../../../platform/notification/common/notification.service.js";
 import { RectangleRenderer } from "./rectangleRenderer.js";
 import type { ViewContext } from "../../common/viewModel/viewContext.js";
-import { DecorationCssRuleExtractor } from "./decorationCssRuleExtractor.js";
-declare enum GpuRenderLimits {
-    maxGpuLines = 3000,
-    maxGpuCols = 200
-}
+import { DecorationCssRuleExtractor } from "./css/decorationCssRuleExtractor.js";
+import { DecorationStyleCache } from "./css/decorationStyleCache.js";
 export declare class ViewGpuContext extends Disposable {
     private readonly _instantiationService;
     private readonly _notificationService;
     private readonly configurationService;
-    readonly maxGpuLines = GpuRenderLimits.maxGpuLines;
-    readonly maxGpuCols = GpuRenderLimits.maxGpuCols;
+    readonly maxGpuCols = 2000;
     readonly canvas: FastDomNode<HTMLCanvasElement>;
     readonly ctx: GPUCanvasContext;
-    readonly device: Promise<GPUDevice>;
+    static device: Promise<GPUDevice>;
+    static deviceSync: GPUDevice | undefined;
     readonly rectangleRenderer: RectangleRenderer;
     private static readonly _decorationCssRuleExtractor;
     static get decorationCssRuleExtractor(): DecorationCssRuleExtractor;
+    private static readonly _decorationStyleCache;
+    static get decorationStyleCache(): DecorationStyleCache;
     private static _atlas;
     static get atlas(): TextureAtlas;
     get atlas(): TextureAtlas;
@@ -34,8 +33,8 @@ export declare class ViewGpuContext extends Disposable {
         height: number;
     }>;
     readonly devicePixelRatio: IObservable<number>;
+    readonly contentLeft: IObservable<number>;
     constructor(context: ViewContext, _instantiationService: IInstantiationService, _notificationService: INotificationService, configurationService: IConfigurationService);
     canRender(options: ViewLineOptions, viewportData: ViewportData, lineNumber: number): boolean;
     canRenderDetailed(options: ViewLineOptions, viewportData: ViewportData, lineNumber: number): string[];
 }
-export {};

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.js

@@ -20,22 +20,24 @@ import { INotificationService } from '../../../platform/notification/common/noti
 import { GPULifecycle } from './gpuDisposable.js';
 import { ensureNonNullable, observeDevicePixelDimensions } from './gpuUtils.js';
 import { RectangleRenderer } from './rectangleRenderer.js';
-import { DecorationCssRuleExtractor } from './decorationCssRuleExtractor.js';
+import { DecorationCssRuleExtractor } from './css/decorationCssRuleExtractor.js';
+import { EditorOption } from '../../common/config/editorOptions.js';
 import { InlineDecorationType } from '../../common/viewModel.js';
+import { DecorationStyleCache } from './css/decorationStyleCache.js';
+import { ViewportRenderStrategy } from './renderStrategy/viewportRenderStrategy.js';
 import Severity$1 from '../../../base/common/severity.js';
 
 var ViewGpuContext_1;
-var GpuRenderLimits;
-(function (GpuRenderLimits) {
-    GpuRenderLimits[GpuRenderLimits["maxGpuLines"] = 3000] = "maxGpuLines";
-    GpuRenderLimits[GpuRenderLimits["maxGpuCols"] = 200] = "maxGpuCols";
-})(GpuRenderLimits || (GpuRenderLimits = {}));
 let ViewGpuContext = class ViewGpuContext extends Disposable {
     static { ViewGpuContext_1 = this; }
     static { this._decorationCssRuleExtractor = ( new DecorationCssRuleExtractor()); }
     static get decorationCssRuleExtractor() {
         return ViewGpuContext_1._decorationCssRuleExtractor;
     }
+    static { this._decorationStyleCache = ( new DecorationStyleCache()); }
+    static get decorationStyleCache() {
+        return ViewGpuContext_1._decorationStyleCache;
+    }
     static get atlas() {
         if (!ViewGpuContext_1._atlas) {
             throw ( new BugIndicatingError('Cannot call ViewGpuContext.textureAtlas before device is resolved'));
@@ -50,8 +52,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
         this._instantiationService = _instantiationService;
         this._notificationService = _notificationService;
         this.configurationService = configurationService;
-        this.maxGpuLines = GpuRenderLimits.maxGpuLines;
-        this.maxGpuCols = GpuRenderLimits.maxGpuCols;
+        this.maxGpuCols = ViewportRenderStrategy.maxSupportedColumns;
         this.canvas = createFastDomNode(document.createElement('canvas'));
         this.canvas.setClassName('editorCanvas');
         this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
@@ -62,19 +63,21 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
             }
         }));
         this.ctx = ensureNonNullable(this.canvas.domNode.getContext('webgpu'));
-        this.device = GPULifecycle.requestDevice((message) => {
-            const choices = [{
-                    label: ( localize(144, "Use DOM-based rendering")),
-                    run: () => this.configurationService.updateValue('editor.experimentalGpuAcceleration', 'off'),
-                }];
-            this._notificationService.prompt(Severity$1.Warning, message, choices);
-        }).then(ref => this._register(ref).object);
-        this.device.then(device => {
-            if (!ViewGpuContext_1._atlas) {
-                ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, device.limits.maxTextureDimension2D, undefined);
-            }
-        });
-        this.rectangleRenderer = this._instantiationService.createInstance(RectangleRenderer, context, this.canvas.domNode, this.ctx, this.device);
+        if (!ViewGpuContext_1.device) {
+            ViewGpuContext_1.device = GPULifecycle.requestDevice((message) => {
+                const choices = [{
+                        label: ( localize(144, "Use DOM-based rendering")),
+                        run: () => this.configurationService.updateValue('editor.experimentalGpuAcceleration', 'off'),
+                    }];
+                this._notificationService.prompt(Severity$1.Warning, message, choices);
+            }).then(ref => {
+                ViewGpuContext_1.deviceSync = ref.object;
+                if (!ViewGpuContext_1._atlas) {
+                    ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, ref.object.limits.maxTextureDimension2D, undefined);
+                }
+                return ref.object;
+            });
+        }
         const dprObs = observableValue(this, getActiveWindow().devicePixelRatio);
         this._register(addDisposableListener(getActiveWindow(), 'resize', () => {
             dprObs.set(getActiveWindow().devicePixelRatio, undefined);
@@ -88,13 +91,17 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
             canvasDevicePixelDimensions.set({ width, height }, undefined);
         }));
         this.canvasDevicePixelDimensions = canvasDevicePixelDimensions;
+        const contentLeft = observableValue(this, 0);
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            contentLeft.set(context.configuration.options.get(EditorOption.layoutInfo).contentLeft, undefined);
+        }));
+        this.contentLeft = contentLeft;
+        this.rectangleRenderer = this._instantiationService.createInstance(RectangleRenderer, context, this.contentLeft, this.devicePixelRatio, this.canvas.domNode, this.ctx, ViewGpuContext_1.device);
     }
     canRender(options, viewportData, lineNumber) {
         const data = viewportData.getViewLineRenderingData(lineNumber);
         if (data.containsRTL ||
-            data.maxColumn > GpuRenderLimits.maxGpuCols ||
-            data.continuesWithWrappedLine ||
-            lineNumber >= GpuRenderLimits.maxGpuLines) {
+            data.maxColumn > this.maxGpuCols) {
             return false;
         }
         if (data.inlineDecorations.length > 0) {
@@ -110,7 +117,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
                         return false;
                     }
                     for (const r of rule.style) {
-                        if (!gpuSupportedDecorationCssRules.includes(r)) {
+                        if (!supportsCssRule(r)) {
                             return false;
                         }
                     }
@@ -130,12 +137,9 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
         if (data.containsRTL) {
             reasons.push('containsRTL');
         }
-        if (data.maxColumn > GpuRenderLimits.maxGpuCols) {
+        if (data.maxColumn > this.maxGpuCols) {
             reasons.push('maxColumn > maxGpuCols');
         }
-        if (data.continuesWithWrappedLine) {
-            reasons.push('continuesWithWrappedLine');
-        }
         if (data.inlineDecorations.length > 0) {
             let supported = true;
             const problemTypes = [];
@@ -154,8 +158,8 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
                         return false;
                     }
                     for (const r of rule.style) {
-                        if (!gpuSupportedDecorationCssRules.includes(r)) {
-                            problemRules.push(r);
+                        if (!supportsCssRule(r)) {
+                            problemRules.push(`${r}: ${rule.style[r]}`);
                             return false;
                         }
                     }
@@ -175,9 +179,6 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
                 reasons.push(`inlineDecorations with unsupported CSS selectors (${( problemSelectors.map(e => `\`${e}\``)).join(', ')})`);
             }
         }
-        if (lineNumber >= GpuRenderLimits.maxGpuLines) {
-            reasons.push('lineNumber >= maxGpuLines');
-        }
         return reasons;
     }
 };
@@ -188,6 +189,16 @@ ViewGpuContext = ViewGpuContext_1 = ( __decorate([
 ], ViewGpuContext));
 const gpuSupportedDecorationCssRules = [
     'color',
+    'font-weight',
+    'opacity',
 ];
+function supportsCssRule(rule, style) {
+    if (!gpuSupportedDecorationCssRules.includes(rule)) {
+        return false;
+    }
+    switch (rule) {
+        default: return true;
+    }
+}
 
 export { ViewGpuContext };

package/vscode/src/vs/editor/browser/observableCodeEditor.d.ts

@@ -1,12 +1,15 @@
-import { Disposable, IDisposable } from "../../base/common/lifecycle.js";
-import { IObservable, ITransaction } from "../../base/common/observable.js";
+import { Disposable, DisposableStore, IDisposable } from "../../base/common/lifecycle.js";
+import { IObservable, IObservableWithChange, ITransaction } from "../../base/common/observable.js";
 import { EditorOption, FindComputedEditorOptionValueById } from "../common/config/editorOptions.js";
+import { LineRange } from "../common/core/lineRange.js";
+import { OffsetRange } from "../common/core/offsetRange.js";
 import { Position } from "../common/core/position.js";
 import { Selection } from "../common/core/selection.js";
 import { ICursorSelectionChangedEvent } from "../common/cursorEvents.js";
 import { IModelDeltaDecoration, ITextModel } from "../common/model.js";
 import { IModelContentChangedEvent } from "../common/textModelEvents.js";
-import { ICodeEditor, IOverlayWidgetPosition } from "./editorBrowser.js";
+import { ICodeEditor, IOverlayWidgetPosition, IPasteEvent } from "./editorBrowser.js";
+import { Point } from "./point.js";
 export declare function observableCodeEditor(editor: ICodeEditor): ObservableCodeEditor;
 export declare class ObservableCodeEditor extends Disposable {
     readonly editor: ICodeEditor;
@@ -22,31 +25,35 @@ export declare class ObservableCodeEditor extends Disposable {
     private _forceUpdate;
     private readonly _model;
     readonly model: IObservable<ITextModel | null>;
-    readonly isReadonly: IObservable<boolean, unknown>;
+    readonly isReadonly: IObservable<boolean>;
     private readonly _versionId;
-    readonly versionId: IObservable<number | null, IModelContentChangedEvent | undefined>;
+    readonly versionId: IObservableWithChange<number | null, IModelContentChangedEvent | undefined>;
     private readonly _selections;
-    readonly selections: IObservable<Selection[] | null, ICursorSelectionChangedEvent | undefined>;
-    readonly positions: IObservable<readonly Position[] | null, unknown>;
-    readonly isFocused: IObservable<boolean, unknown>;
-    readonly isTextFocused: IObservable<boolean, unknown>;
-    readonly inComposition: IObservable<boolean, unknown>;
+    readonly selections: IObservableWithChange<Selection[] | null, ICursorSelectionChangedEvent | undefined>;
+    readonly positions: IObservable<readonly Position[] | null>;
+    readonly isFocused: IObservable<boolean>;
+    readonly isTextFocused: IObservable<boolean>;
+    readonly inComposition: IObservable<boolean>;
     readonly value: import("../../base/common/observable.js").ISettableObservable<string, void>;
-    readonly valueIsEmpty: IObservable<boolean, unknown>;
-    readonly cursorSelection: IObservable<Selection | null, unknown>;
-    readonly cursorPosition: IObservable<Position | null, unknown>;
-    readonly cursorLineNumber: IObservable<number | null, unknown>;
+    readonly valueIsEmpty: IObservable<boolean>;
+    readonly cursorSelection: IObservable<Selection | null>;
+    readonly cursorPosition: IObservable<Position | null>;
+    readonly cursorLineNumber: IObservable<number | null>;
     readonly onDidType: import("../../base/common/observable.js").IObservableSignal<string>;
-    readonly scrollTop: IObservable<number, unknown>;
-    readonly scrollLeft: IObservable<number, unknown>;
-    readonly layoutInfo: IObservable<import("../common/config/editorOptions.js").EditorLayoutInfo, unknown>;
-    readonly layoutInfoContentLeft: IObservable<number, unknown>;
-    readonly layoutInfoDecorationsLeft: IObservable<number, unknown>;
-    readonly contentWidth: IObservable<number, unknown>;
+    readonly onDidPaste: import("../../base/common/observable.js").IObservableSignal<IPasteEvent>;
+    readonly scrollTop: IObservable<number>;
+    readonly scrollLeft: IObservable<number>;
+    readonly layoutInfo: IObservable<import("../common/config/editorOptions.js").EditorLayoutInfo>;
+    readonly layoutInfoContentLeft: IObservable<number>;
+    readonly layoutInfoDecorationsLeft: IObservable<number>;
+    readonly layoutInfoWidth: IObservable<number>;
+    readonly contentWidth: IObservable<number>;
     getOption<T extends EditorOption>(id: T): IObservable<FindComputedEditorOptionValueById<T>>;
     setDecorations(decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
-    private _overlayWidgetCounter;
+    private _widgetCounter;
     createOverlayWidget(widget: IObservableOverlayWidget): IDisposable;
+    observeLineOffsetRange(lineRange: IObservable<LineRange>, store: DisposableStore): IObservable<OffsetRange>;
+    observePosition(position: IObservable<Position | null>, store: DisposableStore): IObservable<Point | null>;
 }
 interface IObservableOverlayWidget {
     get domNode(): HTMLElement;