@codingame/monaco-vscode-api 13.1.7 → 14.0.0

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContext.js

@@ -33,9 +33,9 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         super(context);
         this._visibleRangeProvider = _visibleRangeProvider;
         this._accessibilityService = _accessibilityService;
+        this._editContextPrimarySelection = ( new Selection(1, 1, 1, 1));
         this._decorations = [];
         this._primarySelection = ( new Selection(1, 1, 1, 1));
-        this._textStartPositionWithinEditor = ( new Position(1, 1));
         this._targetWindowId = -1;
         this._scrollTop = 0;
         this._scrollLeft = 0;
@@ -43,6 +43,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this.domNode.setClassName(`native-edit-context`);
         this.textArea = ( new FastDomNode(document.createElement('textarea')));
         this.textArea.setClassName('native-edit-context-textarea');
+        this.textArea.setAttribute('tabindex', '-1');
         this._updateDomAttributes();
         overflowGuardContainer.appendChild(this.domNode);
         overflowGuardContainer.appendChild(this.textArea);
@@ -202,16 +203,23 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     }
     _updateEditContext() {
         const editContextState = this._getNewEditContextState();
+        if (!editContextState) {
+            return;
+        }
         this._editContext.updateText(0, Number.MAX_SAFE_INTEGER, editContextState.text);
         this._editContext.updateSelection(editContextState.selectionStartOffset, editContextState.selectionEndOffset);
-        this._textStartPositionWithinEditor = editContextState.textStartPositionWithinEditor;
+        this._editContextPrimarySelection = editContextState.editContextPrimarySelection;
     }
     _emitTypeEvent(viewController, e) {
         if (!this._editContext) {
             return;
         }
+        if (!this._editContextPrimarySelection.equalsSelection(this._primarySelection)) {
+            this._updateEditContext();
+        }
         const model = this._context.viewModel.model;
-        const offsetOfStartOfText = model.getOffsetAt(this._textStartPositionWithinEditor);
+        const startPositionOfEditContext = this._editContextStartPosition();
+        const offsetOfStartOfText = model.getOffsetAt(startPositionOfEditContext);
         const offsetOfSelectionEnd = model.getOffsetAt(this._primarySelection.getEndPosition());
         const offsetOfSelectionStart = model.getOffsetAt(this._primarySelection.getStartPosition());
         const selectionEndOffset = offsetOfSelectionEnd - offsetOfStartOfText;
@@ -254,9 +262,13 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         }
     }
     _getNewEditContextState() {
+        const editContextPrimarySelection = this._primarySelection;
         const model = this._context.viewModel.model;
-        const primarySelectionStartLine = this._primarySelection.startLineNumber;
-        const primarySelectionEndLine = this._primarySelection.endLineNumber;
+        if (!model.isValidRange(editContextPrimarySelection)) {
+            return;
+        }
+        const primarySelectionStartLine = editContextPrimarySelection.startLineNumber;
+        const primarySelectionEndLine = editContextPrimarySelection.endLineNumber;
         const endColumnOfEndLineNumber = model.getLineMaxColumn(primarySelectionEndLine);
         const rangeOfText = ( new Range(
             primarySelectionStartLine,
@@ -265,26 +277,28 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             endColumnOfEndLineNumber
         ));
         const text = model.getValueInRange(rangeOfText, EndOfLinePreference.TextDefined);
-        const selectionStartOffset = this._primarySelection.startColumn - 1;
-        const selectionEndOffset = text.length + this._primarySelection.endColumn - endColumnOfEndLineNumber;
-        const textStartPositionWithinEditor = rangeOfText.getStartPosition();
+        const selectionStartOffset = editContextPrimarySelection.startColumn - 1;
+        const selectionEndOffset = text.length + editContextPrimarySelection.endColumn - endColumnOfEndLineNumber;
         return {
             text,
             selectionStartOffset,
             selectionEndOffset,
-            textStartPositionWithinEditor
+            editContextPrimarySelection
         };
     }
