@codingame/monaco-vscode-api 13.1.7 → 14.0.1

package/vscode/src/vs/editor/browser/gpu/raster/glyphRasterizer.js

@@ -2,9 +2,11 @@
 import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
 import { memoize } from '../../../../base/common/decorators.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
 import { StringBuilder } from '../../../common/core/stringBuilder.js';
 import { TokenMetadata, FontStyle } from '../../../common/encodedTokenAttributes.js';
 import { ensureNonNullable } from '../gpuUtils.js';
+import { ViewGpuContext } from '../viewGpuContext.js';
 
 let nextId = 0;
 class GlyphRasterizer extends Disposable {
@@ -32,18 +34,20 @@ class GlyphRasterizer extends Disposable {
             fontBoundingBoxAscent: 0,
             fontBoundingBoxDescent: 0,
         };
-        this._workGlyphConfig = { chars: undefined, tokenMetadata: 0, charMetadata: 0 };
+        this._workGlyphConfig = { chars: undefined, tokenMetadata: 0, decorationStyleSetId: 0 };
+        this._antiAliasing = isMacintosh ? 'greyscale' : 'subpixel';
         const devicePixelFontSize = Math.ceil(this.fontSize * devicePixelRatio);
         this._canvas = ( new OffscreenCanvas(devicePixelFontSize * 3, devicePixelFontSize * 3));
         this._ctx = ensureNonNullable(this._canvas.getContext('2d', {
-            willReadFrequently: true
+            willReadFrequently: true,
+            alpha: this._antiAliasing === 'greyscale',
         }));
         this._ctx.textBaseline = 'top';
         this._ctx.fillStyle = '#FFFFFF';
         this._ctx.font = `${devicePixelFontSize}px ${this.fontFamily}`;
         this._textMetrics = this._ctx.measureText('A');
     }
