@codingame/monaco-vscode-api 24.3.0 → 25.0.1

package/vscode/src/vs/editor/browser/controller/editContext/screenReaderUtils.d.ts

@@ -1,5 +1,4 @@
 import { Position } from "../../../common/core/position.js";
-import { Range } from "../../../common/core/range.js";
 import { Selection } from "../../../common/core/selection.js";
 import { IComputedEditorOptions } from "../../../common/config/editorOptions.js";
 import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.service.js";
@@ -14,7 +13,7 @@ export interface ISimpleScreenReaderContentState {
     /** the offset where selection ends inside `value` */
     selectionEnd: number;
     /** the editor range in the view coordinate system that matches the selection inside `value` */
-    selection: Range;
+    selection: Selection;
     /** the position of the start of the `value` in the editor */
     startPositionWithinEditor: Position;
     /** the visible line count (wrapped, not necessarily matching \n characters) for the text in `value` before `selectionStart` */

package/vscode/src/vs/editor/browser/controller/editContext/screenReaderUtils.js

@@ -76,10 +76,10 @@ function ariaLabelForScreenReaderContent(options, keybindingService) {
         const toggleKeybindingLabel = keybindingService.lookupKeybinding('editor.action.toggleScreenReaderAccessibilityMode')?.getAriaLabel();
         const runCommandKeybindingLabel = keybindingService.lookupKeybinding('workbench.action.showCommands')?.getAriaLabel();
         const keybindingEditorKeybindingLabel = keybindingService.lookupKeybinding('workbench.action.openGlobalKeybindings')?.getAriaLabel();
-        const editorNotAccessibleMessage = ( localize(131, "The editor is not accessible at this time."));
+        const editorNotAccessibleMessage = ( localize(133, "The editor is not accessible at this time."));
         if (toggleKeybindingLabel) {
             return localize(
-                132,
+                134,
                 "{0} To enable screen reader optimized mode, use {1}",
                 editorNotAccessibleMessage,
                 toggleKeybindingLabel
@@ -87,7 +87,7 @@ function ariaLabelForScreenReaderContent(options, keybindingService) {
         }
         else if (runCommandKeybindingLabel) {
             return localize(
-                133,
+                135,
                 "{0} To enable screen reader optimized mode, open the quick pick with {1} and run the command Toggle Screen Reader Accessibility Mode, which is currently not triggerable via keyboard.",
                 editorNotAccessibleMessage,
                 runCommandKeybindingLabel
@@ -95,7 +95,7 @@ function ariaLabelForScreenReaderContent(options, keybindingService) {
         }
         else if (keybindingEditorKeybindingLabel) {
             return localize(
-                134,
+                136,
                 "{0} Please assign a keybinding for the command Toggle Screen Reader Accessibility Mode by accessing the keybindings editor with {1} and run it.",
                 editorNotAccessibleMessage,
                 keybindingEditorKeybindingLabel

package/vscode/src/vs/editor/browser/controller/editContext/textArea/textAreaEditContext.js

@@ -122,7 +122,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         this.textArea.setAttribute('aria-required', options.get(EditorOption.ariaRequired) ? 'true' : 'false');
         this.textArea.setAttribute('tabindex', String(options.get(EditorOption.tabIndex)));
         this.textArea.setAttribute('role', 'textbox');
-        this.textArea.setAttribute('aria-roledescription', ( localize(135, "editor")));
+        this.textArea.setAttribute('aria-roledescription', ( localize(137, "editor")));
         this.textArea.setAttribute('aria-multiline', 'true');
         this.textArea.setAttribute('aria-autocomplete', options.get(EditorOption.readOnly) ? 'none' : 'both');
         this._ensureReadOnlyAttribute();

package/vscode/src/vs/editor/browser/controller/editContext/textArea/textAreaEditContextState.js

@@ -1,5 +1,6 @@
 
 import { commonPrefixLength, commonSuffixLength } from '../../../../../base/common/strings.js';
+import { SelectionDirection } from '../../../../common/core/selection.js';
 
 class TextAreaState {
     static { this.EMPTY = ( new TextAreaState('', 0, 0, null, undefined)); }
@@ -140,10 +141,23 @@ class TextAreaState {
         };
     }
     static fromScreenReaderContentState(screenReaderContentState) {
+        let selectionStart;
+        let selectionEnd;
+        const direction = screenReaderContentState.selection.getDirection();
+        switch (direction) {
+            case SelectionDirection.LTR:
+                selectionStart = screenReaderContentState.selectionStart;
+                selectionEnd = screenReaderContentState.selectionEnd;
+                break;
+            case SelectionDirection.RTL:
+                selectionStart = screenReaderContentState.selectionEnd;
+                selectionEnd = screenReaderContentState.selectionStart;
+                break;
+        }
         return ( new TextAreaState(
             screenReaderContentState.value,
-            screenReaderContentState.selectionStart,
-            screenReaderContentState.selectionEnd,
+            selectionStart,
+            selectionEnd,
             screenReaderContentState.selection,
             screenReaderContentState.newlineCountBeforeSelection
         ));

package/vscode/src/vs/editor/browser/controller/mouseHandler.js

@@ -14,6 +14,7 @@ import { EditorOption } from '../../common/config/editorOptions.js';
 import { NavigationCommandRevealType } from '../coreCommands.js';
 import { MouseWheelClassifier } from '../../../base/browser/ui/scrollbar/scrollableElement.js';
 import { TopBottomDragScrolling, LeftRightDragScrolling } from './dragScrolling.js';
+import { TextDirection } from '../../common/model.js';
 
 class MouseHandler extends ViewEventHandler {
     constructor(context, viewController, viewHelper) {
@@ -395,7 +396,8 @@ class MouseDownOperation extends Disposable {
         const xLeftBoundary = layoutInfo.contentLeft;
         if (e.relativePos.x <= xLeftBoundary) {
             const outsideDistance = xLeftBoundary - e.relativePos.x;
-            return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(possibleLineNumber, 1)), 'left', outsideDistance);
+            const isRtl = model.getTextDirection(possibleLineNumber) === TextDirection.RTL;
+            return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(possibleLineNumber, isRtl ? model.getLineMaxColumn(possibleLineNumber) : 1)), 'left', outsideDistance);
         }
         const contentRight = (layoutInfo.minimap.minimapLeft === 0
             ? layoutInfo.width - layoutInfo.verticalScrollbarWidth
@@ -403,7 +405,8 @@ class MouseDownOperation extends Disposable {
         const xRightBoundary = contentRight;
         if (e.relativePos.x >= xRightBoundary) {
             const outsideDistance = e.relativePos.x - xRightBoundary;
-            return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(possibleLineNumber, model.getLineMaxColumn(possibleLineNumber))), 'right', outsideDistance);
+            const isRtl = model.getTextDirection(possibleLineNumber) === TextDirection.RTL;
+            return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(possibleLineNumber, isRtl ? 1 : model.getLineMaxColumn(possibleLineNumber))), 'right', outsideDistance);
         }
         return null;
     }

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

@@ -865,7 +865,7 @@ var CoreNavigationCommands;
                         type: 'object',
                         properties: {
                             'sticky': {
-                                description: ( localize(136, "Stick to the end even when going to longer lines")),
+                                description: ( localize(138, "Stick to the end even when going to longer lines")),
                                 type: 'boolean',
                                 default: false
                             }
@@ -893,7 +893,7 @@ var CoreNavigationCommands;
                         type: 'object',
                         properties: {
                             'sticky': {
-                                description: ( localize(136, "Stick to the end even when going to longer lines")),
+                                description: ( localize(138, "Stick to the end even when going to longer lines")),
                                 type: 'boolean',
                                 default: false
                             }
@@ -1053,8 +1053,9 @@ var CoreNavigationCommands;
             const desiredScrollTop = this._computeDesiredScrollTop(viewModel, args);
             if (args.revealCursor) {
                 const desiredVisibleViewRange = viewModel.getCompletelyVisibleViewRangeAtScrollTop(desiredScrollTop);
+                const paddedRange = viewModel.getViewRangeWithCursorPadding(desiredVisibleViewRange);
                 viewModel.setCursorStates(source, CursorChangeReason.Explicit, [
-                    CursorMoveCommands.findPositionInViewportIfOutside(viewModel, viewModel.getPrimaryCursorState(), desiredVisibleViewRange, args.select)
+                    CursorMoveCommands.findPositionInViewportIfOutside(viewModel, viewModel.getPrimaryCursorState(), paddedRange, args.select)
                 ]);
             }
             viewModel.viewLayout.setScrollPosition({ scrollTop: desiredScrollTop }, ScrollType.Smooth);
@@ -1434,7 +1435,7 @@ var CoreNavigationCommands;
                 viewModel.getPrimaryCursorState()
             ]);
             viewModel.revealAllCursors(args.source, true);
-            status(( localize(137, "Removed secondary cursors")));
+            status(( localize(139, "Removed secondary cursors")));
         }
     }));
     CoreNavigationCommands.RevealLine = registerEditorCommand(new (class extends CoreEditorCommand {

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

@@ -401,17 +401,17 @@ const UndoCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localize(138, "&&Undo")),
+            title: ( localize(140, "&&Undo")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(139, "Undo")),
+            title: ( localize(141, "Undo")),
             order: 1
         }, {
             menuId: MenuId.SimpleEditorContext,
             group: '1_do',
-            title: ( localize(139, "Undo")),
+            title: ( localize(141, "Undo")),
             order: 1
         }]
 })));
