@codingame/monaco-vscode-api 24.3.0 → 25.0.1

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

@@ -294,5 +294,33 @@ function generateTokensCSSForColorMap(colorMap) {
     rules.push('.mtks.mtku { text-decoration: underline line-through; text-underline-position: under; }');
     return rules.join('\n');
 }
+function generateTokensCSSForFontMap(fontMap) {
+    const rules = [];
+    const fonts = ( new Set());
+    for (let i = 1, len = fontMap.length; i < len; i++) {
+        const font = fontMap[i];
+        if (!font.fontFamily && !font.fontSize) {
+            continue;
+        }
+        const className = classNameForFontTokenDecorations(font.fontFamily ?? '', font.fontSize ?? '');
+        if (( fonts.has(className))) {
+            continue;
+        }
+        fonts.add(className);
+        let rule = `.${className} {`;
+        if (font.fontFamily) {
+            rule += `font-family: ${font.fontFamily};`;
+        }
+        if (font.fontSize) {
+            rule += `font-size: ${font.fontSize};`;
+        }
+        rule += `}`;
+        rules.push(rule);
+    }
+    return rules.join('\n');
+}
+function classNameForFontTokenDecorations(fontFamily, fontSize) {
+    return `font-decoration-${fontFamily.toLowerCase()}-${fontSize.toLowerCase()}`;
+}
 
-export { ColorMap, ExternalThemeTrieElement, ParsedTokenThemeRule, ThemeTrieElement, ThemeTrieElementRule, TokenTheme, generateTokensCSSForColorMap, parseTokenTheme, strcmp, toStandardTokenType };
+export { ColorMap, ExternalThemeTrieElement, ParsedTokenThemeRule, ThemeTrieElement, ThemeTrieElementRule, TokenTheme, classNameForFontTokenDecorations, generateTokensCSSForColorMap, generateTokensCSSForFontMap, parseTokenTheme, strcmp, toStandardTokenType };

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

@@ -19,6 +19,7 @@ import { ContiguousMultilineTokens } from "./tokens/contiguousMultilineTokens.js
 import { ExtensionIdentifier } from "../../platform/extensions/common/extensions.js";
 import { IMarkerData } from "../../platform/markers/common/markers.js";
 import { EditDeltaInfo } from "./textModelEditSource.js";
+import { FontTokensUpdate } from "./textModelEvents.js";
 /**
  * @internal
  */
@@ -43,6 +44,16 @@ export declare class TokenizationResult {
     _tokenizationResultBrand: void;
     constructor(tokens: Token[], endState: IState);
 }
+/**
+ * @internal
+ */
+export interface IFontToken {
+    readonly startIndex: number;
+    readonly endIndex: number;
+    readonly fontFamily: string | null;
+    readonly fontSize: string | null;
+    readonly lineHeight: number | null;
+}
 /**
  * @internal
  */
