@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -5,7 +5,7 @@ import { Color } from '../../../base/common/color.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { isWindows } from '../../../base/common/platform.js';
 import { firstNonWhitespaceIndex, lastNonWhitespaceIndex } from '../../../base/common/strings.js';
-import { EditorOption, filterValidationDecorations, EDITOR_FONT_DEFAULTS } from '../config/editorOptions.js';
+import { EditorOption, filterValidationDecorations, filterFontDecorations, EDITOR_FONT_DEFAULTS } from '../config/editorOptions.js';
 import { CursorsController } from '../cursor/cursor.js';
 import { CursorConfiguration } from '../cursorCommon.js';
 import { CursorChangeReason } from '../cursorEvents.js';
@@ -13,7 +13,7 @@ import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { ScrollType } from '../editorCommon.js';
 import { EndOfLinePreference, TrackedRangeStickiness } from '../model.js';
-import { InternalModelContentChangeEvent, RawContentChangedType, ModelLineHeightChangedEvent } from '../textModelEvents.js';
+import { InternalModelContentChangeEvent, RawContentChangedType, ModelLineHeightChangedEvent, ModelFontChangedEvent } from '../textModelEvents.js';
 import { TokenizationRegistry } from '../languages.js';
 import { ColorId } from '../encodedTokenAttributes.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
@@ -23,7 +23,7 @@ import { ViewLayout } from '../viewLayout/viewLayout.js';
 import { MinimapTokensColorTracker } from './minimapTokensColorTracker.js';
 import { ViewLineRenderingData, MinimapLinesRenderingData, OverviewRulerDecorationsGroup } from '../viewModel.js';
 import { ViewModelDecorations } from './viewModelDecorations.js';
-import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, WidgetFocusChangedEvent, ModelContentChangedEvent, ModelLineHeightChangedEvent as ModelLineHeightChangedEvent$1, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
+import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, WidgetFocusChangedEvent, ModelContentChangedEvent, ModelLineHeightChangedEvent as ModelLineHeightChangedEvent$1, ModelFontChangedEvent as ModelFontChangedEvent$1, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
 import { ViewModelLinesFromModelAsIs, ViewModelLinesFromProjectedModel } from './viewModelLines.js';
 import { GlyphMarginLanesModel } from './glyphLanesModel.js';
 
@@ -394,6 +394,16 @@ class ViewModel extends Disposable {
                 }
             }));
         }