@@ -428,17 +428,17 @@ const RedoCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localize(140, "&&Redo")),
+            title: ( localize(142, "&&Redo")),
             order: 2
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(141, "Redo")),
+            title: ( localize(143, "Redo")),
             order: 1
         }, {
             menuId: MenuId.SimpleEditorContext,
             group: '1_do',
-            title: ( localize(141, "Redo")),
+            title: ( localize(143, "Redo")),
             order: 2
         }]
 })));
@@ -454,17 +454,17 @@ const SelectAllCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarSelectionMenu,
             group: '1_basic',
-            title: ( localize(142, "&&Select All")),
+            title: ( localize(144, "&&Select All")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(143, "Select All")),
+            title: ( localize(145, "Select All")),
             order: 1
         }, {
             menuId: MenuId.SimpleEditorContext,
             group: '9_select',
-            title: ( localize(143, "Select All")),
+            title: ( localize(145, "Select All")),
             order: 1
         }]
 })));

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

@@ -9,4 +9,8 @@ export declare class DecorationCssRuleExtractor extends Disposable {
     constructor();
     getStyleRules(canvas: HTMLElement, decorationClassName: string): CSSStyleRule[];
     private _getStyleRules;
+    /**
+     * Resolves a CSS variable to its computed value using the container element.
+     */
+    resolveCssVariable(canvas: HTMLCanvasElement, variableName: string): string;
 }

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

