@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -29,11 +29,11 @@ import { PieceTreeTextBufferBuilder } from './pieceTreeTextBuffer/pieceTreeTextB
 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 } from '../textModelEvents.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 { TextModelEditReason } from '../textModelEditReason.js';
+import { EditReasons } from '../textModelEditReason.js';
 
 var TextModel_1;
 function createTextBufferFactory(text) {
@@ -181,7 +181,7 @@ let TextModel = class TextModel extends Disposable {
         this._onWillDispose = this._register(( new Emitter()));
         this.onWillDispose = this._onWillDispose.event;
         this._onDidChangeDecorations = this._register(( new DidChangeDecorationsEmitter(
-            (affectedInjectedTextLines, affectedLineHeights) => this.handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines, affectedLineHeights)
+            (affectedInjectedTextLines, affectedLineHeights, affectedFontLines) => this.handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines, affectedLineHeights, affectedFontLines)
         )));
         this.onDidChangeDecorations = this._onDidChangeDecorations.event;
         this._onDidChangeOptions = this._register(( new Emitter()));
@@ -191,6 +191,8 @@ let TextModel = class TextModel extends Disposable {
         this._onDidChangeInjectedText = this._register(( new Emitter()));
         this._onDidChangeLineHeight = this._register(( new Emitter()));
         this.onDidChangeLineHeight = this._onDidChangeLineHeight.event;
+        this._onDidChangeFont = this._register(( new Emitter()));
+        this.onDidChangeFont = this._onDidChangeFont.event;
         this._eventEmitter = this._register(( new DidChangeContentEmitter()));
         this._languageSelectionListener = this._register(( new MutableDisposable()));
         this._deltaDecorationCallCnt = 0;
@@ -274,6 +276,7 @@ let TextModel = class TextModel extends Disposable {
             || this._onDidChangeAttached.hasListeners()
             || this._onDidChangeInjectedText.hasListeners()
             || this._onDidChangeLineHeight.hasListeners()
+            || this._onDidChangeFont.hasListeners()
             || this._eventEmitter.hasListeners());
     }
     _assertNotDisposed() {
@@ -297,15 +300,15 @@ let TextModel = class TextModel extends Disposable {
         this._bracketPairs.handleDidChangeContent(change);
         this._eventEmitter.fire(( new InternalModelContentChangeEvent(rawChange, change)));
     }
-    setValue(value) {
+    setValue(value, reason = EditReasons.setValue()) {
         this._assertNotDisposed();
         if (value === null || value === undefined) {
             throw illegalArgument();
         }
         const { textBuffer, disposable } = createTextBuffer(value, this._options.defaultEOL);
-        this._setValueFromTextBuffer(textBuffer, disposable);
+        this._setValueFromTextBuffer(textBuffer, disposable, reason);
     }
-    _createContentChanged2(range, rangeOffset, rangeLength, rangeEndPosition, text, isUndoing, isRedoing, isFlush, isEolChange) {
+    _createContentChanged2(range, rangeOffset, rangeLength, rangeEndPosition, text, isUndoing, isRedoing, isFlush, isEolChange, reason) {
         return {
             changes: [{
                     range: range,
@@ -318,10 +321,12 @@ let TextModel = class TextModel extends Disposable {
             versionId: this.getVersionId(),
             isUndoing: isUndoing,
             isRedoing: isRedoing,
-            isFlush: isFlush
+            isFlush: isFlush,
+            detailedReasons: [reason],
+            detailedReasonsChangeLengths: [1],
         };
     }
-    _setValueFromTextBuffer(textBuffer, textBufferDisposable) {
+    _setValueFromTextBuffer(textBuffer, textBufferDisposable, reason) {
         this._assertNotDisposed();
         const oldFullModelRange = this.getFullModelRange();
         const oldModelValueLength = this.getValueLengthInRange(oldFullModelRange);
@@ -337,7 +342,7 @@ let TextModel = class TextModel extends Disposable {
         this._trimAutoWhitespaceLines = null;
         this._emitContentChangedEvent(( new ModelRawContentChangedEvent([
             ( new ModelRawFlush())
-        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, ( new Position(endLineNumber, endColumn)), this.getValue(), false, false, true, false));
+        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, ( new Position(endLineNumber, endColumn)), this.getValue(), false, false, true, false, reason));
     }
     setEOL(eol) {
         this._assertNotDisposed();
@@ -355,7 +360,7 @@ let TextModel = class TextModel extends Disposable {
         this._onAfterEOLChange();
         this._emitContentChangedEvent(( new ModelRawContentChangedEvent([
             ( new ModelRawEOLChanged())
-        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, ( new Position(endLineNumber, endColumn)), this.getValue(), false, false, false, true));
+        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, ( new Position(endLineNumber, endColumn)), this.getValue(), false, false, false, true, EditReasons.eolChange()));
     }
     _onBeforeEOLChange() {
         this._decorationsTree.ensureAllNodesHaveRanges(this);
@@ -938,18 +943,21 @@ let TextModel = class TextModel extends Disposable {
         }
         return result;
     }
-    pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group) {
+    edit(edit, options) {
+        this.pushEditOperations(null, ( edit.replacements.map(r => ({ range: r.range, text: r.text }))), null);
+    }
+    pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group, reason) {
         try {
             this._onDidChangeDecorations.beginDeferredEmit();
             this._eventEmitter.beginDeferredEmit();
-            return this._pushEditOperations(beforeCursorState, this._validateEditOperations(editOperations), cursorStateComputer, group);
+            return this._pushEditOperations(beforeCursorState, this._validateEditOperations(editOperations), cursorStateComputer, group, reason);
         }
         finally {
             this._eventEmitter.endDeferredEmit();
             this._onDidChangeDecorations.endDeferredEmit();
         }
     }
-    _pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group) {
+    _pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group, reason) {
         if (this._options.trimAutoWhitespace && this._trimAutoWhitespaceLines) {
             const incomingEdits = ( editOperations.map((op) => {
                 return {
@@ -1010,7 +1018,7 @@ let TextModel = class TextModel extends Disposable {
         if (this._initialUndoRedoSnapshot === null) {
             this._initialUndoRedoSnapshot = this._undoRedoService.createSnapshot(this.uri);
         }
-        return this._commandManager.pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group);
+        return this._commandManager.pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group, reason);
     }
     _applyUndo(changes, eol, resultingAlternativeVersionId, resultingSelection) {
         const edits = ( changes.map((change) => {
@@ -1061,19 +1069,19 @@ let TextModel = class TextModel extends Disposable {
             this._onDidChangeDecorations.endDeferredEmit();
         }
     }
-    applyEdits(rawOperations, computeUndoEdits = false) {
+    applyEdits(rawOperations, computeUndoEdits, reason) {
         try {
             this._onDidChangeDecorations.beginDeferredEmit();
             this._eventEmitter.beginDeferredEmit();
             const operations = this._validateEditOperations(rawOperations);
-            return this._doApplyEdits(operations, computeUndoEdits);
+            return this._doApplyEdits(operations, computeUndoEdits ?? false, reason ?? EditReasons.applyEdits());
         }
         finally {
             this._eventEmitter.endDeferredEmit();
             this._onDidChangeDecorations.endDeferredEmit();
         }
     }
-    _doApplyEdits(rawOperations, computeUndoEdits) {
+    _doApplyEdits(rawOperations, computeUndoEdits, reason) {
         const oldLineCount = this._buffer.getLineCount();
         const result = this._buffer.applyEdits(rawOperations, this._options.trimAutoWhitespace, computeUndoEdits);
         const newLineCount = this._buffer.getLineCount();
@@ -1147,7 +1155,9 @@ let TextModel = class TextModel extends Disposable {
                 versionId: this.getVersionId(),
                 isUndoing: this._isUndoing,
                 isRedoing: this._isRedoing,
-                isFlush: false
+                isFlush: false,
+                detailedReasons: [reason],
+                detailedReasonsChangeLengths: [contentChanges.length],
             });
         }
         return (result.reverseEdits === null ? undefined : result.reverseEdits);
@@ -1164,7 +1174,7 @@ let TextModel = class TextModel extends Disposable {
     canRedo() {
         return this._undoRedoService.canRedo(this.uri);
     }
-    handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines, affectedLineHeights) {
+    handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines, affectedLineHeights, affectedFontLines) {
         if (affectedInjectedTextLines && affectedInjectedTextLines.size > 0) {
             const affectedLines = Array.from(affectedInjectedTextLines);
             const lineChangeEvents = ( affectedLines.map(lineNumber => ( new ModelRawLineChanged(
@@ -1184,6 +1194,11 @@ let TextModel = class TextModel extends Disposable {
             ))));
             this._onDidChangeLineHeight.fire(( new ModelLineHeightChangedEvent(lineHeightChangeEvent)));
         }
+        if (affectedFontLines && affectedFontLines.size > 0) {
+            const affectedLines = Array.from(affectedFontLines);
+            const fontChangeEvent = ( affectedLines.map(fontChange => ( new ModelFontChanged(fontChange.ownerId, fontChange.lineNumber))));
+            this._onDidChangeFont.fire(( new ModelFontChangedEvent(fontChangeEvent)));
+        }
     }
     changeDecorations(callback, ownerId = 0) {
         this._assertNotDisposed();
@@ -1302,30 +1317,30 @@ let TextModel = class TextModel extends Disposable {
         }
         return this._decorationsTree.getNodeRange(this, node);
     }
-    getLineDecorations(lineNumber, ownerId = 0, filterOutValidation = false) {
+    getLineDecorations(lineNumber, ownerId = 0, filterOutValidation = false, filterFontDecorations = false) {
         if (lineNumber < 1 || lineNumber > this.getLineCount()) {
             return [];
         }
-        return this.getLinesDecorations(lineNumber, lineNumber, ownerId, filterOutValidation);
+        return this.getLinesDecorations(lineNumber, lineNumber, ownerId, filterOutValidation, filterFontDecorations);
     }
-    getLinesDecorations(_startLineNumber, _endLineNumber, ownerId = 0, filterOutValidation = false, onlyMarginDecorations = false) {
+    getLinesDecorations(_startLineNumber, _endLineNumber, ownerId = 0, filterOutValidation = false, filterFontDecorations = false, onlyMarginDecorations = false) {
         const lineCount = this.getLineCount();
         const startLineNumber = Math.min(lineCount, Math.max(1, _startLineNumber));
         const endLineNumber = Math.min(lineCount, Math.max(1, _endLineNumber));
         const endColumn = this.getLineMaxColumn(endLineNumber);
         const range = ( new Range(startLineNumber, 1, endLineNumber, endColumn));
-        const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, onlyMarginDecorations);
+        const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
         pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
         return decorations;
     }
-    getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {
+    getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, filterFontDecorations = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {
         const validatedRange = this.validateRange(range);
-        const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMarginDecorations);
+        const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
         pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
         return decorations;
     }
-    getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false) {
-        return this._decorationsTree.getAll(this, ownerId, filterOutValidation, true, false);
+    getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false, filterFontDecorations = false) {
+        return this._decorationsTree.getAll(this, ownerId, filterOutValidation, filterFontDecorations, true, false);
     }
     getInjectedTextDecorations(ownerId = 0) {
         return this._decorationsTree.getAllInjectedText(this, ownerId);
@@ -1339,18 +1354,23 @@ let TextModel = class TextModel extends Disposable {
         const result = this._decorationsTree.getInjectedTextInInterval(this, startOffset, endOffset, 0);
         return LineInjectedText.fromDecorations(result).filter(t => t.lineNumber === lineNumber);
     }
-    getAllDecorations(ownerId = 0, filterOutValidation = false) {
-        let result = this._decorationsTree.getAll(this, ownerId, filterOutValidation, false, false);
+    getFontDecorationsInRange(range, ownerId = 0) {
+        const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);
+        const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);
+        return this._decorationsTree.getFontDecorationsInInterval(this, startOffset, endOffset, ownerId);
+    }
+    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));
         return result;
     }
     getAllMarginDecorations(ownerId = 0) {
-        return this._decorationsTree.getAll(this, ownerId, false, false, true);
+        return this._decorationsTree.getAll(this, ownerId, false, false, false, true);
     }
-    _getDecorationsInRange(filterRange, filterOwnerId, filterOutValidation, onlyMarginDecorations) {
+    _getDecorationsInRange(filterRange, filterOwnerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations) {
         const startOffset = this._buffer.getOffsetAt(filterRange.startLineNumber, filterRange.startColumn);
         const endOffset = this._buffer.getOffsetAt(filterRange.endLineNumber, filterRange.endColumn);
-        return this._decorationsTree.getAllInInterval(this, startOffset, endOffset, filterOwnerId, filterOutValidation, onlyMarginDecorations);
+        return this._decorationsTree.getAllInInterval(this, startOffset, endOffset, filterOwnerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
     }
     getRangeAt(start, end) {
         return this._buffer.getRangeAt(start, end - start);
@@ -1372,6 +1392,10 @@ let TextModel = class TextModel extends Disposable {
             const oldRange = this.getDecorationRange(decorationId);
             this._onDidChangeDecorations.recordLineAffectedByLineHeightChange(ownerId, decorationId, oldRange.startLineNumber, null);
         }
+        if (node.options.affectsFont) {
+            const oldRange = this.getDecorationRange(decorationId);
+            this._onDidChangeDecorations.recordLineAffectedByFontChange(ownerId, node.id, oldRange.startLineNumber);
+        }
         const range = this._validateRangeRelaxedNoAllocations(_range);
         const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);
         const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);
@@ -1388,6 +1412,9 @@ let TextModel = class TextModel extends Disposable {
         if (node.options.lineHeight !== null) {
             this._onDidChangeDecorations.recordLineAffectedByLineHeightChange(ownerId, decorationId, range.startLineNumber, node.options.lineHeight);
         }
+        if (node.options.affectsFont) {
+            this._onDidChangeDecorations.recordLineAffectedByFontChange(ownerId, node.id, range.startLineNumber);
+        }
     }
     _changeDecorationOptionsImpl(ownerId, decorationId, options) {
         const node = this._decorations[decorationId];
@@ -1410,6 +1437,10 @@ let TextModel = class TextModel extends Disposable {
             const nodeRange = this._decorationsTree.getNodeRange(this, node);
             this._onDidChangeDecorations.recordLineAffectedByLineHeightChange(ownerId, decorationId, nodeRange.startLineNumber, options.lineHeight);
         }
+        if (node.options.affectsFont || options.affectsFont) {
+            const nodeRange = this._decorationsTree.getNodeRange(this, node);
+            this._onDidChangeDecorations.recordLineAffectedByFontChange(ownerId, decorationId, nodeRange.startLineNumber);
+        }
         const movedInOverviewRuler = nodeWasInOverviewRuler !== nodeIsInOverviewRuler;
         const changedWhetherInjectedText = isOptionsInjectedText(options) !== isNodeInjectedText(node);
         if (movedInOverviewRuler || changedWhetherInjectedText) {
@@ -1451,6 +1482,10 @@ let TextModel = class TextModel extends Disposable {
                             const nodeRange = this._decorationsTree.getNodeRange(this, node);
                             this._onDidChangeDecorations.recordLineAffectedByLineHeightChange(ownerId, decorationId, nodeRange.startLineNumber, null);
                         }
+                        if (node.options.affectsFont) {
+                            const nodeRange = this._decorationsTree.getNodeRange(this, node);
+                            this._onDidChangeDecorations.recordLineAffectedByFontChange(ownerId, decorationId, nodeRange.startLineNumber);
+                        }
                         this._decorationsTree.delete(node);
                         if (!suppressEvents) {
                             this._onDidChangeDecorations.checkAffectedAndFire(node.options);
@@ -1481,6 +1516,9 @@ let TextModel = class TextModel extends Disposable {
                     if (node.options.lineHeight !== null) {
                         this._onDidChangeDecorations.recordLineAffectedByLineHeightChange(ownerId, node.id, range.startLineNumber, node.options.lineHeight);
                     }
+                    if (node.options.affectsFont) {
+                        this._onDidChangeDecorations.recordLineAffectedByFontChange(ownerId, node.id, range.startLineNumber);
+                    }
                     if (!suppressEvents) {
                         this._onDidChangeDecorations.checkAffectedAndFire(options);
                     }
@@ -1535,9 +1573,6 @@ let TextModel = class TextModel extends Disposable {
     toString() {
         return `TextModel(${( this.uri.toString())})`;
     }
-    editWithReason(editReason, cb) {
-        return TextModelEditReason.editWithReason(editReason, cb);
-    }
 };
 TextModel = TextModel_1 = ( __decorate([
     ( __param(4, IUndoRedoService)),
@@ -1573,7 +1608,7 @@ class DecorationsTrees {
         this._injectedTextDecorationsTree = ( new IntervalTree());
     }
     ensureAllNodesHaveRanges(host) {
-        this.getAll(host, 0, false, false, false);
+        this.getAll(host, 0, false, false, false, false);
     }
     _ensureNodesHaveRanges(host, nodes) {
         for (const node of nodes) {
@@ -1583,45 +1618,50 @@ class DecorationsTrees {
         }
         return nodes;
     }
-    getAllInInterval(host, start, end, filterOwnerId, filterOutValidation, onlyMarginDecorations) {
+    getAllInInterval(host, start, end, filterOwnerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations) {
         const versionId = host.getVersionId();
-        const result = this._intervalSearch(start, end, filterOwnerId, filterOutValidation, versionId, onlyMarginDecorations);
+        const result = this._intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, versionId, onlyMarginDecorations);
         return this._ensureNodesHaveRanges(host, result);
     }
-    _intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
-        const r0 = this._decorationsTree0.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
-        const r1 = this._decorationsTree1.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
-        const r2 = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+    _intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
+        const r0 = this._decorationsTree0.intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
+        const r1 = this._decorationsTree1.intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
+        const r2 = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
         return r0.concat(r1).concat(r2);
     }
     getInjectedTextInInterval(host, start, end, filterOwnerId) {
         const versionId = host.getVersionId();
-        const result = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, false, versionId, false);
+        const result = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, false, false, versionId, false);
         return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());
     }
+    getFontDecorationsInInterval(host, start, end, filterOwnerId) {
+        const versionId = host.getVersionId();
+        const decorations = this._decorationsTree0.intervalSearch(start, end, filterOwnerId, false, false, versionId, false);
+        return this._ensureNodesHaveRanges(host, decorations).filter((i) => i.options.affectsFont);
+    }
     getAllInjectedText(host, filterOwnerId) {
         const versionId = host.getVersionId();
-        const result = this._injectedTextDecorationsTree.search(filterOwnerId, false, versionId, false);
+        const result = this._injectedTextDecorationsTree.search(filterOwnerId, false, false, versionId, false);
         return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());
     }
     getAllCustomLineHeights(host, filterOwnerId) {
         const versionId = host.getVersionId();
-        const result = this._search(filterOwnerId, false, false, versionId, false);
+        const result = this._search(filterOwnerId, false, false, false, versionId, false);
         return this._ensureNodesHaveRanges(host, result).filter((i) => typeof i.options.lineHeight === 'number');
     }
-    getAll(host, filterOwnerId, filterOutValidation, overviewRulerOnly, onlyMarginDecorations) {
+    getAll(host, filterOwnerId, filterOutValidation, filterFontDecorations, overviewRulerOnly, onlyMarginDecorations) {
         const versionId = host.getVersionId();
-        const result = this._search(filterOwnerId, filterOutValidation, overviewRulerOnly, versionId, onlyMarginDecorations);
+        const result = this._search(filterOwnerId, filterOutValidation, filterFontDecorations, overviewRulerOnly, versionId, onlyMarginDecorations);
         return this._ensureNodesHaveRanges(host, result);
     }
-    _search(filterOwnerId, filterOutValidation, overviewRulerOnly, cachedVersionId, onlyMarginDecorations) {
+    _search(filterOwnerId, filterOutValidation, filterFontDecorations, overviewRulerOnly, cachedVersionId, onlyMarginDecorations) {
         if (overviewRulerOnly) {
-            return this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+            return this._decorationsTree1.search(filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
         }
         else {
-            const r0 = this._decorationsTree0.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
-            const r1 = this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
-            const r2 = this._injectedTextDecorationsTree.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+            const r0 = this._decorationsTree0.search(filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
+            const r1 = this._decorationsTree1.search(filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
+            const r2 = this._injectedTextDecorationsTree.search(filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
             return r0.concat(r1).concat(r2);
         }
     }
@@ -1798,6 +1838,8 @@ class ModelDecorationOptions {
         this.lineNumberHoverMessage = options.lineNumberHoverMessage || null;
         this.isWholeLine = options.isWholeLine || false;
         this.lineHeight = options.lineHeight ? Math.min(options.lineHeight, LINE_HEIGHT_CEILING) : null;
+        this.fontSize = options.fontSize || null;
+        this.affectsFont = !!options.fontSize || !!options.fontFamily || !!options.fontWeight || !!options.fontStyle;
         this.showIfCollapsed = options.showIfCollapsed || false;
         this.collapseOnReplaceEdit = options.collapseOnReplaceEdit || false;
         this.overviewRuler = options.overviewRuler ? ( new ModelDecorationOverviewRulerOptions(options.overviewRuler)) : null;
@@ -1843,6 +1885,16 @@ class LineHeightChangingDecoration {
         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();
@@ -1851,6 +1903,7 @@ class DidChangeDecorationsEmitter extends Disposable {
         this.event = this._actual.event;
         this._affectedInjectedTextLines = null;
         this._affectedLineHeights = null;
+        this._affectedFontLines = null;
         this._deferredCnt = 0;
         this._shouldFireDeferred = false;
         this._affectsMinimap = false;
@@ -1874,6 +1927,8 @@ class DidChangeDecorationsEmitter extends Disposable {
             this._affectedInjectedTextLines = null;
             this._affectedLineHeights?.clear();
             this._affectedLineHeights = null;
+            this._affectedFontLines?.clear();
+            this._affectedFontLines = null;
         }
     }
     recordLineAffectedByInjectedText(lineNumber) {
@@ -1888,6 +1943,12 @@ class DidChangeDecorationsEmitter extends Disposable {
         }
         this._affectedLineHeights.add(( new LineHeightChangingDecoration(ownerId, decorationId, lineNumber, lineHeight)));
     }
+    recordLineAffectedByFontChange(ownerId, decorationId, lineNumber) {
+        if (!this._affectedFontLines) {
+            this._affectedFontLines = ( new SetWithKey([], LineFontChangingDecoration.toKey));
+        }
+        this._affectedFontLines.add(( new LineFontChangingDecoration(ownerId, decorationId, lineNumber)));
+    }
     checkAffectedAndFire(options) {
         this._affectsMinimap ||= !!options.minimap?.position;
         this._affectsOverviewRuler ||= !!options.overviewRuler?.color;
@@ -1910,7 +1971,7 @@ class DidChangeDecorationsEmitter extends Disposable {
         }
     }
     doFire() {
-        this.handleBeforeFire(this._affectedInjectedTextLines, this._affectedLineHeights);
+        this.handleBeforeFire(this._affectedInjectedTextLines, this._affectedLineHeights, this._affectedFontLines);
         const event = {
             affectsMinimap: this._affectsMinimap,
             affectsOverviewRuler: this._affectsOverviewRuler,

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

@@ -7,8 +7,8 @@ import { LineRange } from '../../core/ranges/lineRange.js';
 import '../../../../base/common/observableInternal/index.js';
 import { itemsEquals, itemEquals, equalsIfDefined } from '../../../../base/common/equals.js';
 import { observableSignal } from '../../../../base/common/observableInternal/observables/observableSignal.js';
-import { derivedOpts } from '../../../../base/common/observableInternal/observables/derived.js';
 import { observableValueOpts } from '../../../../base/common/observableInternal/observables/observableValueOpts.js';
+import { derivedOpts } from '../../../../base/common/observableInternal/observables/derived.js';
 
 class AttachedViews {
     constructor() {

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

@@ -1,4 +1,3 @@
-import type * as TreeSitter from "@vscode/tree-sitter-wasm";
 import { Emitter, Event } from "../../../../../base/common/event.js";
 import { StandardTokenType } from "../../../encodedTokenAttributes.js";
 import { ILanguageIdCodec } from "../../../languages.js";
@@ -36,5 +35,3 @@ export declare class TreeSitterSyntaxTokenBackend extends AbstractSyntaxTokenBac
     tokenizeLinesAt(lineNumber: number, lines: string[]): LineTokens[] | null;
     get hasTokens(): boolean;
 }
-export declare function rangesEqual(a: TreeSitter.Range, b: TreeSitter.Range): boolean;
-export declare function rangesIntersect(a: TreeSitter.Range, b: TreeSitter.Range): boolean;

package/vscode/src/vs/editor/common/model/tokens/treeSitter/treeSitterSyntaxTokenBackend.js

@@ -156,17 +156,5 @@ TreeSitterSyntaxTokenBackend = ( __decorate([
     ( __param(4, ITreeSitterLibraryService)),
     ( __param(5, IInstantiationService))
 ], TreeSitterSyntaxTokenBackend));
-function rangesEqual(a, b) {
-    return (a.startPosition.row === b.startPosition.row)
-        && (a.startPosition.column === b.startPosition.column)
-        && (a.endPosition.row === b.endPosition.row)
-        && (a.endPosition.column === b.endPosition.column)
-        && (a.startIndex === b.startIndex)
-        && (a.endIndex === b.endIndex);
-}
-function rangesIntersect(a, b) {
-    return (a.startIndex <= b.startIndex && a.endIndex >= b.startIndex) ||
-        (b.startIndex <= a.startIndex && b.endIndex >= a.startIndex);
-}
 
-export { TreeSitterSyntaxTokenBackend, rangesEqual, rangesIntersect };
+export { TreeSitterSyntaxTokenBackend };

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

@@ -51,3 +51,5 @@ export interface RangeChange {
     newRangeStartOffset: number;
     newRangeEndOffset: number;
 }
+export declare function rangesEqual(a: TreeSitter.Range, b: TreeSitter.Range): boolean;
+export declare function rangesIntersect(a: TreeSitter.Range, b: TreeSitter.Range): boolean;

package/vscode/src/vs/editor/common/model/tokens/treeSitter/treeSitterTree.js

@@ -8,7 +8,6 @@ import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
 import { TextLength } from '../../../core/text/textLength.js';
 import { gotoParent, getClosestPreviousNodes, nextSiblingOrParentSibling, gotoNthChild } from './cursorUtils.js';
-import { rangesIntersect, rangesEqual } from './treeSitterSyntaxTokenBackend.js';
 import { Range } from '../../../core/range.js';
 import { transaction } from '../../../../../base/common/observableInternal/transaction.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
@@ -377,5 +376,17 @@ function newTimeOutProgressCallback() {
         return false;
     };
 }
+function rangesEqual(a, b) {
+    return (a.startPosition.row === b.startPosition.row)
+        && (a.startPosition.column === b.startPosition.column)
+        && (a.endPosition.row === b.endPosition.row)
+        && (a.endPosition.column === b.endPosition.column)
+        && (a.startIndex === b.startIndex)
+        && (a.endIndex === b.endIndex);
+}
+function rangesIntersect(a, b) {
+    return (a.startIndex <= b.startIndex && a.endIndex >= b.startIndex) ||
+        (b.startIndex <= a.startIndex && b.endIndex >= a.startIndex);
+}
 
-export { TreeSitterTree };
+export { TreeSitterTree, rangesEqual, rangesIntersect };

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

@@ -13,13 +13,14 @@ import { IWordAtPosition } from "./core/wordHelper.js";
 import { FormattingOptions } from "./languages.js";
 import { ILanguageSelection } from "./languages/language.js";
 import { IBracketPairsTextModelPart } from "./textModelBracketPairs.js";
-import { IModelContentChange, IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent, InternalModelContentChangeEvent, ModelInjectedTextChangedEvent, ModelLineHeightChangedEvent } from "./textModelEvents.js";
+import { IModelContentChange, IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent, InternalModelContentChangeEvent, ModelFontChangedEvent, ModelInjectedTextChangedEvent, ModelLineHeightChangedEvent } from "./textModelEvents.js";
 import { IGuidesTextModelPart } from "./textModelGuides.js";
 import { ITokenizationTextModelPart } from "./tokenizationTextModelPart.js";
 import { UndoRedoGroup } from "../../platform/undoRedo/common/undoRedo.js";
-import { TokenArray } from "./tokens/tokenArray.js";
+import { TokenArray } from "./tokens/lineTokens.js";
 import { IEditorModel } from "./editorCommon.js";
 import { TextModelEditReason } from "./textModelEditReason.js";
+import { TextEdit } from "./core/edits/textEdit.js";
 export declare enum OverviewRulerLane {
     Left = 1,
     Center = 2,
@@ -87,6 +88,10 @@ export interface IModelDecorationOptions {
     glyphMarginClassName?: string | null;
     glyphMargin?: IModelDecorationGlyphMarginOptions | null;
     lineHeight?: number | null;
+    fontFamily?: string | null;
+    fontSize?: string | null;
+    fontWeight?: string | null;
+    fontStyle?: string | null;
     linesDecorationsClassName?: string | null;
     linesDecorationsTooltip?: string | null;
     lineNumberClassName?: string | null;
@@ -100,6 +105,7 @@ export interface IModelDecorationOptions {
     before?: InjectedTextOptions | null;
     hideInCommentTokens?: boolean | null;
     hideInStringTokens?: boolean | null;
+    affectsFont?: boolean | null;
 }
 export interface InjectedTextOptions {
     readonly content: string;

package/vscode/src/vs/editor/common/services/editorWebWorker.d.ts

@@ -12,6 +12,7 @@ import { IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-chat-serv
 import { FindSectionHeaderOptions, SectionHeader } from "./findSectionHeaders.js";
 import { IRawModelData, IWorkerTextModelSyncChannelServer } from "./textModelSync/textModelSync.protocol.js";
 import { ICommonModel } from "./textModelSync/textModelSync.impl.js";
+import { ISerializedStringEdit } from "../core/edits/stringEdit.js";
 export interface IMirrorModel extends IMirrorTextModel {
     readonly uri: URI;
     readonly version: number;
@@ -43,6 +44,9 @@ export declare class EditorWorker implements IDisposable, IWorkerTextModelSyncCh
     private static computeDiff;
     private static _modelsAreIdentical;
     $computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
+    $computeStringDiff(original: string, modified: string, options: {
+        maxComputationTimeMs: number;
+    }, algorithm: DiffAlgorithmName): ISerializedStringEdit;
     private static readonly _diffLimit;
     $computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[], pretty: boolean): Promise<TextEdit[]>;
     $computeHumanReadableDiff(modelUrl: string, edits: TextEdit[], options: ILinesDiffComputerOptions): TextEdit[];

package/vscode/src/vs/editor/common/services/editorWebWorker.js

@@ -8,11 +8,14 @@ import { createMonacoBaseAPI } from './editorBaseApi.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
 import { DiffComputer } from '../diff/legacyLinesDiffComputer.js';
+import { DetailedLineRangeMapping } from '../diff/rangeMapping.js';
 import { linesDiffComputers } from '../diff/linesDiffComputers.js';
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
 import { findSectionHeaders } from './findSectionHeaders.js';
 import { WorkerTextModelSyncServer } from './textModelSync/textModelSync.impl.js';
+import { StringText } from '../core/text/abstractText.js';
+import '../core/text/positionToOffset.js';
 
 class EditorWorker {
     constructor(_foreignModule = null) {
@@ -127,6 +130,17 @@ class EditorWorker {
         }));
         return diffComputer.computeDiff().changes;
     }
+    $computeStringDiff(original, modified, options, algorithm) {
+        const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();
+        const originalText = ( new StringText(original));
+        const originalLines = originalText.getLines();
+        const modifiedText = ( new StringText(modified));
+        const modifiedLines = modifiedText.getLines();
+        const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, { ignoreTrimWhitespace: false, maxComputationTimeMs: options.maxComputationTimeMs, computeMoves: false, extendToSubwords: false });
+        const textEdit = DetailedLineRangeMapping.toTextEdit(result.changes, modifiedText);
+        const strEdit = originalText.getTransformer().getStringEdit(textEdit);
+        return strEdit.toJson();
+    }
     static { this._diffLimit = 100000; }
     async $computeMoreMinimalEdits(modelUrl, edits, pretty) {
         const model = this._getModel(modelUrl);

package/vscode/src/vs/editor/common/services/editorWorker.service.d.ts

@@ -1,4 +1,5 @@
 import { URI } from "../../../base/common/uri.js";
+import { StringEdit } from "../core/edits/stringEdit.js";
 import { IRange } from "../core/range.js";
 import { IDocumentDiffProviderOptions, IDocumentDiff } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
 import { IChange } from "../diff/legacyLinesDiffComputer.js";
@@ -16,6 +17,9 @@ export interface IEditorWorkerService {
     computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
     computeMoreMinimalEdits(resource: URI, edits: TextEdit[] | null | undefined, pretty?: boolean): Promise<TextEdit[] | undefined>;
     computeHumanReadableDiff(resource: URI, edits: TextEdit[] | null | undefined): Promise<TextEdit[] | undefined>;
+    computeStringEditFromDiff(original: string, modified: string, options: {
+        maxComputationTimeMs: number;
+    }, algorithm: DiffAlgorithmName): Promise<StringEdit>;
     canComputeWordRanges(resource: URI): boolean;
     computeWordRanges(resource: URI, range: IRange): Promise<{
         [word: string]: IRange[];