+        const allowVariableFonts = this._configuration.options.get(EditorOption.effectiveAllowVariableFonts);
+        if (allowVariableFonts) {
+            this._register(this.model.onDidChangeFont((e) => {
+                const filteredChanges = e.changes.filter((change) => change.ownerId === this._editorId || change.ownerId === 0);
+                if (filteredChanges.length > 0) {
+                    const filteredEvent = new ModelFontChangedEvent(filteredChanges);
+                    this._eventDispatcher.emitOutgoingEvent(( new ModelFontChangedEvent$1(filteredEvent)));
+                }
+            }));
+        }
         this._register(this.model.onDidChangeTokens((e) => {
             const viewRanges = [];
             for (let j = 0, lenJ = e.ranges.length; j < lenJ; j++) {
@@ -463,6 +473,21 @@ class ViewModel extends Disposable {
             this._eventDispatcher.emitOutgoingEvent(( new ModelDecorationsChangedEvent(e)));
         }));
     }
+    getFontSizeAtPosition(position) {
+        const allowVariableFonts = this._configuration.options.get(EditorOption.effectiveAllowVariableFonts);
+        if (!allowVariableFonts) {
+            return null;
+        }
+        const fontDecorations = this.model.getFontDecorationsInRange(Range.fromPositions(position), this._editorId);
+        let fontSize = this._configuration.options.get(EditorOption.fontInfo).fontSize + 'px';
+        for (const fontDecoration of fontDecorations) {
+            if (fontDecoration.options.fontSize) {
+                fontSize = fontDecoration.options.fontSize;
+                break;
+            }
+        }
+        return fontSize;
+    }
     setHiddenAreas(ranges, source, forceUpdate) {
         this.hiddenAreasModel.setHiddenAreas(source, ranges);
         const mergedRanges = this.hiddenAreasModel.getMergedRanges();
@@ -664,15 +689,16 @@ class ViewModel extends Disposable {
         return this._lines.getInjectedTextAt(viewPosition);
     }
     getViewportViewLineRenderingData(visibleRange, lineNumber) {
-        const allInlineDecorations = this._decorations.getDecorationsViewportData(visibleRange).inlineDecorations;
+        const decorationViewportData = this._decorations.getDecorationsViewportData(visibleRange);
+        const allInlineDecorations = decorationViewportData.inlineDecorations;
         const inlineDecorations = allInlineDecorations[lineNumber - visibleRange.startLineNumber];
-        return this._getViewLineRenderingData(lineNumber, inlineDecorations);
+        return this._getViewLineRenderingData(lineNumber, inlineDecorations, decorationViewportData.hasVariableFonts);
     }
     getViewLineRenderingData(lineNumber) {
-        const inlineDecorations = this._decorations.getInlineDecorationsOnLine(lineNumber);
-        return this._getViewLineRenderingData(lineNumber, inlineDecorations);
+        const decorations = this._decorations.getInlineDecorationsOnLine(lineNumber);
+        return this._getViewLineRenderingData(lineNumber, decorations.inlineDecorations, decorations.hasVariableFonts);
     }
-    _getViewLineRenderingData(lineNumber, inlineDecorations) {
+    _getViewLineRenderingData(lineNumber, inlineDecorations, hasVariableFonts) {
         const mightContainRTL = this.model.mightContainRTL();
         const mightContainNonBasicASCII = this.model.mightContainNonBasicASCII();
         const tabSize = this.getTabSize();
@@ -693,7 +719,8 @@ class ViewModel extends Disposable {
             lineData.tokens,
             inlineDecorations,
             tabSize,
-            lineData.startVisibleColumn
+            lineData.startVisibleColumn,
+            hasVariableFonts
         ));
     }
     getViewLineData(lineNumber) {
@@ -704,7 +731,7 @@ class ViewModel extends Disposable {
         return ( new MinimapLinesRenderingData(this.getTabSize(), result));
     }
     getAllOverviewRulerDecorations(theme) {
-        const decorations = this.model.getOverviewRulerDecorations(this._editorId, filterValidationDecorations(this._configuration.options));
+        const decorations = this.model.getOverviewRulerDecorations(this._editorId, filterValidationDecorations(this._configuration.options), filterFontDecorations(this._configuration.options));
         const result = ( new OverviewRulerDecorations());
         for (const decoration of decorations) {
             const decorationOptions = decoration.options;
@@ -951,8 +978,8 @@ class ViewModel extends Disposable {
         }
         this._withViewEventsCollector(callback);
     }
-    executeEdits(source, edits, cursorStateComputer) {
-        this._executeCursorEdit(eventsCollector => this._cursor.executeEdits(eventsCollector, source, edits, cursorStateComputer));
+    executeEdits(source, edits, cursorStateComputer, reason) {
+        this._executeCursorEdit(eventsCollector => this._cursor.executeEdits(eventsCollector, source, edits, cursorStateComputer, reason));
     }
     startComposition() {
         this._executeCursorEdit(eventsCollector => this._cursor.startComposition(eventsCollector));

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

@@ -35,7 +35,7 @@ export interface IViewModelLines extends IDisposable {
     getViewLineMaxColumn(viewLineNumber: number): number;
     getViewLineData(viewLineNumber: number): ViewLineData;
     getViewLinesData(viewStartLineNumber: number, viewEndLineNumber: number, needed: boolean[]): Array<ViewLineData | null>;
-    getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
+    getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
     getInjectedTextAt(viewPosition: Position): InjectedText | null;
     normalizePosition(position: Position, affinity: PositionAffinity): Position;
     getLineIndentColumn(lineNumber: number): number;
@@ -100,7 +100,7 @@ export declare class ViewModelLinesFromProjectedModel implements IViewModelLines
     convertModelPositionToViewPosition(_modelLineNumber: number, _modelColumn: number, affinity?: PositionAffinity, allowZeroLineNumber?: boolean, belowHiddenRanges?: boolean): Position;
     convertModelRangeToViewRange(modelRange: Range, affinity?: PositionAffinity): Range;
     getViewLineNumberOfModelPosition(modelLineNumber: number, modelColumn: number): number;
-    getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
+    getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
     getInjectedTextAt(position: Position): InjectedText | null;
     normalizePosition(position: Position, affinity: PositionAffinity): Position;
     getLineIndentColumn(lineNumber: number): number;
@@ -135,7 +135,7 @@ export declare class ViewModelLinesFromModelAsIs implements IViewModelLines {
     getViewLineMaxColumn(viewLineNumber: number): number;
     getViewLineData(viewLineNumber: number): ViewLineData;
     getViewLinesData(viewStartLineNumber: number, viewEndLineNumber: number, needed: boolean[]): Array<ViewLineData | null>;
-    getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
+    getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, onlyMinimapDecorations: boolean, onlyMarginDecorations: boolean): IModelDecoration[];
     normalizePosition(position: Position, affinity: PositionAffinity): Position;
     getLineIndentColumn(lineNumber: number): number;
     getInjectedTextAt(position: Position): InjectedText | null;

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

@@ -624,11 +624,11 @@ class ViewModelLinesFromProjectedModel {
         const deltaLineNumber = 1 + this.projectedModelLineLineCounts.getPrefixSum(lineIndex);
         return this.modelLineProjections[lineIndex].getViewLineNumberOfModelPosition(deltaLineNumber, this.model.getLineMaxColumn(lineIndex + 1));
     }
-    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations, onlyMarginDecorations) {
+    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations) {
         const modelStart = this.convertViewPositionToModelPosition(range.startLineNumber, range.startColumn);
         const modelEnd = this.convertViewPositionToModelPosition(range.endLineNumber, range.endColumn);
         if (modelEnd.lineNumber - modelStart.lineNumber <= range.endLineNumber - range.startLineNumber) {
-            return this.model.getDecorationsInRange(( new Range(modelStart.lineNumber, 1, modelEnd.lineNumber, modelEnd.column)), ownerId, filterOutValidation, onlyMinimapDecorations, onlyMarginDecorations);
+            return this.model.getDecorationsInRange(( new Range(modelStart.lineNumber, 1, modelEnd.lineNumber, modelEnd.column)), ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations);
         }
         let result = [];
         const modelStartLineIndex = modelStart.lineNumber - 1;
@@ -647,13 +647,13 @@ class ViewModelLinesFromProjectedModel {
             else {
                 if (reqStart !== null) {
                     const maxLineColumn = this.model.getLineMaxColumn(modelLineIndex);
-                    result = result.concat(this.model.getDecorationsInRange(( new Range(reqStart.lineNumber, reqStart.column, modelLineIndex, maxLineColumn)), ownerId, filterOutValidation, onlyMinimapDecorations));
+                    result = result.concat(this.model.getDecorationsInRange(( new Range(reqStart.lineNumber, reqStart.column, modelLineIndex, maxLineColumn)), ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
                     reqStart = null;
                 }
             }
         }
         if (reqStart !== null) {
-            result = result.concat(this.model.getDecorationsInRange(( new Range(reqStart.lineNumber, reqStart.column, modelEnd.lineNumber, modelEnd.column)), ownerId, filterOutValidation, onlyMinimapDecorations));
+            result = result.concat(this.model.getDecorationsInRange(( new Range(reqStart.lineNumber, reqStart.column, modelEnd.lineNumber, modelEnd.column)), ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
             reqStart = null;
         }
         result.sort((a, b) => {
@@ -876,8 +876,8 @@ class ViewModelLinesFromModelAsIs {
         }
         return result;
     }
-    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations, onlyMarginDecorations) {
-        return this.model.getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations, onlyMarginDecorations);
+    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations) {
+        return this.model.getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations);
     }
     normalizePosition(position, affinity) {
         return this.model.normalizePosition(position, affinity);

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

@@ -25,6 +25,7 @@ export interface IViewModel extends ICursorSimpleModel {
     setHasWidgetFocus(hasWidgetFocus: boolean): void;
     onCompositionStart(): void;
     onCompositionEnd(): void;
+    getFontSizeAtPosition(position: IPosition): string | null;
     getMinimapDecorationsInRange(range: Range): ViewModelDecoration[];
     getDecorationsInViewport(visibleRange: Range): ViewModelDecoration[];
     getViewportViewLineRenderingData(visibleRange: Range, lineNumber: number): ViewLineRenderingData;
@@ -175,7 +176,8 @@ export declare class ViewLineRenderingData {
     readonly inlineDecorations: InlineDecoration[];
     readonly tabSize: number;
     readonly startVisibleColumn: number;
-    constructor(minColumn: number, maxColumn: number, content: string, continuesWithWrappedLine: boolean, mightContainRTL: boolean, mightContainNonBasicASCII: boolean, tokens: IViewLineTokens, inlineDecorations: InlineDecoration[], tabSize: number, startVisibleColumn: number);
+    readonly hasVariableFonts: boolean;
+    constructor(minColumn: number, maxColumn: number, content: string, continuesWithWrappedLine: boolean, mightContainRTL: boolean, mightContainNonBasicASCII: boolean, tokens: IViewLineTokens, inlineDecorations: InlineDecoration[], tabSize: number, startVisibleColumn: number, hasVariableFonts: boolean);
     static isBasicASCII(lineContent: string, mightContainNonBasicASCII: boolean): boolean;
     static containsRTL(lineContent: string, isBasicASCII: boolean, mightContainRTL: boolean): boolean;
 }

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

@@ -31,7 +31,7 @@ class ViewLineData {
     }
 }
 class ViewLineRenderingData {
-    constructor(minColumn, maxColumn, content, continuesWithWrappedLine, mightContainRTL, mightContainNonBasicASCII, tokens, inlineDecorations, tabSize, startVisibleColumn) {
+    constructor(minColumn, maxColumn, content, continuesWithWrappedLine, mightContainRTL, mightContainNonBasicASCII, tokens, inlineDecorations, tabSize, startVisibleColumn, hasVariableFonts) {
         this.minColumn = minColumn;
         this.maxColumn = maxColumn;
         this.content = content;
@@ -42,6 +42,7 @@ class ViewLineRenderingData {
         this.inlineDecorations = inlineDecorations;
         this.tabSize = tabSize;
         this.startVisibleColumn = startVisibleColumn;
+        this.hasVariableFonts = hasVariableFonts;
     }
     static isBasicASCII(lineContent, mightContainNonBasicASCII) {
         if (mightContainNonBasicASCII) {

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

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

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

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

package/vscode/src/vs/editor/contrib/anchorSelect/browser/anchorSelect.js

@@ -38,12 +38,12 @@ let SelectionAnchorController = class SelectionAnchorController {
                 this.decorationId = accessor.addDecoration(Selection.fromPositions(position, position), {
                     description: 'selection-anchor',
                     stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
-                    hoverMessage: ( new MarkdownString()).appendText(( localize(872, "Selection Anchor"))),
+                    hoverMessage: ( new MarkdownString()).appendText(( localize(883, "Selection Anchor"))),
                     className: 'selection-anchor'
                 });
             });
             this.selectionAnchorSetContextKey.set(!!this.decorationId);
-            alert(( localize(873, "Anchor set at {0}:{1}", position.lineNumber, position.column)));
+            alert(( localize(884, "Anchor set at {0}:{1}", position.lineNumber, position.column)));
         }
     }
     goToSelectionAnchor() {
@@ -86,7 +86,7 @@ class SetSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.setSelectionAnchor',
-            label: ( localize2(874, "Set Selection Anchor")),
+            label: ( localize2(885, "Set Selection Anchor")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -103,7 +103,7 @@ class GoToSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.goToSelectionAnchor',
-            label: ( localize2(875, "Go to Selection Anchor")),
+            label: ( localize2(886, "Go to Selection Anchor")),
             precondition: SelectionAnchorSet,
         });
     }
@@ -115,7 +115,7 @@ class SelectFromAnchorToCursor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.selectFromAnchorToCursor',
-            label: ( localize2(876, "Select from Anchor to Cursor")),
+            label: ( localize2(887, "Select from Anchor to Cursor")),
             precondition: SelectionAnchorSet,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -132,7 +132,7 @@ class CancelSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.cancelSelectionAnchor',
-            label: ( localize2(877, "Cancel Selection Anchor")),
+            label: ( localize2(888, "Cancel Selection Anchor")),
             precondition: SelectionAnchorSet,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

package/vscode/src/vs/editor/contrib/bracketMatching/browser/bracketMatching.js

@@ -29,12 +29,12 @@ import '../../../../platform/theme/common/colors/searchColors.js';
 import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
 
 registerCss(bracketMatching);
-const overviewRulerBracketMatchForeground = registerColor('editorOverviewRuler.bracketMatchForeground', '#A0A0A0', ( localize(878, 'Overview ruler marker color for matching brackets.')));
+const overviewRulerBracketMatchForeground = registerColor('editorOverviewRuler.bracketMatchForeground', '#A0A0A0', ( localize(889, 'Overview ruler marker color for matching brackets.')));
 class JumpToBracketAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.jumpToBracket',
-            label: ( localize2(879, "Go to Bracket")),
+            label: ( localize2(890, "Go to Bracket")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -51,10 +51,10 @@ class SelectToBracketAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.selectToBracket',
-            label: ( localize2(880, "Select to Bracket")),
+            label: ( localize2(891, "Select to Bracket")),
             precondition: undefined,
             metadata: {
-                description: ( localize2(881, "Select the text inside and including the brackets or curly braces")),
+                description: ( localize2(892, "Select the text inside and including the brackets or curly braces")),
                 args: [{
                         name: 'args',
                         schema: {
@@ -82,7 +82,7 @@ class RemoveBracketsAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.removeBrackets',
-            label: ( localize2(882, "Remove Brackets")),
+            label: ( localize2(893, "Remove Brackets")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -350,7 +350,7 @@ MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
     group: '5_infile_nav',
     command: {
         id: 'editor.action.jumpToBracket',
-        title: ( localize(883, "Go to &&Bracket"))
+        title: ( localize(894, "Go to &&Bracket"))
     },
     order: 2
 });

package/vscode/src/vs/editor/contrib/caretOperations/browser/caretOperations.js

@@ -27,7 +27,7 @@ class MoveCaretLeftAction extends MoveCaretAction {
     constructor() {
         super(true, {
             id: 'editor.action.moveCarretLeftAction',
-            label: ( localize2(884, "Move Selected Text Left")),
+            label: ( localize2(895, "Move Selected Text Left")),
             precondition: EditorContextKeys.writable
         });
     }
@@ -36,7 +36,7 @@ class MoveCaretRightAction extends MoveCaretAction {
     constructor() {
         super(false, {
             id: 'editor.action.moveCarretRightAction',
-            label: ( localize2(885, "Move Selected Text Right")),
+            label: ( localize2(896, "Move Selected Text Right")),
             precondition: EditorContextKeys.writable
         });
     }

package/vscode/src/vs/editor/contrib/caretOperations/browser/transpose.js

@@ -12,7 +12,7 @@ class TransposeLettersAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.transposeLetters',
-            label: ( localize2(886, "Transpose Letters")),
+            label: ( localize2(897, "Transpose Letters")),
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,

package/vscode/src/vs/editor/contrib/clipboard/browser/clipboard.js

@@ -40,23 +40,23 @@ const CutAction = supportsCut ? registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '2_ccp',
-            title: ( localize(887, "Cu&&t")),
+            title: ( localize(898, "Cu&&t")),
             order: 1
         }, {
             menuId: MenuId.EditorContext,
             group: CLIPBOARD_CONTEXT_MENU_GROUP,
-            title: ( localize(888, "Cut")),
+            title: ( localize(899, "Cut")),
             when: EditorContextKeys.writable,
             order: 1,
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(888, "Cut")),
+            title: ( localize(899, "Cut")),
             order: 1
         }, {
             menuId: MenuId.SimpleEditorContext,
             group: CLIPBOARD_CONTEXT_MENU_GROUP,
-            title: ( localize(888, "Cut")),
+            title: ( localize(899, "Cut")),
             when: EditorContextKeys.writable,
             order: 1,
         }]
@@ -73,29 +73,29 @@ const CopyAction = supportsCopy ? registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '2_ccp',
-            title: ( localize(889, "&&Copy")),
+            title: ( localize(900, "&&Copy")),
             order: 2
         }, {
             menuId: MenuId.EditorContext,
             group: CLIPBOARD_CONTEXT_MENU_GROUP,
-            title: ( localize(890, "Copy")),
+            title: ( localize(901, "Copy")),
             order: 2,
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(890, "Copy")),
+            title: ( localize(901, "Copy")),
             order: 1
         }, {
             menuId: MenuId.SimpleEditorContext,
             group: CLIPBOARD_CONTEXT_MENU_GROUP,
-            title: ( localize(890, "Copy")),
+            title: ( localize(901, "Copy")),
             order: 2,
         }]
 }))) : undefined;
-MenuRegistry.appendMenuItem(MenuId.MenubarEditMenu, { submenu: MenuId.MenubarCopy, title: ( localize2(891, "Copy As")), group: '2_ccp', order: 3 });
-MenuRegistry.appendMenuItem(MenuId.EditorContext, { submenu: MenuId.EditorContextCopy, title: ( localize2(891, "Copy As")), group: CLIPBOARD_CONTEXT_MENU_GROUP, order: 3 });
-MenuRegistry.appendMenuItem(MenuId.EditorContext, { submenu: MenuId.EditorContextShare, title: ( localize2(892, "Share")), group: '11_share', order: -1, when: ( ContextKeyExpr.and(( ContextKeyExpr.notEquals('resourceScheme', 'output')), EditorContextKeys.editorTextFocus)) });
-MenuRegistry.appendMenuItem(MenuId.ExplorerContext, { submenu: MenuId.ExplorerContextShare, title: ( localize2(892, "Share")), group: '11_share', order: -1 });
+MenuRegistry.appendMenuItem(MenuId.MenubarEditMenu, { submenu: MenuId.MenubarCopy, title: ( localize2(902, "Copy As")), group: '2_ccp', order: 3 });
+MenuRegistry.appendMenuItem(MenuId.EditorContext, { submenu: MenuId.EditorContextCopy, title: ( localize2(902, "Copy As")), group: CLIPBOARD_CONTEXT_MENU_GROUP, order: 3 });
+MenuRegistry.appendMenuItem(MenuId.EditorContext, { submenu: MenuId.EditorContextShare, title: ( localize2(903, "Share")), group: '11_share', order: -1, when: ( ContextKeyExpr.and(( ContextKeyExpr.notEquals('resourceScheme', 'output')), EditorContextKeys.editorTextFocus)) });
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, { submenu: MenuId.ExplorerContextShare, title: ( localize2(903, "Share")), group: '11_share', order: -1 });
 const PasteAction = supportsPaste ? registerCommand(( new MultiCommand({
     id: 'editor.action.clipboardPasteAction',
     precondition: undefined,
@@ -109,23 +109,23 @@ const PasteAction = supportsPaste ? registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '2_ccp',
-            title: ( localize(893, "&&Paste")),
+            title: ( localize(904, "&&Paste")),
             order: 4
         }, {
             menuId: MenuId.EditorContext,
             group: CLIPBOARD_CONTEXT_MENU_GROUP,
-            title: ( localize(894, "Paste")),
+            title: ( localize(905, "Paste")),
             when: EditorContextKeys.writable,
             order: 4,
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(894, "Paste")),
+            title: ( localize(905, "Paste")),
             order: 1
         }, {
             menuId: MenuId.SimpleEditorContext,
             group: CLIPBOARD_CONTEXT_MENU_GROUP,
-            title: ( localize(894, "Paste")),
+            title: ( localize(905, "Paste")),
             when: EditorContextKeys.writable,
             order: 4,
         }]
@@ -134,7 +134,7 @@ class ExecCommandCopyWithSyntaxHighlightingAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.clipboardCopyWithSyntaxHighlightingAction',
-            label: ( localize2(895, "Copy with Syntax Highlighting")),
+            label: ( localize2(906, "Copy with Syntax Highlighting")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
@@ -169,7 +169,7 @@ function registerExecCommandImpl(target, browserCommand) {
             if (selection && selection.isEmpty() && !emptySelectionClipboard) {
                 return true;
             }
-            if (focusedEditor.getOption(EditorOption.effectiveExperimentalEditContextEnabled) && browserCommand === 'cut') {
+            if (focusedEditor.getOption(EditorOption.effectiveEditContext) && browserCommand === 'cut') {
                 focusedEditor.getContainerDomNode().ownerDocument.execCommand('copy');
                 focusedEditor.trigger(undefined, Handler.Cut, undefined);
             }
@@ -195,8 +195,8 @@ if (PasteAction) {
         const productService = accessor.get(IProductService);
         const focusedEditor = codeEditorService.getFocusedCodeEditor();
         if (focusedEditor && focusedEditor.hasModel() && focusedEditor.hasTextFocus()) {
-            const experimentalEditContextEnabled = focusedEditor.getOption(EditorOption.effectiveExperimentalEditContextEnabled);
-            if (experimentalEditContextEnabled) {
+            const editContextEnabled = focusedEditor.getOption(EditorOption.effectiveEditContext);
+            if (editContextEnabled) {
                 const nativeEditContext = NativeEditContextRegistry.get(focusedEditor.getId());
                 if (nativeEditContext) {
                     nativeEditContext.onWillPaste();

package/vscode/src/vs/editor/contrib/codeAction/browser/codeAction.js

@@ -19,6 +19,7 @@ import { Selection } from '../../../common/core/selection.js';
 import { CodeActionTriggerType } from '../../../common/languages.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.service.js';
 import { IModelService } from '../../../common/services/model.service.js';
+import { EditReasons } from '../../../common/textModelEditReason.js';
 import { TextModelCancellationTokenSource } from '../../editorState/browser/editorState.js';
 import { CodeActionKind, filtersAction, CodeActionItem, mayIncludeActionsOfKind, CodeActionTriggerSource } from '../common/types.js';
 
@@ -233,6 +234,7 @@ async function applyCodeAction(accessor, item, codeActionReason, options, token
             code: 'undoredo.codeAction',
             respectAutoSaveConfig: codeActionReason !== ApplyCodeActionReason.OnSave,
             showPreview: options?.preview,
+            reason: EditReasons.codeAction({ kind: item.action.kind, extensionId: item.provider?.extensionId }),
         });
         if (!result.isApplied) {
             return;
@@ -246,7 +248,7 @@ async function applyCodeAction(accessor, item, codeActionReason, options, token
             const message = asMessage(err);
             notificationService.error(typeof message === 'string'
                 ? message
-                : ( localize(896, "An unknown error occurred while applying the code action")));
+                : ( localize(907, "An unknown error occurred while applying the code action")));
         }
     }
     setTimeout(() => accessibilitySignalService.playSignal(AccessibilitySignal.codeActionApplied), CODE_ACTION_SOUND_APPLIED_DURATION);