@@ -1,6 +1,6 @@
 
 import { registerCss } from '../../../../../../../css.js';
-import { $, getActiveDocument } from '../../../../base/browser/dom.js';
+import { $, getActiveDocument, getActiveWindow } from '../../../../base/browser/dom.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import * as decorationCssRuleExtractor from './media/decorationCssRuleExtractor.css';
 
@@ -52,6 +52,12 @@ class DecorationCssRuleExtractor extends Disposable {
         }
         return rules;
     }
+    resolveCssVariable(canvas, variableName) {
+        canvas.appendChild(this._container);
+        const result = getActiveWindow().getComputedStyle(this._container).getPropertyValue(variableName).trim();
+        canvas.removeChild(this._container);
+        return result;
+    }
 }
 
 export { DecorationCssRuleExtractor };

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

@@ -11,6 +11,18 @@ export interface IDecorationStyleSet {
      * A number between 0 and 1 representing the opacity of the text.
      */
     opacity: number | undefined;
+    /**
+     * Whether the text should be rendered with a strikethrough.
+     */
+    strikethrough: boolean | undefined;
+    /**
+     * The thickness of the strikethrough line in pixels (CSS pixels, not device pixels).
+     */
+    strikethroughThickness: number | undefined;
+    /**
+     * A 32-bit number representing the strikethrough color.
+     */
+    strikethroughColor: number | undefined;
 }
 export interface IDecorationStyleCacheEntry extends IDecorationStyleSet {
     /**
@@ -22,6 +34,6 @@ export declare class DecorationStyleCache {
     private _nextId;
     private readonly _cacheById;
     private readonly _cacheByStyle;
-    getOrCreateEntry(color: number | undefined, bold: boolean | undefined, opacity: number | undefined): number;
+    getOrCreateEntry(color: number | undefined, bold: boolean | undefined, opacity: number | undefined, strikethrough: boolean | undefined, strikethroughThickness: number | undefined, strikethroughColor: number | undefined): number;
     getStyleSet(id: number): IDecorationStyleSet | undefined;
 }

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

@@ -7,11 +7,11 @@ class DecorationStyleCache {
         this._cacheById = ( new Map());
         this._cacheByStyle = ( new NKeyMap());
     }
-    getOrCreateEntry(color, bold, opacity) {
-        if (color === undefined && bold === undefined && opacity === undefined) {
+    getOrCreateEntry(color, bold, opacity, strikethrough, strikethroughThickness, strikethroughColor) {
+        if (color === undefined && bold === undefined && opacity === undefined && strikethrough === undefined && strikethroughThickness === undefined && strikethroughColor === undefined) {
             return 0;
         }
-        const result = this._cacheByStyle.get(color ?? 0, bold ? 1 : 0, opacity === undefined ? '' : opacity.toFixed(2));
+        const result = this._cacheByStyle.get(color ?? 0, bold ? 1 : 0, opacity === undefined ? '' : opacity.toFixed(2), strikethrough ? 1 : 0, strikethroughThickness === undefined ? '' : strikethroughThickness.toFixed(2), strikethroughColor ?? 0);
         if (result) {
             return result.id;
         }
@@ -21,9 +21,12 @@ class DecorationStyleCache {
             color,
             bold,
             opacity,
+            strikethrough,
+            strikethroughThickness,
+            strikethroughColor,
         };
         this._cacheById.set(id, entry);
-        this._cacheByStyle.set(entry, color ?? 0, bold ? 1 : 0, opacity === undefined ? '' : opacity.toFixed(2));
+        this._cacheByStyle.set(entry, color ?? 0, bold ? 1 : 0, opacity === undefined ? '' : opacity.toFixed(2), strikethrough ? 1 : 0, strikethroughThickness === undefined ? '' : strikethroughThickness.toFixed(2), strikethroughColor ?? 0);
         return id;
     }
     getStyleSet(id) {

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

@@ -73,7 +73,7 @@ class GlyphRasterizer extends Disposable {
             this._canvas.height = canvasDim;
         }
         this._ctx.save();
-        const xSubPixelXOffset = (tokenMetadata & 0b1111) / 10;
+        const subPixelXOffset = (tokenMetadata & 0b1111) / 10;
         const bgId = TokenMetadata.getBackground(tokenMetadata);
         const bg = colorMap[bgId];
         const decorationStyleSet = this._decorationStyleCache.getStyleSet(decorationStyleSetId);
@@ -107,11 +107,21 @@ class GlyphRasterizer extends Disposable {
         else {
             this._ctx.fillStyle = colorMap[TokenMetadata.getForeground(tokenMetadata)];
         }
-        this._ctx.textBaseline = 'top';
         if (decorationStyleSet?.opacity !== undefined) {
             this._ctx.globalAlpha = decorationStyleSet.opacity;
         }
-        this._ctx.fillText(chars, originX + xSubPixelXOffset, originY);
+        this._ctx.textBaseline = 'top';
+        this._ctx.fillText(chars, originX + subPixelXOffset, originY);
+        if (decorationStyleSet?.strikethrough) {
+            const strikethroughY = Math.round(originY - this._textMetrics.alphabeticBaseline * 0.65);
+            const lineWidth = decorationStyleSet?.strikethroughThickness !== undefined
+                ? Math.round(decorationStyleSet.strikethroughThickness * this.devicePixelRatio)
+                : Math.max(1, Math.floor(devicePixelFontSize / 10));
+            if (decorationStyleSet?.strikethroughColor !== undefined) {
+                this._ctx.fillStyle = `#${( decorationStyleSet.strikethroughColor.toString(16)).padStart(8, '0')}`;
+            }
+            this._ctx.fillRect(originX, strikethroughY - Math.floor(lineWidth / 2), Math.ceil(this._textMetrics.width), lineWidth);
+        }
         this._ctx.restore();
         const imageData = this._ctx.getImageData(0, 0, this._canvas.width, this._canvas.height);
         if (this._antiAliasing === 'subpixel') {

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

@@ -159,6 +159,9 @@ class FullFileRenderStrategy extends BaseRenderStrategy {
         let decorationStyleSetBold;
         let decorationStyleSetColor;
         let decorationStyleSetOpacity;
+        let decorationStyleSetStrikethrough;
+        let decorationStyleSetStrikethroughThickness;
+        let decorationStyleSetStrikethroughColor;
         let lineData;
         let decoration;
         let fillStartIndex = 0;
@@ -244,6 +247,9 @@ class FullFileRenderStrategy extends BaseRenderStrategy {
                     decorationStyleSetColor = undefined;
                     decorationStyleSetBold = undefined;
                     decorationStyleSetOpacity = undefined;
+                    decorationStyleSetStrikethrough = undefined;
+                    decorationStyleSetStrikethroughThickness = undefined;
+                    decorationStyleSetStrikethroughColor = undefined;
                     for (decoration of lineData.inlineDecorations) {
                         if ((y < decoration.range.startLineNumber || y > decoration.range.endLineNumber) ||
                             (y === decoration.range.startLineNumber && x < decoration.range.startColumn - 1) ||
@@ -278,6 +284,35 @@ class FullFileRenderStrategy extends BaseRenderStrategy {
                                         decorationStyleSetOpacity = parsedValue;
                                         break;
                                     }
+                                    case 'text-decoration':
+                                    case 'text-decoration-line': {
+                                        if (value === 'line-through') {
+                                            decorationStyleSetStrikethrough = true;
+                                        }
+                                        break;
+                                    }
+                                    case 'text-decoration-thickness': {
+                                        const match = value.match(/^(\d+(?:\.\d+)?)px$/);
+                                        if (match) {
+                                            decorationStyleSetStrikethroughThickness = parseFloat(match[1]);
+                                        }
+                                        break;
+                                    }
+                                    case 'text-decoration-color': {
+                                        let colorValue = value;
+                                        const varMatch = value.match(/^var\((--[^,]+),\s*(?:initial|inherit)\)$/);
+                                        if (varMatch) {
+                                            colorValue = ViewGpuContext.decorationCssRuleExtractor.resolveCssVariable(this._viewGpuContext.canvas.domNode, varMatch[1]);
+                                        }
+                                        const parsedColor = Color.Format.CSS.parse(colorValue);
+                                        if (parsedColor) {
+                                            decorationStyleSetStrikethroughColor = parsedColor.toNumber32Bit();
+                                        }
+                                        break;
+                                    }
+                                    case 'text-decoration-style': {
+                                        break;
+                                    }
                                     default: throw ( new BugIndicatingError('Unexpected inline decoration style'));
                                 }
                             }
@@ -297,7 +332,7 @@ class FullFileRenderStrategy extends BaseRenderStrategy {
                         }
                         continue;
                     }
-                    const decorationStyleSetId = ViewGpuContext.decorationStyleCache.getOrCreateEntry(decorationStyleSetColor, decorationStyleSetBold, decorationStyleSetOpacity);
+                    const decorationStyleSetId = ViewGpuContext.decorationStyleCache.getOrCreateEntry(decorationStyleSetColor, decorationStyleSetBold, decorationStyleSetOpacity, decorationStyleSetStrikethrough, decorationStyleSetStrikethroughThickness, decorationStyleSetStrikethroughColor);
                     glyph = this._viewGpuContext.atlas.getGlyph(this.glyphRasterizer, chars, tokenMetadata, decorationStyleSetId, absoluteOffsetX);
                     absoluteOffsetY = Math.round(
                     viewportData.relativeVerticalOffset[y - viewportData.startLineNumber] * dpr +

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

@@ -130,6 +130,9 @@ class ViewportRenderStrategy extends BaseRenderStrategy {
         let decorationStyleSetBold;
         let decorationStyleSetColor;
         let decorationStyleSetOpacity;
+        let decorationStyleSetStrikethrough;
+        let decorationStyleSetStrikethroughThickness;
+        let decorationStyleSetStrikethroughColor;
         let lineData;
         let decoration;
         let fillStartIndex = 0;
@@ -180,6 +183,9 @@ class ViewportRenderStrategy extends BaseRenderStrategy {
                     decorationStyleSetColor = undefined;
                     decorationStyleSetBold = undefined;
                     decorationStyleSetOpacity = undefined;
+                    decorationStyleSetStrikethrough = undefined;
+                    decorationStyleSetStrikethroughThickness = undefined;
+                    decorationStyleSetStrikethroughColor = undefined;
                     for (decoration of lineData.inlineDecorations) {
                         if ((y < decoration.range.startLineNumber || y > decoration.range.endLineNumber) ||
                             (y === decoration.range.startLineNumber && x < decoration.range.startColumn - 1) ||
@@ -214,6 +220,35 @@ class ViewportRenderStrategy extends BaseRenderStrategy {
                                         decorationStyleSetOpacity = parsedValue;
                                         break;
                                     }
+                                    case 'text-decoration':
+                                    case 'text-decoration-line': {
+                                        if (value === 'line-through') {
+                                            decorationStyleSetStrikethrough = true;
+                                        }
+                                        break;
+                                    }
+                                    case 'text-decoration-thickness': {
+                                        const match = value.match(/^(\d+(?:\.\d+)?)px$/);
+                                        if (match) {
+                                            decorationStyleSetStrikethroughThickness = parseFloat(match[1]);
+                                        }
+                                        break;
+                                    }
+                                    case 'text-decoration-color': {
+                                        let colorValue = value;
+                                        const varMatch = value.match(/^var\((--[^,]+),\s*(?:initial|inherit)\)$/);
+                                        if (varMatch) {
+                                            colorValue = ViewGpuContext.decorationCssRuleExtractor.resolveCssVariable(this._viewGpuContext.canvas.domNode, varMatch[1]);
+                                        }
+                                        const parsedColor = Color.Format.CSS.parse(colorValue);
+                                        if (parsedColor) {
+                                            decorationStyleSetStrikethroughColor = parsedColor.toNumber32Bit();
+                                        }
+                                        break;
+                                    }
+                                    case 'text-decoration-style': {
+                                        break;
+                                    }
                                     default: throw ( new BugIndicatingError('Unexpected inline decoration style'));
                                 }
                             }
@@ -233,7 +268,7 @@ class ViewportRenderStrategy extends BaseRenderStrategy {
                         }
                         continue;
                     }
-                    const decorationStyleSetId = ViewGpuContext.decorationStyleCache.getOrCreateEntry(decorationStyleSetColor, decorationStyleSetBold, decorationStyleSetOpacity);
+                    const decorationStyleSetId = ViewGpuContext.decorationStyleCache.getOrCreateEntry(decorationStyleSetColor, decorationStyleSetBold, decorationStyleSetOpacity, decorationStyleSetStrikethrough, decorationStyleSetStrikethroughThickness, decorationStyleSetStrikethroughColor);
                     glyph = this._viewGpuContext.atlas.getGlyph(this.glyphRasterizer, chars, tokenMetadata, decorationStyleSetId, absoluteOffsetX);
                     absoluteOffsetY = Math.round(
                     viewportData.relativeVerticalOffset[y - viewportData.startLineNumber] * dpr +

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

@@ -3,6 +3,7 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { localize } from '../../../nls.js';
 import { createElement, getActiveWindow, addDisposableListener } from '../../../base/browser/dom.js';
 import { createFastDomNode } from '../../../base/browser/fastDomNode.js';
+import { Color } from '../../../base/common/color.js';
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import '../../../base/common/observableInternal/index.js';
@@ -62,7 +63,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
         if (!ViewGpuContext_1.device) {
             ViewGpuContext_1.device = GPULifecycle.requestDevice((message) => {
                 const choices = [{
-                        label: ( localize(144, "Use DOM-based rendering")),
+                        label: ( localize(146, "Use DOM-based rendering")),
                         run: () => this.configurationService.updateValue('editor.experimentalGpuAcceleration', 'off'),
                     }];
                 this._notificationService.prompt(Severity$1.Warning, message, choices);
@@ -113,7 +114,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
                         return false;
                     }
                     for (const r of rule.style) {
-                        if (!supportsCssRule(r)) {
+                        if (!supportsCssRule(r, rule.style)) {
                             return false;
                         }
                     }
@@ -154,7 +155,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
                         return false;
                     }
                     for (const r of rule.style) {
-                        if (!supportsCssRule(r)) {
+                        if (!supportsCssRule(r, rule.style)) {
                             problemRules.push(`${r}: ${rule.style[r]}`);
                             return false;
                         }
@@ -187,12 +188,37 @@ const gpuSupportedDecorationCssRules = [
     'color',
     'font-weight',
     'opacity',
+    'text-decoration',
+    'text-decoration-color',
+    'text-decoration-line',
+    'text-decoration-style',
+    'text-decoration-thickness',
 ];
 function supportsCssRule(rule, style) {
     if (!gpuSupportedDecorationCssRules.includes(rule)) {
         return false;
     }
     switch (rule) {
+        case 'text-decoration':
+        case 'text-decoration-line': {
+            const value = style.getPropertyValue(rule);
+            return value === 'line-through';
+        }
+        case 'text-decoration-color': {
+            const value = style.getPropertyValue(rule);
+            if (/^var\(--[^,]+,\s*(?:initial|inherit)\)$/.test(value)) {
+                return true;
+            }
+            return Color.Format.CSS.parse(value) !== null;
+        }
+        case 'text-decoration-style': {
+            const value = style.getPropertyValue(rule);
+            return value === 'initial';
+        }
+        case 'text-decoration-thickness': {
+            const value = style.getPropertyValue(rule);
+            return value === 'initial' || /^\d+(\.\d+)?px$/.test(value);
+        }
         default: return true;
     }
 }

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

@@ -26,6 +26,14 @@ export declare class ObservableCodeEditor extends Disposable {
     private _beginUpdate;
     private _endUpdate;
     private constructor();
+    /**
+     * Batches the transactions started by observableFromEvent.
+     *
+     * If the callback causes the editor to fire an event that updates
+     * an observable value backed by observableFromEvent (such as scrollTop etc.),
+     * then all such updates will be part of the same transaction.
+    */
+    transaction<T>(cb: (tx: ITransaction) => T): T;
     forceUpdate(): void;
     forceUpdate<T>(cb: (tx: ITransaction) => T): T;
     private _forceUpdate;