@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -281,19 +281,22 @@ export interface InlineCompletionDisplayLocation {
 export type IconPath = ThemeIcon;
 export interface InlineCompletions<TItem extends InlineCompletion = InlineCompletion> {
     readonly items: readonly TItem[];
-    readonly commands?: Command[];
+    readonly commands?: InlineCompletionCommand[];
     readonly suppressSuggestions?: boolean | undefined;
     readonly enableForwardStability?: boolean | undefined;
 }
+export type InlineCompletionCommand = {
+    command: Command;
+    icon?: ThemeIcon;
+};
 export type InlineCompletionProviderGroupId = string;
 export interface InlineCompletionsProvider<T extends InlineCompletions = InlineCompletions> {
     provideInlineCompletions(model: model.ITextModel, position: Position, context: InlineCompletionContext, token: CancellationToken): ProviderResult<T>;
-    provideInlineEditsForRange?(model: model.ITextModel, range: Range, context: InlineCompletionContext, token: CancellationToken): ProviderResult<T>;
     handleItemDidShow?(completions: T, item: T["items"][number], updatedInsertText: string): void;
     handlePartialAccept?(completions: T, item: T["items"][number], acceptedCharacters: number, info: PartialAcceptInfo): void;
     handleRejection?(completions: T, item: T["items"][number]): void;
-    handleEndOfLifetime?(completions: T, item: T["items"][number], reason: InlineCompletionEndOfLifeReason<T["items"][number]>): void;
-    freeInlineCompletions(completions: T): void;
+    handleEndOfLifetime?(completions: T, item: T["items"][number], reason: InlineCompletionEndOfLifeReason<T["items"][number]>, lifetimeSummary: LifetimeSummary): void;
+    disposeInlineCompletions(completions: T, reason: InlineCompletionsDisposeReason): void;
     onDidChangeInlineCompletions?: Event<void>;
     groupId?: InlineCompletionProviderGroupId;
     yieldsToGroupIds?: InlineCompletionProviderGroupId[];
@@ -301,6 +304,9 @@ export interface InlineCompletionsProvider<T extends InlineCompletions = InlineC
     debounceDelayMs?: number;
     toString?(): string;
 }
+export type InlineCompletionsDisposeReason = {
+    kind: "lostRace" | "tokenCancellation" | "other" | "empty" | "notTaken";
+};
 export declare enum InlineCompletionEndOfLifeReasonKind {
     Accepted = 0,
     Rejected = 1,
@@ -315,6 +321,27 @@ export type InlineCompletionEndOfLifeReason<TInlineCompletion = InlineCompletion
     supersededBy?: TInlineCompletion;
     userTypingDisagreed: boolean;
 };
+export type LifetimeSummary = {
+    requestUuid: string;
+    partiallyAccepted: number;
+    shown: boolean;
+    shownDuration: number;
+    shownDurationUncollapsed: number;
+    timeUntilShown: number | undefined;
+    editorType: string;
+    viewKind: string | undefined;
+    error: string | undefined;
+    languageId: string;
+    requestReason: string;
+    cursorColumnDistance?: number;
+    cursorLineDistance?: number;
+    lineCountOriginal?: number;
+    lineCountModified?: number;
+    characterCountOriginal?: number;
+    characterCountModified?: number;
+    disjointReplacements?: number;
+    sameShapeReplacements?: boolean;
+};
 export interface CodeAction {
     title: string;
     command?: Command;
@@ -956,26 +983,3 @@ export interface DocumentDropEditProvider {
     provideDocumentDropEdits(model: model.ITextModel, position: IPosition, dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): ProviderResult<DocumentDropEditsSession>;
     resolveDocumentDropEdit?(edit: DocumentDropEdit, token: CancellationToken): Promise<DocumentDropEdit>;
 }
-export interface IInlineEdit {
-    text: string;
-    range: IRange;
-    showRange?: IRange;
-    accepted?: Command;
-    rejected?: Command;
-    shown?: Command;
-    commands?: Command[];
-    action?: Command;
-}
-export interface IInlineEditContext {
-    triggerKind: InlineEditTriggerKind;
-    requestUuid: string;
-}
-export declare enum InlineEditTriggerKind {
-    Invoke = 0,
-    Automatic = 1
-}
-export interface InlineEditProvider<T extends IInlineEdit = IInlineEdit> {
-    displayName?: string;
-    provideInlineEdit(model: model.ITextModel, context: IInlineEditContext, token: CancellationToken): ProviderResult<T>;
-    freeInlineEdit(edit: T): void;
-}

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

@@ -113,35 +113,35 @@ var CompletionItemKinds;
     CompletionItemKinds.toIcon = toIcon;
     function toLabel(kind) {
         switch (kind) {
-            case CompletionItemKind.Method: return localize(765, 'Method');
-            case CompletionItemKind.Function: return localize(766, 'Function');
-            case CompletionItemKind.Constructor: return localize(767, 'Constructor');
-            case CompletionItemKind.Field: return localize(768, 'Field');
-            case CompletionItemKind.Variable: return localize(769, 'Variable');
-            case CompletionItemKind.Class: return localize(770, 'Class');
-            case CompletionItemKind.Struct: return localize(771, 'Struct');
-            case CompletionItemKind.Interface: return localize(772, 'Interface');
-            case CompletionItemKind.Module: return localize(773, 'Module');
-            case CompletionItemKind.Property: return localize(774, 'Property');
-            case CompletionItemKind.Event: return localize(775, 'Event');
-            case CompletionItemKind.Operator: return localize(776, 'Operator');
-            case CompletionItemKind.Unit: return localize(777, 'Unit');
-            case CompletionItemKind.Value: return localize(778, 'Value');
-            case CompletionItemKind.Constant: return localize(779, 'Constant');
-            case CompletionItemKind.Enum: return localize(780, 'Enum');
-            case CompletionItemKind.EnumMember: return localize(781, 'Enum Member');
-            case CompletionItemKind.Keyword: return localize(782, 'Keyword');
-            case CompletionItemKind.Text: return localize(783, 'Text');
-            case CompletionItemKind.Color: return localize(784, 'Color');
-            case CompletionItemKind.File: return localize(785, 'File');
-            case CompletionItemKind.Reference: return localize(786, 'Reference');
-            case CompletionItemKind.Customcolor: return localize(787, 'Custom Color');
-            case CompletionItemKind.Folder: return localize(788, 'Folder');
-            case CompletionItemKind.TypeParameter: return localize(789, 'Type Parameter');
-            case CompletionItemKind.User: return localize(790, 'User');
-            case CompletionItemKind.Issue: return localize(791, 'Issue');
-            case CompletionItemKind.Tool: return localize(792, 'Tool');
-            case CompletionItemKind.Snippet: return localize(793, 'Snippet');
+            case CompletionItemKind.Method: return localize(776, 'Method');
+            case CompletionItemKind.Function: return localize(777, 'Function');
+            case CompletionItemKind.Constructor: return localize(778, 'Constructor');
+            case CompletionItemKind.Field: return localize(779, 'Field');
+            case CompletionItemKind.Variable: return localize(780, 'Variable');
+            case CompletionItemKind.Class: return localize(781, 'Class');
+            case CompletionItemKind.Struct: return localize(782, 'Struct');
+            case CompletionItemKind.Interface: return localize(783, 'Interface');
+            case CompletionItemKind.Module: return localize(784, 'Module');
+            case CompletionItemKind.Property: return localize(785, 'Property');
+            case CompletionItemKind.Event: return localize(786, 'Event');
+            case CompletionItemKind.Operator: return localize(787, 'Operator');
+            case CompletionItemKind.Unit: return localize(788, 'Unit');
+            case CompletionItemKind.Value: return localize(789, 'Value');
+            case CompletionItemKind.Constant: return localize(790, 'Constant');
+            case CompletionItemKind.Enum: return localize(791, 'Enum');
+            case CompletionItemKind.EnumMember: return localize(792, 'Enum Member');
+            case CompletionItemKind.Keyword: return localize(793, 'Keyword');
+            case CompletionItemKind.Text: return localize(794, 'Text');
+            case CompletionItemKind.Color: return localize(795, 'Color');
+            case CompletionItemKind.File: return localize(796, 'File');
+            case CompletionItemKind.Reference: return localize(797, 'Reference');
+            case CompletionItemKind.Customcolor: return localize(798, 'Custom Color');
+            case CompletionItemKind.Folder: return localize(799, 'Folder');
+            case CompletionItemKind.TypeParameter: return localize(800, 'Type Parameter');
+            case CompletionItemKind.User: return localize(801, 'User');
+            case CompletionItemKind.Issue: return localize(802, 'Issue');
+            case CompletionItemKind.Tool: return localize(803, 'Tool');
+            case CompletionItemKind.Snippet: return localize(804, 'Snippet');
             default: return '';
         }
     }
@@ -297,35 +297,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(794, "array")),
-    [SymbolKind.Boolean]: ( localize(795, "boolean")),
-    [SymbolKind.Class]: ( localize(796, "class")),
-    [SymbolKind.Constant]: ( localize(797, "constant")),
-    [SymbolKind.Constructor]: ( localize(798, "constructor")),
-    [SymbolKind.Enum]: ( localize(799, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(800, "enumeration member")),
-    [SymbolKind.Event]: ( localize(801, "event")),
-    [SymbolKind.Field]: ( localize(802, "field")),
-    [SymbolKind.File]: ( localize(803, "file")),
-    [SymbolKind.Function]: ( localize(804, "function")),
-    [SymbolKind.Interface]: ( localize(805, "interface")),
-    [SymbolKind.Key]: ( localize(806, "key")),
-    [SymbolKind.Method]: ( localize(807, "method")),
-    [SymbolKind.Module]: ( localize(808, "module")),
-    [SymbolKind.Namespace]: ( localize(809, "namespace")),
-    [SymbolKind.Null]: ( localize(810, "null")),
-    [SymbolKind.Number]: ( localize(811, "number")),
-    [SymbolKind.Object]: ( localize(812, "object")),
-    [SymbolKind.Operator]: ( localize(813, "operator")),
-    [SymbolKind.Package]: ( localize(814, "package")),
-    [SymbolKind.Property]: ( localize(815, "property")),
-    [SymbolKind.String]: ( localize(816, "string")),
-    [SymbolKind.Struct]: ( localize(817, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(818, "type parameter")),
-    [SymbolKind.Variable]: ( localize(819, "variable")),
+    [SymbolKind.Array]: ( localize(805, "array")),
+    [SymbolKind.Boolean]: ( localize(806, "boolean")),
+    [SymbolKind.Class]: ( localize(807, "class")),
+    [SymbolKind.Constant]: ( localize(808, "constant")),
+    [SymbolKind.Constructor]: ( localize(809, "constructor")),
+    [SymbolKind.Enum]: ( localize(810, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(811, "enumeration member")),
+    [SymbolKind.Event]: ( localize(812, "event")),
+    [SymbolKind.Field]: ( localize(813, "field")),
+    [SymbolKind.File]: ( localize(814, "file")),
+    [SymbolKind.Function]: ( localize(815, "function")),
+    [SymbolKind.Interface]: ( localize(816, "interface")),
+    [SymbolKind.Key]: ( localize(817, "key")),
+    [SymbolKind.Method]: ( localize(818, "method")),
+    [SymbolKind.Module]: ( localize(819, "module")),
+    [SymbolKind.Namespace]: ( localize(820, "namespace")),
+    [SymbolKind.Null]: ( localize(821, "null")),
+    [SymbolKind.Number]: ( localize(822, "number")),
+    [SymbolKind.Object]: ( localize(823, "object")),
+    [SymbolKind.Operator]: ( localize(824, "operator")),
+    [SymbolKind.Package]: ( localize(825, "package")),
+    [SymbolKind.Property]: ( localize(826, "property")),
+    [SymbolKind.String]: ( localize(827, "string")),
+    [SymbolKind.Struct]: ( localize(828, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(829, "type parameter")),
+    [SymbolKind.Variable]: ( localize(830, "variable")),
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(820, '{0} ({1})', symbolName, symbolKindNames[kind]);
+    return localize(831, '{0} ({1})', symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function (SymbolTag) {
@@ -513,10 +513,5 @@ var ExternalUriOpenerPriority;
     ExternalUriOpenerPriority[ExternalUriOpenerPriority["Default"] = 2] = "Default";
     ExternalUriOpenerPriority[ExternalUriOpenerPriority["Preferred"] = 3] = "Preferred";
 })(ExternalUriOpenerPriority || (ExternalUriOpenerPriority = {}));
-var InlineEditTriggerKind;
-(function (InlineEditTriggerKind) {
-    InlineEditTriggerKind[InlineEditTriggerKind["Invoke"] = 0] = "Invoke";
-    InlineEditTriggerKind[InlineEditTriggerKind["Automatic"] = 1] = "Automatic";
-})(InlineEditTriggerKind || (InlineEditTriggerKind = {}));
 
-export { CodeActionTriggerType, Command, CommentMode, CommentState, CommentThreadApplicability, CommentThreadCollapsibleState, CommentThreadState, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemKinds, CompletionItemTag, CompletionTriggerKind, DocumentHighlightKind, DocumentPasteTriggerKind, EncodedTokenizationResult, ExternalUriOpenerPriority, FoldingRangeKind, HoverVerbosityAction, InlayHintKind, InlineCompletionEndOfLifeReasonKind, InlineCompletionTriggerKind, InlineEditTriggerKind, LazyTokenizationSupport, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, SelectedSuggestionInfo, SignatureHelpTriggerKind, SymbolKind, SymbolKinds, SymbolTag, TextEdit, Token, TokenizationRegistry, TokenizationResult, getAriaLabelForSymbol, isLocation, isLocationLink, symbolKindNames };
+export { CodeActionTriggerType, Command, CommentMode, CommentState, CommentThreadApplicability, CommentThreadCollapsibleState, CommentThreadState, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemKinds, CompletionItemTag, CompletionTriggerKind, DocumentHighlightKind, DocumentPasteTriggerKind, EncodedTokenizationResult, ExternalUriOpenerPriority, FoldingRangeKind, HoverVerbosityAction, InlayHintKind, InlineCompletionEndOfLifeReasonKind, InlineCompletionTriggerKind, LazyTokenizationSupport, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, SelectedSuggestionInfo, SignatureHelpTriggerKind, SymbolKind, SymbolKinds, SymbolTag, TextEdit, Token, TokenizationRegistry, TokenizationResult, getAriaLabelForSymbol, isLocation, isLocationLink, symbolKindNames };

package/vscode/src/vs/editor/common/model/editStack.d.ts

@@ -7,6 +7,7 @@ import { URI } from "../../../base/common/uri.js";
 import { TextChange } from "../core/textChange.js";
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import { ISingleEditOperation } from "../core/editOperation.js";
+import { TextModelEditReason } from "../textModelEditReason.js";
 export declare class SingleModelEditStackData {
     readonly beforeVersionId: number;
     afterVersionId: number;
@@ -82,6 +83,6 @@ export declare class EditStack {
     clear(): void;
     private _getOrCreateEditStackElement;
     pushEOL(eol: EndOfLineSequence): void;
-    pushEditOperation(beforeCursorState: Selection[] | null, editOperations: ISingleEditOperation[], cursorStateComputer: ICursorStateComputer | null, group?: UndoRedoGroup): Selection[] | null;
+    pushEditOperation(beforeCursorState: Selection[] | null, editOperations: ISingleEditOperation[], cursorStateComputer: ICursorStateComputer | null, group?: UndoRedoGroup, reason?: TextModelEditReason): Selection[] | null;
     private static _computeCursorState;
 }

package/vscode/src/vs/editor/common/model/editStack.js

@@ -8,6 +8,7 @@ import { URI } from '../../../base/common/uri.js';
 import { compressConsecutiveTextChanges, TextChange } from '../core/textChange.js';
 import { writeUInt32BE, readUInt32BE, writeUInt8, readUInt8 } from '../../../base/common/buffer.js';
 import { basename } from '../../../base/common/resources.js';
+import { EditReasons } from '../textModelEditReason.js';
 
 function uriGetComparisonKey(resource) {
     return ( resource.toString());
@@ -353,7 +354,7 @@ class EditStack {
         if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
             return lastElement;
         }
-        const newElement = ( new SingleModelEditStackElement(( localize(822, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(833, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }
@@ -362,9 +363,9 @@ class EditStack {
         this._model.setEOL(eol);
         editStackElement.append(this._model, [], getModelEOL(this._model), this._model.getAlternativeVersionId(), null);
     }
-    pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group) {
+    pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group, reason = EditReasons.unknown({ name: 'pushEditOperation' })) {
         const editStackElement = this._getOrCreateEditStackElement(beforeCursorState, group);
-        const inverseEditOperations = this._model.applyEdits(editOperations, true);
+        const inverseEditOperations = this._model.applyEdits(editOperations, true, reason);
         const afterCursorState = EditStack._computeCursorState(cursorStateComputer, inverseEditOperations);
         const textChanges = ( inverseEditOperations.map((op, index) => ({ index: index, textChange: op.textChange })));
         textChanges.sort((a, b) => {

package/vscode/src/vs/editor/common/model/intervalTree.d.ts

@@ -43,8 +43,8 @@ export declare class IntervalTree {
     root: IntervalNode;
     requestNormalizeDelta: boolean;
     constructor();
-    intervalSearch(start: number, end: number, filterOwnerId: number, filterOutValidation: boolean, cachedVersionId: number, onlyMarginDecorations: boolean): IntervalNode[];
-    search(filterOwnerId: number, filterOutValidation: boolean, cachedVersionId: number, onlyMarginDecorations: boolean): IntervalNode[];
+    intervalSearch(start: number, end: number, filterOwnerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, cachedVersionId: number, onlyMarginDecorations: boolean): IntervalNode[];
+    search(filterOwnerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, cachedVersionId: number, onlyMarginDecorations: boolean): IntervalNode[];
     collectNodesFromOwner(ownerId: number): IntervalNode[];
     collectNodesPostOrder(): IntervalNode[];
     insert(node: IntervalNode): void;

package/vscode/src/vs/editor/common/model/intervalTree.js

@@ -36,6 +36,9 @@ var Constants;
     Constants[Constants["IsMarginMask"] = 64] = "IsMarginMask";
     Constants[Constants["IsMarginMaskInverse"] = 191] = "IsMarginMaskInverse";
     Constants[Constants["IsMarginOffset"] = 6] = "IsMarginOffset";
+    Constants[Constants["AffectsFontMask"] = 128] = "AffectsFontMask";
+    Constants[Constants["AffectsFontMaskInverse"] = 127] = "AffectsFontMaskInverse";
+    Constants[Constants["AffectsFontOffset"] = 7] = "AffectsFontOffset";
     Constants[Constants["MIN_SAFE_DELTA"] = -1073741824] = "MIN_SAFE_DELTA";
     Constants[Constants["MAX_SAFE_DELTA"] = 1073741824] = "MAX_SAFE_DELTA";
 })(Constants || (Constants = {}));
@@ -63,6 +66,12 @@ function getNodeIsInGlyphMargin(node) {
 function setNodeIsInGlyphMargin(node, value) {
     node.metadata = ((node.metadata & Constants.IsMarginMaskInverse) | ((value ? 1 : 0) << Constants.IsMarginOffset));
 }
+function getNodeAffectsFont(node) {
+    return ((node.metadata & Constants.AffectsFontMask) >>> Constants.AffectsFontOffset) === 1;
+}
+function setNodeAffectsFont(node, value) {
+    node.metadata = ((node.metadata & Constants.AffectsFontMaskInverse) | ((value ? 1 : 0) << Constants.AffectsFontOffset));
+}
 function getNodeStickiness(node) {
     return ((node.metadata & Constants.StickinessMask) >>> Constants.StickinessOffset);
 }
@@ -93,6 +102,7 @@ class IntervalNode {
         setNodeIsInGlyphMargin(this, false);
         _setNodeStickiness(this, TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges);
         setCollapseOnReplaceEdit(this, false);
+        setNodeAffectsFont(this, false);
         this.cachedVersionId = 0;
         this.cachedAbsoluteStart = start;
         this.cachedAbsoluteEnd = end;
@@ -117,6 +127,7 @@ class IntervalNode {
         setNodeIsInGlyphMargin(this, this.options.glyphMarginClassName !== null);
         _setNodeStickiness(this, this.options.stickiness);
         setCollapseOnReplaceEdit(this, this.options.collapseOnReplaceEdit);
+        setNodeAffectsFont(this, this.options.affectsFont ?? false);
     }
     setCachedOffsets(absoluteStart, absoluteEnd, cachedVersionId) {
         if (this.cachedVersionId !== cachedVersionId) {
@@ -142,17 +153,17 @@ class IntervalTree {
         this.root = SENTINEL;
         this.requestNormalizeDelta = false;
     }
-    intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+    intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
         if (this.root === SENTINEL) {
             return [];
         }
-        return intervalSearch(this, start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+        return intervalSearch(this, start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
     }
-    search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+    search(filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
         if (this.root === SENTINEL) {
             return [];
         }
-        return search(this, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+        return search(this, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
     }
     collectNodesFromOwner(ownerId) {
         return collectNodesFromOwner(this, ownerId);
@@ -201,7 +212,7 @@ class IntervalTree {
         this._normalizeDeltaIfNecessary();
     }
     getAllInOrder() {
-        return search(this, 0, false, 0, false);
+        return search(this, 0, false, false, 0, false);
     }
     _normalizeDeltaIfNecessary() {
         if (!this.requestNormalizeDelta) {
@@ -467,7 +478,7 @@ function collectNodesPostOrder(T) {
     setNodeIsVisited(T.root, false);
     return result;
 }
-function search(T, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+function search(T, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
     let node = T.root;
     let delta = 0;
     let nodeStart = 0;
@@ -498,6 +509,9 @@ function search(T, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarg
         if (filterOutValidation && getNodeIsForValidation(node)) {
             include = false;
         }
+        if (filterFontDecorations && getNodeAffectsFont(node)) {
+            include = false;
+        }
         if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {
             include = false;
         }
@@ -514,7 +528,7 @@ function search(T, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarg
     setNodeIsVisited(T.root, false);
     return result;
 }
-function intervalSearch(T, intervalStart, intervalEnd, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+function intervalSearch(T, intervalStart, intervalEnd, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
     let node = T.root;
     let delta = 0;
     let nodeMaxEnd = 0;
@@ -558,6 +572,9 @@ function intervalSearch(T, intervalStart, intervalEnd, filterOwnerId, filterOutV
             if (filterOutValidation && getNodeIsForValidation(node)) {
                 include = false;
             }
+            if (filterFontDecorations && getNodeAffectsFont(node)) {
+                include = false;
+            }
             if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {
                 include = false;
             }

package/vscode/src/vs/editor/common/model/textModel.d.ts

@@ -16,15 +16,16 @@ import { ILanguageService } from "../languages/language.service.js";
 import { ILanguageConfigurationService } from "../languages/languageConfigurationRegistry.service.js";
 import * as model from "../model.js";
 import { IBracketPairsTextModelPart } from "../textModelBracketPairs.js";
-import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelOptionsChangedEvent, InternalModelContentChangeEvent, ModelInjectedTextChangedEvent, ModelLineHeightChangedEvent } from "../textModelEvents.js";
+import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelOptionsChangedEvent, InternalModelContentChangeEvent, ModelInjectedTextChangedEvent, ModelLineHeightChangedEvent, ModelFontChangedEvent } from "../textModelEvents.js";
 import { IGuidesTextModelPart } from "../textModelGuides.js";
 import { ITokenizationTextModelPart } from "../tokenizationTextModelPart.js";
 import { IInstantiationService } from "../../../platform/instantiation/common/instantiation.js";
 import { IColorTheme } from "../../../platform/theme/common/themeService.js";
 import { ResourceEditStackSnapshot, UndoRedoGroup } from "../../../platform/undoRedo/common/undoRedo.js";
 import { IUndoRedoService } from "../../../platform/undoRedo/common/undoRedo.service.js";
-import { TokenArray } from "../tokens/tokenArray.js";
+import { TokenArray } from "../tokens/lineTokens.js";
 import { TextModelEditReason } from "../textModelEditReason.js";
+import { TextEdit } from "../core/edits/textEdit.js";
 export declare function createTextBufferFactory(text: string): model.ITextBufferFactory;
 interface ITextStream {
     on(event: "data", callback: (data: string) => void): void;
@@ -64,6 +65,8 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     private readonly _onDidChangeInjectedText;
     private readonly _onDidChangeLineHeight;
     readonly onDidChangeLineHeight: Event<ModelLineHeightChangedEvent>;
+    private readonly _onDidChangeFont;
+    readonly onDidChangeFont: Event<ModelFontChangedEvent>;
     private readonly _eventEmitter;
     onDidChangeContent(listener: (e: IModelContentChangedEvent) => void): IDisposable;
     onDidChangeContentOrInjectedText(listener: (e: InternalModelContentChangeEvent | ModelInjectedTextChangedEvent) => void): IDisposable;
@@ -108,7 +111,11 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     equalsTextBuffer(other: model.ITextBuffer): boolean;
     getTextBuffer(): model.ITextBuffer;
     private _emitContentChangedEvent;
-    setValue(value: string | model.ITextSnapshot): void;
+    setValue(value: string | model.ITextSnapshot, reason?: TextModelEditReason & {
+        metadataT: {
+            readonly source: "setValue";
+        };
+    }): void;
     private _createContentChanged2;
     private _setValueFromTextBuffer;
     setEOL(eol: model.EndOfLineSequence): void;
@@ -176,7 +183,10 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     pushEOL(eol: model.EndOfLineSequence): void;
     private _validateEditOperation;
     private _validateEditOperations;
-    pushEditOperations(beforeCursorState: Selection[] | null, editOperations: model.IIdentifiedSingleEditOperation[], cursorStateComputer: model.ICursorStateComputer | null, group?: UndoRedoGroup): Selection[] | null;
+    edit(edit: TextEdit, options?: {
+        reason?: TextModelEditReason;
+    }): void;
+    pushEditOperations(beforeCursorState: Selection[] | null, editOperations: model.IIdentifiedSingleEditOperation[], cursorStateComputer: model.ICursorStateComputer | null, group?: UndoRedoGroup, reason?: TextModelEditReason): Selection[] | null;
     private _pushEditOperations;
     _applyUndo(changes: TextChange[], eol: model.EndOfLineSequence, resultingAlternativeVersionId: number, resultingSelection: Selection[] | null): void;
     _applyRedo(changes: TextChange[], eol: model.EndOfLineSequence, resultingAlternativeVersionId: number, resultingSelection: Selection[] | null): void;
@@ -184,6 +194,8 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[]): void;
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: false): void;
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: true): model.IValidEditOperation[];
+    applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: false, reason: TextModelEditReason): void;
+    applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: true, reason: TextModelEditReason): model.IValidEditOperation[];
     private _doApplyEdits;
     undo(): void | Promise<void>;
     canUndo(): boolean;
@@ -199,14 +211,15 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     removeAllDecorationsWithOwnerId(ownerId: number): void;
     getDecorationOptions(decorationId: string): model.IModelDecorationOptions | null;
     getDecorationRange(decorationId: string): Range | null;
-    getLineDecorations(lineNumber: number, ownerId?: number, filterOutValidation?: boolean): model.IModelDecoration[];
-    getLinesDecorations(_startLineNumber: number, _endLineNumber: number, ownerId?: number, filterOutValidation?: boolean, onlyMarginDecorations?: boolean): model.IModelDecoration[];
-    getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): model.IModelDecoration[];
-    getOverviewRulerDecorations(ownerId?: number, filterOutValidation?: boolean): model.IModelDecoration[];
+    getLineDecorations(lineNumber: number, ownerId?: number, filterOutValidation?: boolean, filterFontDecorations?: boolean): model.IModelDecoration[];
+    getLinesDecorations(_startLineNumber: number, _endLineNumber: number, ownerId?: number, filterOutValidation?: boolean, filterFontDecorations?: boolean, onlyMarginDecorations?: boolean): model.IModelDecoration[];
+    getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean, filterFontDecorations?: boolean, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): model.IModelDecoration[];
+    getOverviewRulerDecorations(ownerId?: number, filterOutValidation?: boolean, filterFontDecorations?: boolean): model.IModelDecoration[];
     getInjectedTextDecorations(ownerId?: number): model.IModelDecoration[];
     getCustomLineHeightsDecorations(ownerId?: number): model.IModelDecoration[];
     private _getInjectedTextInLine;
-    getAllDecorations(ownerId?: number, filterOutValidation?: boolean): model.IModelDecoration[];
+    getFontDecorationsInRange(range: IRange, ownerId?: number): model.IModelDecoration[];
+    getAllDecorations(ownerId?: number, filterOutValidation?: boolean, filterFontDecorations?: boolean): model.IModelDecoration[];
     getAllMarginDecorations(ownerId?: number): model.IModelDecoration[];
     private _getDecorationsInRange;
     getRangeAt(start: number, end: number): Range;
@@ -222,7 +235,6 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     normalizePosition(position: Position, affinity: model.PositionAffinity): Position;
     getLineIndentColumn(lineNumber: number): number;
     toString(): string;
-    editWithReason<T>(editReason: TextModelEditReason, cb: () => T): T;
 }
 export declare function indentOfLine(line: string): number;
 export interface IDecorationsTreesHost {
@@ -289,6 +301,7 @@ export declare class ModelDecorationOptions implements model.IModelDecorationOpt
     readonly glyphMarginHoverMessage: IMarkdownString | IMarkdownString[] | null;
     readonly isWholeLine: boolean;
     readonly lineHeight: number | null;
+    readonly fontSize: string | null;
     readonly showIfCollapsed: boolean;
     readonly collapseOnReplaceEdit: boolean;
     readonly overviewRuler: ModelDecorationOverviewRulerOptions | null;
@@ -309,6 +322,7 @@ export declare class ModelDecorationOptions implements model.IModelDecorationOpt
     readonly before: ModelDecorationInjectedTextOptions | null;
     readonly hideInCommentTokens: boolean | null;
     readonly hideInStringTokens: boolean | null;
+    readonly affectsFont: boolean | null;
     private constructor();
 }
 export {};