@@ -54,6 +65,7 @@ export declare class EncodedTokenizationResult {
      *
      */
     readonly tokens: Uint32Array;
+    readonly fontInfo: IFontToken[];
     readonly endState: IState;
     _encodedTokenizationResultBrand: void;
     constructor(
@@ -63,7 +75,7 @@ export declare class EncodedTokenizationResult {
      *  - at offset 2*i + 1 => metadata
      *
      */
-    tokens: Uint32Array, endState: IState);
+    tokens: Uint32Array, fontInfo: IFontToken[], endState: IState);
 }
 export interface SyntaxNode {
     startIndex: number;
@@ -112,6 +124,7 @@ export interface IBackgroundTokenizer extends IDisposable {
  */
 export interface IBackgroundTokenizationStore {
     setTokens(tokens: ContiguousMultilineTokens[]): void;
+    setFontInfo(changes: FontTokensUpdate): void;
     setEndState(lineNumber: number, state: IState): void;
     /**
      * Should be called to indicate that the background tokenization has finished for now.
@@ -755,6 +768,7 @@ export declare enum InlineCompletionEndOfLifeReasonKind {
 }
 export type InlineCompletionEndOfLifeReason<TInlineCompletion = InlineCompletion> = {
     kind: InlineCompletionEndOfLifeReasonKind.Accepted;
+    alternativeAction: boolean;
 } | {
     kind: InlineCompletionEndOfLifeReasonKind.Rejected;
 } | {
@@ -797,9 +811,9 @@ export type LifetimeSummary = {
     availableProviders: string;
     skuPlan: string | undefined;
     skuType: string | undefined;
-    renameCreated: boolean;
+    renameCreated: boolean | undefined;
     renameDuration: number | undefined;
-    renameTimedOut: boolean;
+    renameTimedOut: boolean | undefined;
     renameDroppedOtherEdits: number | undefined;
     renameDroppedRenameEdits: number | undefined;
     editKind: string | undefined;

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

@@ -26,8 +26,9 @@ class TokenizationResult {
 }
 class EncodedTokenizationResult {
     constructor(
-    tokens, endState) {
+    tokens, fontInfo, endState) {
         this.tokens = tokens;
+        this.fontInfo = fontInfo;
         this.endState = endState;
         this._encodedTokenizationResultBrand = undefined;
     }
@@ -113,35 +114,35 @@ var CompletionItemKinds;
     CompletionItemKinds.toIcon = toIcon;
     function toLabel(kind) {
         switch (kind) {
-            case CompletionItemKind.Method: return localize(795, 'Method');
-            case CompletionItemKind.Function: return localize(796, 'Function');
-            case CompletionItemKind.Constructor: return localize(797, 'Constructor');
-            case CompletionItemKind.Field: return localize(798, 'Field');
-            case CompletionItemKind.Variable: return localize(799, 'Variable');
-            case CompletionItemKind.Class: return localize(800, 'Class');
-            case CompletionItemKind.Struct: return localize(801, 'Struct');
-            case CompletionItemKind.Interface: return localize(802, 'Interface');
-            case CompletionItemKind.Module: return localize(803, 'Module');
-            case CompletionItemKind.Property: return localize(804, 'Property');
-            case CompletionItemKind.Event: return localize(805, 'Event');
-            case CompletionItemKind.Operator: return localize(806, 'Operator');
-            case CompletionItemKind.Unit: return localize(807, 'Unit');
-            case CompletionItemKind.Value: return localize(808, 'Value');
-            case CompletionItemKind.Constant: return localize(809, 'Constant');
-            case CompletionItemKind.Enum: return localize(810, 'Enum');
-            case CompletionItemKind.EnumMember: return localize(811, 'Enum Member');
-            case CompletionItemKind.Keyword: return localize(812, 'Keyword');
-            case CompletionItemKind.Text: return localize(813, 'Text');
-            case CompletionItemKind.Color: return localize(814, 'Color');
-            case CompletionItemKind.File: return localize(815, 'File');
-            case CompletionItemKind.Reference: return localize(816, 'Reference');
-            case CompletionItemKind.Customcolor: return localize(817, 'Custom Color');
-            case CompletionItemKind.Folder: return localize(818, 'Folder');
-            case CompletionItemKind.TypeParameter: return localize(819, 'Type Parameter');
-            case CompletionItemKind.User: return localize(820, 'User');
-            case CompletionItemKind.Issue: return localize(821, 'Issue');
-            case CompletionItemKind.Tool: return localize(822, 'Tool');
-            case CompletionItemKind.Snippet: return localize(823, 'Snippet');
+            case CompletionItemKind.Method: return localize(798, 'Method');
+            case CompletionItemKind.Function: return localize(799, 'Function');
+            case CompletionItemKind.Constructor: return localize(800, 'Constructor');
+            case CompletionItemKind.Field: return localize(801, 'Field');
+            case CompletionItemKind.Variable: return localize(802, 'Variable');
+            case CompletionItemKind.Class: return localize(803, 'Class');
+            case CompletionItemKind.Struct: return localize(804, 'Struct');
+            case CompletionItemKind.Interface: return localize(805, 'Interface');
+            case CompletionItemKind.Module: return localize(806, 'Module');
+            case CompletionItemKind.Property: return localize(807, 'Property');
+            case CompletionItemKind.Event: return localize(808, 'Event');
+            case CompletionItemKind.Operator: return localize(809, 'Operator');
+            case CompletionItemKind.Unit: return localize(810, 'Unit');
+            case CompletionItemKind.Value: return localize(811, 'Value');
+            case CompletionItemKind.Constant: return localize(812, 'Constant');
+            case CompletionItemKind.Enum: return localize(813, 'Enum');
+            case CompletionItemKind.EnumMember: return localize(814, 'Enum Member');
+            case CompletionItemKind.Keyword: return localize(815, 'Keyword');
+            case CompletionItemKind.Text: return localize(816, 'Text');
+            case CompletionItemKind.Color: return localize(817, 'Color');
+            case CompletionItemKind.File: return localize(818, 'File');
+            case CompletionItemKind.Reference: return localize(819, 'Reference');
+            case CompletionItemKind.Customcolor: return localize(820, 'Custom Color');
+            case CompletionItemKind.Folder: return localize(821, 'Folder');
+            case CompletionItemKind.TypeParameter: return localize(822, 'Type Parameter');
+            case CompletionItemKind.User: return localize(823, 'User');
+            case CompletionItemKind.Issue: return localize(824, 'Issue');
+            case CompletionItemKind.Tool: return localize(825, 'Tool');
+            case CompletionItemKind.Snippet: return localize(826, 'Snippet');
             default: return '';
         }
     }
@@ -353,35 +354,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(824, "array")),
-    [SymbolKind.Boolean]: ( localize(825, "boolean")),
-    [SymbolKind.Class]: ( localize(826, "class")),
-    [SymbolKind.Constant]: ( localize(827, "constant")),
-    [SymbolKind.Constructor]: ( localize(828, "constructor")),
-    [SymbolKind.Enum]: ( localize(829, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(830, "enumeration member")),
-    [SymbolKind.Event]: ( localize(831, "event")),
-    [SymbolKind.Field]: ( localize(832, "field")),
-    [SymbolKind.File]: ( localize(833, "file")),
-    [SymbolKind.Function]: ( localize(834, "function")),
-    [SymbolKind.Interface]: ( localize(835, "interface")),
-    [SymbolKind.Key]: ( localize(836, "key")),
-    [SymbolKind.Method]: ( localize(837, "method")),
-    [SymbolKind.Module]: ( localize(838, "module")),
-    [SymbolKind.Namespace]: ( localize(839, "namespace")),
-    [SymbolKind.Null]: ( localize(840, "null")),
-    [SymbolKind.Number]: ( localize(841, "number")),
-    [SymbolKind.Object]: ( localize(842, "object")),
-    [SymbolKind.Operator]: ( localize(843, "operator")),
-    [SymbolKind.Package]: ( localize(844, "package")),
-    [SymbolKind.Property]: ( localize(845, "property")),
-    [SymbolKind.String]: ( localize(846, "string")),
-    [SymbolKind.Struct]: ( localize(847, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(848, "type parameter")),
-    [SymbolKind.Variable]: ( localize(849, "variable")),
+    [SymbolKind.Array]: ( localize(827, "array")),
+    [SymbolKind.Boolean]: ( localize(828, "boolean")),
+    [SymbolKind.Class]: ( localize(829, "class")),
+    [SymbolKind.Constant]: ( localize(830, "constant")),
+    [SymbolKind.Constructor]: ( localize(831, "constructor")),
+    [SymbolKind.Enum]: ( localize(832, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(833, "enumeration member")),
+    [SymbolKind.Event]: ( localize(834, "event")),
+    [SymbolKind.Field]: ( localize(835, "field")),
+    [SymbolKind.File]: ( localize(836, "file")),
+    [SymbolKind.Function]: ( localize(837, "function")),
+    [SymbolKind.Interface]: ( localize(838, "interface")),
+    [SymbolKind.Key]: ( localize(839, "key")),
+    [SymbolKind.Method]: ( localize(840, "method")),
+    [SymbolKind.Module]: ( localize(841, "module")),
+    [SymbolKind.Namespace]: ( localize(842, "namespace")),
+    [SymbolKind.Null]: ( localize(843, "null")),
+    [SymbolKind.Number]: ( localize(844, "number")),
+    [SymbolKind.Object]: ( localize(845, "object")),
+    [SymbolKind.Operator]: ( localize(846, "operator")),
+    [SymbolKind.Package]: ( localize(847, "package")),
+    [SymbolKind.Property]: ( localize(848, "property")),
+    [SymbolKind.String]: ( localize(849, "string")),
+    [SymbolKind.Struct]: ( localize(850, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(851, "type parameter")),
+    [SymbolKind.Variable]: ( localize(852, "variable")),
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(850, '{0} ({1})', symbolName, symbolKindNames[kind]);
+    return localize(853, '{0} ({1})', symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function (SymbolTag) {

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

@@ -1,4 +1,3 @@
-import { Event } from "../../../base/common/event.js";
 import { Range } from "../core/range.js";
 import { IModelDecoration } from "../model.js";
 export interface DecorationProvider {
@@ -17,5 +16,19 @@ export interface DecorationProvider {
      * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
      */
     getAllDecorations(ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean): IModelDecoration[];
-    readonly onDidChange: Event<void>;
+}
+export declare class LineHeightChangingDecoration {
+    readonly ownerId: number;
+    readonly decorationId: string;
+    readonly lineNumber: number;
+    readonly lineHeight: number | null;
+    static toKey(obj: LineHeightChangingDecoration): string;
+    constructor(ownerId: number, decorationId: string, lineNumber: number, lineHeight: number | null);
+}
+export declare class LineFontChangingDecoration {
+    readonly ownerId: number;
+    readonly decorationId: string;
+    readonly lineNumber: number;
+    static toKey(obj: LineFontChangingDecoration): string;
+    constructor(ownerId: number, decorationId: string, lineNumber: number);
 }

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

@@ -0,0 +1,25 @@
+
+
+class LineHeightChangingDecoration {
+    static toKey(obj) {
+        return `${obj.ownerId};${obj.decorationId};${obj.lineNumber}`;
+    }
+    constructor(ownerId, decorationId, lineNumber, lineHeight) {
+        this.ownerId = ownerId;
+        this.decorationId = decorationId;
+        this.lineNumber = lineNumber;
+        this.lineHeight = lineHeight;
+    }
+}
+class LineFontChangingDecoration {
+    static toKey(obj) {
+        return `${obj.ownerId};${obj.decorationId};${obj.lineNumber}`;
+    }
+    constructor(ownerId, decorationId, lineNumber) {
+        this.ownerId = ownerId;
+        this.decorationId = decorationId;
+        this.lineNumber = lineNumber;
+    }
+}
+
+export { LineFontChangingDecoration, LineHeightChangingDecoration };

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

@@ -354,7 +354,7 @@ class EditStack {
         if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
             return lastElement;
         }
-        const newElement = ( new SingleModelEditStackElement(( localize(852, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(855, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

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

@@ -122,7 +122,7 @@ function guessIndentation(source, defaultTabSize, defaultInsertSpaces) {
     }
     let tabSize = defaultTabSize;
     if (insertSpaces) {
-        let tabSizeScore = (insertSpaces ? 0 : 0.1 * linesCount);
+        let tabSizeScore = 0;
         ALLOWED_TAB_SIZE_GUESSES.forEach((possibleTabSize) => {
             const possibleTabSizeScore = spacesDiffCount[possibleTabSize];
             if (possibleTabSizeScore > tabSizeScore) {
@@ -130,7 +130,7 @@ function guessIndentation(source, defaultTabSize, defaultInsertSpaces) {
                 tabSize = possibleTabSize;
             }
         });
-        if (tabSize === 4 && spacesDiffCount[4] > 0 && spacesDiffCount[2] > 0 && spacesDiffCount[2] >= spacesDiffCount[4] / 2) {
+        if (tabSize === 4 && spacesDiffCount[4] > 0 && spacesDiffCount[2] > 0 && spacesDiffCount[2] >= spacesDiffCount[4] * 2 / 3) {
             tabSize = 2;
         }
     }

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

@@ -5,6 +5,11 @@ import { IMarkdownString } from "../../../base/common/htmlContent.js";
 import { Disposable, IDisposable } from "../../../base/common/lifecycle.js";
 import { ThemeColor } from "../../../base/common/themables.js";
 import { URI } from "../../../base/common/uri.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 { TextEdit } from "../core/edits/textEdit.js";
 import { IPosition, Position } from "../core/position.js";
 import { IRange, Range } from "../core/range.js";
 import { Selection } from "../core/selection.js";
@@ -16,16 +21,11 @@ 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, ModelFontChangedEvent } from "../textModelEvents.js";
+import { TextModelEditSource } from "../textModelEditSource.js";
+import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelOptionsChangedEvent, InternalModelContentChangeEvent, ModelFontChangedEvent, ModelInjectedTextChangedEvent, ModelLineHeightChangedEvent } 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/lineTokens.js";
-import { TextModelEditSource } from "../textModelEditSource.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;
@@ -104,6 +104,7 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     private _decorations;
     private _decorationsTree;
     private readonly _decorationProvider;
+    private readonly _fontTokenDecorationsProvider;
     private readonly _tokenizationTextModelPart;
     get tokenization(): ITokenizationTextModelPart;
     private readonly _bracketPairs;
@@ -215,6 +216,8 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     redo(): void | Promise<void>;
     canRedo(): boolean;
     private handleBeforeFireDecorationsChangedEvent;
+    private _fireOnDidChangeLineHeight;
+    private _fireOnDidChangeFont;
     changeDecorations<T>(callback: (changeAccessor: model.IModelDecorationsChangeAccessor) => T, ownerId?: number): T | null;
     private _changeDecorations;
     deltaDecorations(oldDecorations: string[], newDecorations: model.IModelDeltaDecoration[], ownerId?: number): string[];

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

@@ -1,6 +1,8 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { ArrayQueue, pushMany } from '../../../base/common/arrays.js';
+import { CharCode } from '../../../base/common/charCode.js';
+import { SetWithKey } from '../../../base/common/collections.js';
 import { Color } from '../../../base/common/color.js';
 import { BugIndicatingError, illegalArgument, onUnexpectedError } from '../../../base/common/errors.js';
 import { Emitter } from '../../../base/common/event.js';
@@ -9,15 +11,20 @@ import { listenStream } from '../../../base/common/stream.js';
 import { singleLetterHash, UNUSUAL_LINE_TERMINATORS, isHighSurrogate, htmlAttributeEncodeValue } from '../../../base/common/strings.js';
 import { Constants } from '../../../base/common/uint.js';
 import { URI } from '../../../base/common/uri.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
+import { isDark } from '../../../platform/theme/common/theme.js';
+import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.service.js';
 import { countEOL } from '../core/misc/eolCounter.js';
 import { normalizeIndentation } from '../core/misc/indentation.js';
+import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { Selection } from '../core/selection.js';
-import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
 import { ILanguageService } from '../languages/language.service.js';
 import { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.service.js';
 import { isITextSnapshot, DefaultEndOfLine, TextModelResolvedOptions, EndOfLinePreference, EndOfLineSequence, ValidAnnotatedEditOperation, OverviewRulerLane, GlyphMarginLane, TrackedRangeStickiness } from '../model.js';
+import { EditSources } from '../textModelEditSource.js';
+import { InternalModelContentChangeEvent, ModelRawContentChangedEvent, ModelRawFlush, ModelRawEOLChanged, LineInjectedText, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, ModelInjectedTextChangedEvent, ModelLineHeightChanged, ModelLineHeightChangedEvent, ModelFontChanged, ModelFontChangedEvent } from '../textModelEvents.js';
 import { BracketPairsTextModelPart } from './bracketPairsTextModelPart/bracketPairsImpl.js';
 import { ColorizedBracketPairsDecorationProvider } from './bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js';
 import { EditStack } from './editStack.js';
@@ -27,14 +34,10 @@ import { recomputeMaxEnd, IntervalNode, IntervalTree } from './intervalTree.js';
 import { PieceTreeTextBuffer } from './pieceTreeTextBuffer/pieceTreeTextBuffer.js';
 import { PieceTreeTextBufferBuilder } from './pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';
 import { SearchParams, TextModelSearch } from './textModelSearch.js';
-import { TokenizationTextModelPart } from './tokens/tokenizationTextModelPart.js';
 import { AttachedViews } from './tokens/abstractSyntaxTokenBackend.js';
-import { InternalModelContentChangeEvent, ModelRawContentChangedEvent, ModelRawFlush, ModelRawEOLChanged, LineInjectedText, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, ModelInjectedTextChangedEvent, ModelLineHeightChanged, ModelLineHeightChangedEvent, ModelFontChanged, ModelFontChangedEvent } from '../textModelEvents.js';
-import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
-import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.service.js';
-import { SetWithKey } from '../../../base/common/collections.js';
-import { EditSources } from '../textModelEditSource.js';
-import { isDark } from '../../../platform/theme/common/theme.js';
+import { TokenizationFontDecorationProvider } from './tokens/tokenizationFontDecorationsProvider.js';
+import { LineHeightChangingDecoration, LineFontChangingDecoration } from './decorationProvider.js';
+import { TokenizationTextModelPart } from './tokens/tokenizationTextModelPart.js';
 
 var TextModel_1;
 function createTextBufferFactory(text) {
@@ -231,6 +234,7 @@ let TextModel = class TextModel extends Disposable {
         this._guidesTextModelPart = this._register(( new GuidesTextModelPart(this, this._languageConfigurationService)));
         this._decorationProvider = this._register(( new ColorizedBracketPairsDecorationProvider(this)));
         this._tokenizationTextModelPart = this.instantiationService.createInstance(TokenizationTextModelPart, this, this._bracketPairs, languageId, this._attachedViews);
+        this._fontTokenDecorationsProvider = this._register(( new TokenizationFontDecorationProvider(this, this._tokenizationTextModelPart)));
         this._isTooLargeForSyncing = (bufferTextLength > TextModel_1._MODEL_SYNC_LIMIT);
         this._versionId = 1;
         this._alternativeVersionId = 1;
@@ -250,6 +254,18 @@ let TextModel = class TextModel extends Disposable {
             this._onDidChangeDecorations.fire();
             this._onDidChangeDecorations.endDeferredEmit();
         }));
+        this._register(this._fontTokenDecorationsProvider.onDidChangeLineHeight((affectedLineHeights) => {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._onDidChangeDecorations.fire();
+            this._fireOnDidChangeLineHeight(affectedLineHeights);
+            this._onDidChangeDecorations.endDeferredEmit();
+        }));
+        this._register(this._fontTokenDecorationsProvider.onDidChangeFont((affectedFontLines) => {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._onDidChangeDecorations.fire();
+            this._fireOnDidChangeFont(affectedFontLines);
+            this._onDidChangeDecorations.endDeferredEmit();
+        }));
         this._languageService.requestRichLanguageFeatures(languageId);
         this._register(this._languageConfigurationService.onDidChange(e => {
             this._bracketPairs.handleLanguageConfigurationServiceChange(e);
@@ -299,6 +315,7 @@ let TextModel = class TextModel extends Disposable {
         }
         this._tokenizationTextModelPart.handleDidChangeContent(change);
         this._bracketPairs.handleDidChangeContent(change);
+        this._fontTokenDecorationsProvider.handleDidChangeContent(change);
         this._eventEmitter.fire(( new InternalModelContentChangeEvent(rawChange, change)));
     }
     setValue(value, reason = EditSources.setValue()) {
@@ -935,7 +952,16 @@ let TextModel = class TextModel extends Disposable {
         if (rawOperation instanceof ValidAnnotatedEditOperation) {
             return rawOperation;
         }
-        return new ValidAnnotatedEditOperation(rawOperation.identifier || null, this.validateRange(rawOperation.range), rawOperation.text, rawOperation.forceMoveMarkers || false, rawOperation.isAutoWhitespaceEdit || false, rawOperation._isTracked || false);
+        const validatedRange = this.validateRange(rawOperation.range);
+        let opText = rawOperation.text;
+        if (opText) {
+            const endsWithLoneCR = (opText.length > 0 && opText.charCodeAt(opText.length - 1) === CharCode.CarriageReturn);
+            const removeTrailingCR = (this.getEOL() === '\r\n' && endsWithLoneCR && validatedRange.endColumn === this.getLineMaxColumn(validatedRange.endLineNumber));
+            if (removeTrailingCR) {
+                opText = opText.substring(0, opText.length - 1);
+            }
+        }
+        return new ValidAnnotatedEditOperation(rawOperation.identifier || null, validatedRange, opText, rawOperation.forceMoveMarkers || false, rawOperation.isAutoWhitespaceEdit || false, rawOperation._isTracked || false);
     }
     _validateEditOperations(rawOperations) {
         const result = [];
@@ -1185,6 +1211,10 @@ let TextModel = class TextModel extends Disposable {
             ))));
             this._onDidChangeInjectedText.fire(( new ModelInjectedTextChangedEvent(lineChangeEvents)));
         }
+        this._fireOnDidChangeLineHeight(affectedLineHeights);
+        this._fireOnDidChangeFont(affectedFontLines);
+    }
+    _fireOnDidChangeLineHeight(affectedLineHeights) {
         if (affectedLineHeights && affectedLineHeights.size > 0) {
             const affectedLines = Array.from(affectedLineHeights);
             const lineHeightChangeEvent = ( affectedLines.map(specialLineHeightChange => ( new ModelLineHeightChanged(
@@ -1195,6 +1225,8 @@ let TextModel = class TextModel extends Disposable {
             ))));
             this._onDidChangeLineHeight.fire(( new ModelLineHeightChangedEvent(lineHeightChangeEvent)));
         }
+    }
+    _fireOnDidChangeFont(affectedFontLines) {
         if (affectedFontLines && affectedFontLines.size > 0) {
             const affectedLines = Array.from(affectedFontLines);
             const fontChangeEvent = ( affectedLines.map(fontChange => ( new ModelFontChanged(fontChange.ownerId, fontChange.lineNumber))));
@@ -1332,12 +1364,14 @@ let TextModel = class TextModel extends Disposable {
         const range = ( new Range(startLineNumber, 1, endLineNumber, endColumn));
         const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
         pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
+        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
         return decorations;
     }
     getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, filterFontDecorations = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {
         const validatedRange = this.validateRange(range);
         const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
         pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
+        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
         return decorations;
     }
     getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false, filterFontDecorations = false) {
@@ -1363,6 +1397,7 @@ let TextModel = class TextModel extends Disposable {
     getAllDecorations(ownerId = 0, filterOutValidation = false, filterFontDecorations = false) {
         let result = this._decorationsTree.getAll(this, ownerId, filterOutValidation, filterFontDecorations, false, false);
         result = result.concat(this._decorationProvider.getAllDecorations(ownerId, filterOutValidation));
+        result = result.concat(this._fontTokenDecorationsProvider.getAllDecorations(ownerId, filterOutValidation));
         return result;
     }
     getAllMarginDecorations(ownerId = 0) {
@@ -1876,27 +1911,6 @@ function _normalizeOptions(options) {
     }
     return ModelDecorationOptions.createDynamic(options);
 }
-class LineHeightChangingDecoration {
-    static toKey(obj) {
-        return `${obj.ownerId};${obj.decorationId};${obj.lineNumber}`;
-    }
-    constructor(ownerId, decorationId, lineNumber, lineHeight) {
-        this.ownerId = ownerId;
-        this.decorationId = decorationId;
-        this.lineNumber = lineNumber;
-        this.lineHeight = lineHeight;
-    }
-}
-class LineFontChangingDecoration {
-    static toKey(obj) {
-        return `${obj.ownerId};${obj.decorationId};${obj.lineNumber}`;
-    }
-    constructor(ownerId, decorationId, lineNumber) {
-        this.ownerId = ownerId;
-        this.decorationId = decorationId;
-        this.lineNumber = lineNumber;
-    }
-}
 class DidChangeDecorationsEmitter extends Disposable {
     constructor(handleBeforeFire) {
         super();

package/vscode/src/vs/editor/common/model/tokens/abstractSyntaxTokenBackend.d.ts

@@ -5,7 +5,7 @@ import { StandardTokenType } from "../../encodedTokenAttributes.js";
 import { ILanguageIdCodec } from "../../languages.js";
 import { IAttachedView } from "../../model.js";
 import { TextModel } from "../textModel.js";
-import { IModelContentChangedEvent, IModelTokensChangedEvent } from "../../textModelEvents.js";
+import { IModelContentChangedEvent, IModelTokensChangedEvent, IModelFontTokensChangedEvent } from "../../textModelEvents.js";
 import { BackgroundTokenizationState } from "../../tokenizationTextModelPart.js";
 import { LineTokens } from "../../tokens/lineTokens.js";
 import { IObservable } from "../../../../base/common/observable.js";
@@ -55,6 +55,9 @@ export declare abstract class AbstractSyntaxTokenBackend extends Disposable {
     protected readonly _onDidChangeTokens: Emitter<IModelTokensChangedEvent>;
     /** @internal, should not be exposed by the text model! */
     readonly onDidChangeTokens: Event<IModelTokensChangedEvent>;
+    protected readonly _onDidChangeFontTokens: Emitter<IModelFontTokensChangedEvent>;
+    /** @internal, should not be exposed by the text model! */
+    readonly onDidChangeFontTokens: Event<IModelFontTokensChangedEvent>;
     constructor(_languageIdCodec: ILanguageIdCodec, _textModel: TextModel);
     abstract todo_resetTokenization(fireTokenChangeEvent?: boolean): void;
     abstract handleDidChangeAttached(): void;

package/vscode/src/vs/editor/common/model/tokens/abstractSyntaxTokenBackend.js

@@ -5,7 +5,7 @@ import { Emitter } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { LineRange } from '../../core/ranges/lineRange.js';
 import '../../../../base/common/observableInternal/index.js';
-import { itemsEquals, itemEquals, equalsIfDefined } from '../../../../base/common/equals.js';
+import { arrayEqualsC, thisEqualsC, equalsIfDefinedC } from '../../../../base/common/equals.js';
 import { observableSignal } from '../../../../base/common/observableInternal/observables/observableSignal.js';
 import { observableValueOpts } from '../../../../base/common/observableInternal/observables/observableValueOpts.js';
 import { derivedOpts } from '../../../../base/common/observableInternal/observables/derived.js';
@@ -18,7 +18,7 @@ class AttachedViews {
         this._viewsChanged = observableSignal(this);
         this.visibleLineRanges = derivedOpts({
             owner: this,
-            equalsFn: itemsEquals(itemEquals())
+            equalsFn: arrayEqualsC(thisEqualsC())
         }, reader => {
             this._viewsChanged.read(reader);
             const ranges = LineRange.joinMany(( [...this._views].map(view => view.state.read(reader)?.visibleLineRanges ?? [])));
@@ -61,7 +61,7 @@ class AttachedViewImpl {
     get state() { return this._state; }
     constructor(handleStateChange) {
         this.handleStateChange = handleStateChange;
-        this._state = observableValueOpts({ owner: this, equalsFn: equalsIfDefined((a, b) => a.equals(b)) }, undefined);
+        this._state = observableValueOpts({ owner: this, equalsFn: equalsIfDefinedC((a, b) => a.equals(b)) }, undefined);
     }
     setVisibleLines(visibleLines, stabilized) {
         const visibleLineRanges = ( visibleLines.map((line) => ( new LineRange(line.startLineNumber, line.endLineNumber + 1))));
@@ -107,6 +107,8 @@ class AbstractSyntaxTokenBackend extends Disposable {
         this._textModel = _textModel;
         this._onDidChangeTokens = this._register(( new Emitter()));
         this.onDidChangeTokens = this._onDidChangeTokens.event;
+        this._onDidChangeFontTokens = this._register(( new Emitter()));
+        this.onDidChangeFontTokens = this._onDidChangeFontTokens.event;
     }
     tokenizeIfCheap(lineNumber) {
         if (this.isCheapToTokenize(lineNumber)) {