+    _editContextStartPosition() {
+        return ( new Position(this._editContextPrimarySelection.startLineNumber, 1));
+    }
     _handleTextFormatUpdate(e) {
         if (!this._editContext) {
             return;
         }
         const formats = e.getTextFormats();
-        const textStartPositionWithinEditor = this._textStartPositionWithinEditor;
+        const editContextStartPosition = this._editContextStartPosition();
         const decorations = [];
         formats.forEach(f => {
             const textModel = this._context.viewModel.model;
-            const offsetOfEditContextText = textModel.getOffsetAt(textStartPositionWithinEditor);
+            const offsetOfEditContextText = textModel.getOffsetAt(editContextStartPosition);
             const startPositionOfDecoration = textModel.getPositionAt(offsetOfEditContextText + f.rangeStart);
             const endPositionOfDecoration = textModel.getPositionAt(offsetOfEditContextText + f.rangeEnd);
             const decorationRange = Range.fromPositions(startPositionOfDecoration, endPositionOfDecoration);
@@ -350,7 +364,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         const offsetTransformer = ( new PositionOffsetTransformer(this._editContext.text));
         for (let offset = e.rangeStart; offset < e.rangeEnd; offset++) {
             const editContextStartPosition = offsetTransformer.getPosition(offset);
-            const textStartLineOffsetWithinEditor = this._textStartPositionWithinEditor.lineNumber - 1;
+            const textStartLineOffsetWithinEditor = this._editContextPrimarySelection.startLineNumber - 1;
             const characterStartPosition = ( new Position(
                 textStartLineOffsetWithinEditor + editContextStartPosition.lineNumber,
                 editContextStartPosition.column

package/vscode/src/vs/editor/browser/editorDom.js

@@ -82,12 +82,12 @@ class EditorMouseEventFactory {
         return ( new EditorMouseEvent(e, false, this._editorViewDomNode));
     }
     onContextMenu(target, callback) {
-        return addDisposableListener(target, 'contextmenu', (e) => {
+        return addDisposableListener(target, EventType.CONTEXT_MENU, (e) => {
             callback(this._create(e));
         });
     }
     onMouseUp(target, callback) {
-        return addDisposableListener(target, 'mouseup', (e) => {
+        return addDisposableListener(target, EventType.MOUSE_UP, (e) => {
             callback(this._create(e));
         });
     }
@@ -107,7 +107,7 @@ class EditorMouseEventFactory {
         });
     }
     onMouseMove(target, callback) {
-        return addDisposableListener(target, 'mousemove', (e) => callback(this._create(e)));
+        return addDisposableListener(target, EventType.MOUSE_MOVE, (e) => callback(this._create(e)));
     }
 }
 class EditorPointerEventFactory {

package/vscode/src/vs/editor/browser/editorExtensions.js

@@ -403,6 +403,11 @@ const UndoCommand = registerCommand(( new MultiCommand({
             group: '',
             title: ( localize(139, "Undo")),
             order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: '1_do',
+            title: ( localize(139, "Undo")),
+            order: 1
         }]
 })));
 registerCommand(( new ProxyCommand(UndoCommand, { id: 'default:undo', precondition: undefined })));
@@ -425,6 +430,11 @@ const RedoCommand = registerCommand(( new MultiCommand({
             group: '',
             title: ( localize(141, "Redo")),
             order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: '1_do',
+            title: ( localize(141, "Redo")),
+            order: 2
         }]
 })));
 registerCommand(( new ProxyCommand(RedoCommand, { id: 'default:redo', precondition: undefined })));
@@ -446,6 +456,11 @@ const SelectAllCommand = registerCommand(( new MultiCommand({
             group: '',
             title: ( localize(143, "Select All")),
             order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: '9_select',
+            title: ( localize(143, "Select All")),
+            order: 1
         }]
 })));
 

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

@@ -1,4 +1,4 @@
-import type { FourKeyMap } from "../../../../base/common/map.js";
+import type { NKeyMap } from "../../../../base/common/map.js";
 import type { IBoundingBox, IRasterizedGlyph } from "../raster/raster.js";
 export interface ITextureAtlasPageGlyph {
     pageIndex: number;
@@ -31,4 +31,9 @@ export declare enum UsagePreviewColors {
     Wasted = "#FF0000",
     Restricted = "#FF000088"
 }
-export type GlyphMap<T> = FourKeyMap<string, number, number, string, T>;
+export type GlyphMap<T> = NKeyMap<T, [
+    chars: string,
+    tokenMetadata: number,
+    decorationStyleSetId: number,
+    rasterizerCacheKey: string
+]>;

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlas.d.ts

@@ -26,7 +26,7 @@ export declare class TextureAtlas extends Disposable {
     constructor(_maxTextureSize: number, options: ITextureAtlasOptions | undefined, _themeService: IThemeService, _instantiationService: IInstantiationService);
     private _initFirstPage;
     clear(): void;
-    getGlyph(rasterizer: IGlyphRasterizer, chars: string, tokenMetadata: number, charMetadata: number): Readonly<ITextureAtlasPageGlyph>;
+    getGlyph(rasterizer: IGlyphRasterizer, chars: string, tokenMetadata: number, decorationStyleSetId: number, x: number): Readonly<ITextureAtlasPageGlyph>;
     private _tryGetGlyph;
     private _getGlyphFromNewPage;
     getUsagePreview(): Promise<Blob[]>;

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlas.js

@@ -5,7 +5,7 @@ import { CharCode } from '../../../../base/common/charCode.js';
 import { BugIndicatingError } from '../../../../base/common/errors.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { Disposable, MutableDisposable, toDisposable, dispose } from '../../../../base/common/lifecycle.js';
-import { FourKeyMap } from '../../../../base/common/map.js';
+import { NKeyMap } from '../../../../base/common/map.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
 import { MetadataConsts } from '../../../common/encodedTokenAttributes.js';
@@ -27,7 +27,7 @@ let TextureAtlas = class TextureAtlas extends Disposable {
         this._warmUpTask = this._register(( new MutableDisposable()));
         this._warmedUpRasterizers = ( new Set());
         this._pages = [];
-        this._glyphPageIndex = ( new FourKeyMap());
+        this._glyphPageIndex = ( new NKeyMap());
         this._onDidDeleteGlyphs = this._register(( new Emitter()));
         this.onDidDeleteGlyphs = this._onDidDeleteGlyphs.event;
         this._allocatorType = options?.allocatorType ?? 'slab';
@@ -60,31 +60,32 @@ let TextureAtlas = class TextureAtlas extends Disposable {
         this._initFirstPage();
         this._onDidDeleteGlyphs.fire();
     }
-    getGlyph(rasterizer, chars, tokenMetadata, charMetadata) {
+    getGlyph(rasterizer, chars, tokenMetadata, decorationStyleSetId, x) {
         tokenMetadata &= ~(MetadataConsts.LANGUAGEID_MASK | MetadataConsts.TOKEN_TYPE_MASK | MetadataConsts.BALANCED_BRACKETS_MASK);
+        tokenMetadata |= Math.floor((x % 1) * 10);
         if (!( this._warmedUpRasterizers.has(rasterizer.id))) {
             this._warmUpAtlas(rasterizer);
             this._warmedUpRasterizers.add(rasterizer.id);
         }
-        return this._tryGetGlyph(this._glyphPageIndex.get(chars, tokenMetadata, charMetadata, rasterizer.cacheKey) ?? 0, rasterizer, chars, tokenMetadata, charMetadata);
+        return this._tryGetGlyph(this._glyphPageIndex.get(chars, tokenMetadata, decorationStyleSetId, rasterizer.cacheKey) ?? 0, rasterizer, chars, tokenMetadata, decorationStyleSetId);
     }
-    _tryGetGlyph(pageIndex, rasterizer, chars, tokenMetadata, charMetadata) {
-        this._glyphPageIndex.set(chars, tokenMetadata, charMetadata, rasterizer.cacheKey, pageIndex);
-        return (this._pages[pageIndex].getGlyph(rasterizer, chars, tokenMetadata, charMetadata)
+    _tryGetGlyph(pageIndex, rasterizer, chars, tokenMetadata, decorationStyleSetId) {
+        this._glyphPageIndex.set(pageIndex, chars, tokenMetadata, decorationStyleSetId, rasterizer.cacheKey);
+        return (this._pages[pageIndex].getGlyph(rasterizer, chars, tokenMetadata, decorationStyleSetId)
             ?? (pageIndex + 1 < this._pages.length
-                ? this._tryGetGlyph(pageIndex + 1, rasterizer, chars, tokenMetadata, charMetadata)
+                ? this._tryGetGlyph(pageIndex + 1, rasterizer, chars, tokenMetadata, decorationStyleSetId)
                 : undefined)
-            ?? this._getGlyphFromNewPage(rasterizer, chars, tokenMetadata, charMetadata));
+            ?? this._getGlyphFromNewPage(rasterizer, chars, tokenMetadata, decorationStyleSetId));
     }
-    _getGlyphFromNewPage(rasterizer, chars, tokenMetadata, charMetadata) {
+    _getGlyphFromNewPage(rasterizer, chars, tokenMetadata, decorationStyleSetId) {
         if (this._pages.length >= TextureAtlas_1.maximumPageCount) {
             throw ( new Error(
                 `Attempt to create a texture atlas page past the limit ${TextureAtlas_1.maximumPageCount}`
             ));
         }
         this._pages.push(this._instantiationService.createInstance(TextureAtlasPage, this._pages.length, this.pageSize, this._allocatorType));
-        this._glyphPageIndex.set(chars, tokenMetadata, charMetadata, rasterizer.cacheKey, this._pages.length - 1);
-        return this._pages[this._pages.length - 1].getGlyph(rasterizer, chars, tokenMetadata, charMetadata);
+        this._glyphPageIndex.set(this._pages.length - 1, chars, tokenMetadata, decorationStyleSetId, rasterizer.cacheKey);
+        return this._pages[this._pages.length - 1].getGlyph(rasterizer, chars, tokenMetadata, decorationStyleSetId);
     }
     getUsagePreview() {
         return Promise.all(( this._pages.map(e => e.getUsagePreview())));
@@ -100,25 +101,31 @@ let TextureAtlas = class TextureAtlas extends Disposable {
         this._warmUpTask.value?.clear();
         const taskQueue = this._warmUpTask.value = ( new IdleTaskQueue());
         for (let code = CharCode.A; code <= CharCode.Z; code++) {
-            taskQueue.enqueue(() => {
-                for (const fgColor of ( colorMap.keys())) {
-                    this.getGlyph(rasterizer, String.fromCharCode(code), (fgColor << MetadataConsts.FOREGROUND_OFFSET) & MetadataConsts.FOREGROUND_MASK, 0);
-                }
-            });
+            for (const fgColor of ( colorMap.keys())) {
+                taskQueue.enqueue(() => {
+                    for (let x = 0; x < 1; x += 0.1) {
+                        this.getGlyph(rasterizer, String.fromCharCode(code), (fgColor << MetadataConsts.FOREGROUND_OFFSET) & MetadataConsts.FOREGROUND_MASK, 0, x);
+                    }
+                });
+            }
         }
         for (let code = CharCode.a; code <= CharCode.z; code++) {
-            taskQueue.enqueue(() => {
-                for (const fgColor of ( colorMap.keys())) {
-                    this.getGlyph(rasterizer, String.fromCharCode(code), (fgColor << MetadataConsts.FOREGROUND_OFFSET) & MetadataConsts.FOREGROUND_MASK, 0);
-                }
-            });
+            for (const fgColor of ( colorMap.keys())) {
+                taskQueue.enqueue(() => {
+                    for (let x = 0; x < 1; x += 0.1) {
+                        this.getGlyph(rasterizer, String.fromCharCode(code), (fgColor << MetadataConsts.FOREGROUND_OFFSET) & MetadataConsts.FOREGROUND_MASK, 0, x);
+                    }
+                });
+            }
         }
         for (let code = CharCode.ExclamationMark; code <= CharCode.Tilde; code++) {
-            taskQueue.enqueue(() => {
-                for (const fgColor of ( colorMap.keys())) {
-                    this.getGlyph(rasterizer, String.fromCharCode(code), (fgColor << MetadataConsts.FOREGROUND_OFFSET) & MetadataConsts.FOREGROUND_MASK, 0);
-                }
-            });
+            for (const fgColor of ( colorMap.keys())) {
+                taskQueue.enqueue(() => {
+                    for (let x = 0; x < 1; x += 0.1) {
+                        this.getGlyph(rasterizer, String.fromCharCode(code), (fgColor << MetadataConsts.FOREGROUND_OFFSET) & MetadataConsts.FOREGROUND_MASK, 0, x);
+                    }
+                });
+            }
         }
     }
 };

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlasPage.d.ts

@@ -19,7 +19,7 @@ export declare class TextureAtlasPage extends Disposable implements IReadableTex
     private readonly _allocator;
     private _colorMap;
     constructor(textureIndex: number, pageSize: number, allocatorType: AllocatorType, _logService: ILogService, themeService: IThemeService);
-    getGlyph(rasterizer: IGlyphRasterizer, chars: string, tokenMetadata: number, charMetadata: number): Readonly<ITextureAtlasPageGlyph> | undefined;
+    getGlyph(rasterizer: IGlyphRasterizer, chars: string, tokenMetadata: number, decorationStyleSetId: number): Readonly<ITextureAtlasPageGlyph> | undefined;
     private _createGlyph;
     getUsagePreview(): Promise<Blob>;
     getStats(): string;

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlasPage.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
-import { FourKeyMap } from '../../../../base/common/map.js';
+import { NKeyMap } from '../../../../base/common/map.js';
 import { LogLevel } from '../../../../platform/log/common/log.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
@@ -23,7 +23,7 @@ let TextureAtlasPage = class TextureAtlasPage extends Disposable {
         this._logService = _logService;
         this._version = 0;
         this._usedArea = { left: 0, top: 0, right: 0, bottom: 0 };
-        this._glyphMap = ( new FourKeyMap());
+        this._glyphMap = ( new NKeyMap());
         this._glyphInOrderSet = ( new Set());
         this._canvas = ( new OffscreenCanvas(pageSize, pageSize));
         this._colorMap = themeService.getColorTheme().tokenColorMap;
@@ -43,19 +43,19 @@ let TextureAtlasPage = class TextureAtlasPage extends Disposable {
             this._canvas.height = 1;
         }));
     }
-    getGlyph(rasterizer, chars, tokenMetadata, charMetadata) {
-        return this._glyphMap.get(chars, tokenMetadata, charMetadata, rasterizer.cacheKey) ?? this._createGlyph(rasterizer, chars, tokenMetadata, charMetadata);
+    getGlyph(rasterizer, chars, tokenMetadata, decorationStyleSetId) {
+        return this._glyphMap.get(chars, tokenMetadata, decorationStyleSetId, rasterizer.cacheKey) ?? this._createGlyph(rasterizer, chars, tokenMetadata, decorationStyleSetId);
     }
-    _createGlyph(rasterizer, chars, tokenMetadata, charMetadata) {
+    _createGlyph(rasterizer, chars, tokenMetadata, decorationStyleSetId) {
         if (this._glyphInOrderSet.size >= TextureAtlasPage_1.maximumGlyphCount) {
             return undefined;
         }
-        const rasterizedGlyph = rasterizer.rasterizeGlyph(chars, tokenMetadata, charMetadata, this._colorMap);
+        const rasterizedGlyph = rasterizer.rasterizeGlyph(chars, tokenMetadata, decorationStyleSetId, this._colorMap);
         const glyph = this._allocator.allocate(rasterizedGlyph);
         if (glyph === undefined) {
             return undefined;
         }
-        this._glyphMap.set(chars, tokenMetadata, charMetadata, rasterizer.cacheKey, glyph);
+        this._glyphMap.set(glyph, chars, tokenMetadata, decorationStyleSetId, rasterizer.cacheKey);
         this._glyphInOrderSet.add(glyph);
         this._version++;
         this._usedArea.right = Math.max(this._usedArea.right, glyph.x + glyph.w - 1);
@@ -64,7 +64,7 @@ let TextureAtlasPage = class TextureAtlasPage extends Disposable {
             this._logService.trace('New glyph', {
                 chars,
                 tokenMetadata,
-                charMetadata,
+                decorationStyleSetId,
                 rasterizedGlyph,
                 glyph
             });

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlasSlabAllocator.js

@@ -1,7 +1,7 @@
 
 import { getActiveWindow } from '../../../../base/browser/dom.js';
 import { BugIndicatingError } from '../../../../base/common/errors.js';
-import { TwoKeyMap } from '../../../../base/common/map.js';
+import { NKeyMap } from '../../../../base/common/map.js';
 import { ensureNonNullable } from '../gpuUtils.js';
 import { UsagePreviewColors } from './atlas.js';
 
@@ -10,7 +10,7 @@ class TextureAtlasSlabAllocator {
         this._canvas = _canvas;
         this._textureIndex = _textureIndex;
         this._slabs = [];
-        this._activeSlabsByDims = ( new TwoKeyMap());
+        this._activeSlabsByDims = ( new NKeyMap());
         this._unusedRects = [];
         this._openRegionsByHeight = ( new Map());
         this._openRegionsByWidth = ( new Map());
@@ -151,7 +151,7 @@ class TextureAtlasSlabAllocator {
                     });
                 }
                 this._slabs.push(slab);
-                this._activeSlabsByDims.set(desiredSlabSize.w, desiredSlabSize.h, slab);
+                this._activeSlabsByDims.set(slab, desiredSlabSize.w, desiredSlabSize.h);
             }
             const glyphsPerRow = Math.floor(this._slabW / slab.entryW);
             dx = slab.x + Math.floor(slab.count % glyphsPerRow) * slab.entryW;

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

@@ -0,0 +1,7 @@
+import type { ViewLineRenderingData } from "../../common/viewModel.js";
+import type { ViewLineOptions } from "../viewParts/viewLines/viewLineOptions.js";
+export interface IContentSegmenter {
+    getSegmentAtIndex(index: number): string | undefined;
+    getSegmentData(index: number): Intl.SegmentData | undefined;
+}
+export declare function createContentSegmenter(lineData: ViewLineRenderingData, options: ViewLineOptions): IContentSegmenter;

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

@@ -0,0 +1,49 @@
+
+import { safeIntl } from '../../../base/common/date.js';
+
+function createContentSegmenter(lineData, options) {
+    if (lineData.isBasicASCII && options.useMonospaceOptimizations) {
+        return ( new AsciiContentSegmenter(lineData));
+    }
+    return ( new GraphemeContentSegmenter(lineData));
+}
+class AsciiContentSegmenter {
+    constructor(lineData) {
+        this._content = lineData.content;
+    }
+    getSegmentAtIndex(index) {
+        return this._content[index];
+    }
+    getSegmentData(index) {
+        return undefined;
+    }
+}
+class GraphemeContentSegmenter {
+    constructor(lineData) {
+        this._segments = [];
+        const content = lineData.content;
+        const segmenter = safeIntl.Segmenter(undefined, { granularity: 'grapheme' });
+        const segmentedContent = Array.from(segmenter.segment(content));
+        let segmenterIndex = 0;
+        for (let x = 0; x < content.length; x++) {
+            const segment = segmentedContent[segmenterIndex];
+            if (!segment) {
+                break;
+            }
+            if (segment.index !== x) {
+                this._segments.push(undefined);
+                continue;
+            }
+            segmenterIndex++;
+            this._segments.push(segment);
+        }
+    }
+    getSegmentAtIndex(index) {
+        return this._segments[index]?.segment;
+    }
+    getSegmentData(index) {
+        return this._segments[index];
+    }
+}
+
+export { createContentSegmenter };

package/vscode/src/vs/editor/browser/gpu/{decorationCssRuleExtractor.d.ts → css/decorationCssRuleExtractor.d.ts}

@@ -1,4 +1,4 @@
-import { Disposable } from "../../../base/common/lifecycle.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
 export declare class DecorationCssRuleExtractor extends Disposable {
     private _container;
     private _dummyElement;

package/vscode/src/vs/editor/browser/gpu/{decorationCssRuleExtractor.js → css/decorationCssRuleExtractor.js}

@@ -1,6 +1,6 @@
 
-import { $, getActiveDocument } from '../../../base/browser/dom.js';
-import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { $, getActiveDocument } from '../../../../base/browser/dom.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import './media/decorationCssRuleExtractor.css.js';
 
 class DecorationCssRuleExtractor extends Disposable {

package/vscode/src/vs/editor/browser/gpu/css/decorationStyleCache.d.ts

@@ -0,0 +1,15 @@
+export interface IDecorationStyleSet {
+    color: number | undefined;
+    bold: boolean | undefined;
+    opacity: number | undefined;
+}
+export interface IDecorationStyleCacheEntry extends IDecorationStyleSet {
+    id: number;
+}
+export declare class DecorationStyleCache {
+    private _nextId;
+    private readonly _cacheById;
+    private readonly _cacheByStyle;
+    getOrCreateEntry(color: number | undefined, bold: boolean | undefined, opacity: number | undefined): number;
+    getStyleSet(id: number): IDecorationStyleSet | undefined;
+}

package/vscode/src/vs/editor/browser/gpu/css/decorationStyleCache.js

@@ -0,0 +1,37 @@
+
+import { NKeyMap } from '../../../../base/common/map.js';
+
+class DecorationStyleCache {
+    constructor() {
+        this._nextId = 1;
+        this._cacheById = ( new Map());
+        this._cacheByStyle = ( new NKeyMap());
+    }
+    getOrCreateEntry(color, bold, opacity) {
+        if (color === undefined && bold === undefined && opacity === undefined) {
+            return 0;
+        }
+        const result = this._cacheByStyle.get(color ?? 0, bold ? 1 : 0, opacity === undefined ? '' : opacity.toFixed(2));
+        if (result) {
+            return result.id;
+        }
+        const id = this._nextId++;
+        const entry = {
+            id,
+            color,
+            bold,
+            opacity,
+        };
+        this._cacheById.set(id, entry);
+        this._cacheByStyle.set(entry, color ?? 0, bold ? 1 : 0, opacity === undefined ? '' : opacity.toFixed(2));
+        return id;
+    }
+    getStyleSet(id) {
+        if (id === 0) {
+            return undefined;
+        }
+        return this._cacheById.get(id);
+    }
+}
+
+export { DecorationStyleCache };

package/vscode/src/vs/editor/browser/gpu/{media → css/media}/decorationCssRuleExtractor.css.js

@@ -1,4 +1,4 @@
-import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
 
 var css = ".monaco-editor .monaco-decoration-css-rule-extractor{pointer-events:none;visibility:hidden}";
 n(css,{});

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

@@ -1,6 +1,8 @@
+import type { IDisposable } from "../../../base/common/lifecycle.js";
 import type { ViewConfigurationChangedEvent, ViewLinesChangedEvent, ViewLinesDeletedEvent, ViewLinesInsertedEvent, ViewScrollChangedEvent, ViewTokensChangedEvent } from "../../common/viewEvents.js";
 import type { ViewportData } from "../../common/viewLayout/viewLinesViewportData.js";
 import type { ViewLineOptions } from "../viewParts/viewLines/viewLineOptions.js";
+import type { IGlyphRasterizer } from "./raster/raster.js";
 export declare enum BindingId {
     GlyphInfo = 0,
     Cells = 1,
@@ -10,9 +12,11 @@ export declare enum BindingId {
     AtlasDimensionsUniform = 5,
     ScrollOffset = 6
 }
-export interface IGpuRenderStrategy {
+export interface IGpuRenderStrategy extends IDisposable {
+    readonly type: string;
     readonly wgsl: string;
     readonly bindGroupEntries: GPUBindGroupEntry[];
+    readonly glyphRasterizer: IGlyphRasterizer;
     onLinesDeleted(e: ViewLinesDeletedEvent): boolean;
     onConfigurationChanged(e: ViewConfigurationChangedEvent): boolean;
     onTokensChanged(e: ViewTokensChangedEvent): boolean;
@@ -21,5 +25,5 @@ export interface IGpuRenderStrategy {
     onScrollChanged(e?: ViewScrollChangedEvent): boolean;
     reset(): void;
     update(viewportData: ViewportData, viewLineOptions: ViewLineOptions): number;
-    draw?(pass: GPURenderPassEncoder, viewportData: ViewportData): void;
+    draw(pass: GPURenderPassEncoder, viewportData: ViewportData): void;
 }

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

@@ -11,8 +11,11 @@ export declare class GlyphRasterizer extends Disposable implements IGlyphRasteri
     private readonly _textMetrics;
     private _workGlyph;
     private _workGlyphConfig;
+    private _antiAliasing;
     constructor(fontSize: number, fontFamily: string, devicePixelRatio: number);
-    rasterizeGlyph(chars: string, tokenMetadata: number, charMetadata: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
-    _rasterizeGlyph(chars: string, metadata: number, charMetadata: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
+    rasterizeGlyph(chars: string, tokenMetadata: number, decorationStyleSetId: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
+    _rasterizeGlyph(chars: string, tokenMetadata: number, decorationStyleSetId: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
+    private _clearColor;
     private _findGlyphBoundingBox;
+    getTextMetrics(text: string): TextMetrics;
 }