-    rasterizeGlyph(chars, tokenMetadata, charMetadata, colorMap) {
+    rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, colorMap) {
         if (chars === '') {
             return {
                 source: this._canvas,
@@ -53,43 +57,70 @@ class GlyphRasterizer extends Disposable {
                 fontBoundingBoxDescent: 0,
             };
         }
-        if (this._workGlyphConfig.chars === chars && this._workGlyphConfig.tokenMetadata === tokenMetadata && this._workGlyphConfig.charMetadata === charMetadata) {
+        if (this._workGlyphConfig.chars === chars && this._workGlyphConfig.tokenMetadata === tokenMetadata && this._workGlyphConfig.decorationStyleSetId === decorationStyleSetId) {
             return this._workGlyph;
         }
         this._workGlyphConfig.chars = chars;
         this._workGlyphConfig.tokenMetadata = tokenMetadata;
-        this._workGlyphConfig.charMetadata = charMetadata;
-        return this._rasterizeGlyph(chars, tokenMetadata, charMetadata, colorMap);
+        this._workGlyphConfig.decorationStyleSetId = decorationStyleSetId;
+        return this._rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, colorMap);
     }
-    _rasterizeGlyph(chars, metadata, charMetadata, colorMap) {
+    _rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, colorMap) {
         const devicePixelFontSize = Math.ceil(this.fontSize * this.devicePixelRatio);
         const canvasDim = devicePixelFontSize * 3;
         if (this._canvas.width !== canvasDim) {
             this._canvas.width = canvasDim;
             this._canvas.height = canvasDim;
         }
-        this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+        this._ctx.save();
+        const xSubPixelXOffset = (tokenMetadata & 0b1111) / 10;
+        const bgId = TokenMetadata.getBackground(tokenMetadata);
+        const bg = colorMap[bgId];
+        const decorationStyleSet = ViewGpuContext.decorationStyleCache.getStyleSet(decorationStyleSetId);
+        if (this._antiAliasing === 'subpixel') {
+            this._ctx.fillStyle = bg;
+            this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);
+        }
+        else {
+            this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+        }
         const fontSb = ( new StringBuilder(200));
-        const fontStyle = TokenMetadata.getFontStyle(metadata);
+        const fontStyle = TokenMetadata.getFontStyle(tokenMetadata);
         if (fontStyle & FontStyle.Italic) {
             fontSb.appendString('italic ');
         }
-        if (fontStyle & FontStyle.Bold) {
+        if (decorationStyleSet?.bold !== undefined) {
+            if (decorationStyleSet.bold) {
+                fontSb.appendString('bold ');
+            }
+        }
+        else if (fontStyle & FontStyle.Bold) {
             fontSb.appendString('bold ');
         }
         fontSb.appendString(`${devicePixelFontSize}px ${this.fontFamily}`);
         this._ctx.font = fontSb.build();
         const originX = devicePixelFontSize;
         const originY = devicePixelFontSize;
-        if (charMetadata) {
-            this._ctx.fillStyle = `#${( charMetadata.toString(16)).padStart(8, '0')}`;
+        if (decorationStyleSet?.color !== undefined) {
+            this._ctx.fillStyle = `#${( decorationStyleSet.color.toString(16)).padStart(8, '0')}`;
         }
         else {
-            this._ctx.fillStyle = colorMap[TokenMetadata.getForeground(metadata)];
+            this._ctx.fillStyle = colorMap[TokenMetadata.getForeground(tokenMetadata)];
         }
         this._ctx.textBaseline = 'top';
-        this._ctx.fillText(chars, originX, originY);
+        if (decorationStyleSet?.opacity !== undefined) {
+            this._ctx.globalAlpha = decorationStyleSet.opacity;
+        }
+        this._ctx.fillText(chars, originX + xSubPixelXOffset, originY);
+        this._ctx.restore();
         const imageData = this._ctx.getImageData(0, 0, this._canvas.width, this._canvas.height);
+        if (this._antiAliasing === 'subpixel') {
+            const bgR = parseInt(bg.substring(1, 3), 16);
+            const bgG = parseInt(bg.substring(3, 5), 16);
+            const bgB = parseInt(bg.substring(5, 7), 16);
+            this._clearColor(imageData, bgR, bgG, bgB);
+            this._ctx.putImageData(imageData, 0, 0);
+        }
         this._findGlyphBoundingBox(imageData, this._workGlyph.boundingBox);
         this._workGlyph.source = this._canvas;
         this._workGlyph.originOffset.x = this._workGlyph.boundingBox.left - originX;
@@ -98,6 +129,15 @@ class GlyphRasterizer extends Disposable {
         this._workGlyph.fontBoundingBoxDescent = this._textMetrics.fontBoundingBoxDescent;
         return this._workGlyph;
     }
+    _clearColor(imageData, r, g, b) {
+        for (let offset = 0; offset < imageData.data.length; offset += 4) {
+            if (imageData.data[offset] === r &&
+                imageData.data[offset + 1] === g &&
+                imageData.data[offset + 2] === b) {
+                imageData.data[offset + 3] = 0;
+            }
+        }
+    }
     _findGlyphBoundingBox(imageData, outBoundingBox) {
         const height = this._canvas.height;
         const width = this._canvas.width;
@@ -161,6 +201,9 @@ class GlyphRasterizer extends Disposable {
             }
         }
     }
+    getTextMetrics(text) {
+        return this._ctx.measureText(text);
+    }
 }
 GlyphRasterizer.__decorator = ( __decorate([
     memoize

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

@@ -1,7 +1,8 @@
 export interface IGlyphRasterizer {
     readonly id: number;
     readonly cacheKey: string;
-    rasterizeGlyph(chars: string, tokenMetadata: number, charMetadata: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
+    rasterizeGlyph(chars: string, tokenMetadata: number, decorationStyleSetId: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
+    getTextMetrics(text: string): TextMetrics;
 }
 export interface IBoundingBox {
     left: number;

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

@@ -1,3 +1,4 @@
+import type { IObservable } from "../../../base/common/observable.js";
 import { ViewEventHandler } from "../../common/viewEventHandler.js";
 import type { ViewScrollChangedEvent } from "../../common/viewEvents.js";
 import type { ViewportData } from "../../common/viewLayout/viewLinesViewportData.js";
@@ -31,6 +32,8 @@ export type RectangleRendererEntrySpec = [
 ];
 export declare class RectangleRenderer extends ViewEventHandler {
     private readonly _context;
+    private readonly _contentLeft;
+    private readonly _devicePixelRatio;
     private readonly _canvas;
     private readonly _ctx;
     private _device;
@@ -44,7 +47,7 @@ export declare class RectangleRenderer extends ViewEventHandler {
     private _scrollOffsetValueBuffer;
     private _initialized;
     private readonly _shapeCollection;
-    constructor(_context: ViewContext, _canvas: HTMLCanvasElement, _ctx: GPUCanvasContext, device: Promise<GPUDevice>);
+    constructor(_context: ViewContext, _contentLeft: IObservable<number>, _devicePixelRatio: IObservable<number>, _canvas: HTMLCanvasElement, _ctx: GPUCanvasContext, device: Promise<GPUDevice>);
     private _initWebgpu;
     private _updateBindGroup;
     register(x: number, y: number, width: number, height: number, red: number, green: number, blue: number, alpha: number): IObjectCollectionBufferEntry<RectangleRendererEntrySpec>;

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

@@ -10,9 +10,11 @@ import { createObjectCollectionBuffer } from './objectCollectionBuffer.js';
 import { rectangleRendererWgsl, RectangleRendererBindingId } from './rectangleRenderer.wgsl.js';
 
 class RectangleRenderer extends ViewEventHandler {
-    constructor(_context, _canvas, _ctx, device) {
+    constructor(_context, _contentLeft, _devicePixelRatio, _canvas, _ctx, device) {
         super();
         this._context = _context;
+        this._contentLeft = _contentLeft;
+        this._devicePixelRatio = _devicePixelRatio;
         this._canvas = _canvas;
         this._ctx = _ctx;
         this._shapeBindBuffer = this._register(( new MutableDisposable()));
@@ -192,6 +194,8 @@ class RectangleRenderer extends ViewEventHandler {
         pass.setPipeline(this._pipeline);
         pass.setVertexBuffer(0, this._vertexBuffer);
         pass.setBindGroup(0, this._bindGroup);
+        const contentLeft = Math.ceil(this._contentLeft.get() * this._devicePixelRatio.get());
+        pass.setScissorRect(contentLeft, 0, this._canvas.width - contentLeft, this._canvas.height);
         pass.draw(quadVertices.length / 2, this._shapeCollection.entryCount);
         pass.end();
         const commandBuffer = encoder.finish();

package/vscode/src/vs/editor/browser/gpu/renderStrategy/baseRenderStrategy.d.ts

@@ -0,0 +1,25 @@
+import { ViewEventHandler } from "../../../common/viewEventHandler.js";
+import type { ViewportData } from "../../../common/viewLayout/viewLinesViewportData.js";
+import type { ViewContext } from "../../../common/viewModel/viewContext.js";
+import type { ViewLineOptions } from "../../viewParts/viewLines/viewLineOptions.js";
+import type { IGpuRenderStrategy } from "../gpu.js";
+import { GlyphRasterizer } from "../raster/glyphRasterizer.js";
+import type { ViewGpuContext } from "../viewGpuContext.js";
+export declare abstract class BaseRenderStrategy extends ViewEventHandler implements IGpuRenderStrategy {
+    protected readonly _context: ViewContext;
+    protected readonly _viewGpuContext: ViewGpuContext;
+    protected readonly _device: GPUDevice;
+    protected readonly _glyphRasterizer: {
+        value: GlyphRasterizer;
+    };
+    get glyphRasterizer(): GlyphRasterizer;
+    abstract type: string;
+    abstract wgsl: string;
+    abstract bindGroupEntries: GPUBindGroupEntry[];
+    constructor(_context: ViewContext, _viewGpuContext: ViewGpuContext, _device: GPUDevice, _glyphRasterizer: {
+        value: GlyphRasterizer;
+    });
+    abstract reset(): void;
+    abstract update(viewportData: ViewportData, viewLineOptions: ViewLineOptions): number;
+    abstract draw(pass: GPURenderPassEncoder, viewportData: ViewportData): void;
+}

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

@@ -0,0 +1,16 @@
+
+import { ViewEventHandler } from '../../../common/viewEventHandler.js';
+
+class BaseRenderStrategy extends ViewEventHandler {
+    get glyphRasterizer() { return this._glyphRasterizer.value; }
+    constructor(_context, _viewGpuContext, _device, _glyphRasterizer) {
+        super();
+        this._context = _context;
+        this._viewGpuContext = _viewGpuContext;
+        this._device = _device;
+        this._glyphRasterizer = _glyphRasterizer;
+        this._context.addEventHandler(this);
+    }
+}
+
+export { BaseRenderStrategy };

package/vscode/src/vs/editor/browser/gpu/{fullFileRenderStrategy.d.ts → renderStrategy/fullFileRenderStrategy.d.ts}

@@ -1,16 +1,15 @@
-import { ViewEventHandler } from "../../common/viewEventHandler.js";
-import { type ViewConfigurationChangedEvent, type ViewDecorationsChangedEvent, type ViewLineMappingChangedEvent, type ViewLinesChangedEvent, type ViewLinesDeletedEvent, type ViewLinesInsertedEvent, type ViewScrollChangedEvent, type ViewThemeChangedEvent, type ViewTokensChangedEvent, type ViewZonesChangedEvent } from "../../common/viewEvents.js";
-import type { ViewportData } from "../../common/viewLayout/viewLinesViewportData.js";
-import type { ViewContext } from "../../common/viewModel/viewContext.js";
-import type { ViewLineOptions } from "../viewParts/viewLines/viewLineOptions.js";
-import { type IGpuRenderStrategy } from "./gpu.js";
-import { ViewGpuContext } from "./viewGpuContext.js";
-export declare class FullFileRenderStrategy extends ViewEventHandler implements IGpuRenderStrategy {
-    private readonly _context;
-    private readonly _viewGpuContext;
-    private readonly _device;
+import { type ViewConfigurationChangedEvent, type ViewDecorationsChangedEvent, type ViewLineMappingChangedEvent, type ViewLinesChangedEvent, type ViewLinesDeletedEvent, type ViewLinesInsertedEvent, type ViewScrollChangedEvent, type ViewThemeChangedEvent, type ViewTokensChangedEvent, type ViewZonesChangedEvent } from "../../../common/viewEvents.js";
+import type { ViewportData } from "../../../common/viewLayout/viewLinesViewportData.js";
+import type { ViewContext } from "../../../common/viewModel/viewContext.js";
+import type { ViewLineOptions } from "../../viewParts/viewLines/viewLineOptions.js";
+import { GlyphRasterizer } from "../raster/glyphRasterizer.js";
+import { ViewGpuContext } from "../viewGpuContext.js";
+import { BaseRenderStrategy } from "./baseRenderStrategy.js";
+export declare class FullFileRenderStrategy extends BaseRenderStrategy {
+    static readonly maxSupportedLines = 3000;
+    static readonly maxSupportedColumns = 200;
+    readonly type = "fullfile";
     readonly wgsl: string;
-    private readonly _glyphRasterizer;
     private _cellBindBuffer;
     private _cellValueBuffers;
     private _activeDoubleBufferIndex;
@@ -22,7 +21,9 @@ export declare class FullFileRenderStrategy extends ViewEventHandler implements
     private _scrollInitialized;
     private readonly _queuedBufferUpdates;
     get bindGroupEntries(): GPUBindGroupEntry[];
-    constructor(_context: ViewContext, _viewGpuContext: ViewGpuContext, _device: GPUDevice);
+    constructor(context: ViewContext, viewGpuContext: ViewGpuContext, device: GPUDevice, glyphRasterizer: {
+        value: GlyphRasterizer;
+    });
     onConfigurationChanged(e: ViewConfigurationChangedEvent): boolean;
     onDecorationsChanged(e: ViewDecorationsChangedEvent): boolean;
     onTokensChanged(e: ViewTokensChangedEvent): boolean;

package/vscode/src/vs/editor/browser/gpu/{fullFileRenderStrategy.js → renderStrategy/fullFileRenderStrategy.js}

@@ -1,18 +1,16 @@
 
-import { getActiveWindow } from '../../../base/browser/dom.js';
-import { BugIndicatingError } from '../../../base/common/errors.js';
-import { MandatoryMutableDisposable } from '../../../base/common/lifecycle.js';
-import { EditorOption } from '../../common/config/editorOptions.js';
-import { CursorColumns } from '../../common/core/cursorColumns.js';
-import { ViewEventHandler } from '../../common/viewEventHandler.js';
-import { ViewEventType } from '../../common/viewEvents.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { Color } from '../../../../base/common/color.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { CursorColumns } from '../../../common/core/cursorColumns.js';
+import { ViewEventType } from '../../../common/viewEvents.js';
+import { createContentSegmenter } from '../contentSegmenter.js';
 import { fullFileRenderStrategyWgsl } from './fullFileRenderStrategy.wgsl.js';
-import { BindingId } from './gpu.js';
-import { GPULifecycle } from './gpuDisposable.js';
-import { quadVertices } from './gpuUtils.js';
-import { GlyphRasterizer } from './raster/glyphRasterizer.js';
-import { ViewGpuContext } from './viewGpuContext.js';
-import { Color } from '../../../base/common/color.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';
 
 var Constants;
 (function (Constants) {
@@ -29,18 +27,18 @@ var CellBufferInfo;
     CellBufferInfo[CellBufferInfo["GlyphIndex"] = 4] = "GlyphIndex";
     CellBufferInfo[CellBufferInfo["TextureIndex"] = 5] = "TextureIndex";
 })(CellBufferInfo || (CellBufferInfo = {}));
-class FullFileRenderStrategy extends ViewEventHandler {
+class FullFileRenderStrategy extends BaseRenderStrategy {
+    static { this.maxSupportedLines = 3000; }
+    static { this.maxSupportedColumns = 200; }
     get bindGroupEntries() {
         return [
             { binding: BindingId.Cells, resource: { buffer: this._cellBindBuffer } },
             { binding: BindingId.ScrollOffset, resource: { buffer: this._scrollOffsetBindBuffer } }
         ];
     }
-    constructor(_context, _viewGpuContext, _device) {
-        super();
-        this._context = _context;
-        this._viewGpuContext = _viewGpuContext;
-        this._device = _device;
+    constructor(context, viewGpuContext, device, glyphRasterizer) {
+        super(context, viewGpuContext, device, glyphRasterizer);
+        this.type = 'fullfile';
         this.wgsl = fullFileRenderStrategyWgsl;
         this._activeDoubleBufferIndex = 0;
         this._upToDateLines = [( new Set()), ( new Set())];
@@ -48,11 +46,7 @@ class FullFileRenderStrategy extends ViewEventHandler {
         this._finalRenderedLine = 0;
         this._scrollInitialized = false;
         this._queuedBufferUpdates = [[], []];
-        this._context.addEventHandler(this);
-        const fontFamily = this._context.configuration.options.get(EditorOption.fontFamily);
-        const fontSize = this._context.configuration.options.get(EditorOption.fontSize);
-        this._glyphRasterizer = this._register(( new MandatoryMutableDisposable(( new GlyphRasterizer(fontSize, fontFamily, this._viewGpuContext.devicePixelRatio.get())))));
-        const bufferSize = this._viewGpuContext.maxGpuLines * this._viewGpuContext.maxGpuCols * Constants.IndicesPerCell * Float32Array.BYTES_PER_ELEMENT;
+        const bufferSize = FullFileRenderStrategy.maxSupportedLines * FullFileRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell * Float32Array.BYTES_PER_ELEMENT;
         this._cellBindBuffer = this._register(GPULifecycle.createBuffer(this._device, {
             label: 'Monaco full file cell buffer',
             size: bufferSize,
@@ -73,14 +67,6 @@ class FullFileRenderStrategy extends ViewEventHandler {
     onConfigurationChanged(e) {
         this._invalidateAllLines();
         this._queueBufferUpdate(e);
-        const fontFamily = this._context.configuration.options.get(EditorOption.fontFamily);
-        const fontSize = this._context.configuration.options.get(EditorOption.fontSize);
-        const devicePixelRatio = this._viewGpuContext.devicePixelRatio.get();
-        if (this._glyphRasterizer.value.fontFamily !== fontFamily ||
-            this._glyphRasterizer.value.fontSize !== fontSize ||
-            this._glyphRasterizer.value.devicePixelRatio !== devicePixelRatio) {
-            this._glyphRasterizer.value = ( new GlyphRasterizer(fontSize, fontFamily, devicePixelRatio));
-        }
         return true;
     }
     onDecorationsChanged(e) {
@@ -158,32 +144,36 @@ class FullFileRenderStrategy extends ViewEventHandler {
     }
     update(viewportData, viewLineOptions) {
         let chars = '';
+        let segment;
+        let charWidth = 0;
         let y = 0;
         let x = 0;
         let absoluteOffsetX = 0;
         let absoluteOffsetY = 0;
-        let xOffset = 0;
+        let tabXOffset = 0;
         let glyph;
         let cellIndex = 0;
         let tokenStartIndex = 0;
         let tokenEndIndex = 0;
         let tokenMetadata = 0;
-        let charMetadata = 0;
+        let decorationStyleSetBold;
+        let decorationStyleSetColor;
+        let decorationStyleSetOpacity;
         let lineData;
         let decoration;
-        let content = '';
         let fillStartIndex = 0;
         let fillEndIndex = 0;
         let tokens;
         const dpr = getActiveWindow().devicePixelRatio;
+        let contentSegmenter;
         if (!this._scrollInitialized) {
             this.onScrollChanged();
             this._scrollInitialized = true;
         }
         const cellBuffer = ( new Float32Array(this._cellValueBuffers[this._activeDoubleBufferIndex]));
-        const lineIndexCount = this._viewGpuContext.maxGpuCols * Constants.IndicesPerCell;
+        const lineIndexCount = FullFileRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell;
         const upToDateLines = this._upToDateLines[this._activeDoubleBufferIndex];
-        let dirtyLineStart = Number.MAX_SAFE_INTEGER;
+        let dirtyLineStart = 3000;
         let dirtyLineEnd = 0;
         const queuedBufferUpdates = this._queuedBufferUpdates[this._activeDoubleBufferIndex];
         while (queuedBufferUpdates.length) {
@@ -199,9 +189,9 @@ class FullFileRenderStrategy extends ViewEventHandler {
                     break;
                 }
                 case ViewEventType.ViewLinesDeleted: {
-                    const deletedLineContentStartIndex = (e.fromLineNumber - 1) * this._viewGpuContext.maxGpuCols * Constants.IndicesPerCell;
-                    const deletedLineContentEndIndex = (e.toLineNumber) * this._viewGpuContext.maxGpuCols * Constants.IndicesPerCell;
-                    const nullContentStartIndex = (this._finalRenderedLine - (e.toLineNumber - e.fromLineNumber + 1)) * this._viewGpuContext.maxGpuCols * Constants.IndicesPerCell;
+                    const deletedLineContentStartIndex = (e.fromLineNumber - 1) * FullFileRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell;
+                    const deletedLineContentEndIndex = (e.toLineNumber) * FullFileRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell;
+                    const nullContentStartIndex = (this._finalRenderedLine - (e.toLineNumber - e.fromLineNumber + 1)) * FullFileRenderStrategy.maxSupportedColumns * Constants.IndicesPerCell;
                     cellBuffer.set(cellBuffer.subarray(deletedLineContentEndIndex), deletedLineContentStartIndex);
                     cellBuffer.fill(0, nullContentStartIndex);
                     dirtyLineStart = Math.min(dirtyLineStart, e.fromLineNumber);
@@ -213,8 +203,8 @@ class FullFileRenderStrategy extends ViewEventHandler {
         }
         for (y = viewportData.startLineNumber; y <= viewportData.endLineNumber; y++) {
             if (!this._viewGpuContext.canRender(viewLineOptions, viewportData, y)) {
-                fillStartIndex = ((y - 1) * this._viewGpuContext.maxGpuCols) * Constants.IndicesPerCell;
-                fillEndIndex = (y * this._viewGpuContext.maxGpuCols) * Constants.IndicesPerCell;
+                fillStartIndex = ((y - 1) * FullFileRenderStrategy.maxSupportedColumns) * Constants.IndicesPerCell;
+                fillEndIndex = (y * FullFileRenderStrategy.maxSupportedColumns) * Constants.IndicesPerCell;
                 cellBuffer.fill(0, fillStartIndex, fillEndIndex);
                 dirtyLineStart = Math.min(dirtyLineStart, y);
                 dirtyLineEnd = Math.max(dirtyLineEnd, y);
@@ -226,8 +216,10 @@ class FullFileRenderStrategy extends ViewEventHandler {
             dirtyLineStart = Math.min(dirtyLineStart, y);
             dirtyLineEnd = Math.max(dirtyLineEnd, y);
             lineData = viewportData.getViewLineRenderingData(y);
-            content = lineData.content;
-            xOffset = 0;
+            tabXOffset = 0;
+            contentSegmenter = createContentSegmenter(lineData, viewLineOptions);
+            charWidth = viewLineOptions.spaceWidth * dpr;
+            absoluteOffsetX = 0;
             tokens = lineData.tokens;
             tokenStartIndex = lineData.minColumn - 1;
             tokenEndIndex = 0;
@@ -238,11 +230,20 @@ class FullFileRenderStrategy extends ViewEventHandler {
                 }
                 tokenMetadata = tokens.getMetadata(tokenIndex);
                 for (x = tokenStartIndex; x < tokenEndIndex; x++) {
-                    if (x > this._viewGpuContext.maxGpuCols) {
+                    if (x > FullFileRenderStrategy.maxSupportedColumns) {
                         break;
                     }
-                    chars = content.charAt(x);
-                    charMetadata = 0;
+                    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) ||
@@ -259,7 +260,22 @@ class FullFileRenderStrategy extends ViewEventHandler {
                                         if (!parsedColor) {
                                             throw ( new BugIndicatingError('Invalid color format ' + value));
                                         }
-                                        charMetadata = parsedColor.toNumber24Bit();
+                                        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'));
@@ -268,33 +284,42 @@ class FullFileRenderStrategy extends ViewEventHandler {
                         }
                     }
                     if (chars === ' ' || chars === '\t') {
-                        cellIndex = ((y - 1) * this._viewGpuContext.maxGpuCols + x) * Constants.IndicesPerCell;
+                        cellIndex = ((y - 1) * FullFileRenderStrategy.maxSupportedColumns + x) * Constants.IndicesPerCell;
                         cellBuffer.fill(0, cellIndex, cellIndex + CellBufferInfo.FloatsPerEntry);
                         if (chars === '\t') {
-                            xOffset = CursorColumns.nextRenderTabStop(x + xOffset, lineData.tabSize) - x - 1;
+                            const offsetBefore = x + tabXOffset;
+                            tabXOffset = CursorColumns.nextRenderTabStop(x + tabXOffset, lineData.tabSize);
+                            absoluteOffsetX += charWidth * (tabXOffset - offsetBefore);
+                            tabXOffset -= x + 1;
+                        }
+                        else {
+                            absoluteOffsetX += charWidth;
                         }
                         continue;
                     }
-                    glyph = this._viewGpuContext.atlas.getGlyph(this._glyphRasterizer.value, chars, tokenMetadata, charMetadata);
-                    absoluteOffsetX = Math.round((x + xOffset) * viewLineOptions.spaceWidth * dpr);
+                    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 - 1) * this._viewGpuContext.maxGpuCols + x) * Constants.IndicesPerCell;
-                    cellBuffer[cellIndex + CellBufferInfo.Offset_X] = absoluteOffsetX;
+                    cellIndex = ((y - 1) * FullFileRenderStrategy.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 - 1) * this._viewGpuContext.maxGpuCols + tokenEndIndex) * Constants.IndicesPerCell;
-            fillEndIndex = (y * this._viewGpuContext.maxGpuCols) * Constants.IndicesPerCell;
+            fillStartIndex = ((y - 1) * FullFileRenderStrategy.maxSupportedColumns + tokenEndIndex) * Constants.IndicesPerCell;
+            fillEndIndex = (y * FullFileRenderStrategy.maxSupportedColumns) * Constants.IndicesPerCell;
             cellBuffer.fill(0, fillStartIndex, fillEndIndex);
             upToDateLines.add(y);
         }
         const visibleObjectCount = (viewportData.endLineNumber - viewportData.startLineNumber + 1) * lineIndexCount;
+        dirtyLineStart = Math.min(dirtyLineStart, FullFileRenderStrategy.maxSupportedLines);
+        dirtyLineEnd = Math.min(dirtyLineEnd, FullFileRenderStrategy.maxSupportedLines);
         if (dirtyLineStart <= dirtyLineEnd) {
             this._device.queue.writeBuffer(this._cellBindBuffer, (dirtyLineStart - 1) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT, cellBuffer.buffer, (dirtyLineStart - 1) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT, (dirtyLineEnd - dirtyLineStart + 1) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT);
         }
@@ -307,12 +332,30 @@ class FullFileRenderStrategy extends ViewEventHandler {
         if (this._visibleObjectCount <= 0) {
             throw ( new BugIndicatingError('Attempt to draw 0 objects'));
         }
-        pass.draw(quadVertices.length / 2, this._visibleObjectCount, undefined, (viewportData.startLineNumber - 1) * this._viewGpuContext.maxGpuCols);
+        pass.draw(quadVertices.length / 2, this._visibleObjectCount, undefined, (viewportData.startLineNumber - 1) * FullFileRenderStrategy.maxSupportedColumns);
     }
     _queueBufferUpdate(e) {
         this._queuedBufferUpdates[0].push(e);
         this._queuedBufferUpdates[1].push(e);
     }
 }
+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 { FullFileRenderStrategy };

package/vscode/src/vs/editor/browser/gpu/{fullFileRenderStrategy.wgsl.js → renderStrategy/fullFileRenderStrategy.wgsl.js}

@@ -1,7 +1,7 @@
 
-import { TextureAtlas } from './atlas/textureAtlas.js';
-import { TextureAtlasPage } from './atlas/textureAtlasPage.js';
-import { BindingId } from './gpu.js';
+import { TextureAtlas } from '../atlas/textureAtlas.js';
+import { TextureAtlasPage } from '../atlas/textureAtlasPage.js';
+import { BindingId } from '../gpu.js';
 
 const fullFileRenderStrategyWgsl =  `
 struct GlyphInfo {

package/vscode/src/vs/editor/browser/gpu/renderStrategy/viewportRenderStrategy.d.ts

@@ -0,0 +1,40 @@
+import { type ViewConfigurationChangedEvent, type ViewDecorationsChangedEvent, type ViewLineMappingChangedEvent, type ViewLinesChangedEvent, type ViewLinesDeletedEvent, type ViewLinesInsertedEvent, type ViewScrollChangedEvent, type ViewThemeChangedEvent, type ViewTokensChangedEvent, type ViewZonesChangedEvent } from "../../../common/viewEvents.js";
+import type { ViewportData } from "../../../common/viewLayout/viewLinesViewportData.js";
+import type { ViewContext } from "../../../common/viewModel/viewContext.js";
+import type { ViewLineOptions } from "../../viewParts/viewLines/viewLineOptions.js";
+import { GlyphRasterizer } from "../raster/glyphRasterizer.js";
+import { ViewGpuContext } from "../viewGpuContext.js";
+import { BaseRenderStrategy } from "./baseRenderStrategy.js";
+export declare class ViewportRenderStrategy extends BaseRenderStrategy {
+    static readonly maxSupportedColumns = 2000;
+    readonly type = "viewport";
+    readonly wgsl: string;
+    private _cellBindBufferLineCapacity;
+    private _cellBindBuffer;
+    private _cellValueBuffers;
+    private _activeDoubleBufferIndex;
+    private _visibleObjectCount;
+    private _scrollOffsetBindBuffer;
+    private _scrollOffsetValueBuffer;
+    private _scrollInitialized;
+    get bindGroupEntries(): GPUBindGroupEntry[];
+    private readonly _onDidChangeBindGroupEntries;
+    readonly onDidChangeBindGroupEntries: import("../../../../base/common/event.js").Event<void>;
+    constructor(context: ViewContext, viewGpuContext: ViewGpuContext, device: GPUDevice, glyphRasterizer: {
+        value: GlyphRasterizer;
+    });
+    private _rebuildCellBuffer;
+    onConfigurationChanged(e: ViewConfigurationChangedEvent): boolean;
+    onDecorationsChanged(e: ViewDecorationsChangedEvent): boolean;
+    onTokensChanged(e: ViewTokensChangedEvent): boolean;
+    onLinesDeleted(e: ViewLinesDeletedEvent): boolean;
+    onLinesInserted(e: ViewLinesInsertedEvent): boolean;
+    onLinesChanged(e: ViewLinesChangedEvent): boolean;
+    onScrollChanged(e?: ViewScrollChangedEvent): boolean;
+    onThemeChanged(e: ViewThemeChangedEvent): boolean;
+    onLineMappingChanged(e: ViewLineMappingChangedEvent): boolean;
+    onZonesChanged(e: ViewZonesChangedEvent): boolean;
+    reset(): void;
+    update(viewportData: ViewportData, viewLineOptions: ViewLineOptions): number;
+    draw(pass: GPURenderPassEncoder, viewportData: ViewportData): void;
+}