@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -1,16 +1,98 @@
+declare const privateSymbol: unique symbol;
 export declare class TextModelEditReason {
     readonly metadata: ITextModelEditReasonMetadata;
-    private static _nextMetadataId;
-    private static _metaDataMap;
-    static editWithReason<T>(reason: TextModelEditReason, runner: () => T): T;
-    static _getCurrentMetadata(): ITextModelEditReasonMetadata;
-    constructor(metadata: ITextModelEditReasonMetadata);
-}
-interface ITextModelEditReasonMetadata {
-    source?: "Chat.applyEdits" | "inlineChat.applyEdit" | "reloadFromDisk";
-    extensionId?: string;
-    nes?: boolean;
-    type?: "word" | "line";
-    requestUuid?: string;
+    constructor(metadata: ITextModelEditReasonMetadata, _privateCtorGuard: typeof privateSymbol);
+    toString(): string;
+    getType(): string;
+    toKey(level: number): string;
 }
+type TextModelEditReasonT<T> = TextModelEditReason & {
+    metadataT: T;
+};
+export declare const EditReasons: {
+    unknown(data: {
+        name?: string | null;
+    }): TextModelEditReasonT<{
+        readonly source: "unknown";
+        readonly name: string | null | undefined;
+    }>;
+    rename: () => TextModelEditReasonT<{
+        readonly source: "rename";
+    }>;
+    chatApplyEdits(data: {
+        modelId: string | undefined;
+    }): TextModelEditReasonT<{
+        readonly source: "Chat.applyEdits";
+        readonly $modelId: string | undefined;
+    }>;
+    inlineCompletionAccept(data: {
+        nes: boolean;
+        requestUuid: string;
+        extensionId: string;
+    }): TextModelEditReasonT<{
+        readonly source: "inlineCompletionAccept";
+        readonly $nes: boolean;
+        readonly $extensionId: string;
+        readonly $$requestUuid: string;
+    }>;
+    inlineCompletionPartialAccept(data: {
+        nes: boolean;
+        requestUuid: string;
+        extensionId: string;
+        type: "word" | "line";
+    }): TextModelEditReasonT<{
+        readonly source: "inlineCompletionPartialAccept";
+        readonly type: "line" | "word";
+        readonly $nes: boolean;
+        readonly $extensionId: string;
+        readonly $$requestUuid: string;
+    }>;
+    inlineChatApplyEdit(data: {
+        modelId: string | undefined;
+    }): TextModelEditReasonT<{
+        readonly source: "inlineChat.applyEdits";
+        readonly $modelId: string | undefined;
+    }>;
+    reloadFromDisk: () => TextModelEditReasonT<{
+        readonly source: "reloadFromDisk";
+    }>;
+    cursor(data: {
+        kind: "compositionType" | "compositionEnd" | "type" | "paste" | "cut" | "executeCommands" | "executeCommand";
+        detailedSource?: string | null;
+    }): TextModelEditReasonT<{
+        readonly source: "cursor";
+        readonly kind: "type" | "cut" | "paste" | "compositionType" | "compositionEnd" | "executeCommands" | "executeCommand";
+        readonly detailedSource: string | null | undefined;
+    }>;
+    setValue: () => TextModelEditReasonT<{
+        readonly source: "setValue";
+    }>;
+    eolChange: () => TextModelEditReasonT<{
+        readonly source: "eolChange";
+    }>;
+    applyEdits: () => TextModelEditReasonT<{
+        readonly source: "applyEdits";
+    }>;
+    snippet: () => TextModelEditReasonT<{
+        readonly source: "snippet";
+    }>;
+    suggest: (data: {
+        extensionId: string | undefined;
+    }) => TextModelEditReasonT<{
+        readonly source: "suggest";
+        readonly $extensionId: string | undefined;
+    }>;
+    codeAction: (data: {
+        kind: string | undefined;
+        extensionId: string | undefined;
+    }) => TextModelEditReasonT<{
+        readonly source: "codeAction";
+        readonly $kind: string | undefined;
+        readonly $extensionId: string | undefined;
+    }>;
+};
+type Values<T> = T[keyof T];
+type ITextModelEditReasonMetadata = Values<{
+    [TKey in keyof typeof EditReasons]: ReturnType<typeof EditReasons[TKey]>["metadataT"];
+}>;
 export {};

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

@@ -1,29 +1,95 @@
 
 
+const privateSymbol = Symbol('TextModelEditReason');
 class TextModelEditReason {
-    static { this._nextMetadataId = 0; }
-    static { this._metaDataMap = ( new Map()); }
-    static editWithReason(reason, runner) {
-        const id = this._nextMetadataId++;
-        this._metaDataMap.set(id, reason.metadata);
-        try {
-            const result = runner();
-            return result;
-        }
-        finally {
-            this._metaDataMap.delete(id);
-        }
+    constructor(metadata, _privateCtorGuard) {
+        this.metadata = metadata;
+    }
+    toString() {
+        return `${this.metadata.source}`;
     }
-    static _getCurrentMetadata() {
-        const result = {};
-        for (const metadata of ( this._metaDataMap.values())) {
-            Object.assign(result, metadata);
+    getType() {
+        const metadata = this.metadata;
+        switch (metadata.source) {
+            case 'cursor':
+                return metadata.kind;
+            case 'inlineCompletionAccept':
+                return metadata.source + (metadata.$nes ? ':nes' : '');
+            case 'unknown':
+                return metadata.name || 'unknown';
+            default:
+                return metadata.source;
         }
-        return result;
     }
-    constructor(metadata) {
-        this.metadata = metadata;
+    toKey(level) {
+        const metadata = this.metadata;
+        const keys = ( Object.entries(metadata).filter(([key, value]) => {
+            const prefixCount = (key.match(/\$/g) || []).length;
+            return prefixCount <= level && value !== undefined && value !== null && value !== '';
+        }).map(([key, value]) => `${key}:${value}`));
+        return keys.join('-');
+    }
+}
+function createEditReason(metadata) {
+    return ( new TextModelEditReason(metadata, privateSymbol));
+}
+const EditReasons = {
+    unknown(data) {
+        return createEditReason({
+            source: 'unknown',
+            name: data.name,
+        });
+    },
+    rename: () => createEditReason({ source: 'rename' }),
+    chatApplyEdits(data) {
+        return createEditReason({
+            source: 'Chat.applyEdits',
+            $modelId: avoidPathRedaction(data.modelId),
+        });
+    },
+    inlineCompletionAccept(data) {
+        return createEditReason({
+            source: 'inlineCompletionAccept',
+            $nes: data.nes,
+            $extensionId: data.extensionId,
+            $$requestUuid: data.requestUuid,
+        });
+    },
+    inlineCompletionPartialAccept(data) {
+        return createEditReason({
+            source: 'inlineCompletionPartialAccept',
+            type: data.type,
+            $nes: data.nes,
+            $extensionId: data.extensionId,
+            $$requestUuid: data.requestUuid,
+        });
+    },
+    inlineChatApplyEdit(data) {
+        return createEditReason({
+            source: 'inlineChat.applyEdits',
+            $modelId: avoidPathRedaction(data.modelId),
+        });
+    },
+    reloadFromDisk: () => createEditReason({ source: 'reloadFromDisk' }),
+    cursor(data) {
+        return createEditReason({
+            source: 'cursor',
+            kind: data.kind,
+            detailedSource: data.detailedSource,
+        });
+    },
+    setValue: () => createEditReason({ source: 'setValue' }),
+    eolChange: () => createEditReason({ source: 'eolChange' }),
+    applyEdits: () => createEditReason({ source: 'applyEdits' }),
+    snippet: () => createEditReason({ source: 'snippet' }),
+    suggest: (data) => createEditReason({ source: 'suggest', $extensionId: data.extensionId }),
+    codeAction: (data) => createEditReason({ source: 'codeAction', $kind: data.kind, $extensionId: data.extensionId })
+};
+function avoidPathRedaction(str) {
+    if (str === undefined) {
+        return undefined;
     }
+    return str.replaceAll('/', '|');
 }
 
-export { TextModelEditReason };
+export { EditReasons, TextModelEditReason };

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

@@ -1,6 +1,8 @@
+import { IPosition } from "./core/position.js";
 import { IRange } from "./core/range.js";
 import { Selection } from "./core/selection.js";
 import { IModelDecoration, InjectedTextOptions } from "./model.js";
+import { TextModelEditReason } from "./textModelEditReason.js";
 export interface IModelLanguageChangedEvent {
     readonly oldLanguage: string;
     readonly newLanguage: string;
@@ -22,6 +24,18 @@ export interface IModelContentChangedEvent {
     readonly isRedoing: boolean;
     readonly isFlush: boolean;
     readonly isEolChange: boolean;
+    readonly detailedReasons: TextModelEditReason[];
+    readonly detailedReasonsChangeLengths: number[];
+}
+export interface ISerializedModelContentChangedEvent {
+    readonly changes: IModelContentChange[];
+    readonly eol: string;
+    readonly versionId: number;
+    readonly isUndoing: boolean;
+    readonly isRedoing: boolean;
+    readonly isFlush: boolean;
+    readonly isEolChange: boolean;
+    readonly detailedReason: Record<string, unknown> | undefined;
 }
 export interface IModelDecorationsChangedEvent {
     readonly affectsMinimap: boolean;
@@ -77,6 +91,11 @@ export declare class ModelLineHeightChanged {
     readonly lineHeight: number | null;
     constructor(ownerId: number, decorationId: string, lineNumber: number, lineHeight: number | null);
 }
+export declare class ModelFontChanged {
+    readonly ownerId: number;
+    readonly lineNumber: number;
+    constructor(ownerId: number, lineNumber: number);
+}
 export declare class ModelRawLinesDeleted {
     readonly changeType = RawContentChangedType.LinesDeleted;
     readonly fromLineNumber: number;
@@ -112,6 +131,11 @@ export declare class ModelInjectedTextChangedEvent {
 export declare class ModelLineHeightChangedEvent {
     readonly changes: ModelLineHeightChanged[];
     constructor(changes: ModelLineHeightChanged[]);
+    affects(rangeOrPosition: IRange | IPosition): boolean;
+}
+export declare class ModelFontChangedEvent {
+    readonly changes: ModelFontChanged[];
+    constructor(changes: ModelFontChanged[]);
 }
 export declare class InternalModelContentChangeEvent {
     readonly rawContentChangedEvent: ModelRawContentChangedEvent;

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

@@ -1,4 +1,5 @@
 
+import { Range } from './core/range.js';
 
 var RawContentChangedType;
 (function (RawContentChangedType) {
@@ -94,6 +95,12 @@ class ModelLineHeightChanged {
         this.lineHeight = lineHeight;
     }
 }
+class ModelFontChanged {
+    constructor(ownerId, lineNumber) {
+        this.ownerId = ownerId;
+        this.lineNumber = lineNumber;
+    }
+}
 class ModelRawLinesDeleted {
     constructor(fromLineNumber, toLineNumber) {
         this.changeType = RawContentChangedType.LinesDeleted;
@@ -149,6 +156,29 @@ class ModelLineHeightChangedEvent {
     constructor(changes) {
         this.changes = changes;
     }
+    affects(rangeOrPosition) {
+        if (Range.isIRange(rangeOrPosition)) {
+            for (const change of this.changes) {
+                if (change.lineNumber >= rangeOrPosition.startLineNumber && change.lineNumber <= rangeOrPosition.endLineNumber) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            for (const change of this.changes) {
+                if (change.lineNumber === rangeOrPosition.lineNumber) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
+class ModelFontChangedEvent {
+    constructor(changes) {
+        this.changes = changes;
+    }
 }
 class InternalModelContentChangeEvent {
     constructor(rawContentChangedEvent, contentChangedEvent) {
@@ -176,8 +206,10 @@ class InternalModelContentChangeEvent {
             isUndoing: isUndoing,
             isRedoing: isRedoing,
             isFlush: isFlush,
+            detailedReasons: a.detailedReasons.concat(b.detailedReasons),
+            detailedReasonsChangeLengths: a.detailedReasonsChangeLengths.concat(b.detailedReasonsChangeLengths),
         };
     }
 }
 
-export { InternalModelContentChangeEvent, LineInjectedText, ModelInjectedTextChangedEvent, ModelLineHeightChanged, ModelLineHeightChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, RawContentChangedType };
+export { InternalModelContentChangeEvent, LineInjectedText, ModelFontChanged, ModelFontChangedEvent, ModelInjectedTextChangedEvent, ModelLineHeightChanged, ModelLineHeightChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, RawContentChangedType };

package/vscode/src/vs/editor/common/tokens/lineTokens.d.ts

@@ -3,7 +3,6 @@ import { ColorId, StandardTokenType, ITokenPresentation } from "../encodedTokenA
 import { IPosition } from "../core/position.js";
 import { ITextModel } from "../model.js";
 import { OffsetRange } from "../core/ranges/offsetRange.js";
-import { TokenArray } from "./tokenArray.js";
 export interface IViewLineTokens {
     languageIdCodec: ILanguageIdCodec;
     equals(other: IViewLineTokens): boolean;
@@ -65,3 +64,25 @@ export declare class LineTokens implements IViewLineTokens {
     toString(): string;
 }
 export declare function getStandardTokenTypeAtPosition(model: ITextModel, position: IPosition): StandardTokenType | undefined;
+export declare class TokenArray {
+    private readonly _tokenInfo;
+    static fromLineTokens(lineTokens: LineTokens): TokenArray;
+    static create(tokenInfo: TokenInfo[]): TokenArray;
+    private constructor();
+    toLineTokens(lineContent: string, decoder: ILanguageIdCodec): LineTokens;
+    forEach(cb: (range: OffsetRange, tokenInfo: TokenInfo) => void): void;
+    map<T>(cb: (range: OffsetRange, tokenInfo: TokenInfo) => T): T[];
+    slice(range: OffsetRange): TokenArray;
+    append(other: TokenArray): TokenArray;
+}
+export type ITokenMetadata = number;
+export declare class TokenInfo {
+    readonly length: number;
+    readonly metadata: ITokenMetadata;
+    constructor(length: number, metadata: ITokenMetadata);
+}
+export declare class TokenArrayBuilder {
+    private readonly _tokens;
+    add(length: number, metadata: ITokenMetadata): void;
+    build(): TokenArray;
+}

package/vscode/src/vs/editor/common/tokens/lineTokens.js

@@ -1,7 +1,6 @@
 
 import { FontStyle, MetadataConsts, ColorId, TokenMetadata } from '../encodedTokenAttributes.js';
 import { OffsetRange } from '../core/ranges/offsetRange.js';
-import { TokenArrayBuilder } from './tokenArray.js';
 import { onUnexpectedError } from '../../../base/common/errors.js';
 
 class LineTokens {
@@ -306,5 +305,83 @@ function getStandardTokenTypeAtPosition(model, position) {
     const tokenType = lineTokens.getStandardTokenType(tokenIndex);
     return tokenType;
 }
+class TokenArray {
+    static fromLineTokens(lineTokens) {
+        const tokenInfo = [];
+        for (let i = 0; i < lineTokens.getCount(); i++) {
+            tokenInfo.push(( new TokenInfo(
+                lineTokens.getEndOffset(i) - lineTokens.getStartOffset(i),
+                lineTokens.getMetadata(i)
+            )));
+        }
+        return TokenArray.create(tokenInfo);
+    }
+    static create(tokenInfo) {
+        return ( new TokenArray(tokenInfo));
+    }
+    constructor(_tokenInfo) {
+        this._tokenInfo = _tokenInfo;
+    }
+    toLineTokens(lineContent, decoder) {
+        return LineTokens.createFromTextAndMetadata(( this.map((r, t) => ({ text: r.substring(lineContent), metadata: t.metadata }))), decoder);
+    }
+    forEach(cb) {
+        let lengthSum = 0;
+        for (const tokenInfo of this._tokenInfo) {
+            const range = ( new OffsetRange(lengthSum, lengthSum + tokenInfo.length));
+            cb(range, tokenInfo);
+            lengthSum += tokenInfo.length;
+        }
+    }
+    map(cb) {
+        const result = [];
+        let lengthSum = 0;
+        for (const tokenInfo of this._tokenInfo) {
+            const range = ( new OffsetRange(lengthSum, lengthSum + tokenInfo.length));
+            result.push(cb(range, tokenInfo));
+            lengthSum += tokenInfo.length;
+        }
+        return result;
+    }
+    slice(range) {
+        const result = [];
+        let lengthSum = 0;
+        for (const tokenInfo of this._tokenInfo) {
+            const tokenStart = lengthSum;
+            const tokenEndEx = tokenStart + tokenInfo.length;
+            if (tokenEndEx > range.start) {
+                if (tokenStart >= range.endExclusive) {
+                    break;
+                }
+                const deltaBefore = Math.max(0, range.start - tokenStart);
+                const deltaAfter = Math.max(0, tokenEndEx - range.endExclusive);
+                result.push(( new TokenInfo(tokenInfo.length - deltaBefore - deltaAfter, tokenInfo.metadata)));
+            }
+            lengthSum += tokenInfo.length;
+        }
+        return TokenArray.create(result);
+    }
+    append(other) {
+        const result = this._tokenInfo.concat(other._tokenInfo);
+        return TokenArray.create(result);
+    }
+}
+class TokenInfo {
+    constructor(length, metadata) {
+        this.length = length;
+        this.metadata = metadata;
+    }
+}
+class TokenArrayBuilder {
+    constructor() {
+        this._tokens = [];
+    }
+    add(length, metadata) {
+        this._tokens.push(( new TokenInfo(length, metadata)));
+    }
+    build() {
+        return TokenArray.create(this._tokens);
+    }
+}
 
-export { LineTokens, getStandardTokenTypeAtPosition };
+export { LineTokens, TokenArray, TokenArrayBuilder, TokenInfo, getStandardTokenTypeAtPosition };

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.js

@@ -875,7 +875,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
-        sb.appendString(( localize(870, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(881, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
@@ -886,7 +886,7 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return localize(871, "{0} chars", n);
+        return localize(882, "{0} chars", n);
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

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

@@ -7,6 +7,7 @@ import { ICoordinatesConverter, InlineDecoration, ViewModelDecoration } from "..
 export interface IDecorationsViewportData {
     readonly decorations: ViewModelDecoration[];
     readonly inlineDecorations: InlineDecoration[][];
+    readonly hasVariableFonts: boolean;
 }
 export declare class ViewModelDecorations implements IDisposable {
     private readonly editorId;
@@ -26,7 +27,10 @@ export declare class ViewModelDecorations implements IDisposable {
     private _getOrCreateViewModelDecoration;
     getMinimapDecorationsInRange(range: Range): ViewModelDecoration[];
     getDecorationsViewportData(viewRange: Range): IDecorationsViewportData;
-    getInlineDecorationsOnLine(lineNumber: number, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): InlineDecoration[];
+    getInlineDecorationsOnLine(lineNumber: number, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): {
+        inlineDecorations: InlineDecoration[];
+        hasVariableFonts: boolean;
+    };
     private _getDecorationsInRange;
 }
 export declare function isModelDecorationVisible(model: ITextModel, decoration: IModelDecoration): boolean;

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

@@ -3,7 +3,7 @@ import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { PositionAffinity } from '../model.js';
 import { ViewModelDecoration, InlineDecoration, InlineDecorationType } from '../viewModel.js';
-import { filterValidationDecorations } from '../config/editorOptions.js';
+import { filterValidationDecorations, filterFontDecorations } from '../config/editorOptions.js';
 import { StandardTokenType } from '../encodedTokenAttributes.js';
 
 class ViewModelDecorations {
@@ -79,10 +79,11 @@ class ViewModelDecorations {
             lineNumber,
             this._linesCollection.getViewLineMaxColumn(lineNumber)
         ));
-        return this._getDecorationsInRange(range, onlyMinimapDecorations, onlyMarginDecorations).inlineDecorations[0];
+        const decorations = this._getDecorationsInRange(range, onlyMinimapDecorations, onlyMarginDecorations);
+        return { inlineDecorations: decorations.inlineDecorations[0], hasVariableFonts: decorations.hasVariableFonts };
     }
     _getDecorationsInRange(viewRange, onlyMinimapDecorations, onlyMarginDecorations) {
-        const modelDecorations = this._linesCollection.getDecorationsInRange(viewRange, this.editorId, filterValidationDecorations(this.configuration.options), onlyMinimapDecorations, onlyMarginDecorations);
+        const modelDecorations = this._linesCollection.getDecorationsInRange(viewRange, this.editorId, filterValidationDecorations(this.configuration.options), filterFontDecorations(this.configuration.options), onlyMinimapDecorations, onlyMarginDecorations);
         const startLineNumber = viewRange.startLineNumber;
         const endLineNumber = viewRange.endLineNumber;
         const decorationsInViewport = [];
@@ -91,6 +92,7 @@ class ViewModelDecorations {
         for (let j = startLineNumber; j <= endLineNumber; j++) {
             inlineDecorations[j - startLineNumber] = [];
         }
+        let hasVariableFonts = false;
         for (let i = 0, len = modelDecorations.length; i < len; i++) {
             const modelDecoration = modelDecorations[i];
             const decorationOptions = modelDecoration.options;
@@ -134,10 +136,14 @@ class ViewModelDecorations {
                     inlineDecorations[viewRange.endLineNumber - startLineNumber].push(inlineDecoration);
                 }
             }
+            if (decorationOptions.affectsFont) {
+                hasVariableFonts = true;
+            }
         }
         return {
             decorations: decorationsInViewport,
-            inlineDecorations: inlineDecorations
+            inlineDecorations: inlineDecorations,
+            hasVariableFonts
         };
     }
 }

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

@@ -18,6 +18,7 @@ import { ViewEventHandler } from "../viewEventHandler.js";
 import { ICoordinatesConverter, IViewModel, IWhitespaceChangeAccessor, MinimapLinesRenderingData, OverviewRulerDecorationsGroup, ViewLineData, ViewLineRenderingData, ViewModelDecoration } from "../viewModel.js";
 import { OutgoingViewModelEvent } from "../viewModelEventDispatcher.js";
 import { IThemeService } from "../../../platform/theme/common/themeService.service.js";
+import { TextModelEditReason } from "../textModelEditReason.js";
 export declare class ViewModel extends Disposable implements IViewModel {
     private readonly languageConfigurationService;
     private readonly _themeService;
@@ -57,6 +58,7 @@ export declare class ViewModel extends Disposable implements IViewModel {
     private _registerModelEvents;
     private readonly hiddenAreasModel;
     private previousHiddenAreas;
+    getFontSizeAtPosition(position: IPosition): string | null;
     setHiddenAreas(ranges: Range[], source?: unknown, forceUpdate?: boolean): void;
     getVisibleRangesPlusViewportAboveBelow(): Range[];
     getVisibleRanges(): Range[];
@@ -119,7 +121,7 @@ export declare class ViewModel extends Disposable implements IViewModel {
     saveCursorState(): ICursorState[];
     restoreCursorState(states: ICursorState[]): void;
     private _executeCursorEdit;
-    executeEdits(source: string | null | undefined, edits: IIdentifiedSingleEditOperation[], cursorStateComputer: ICursorStateComputer): void;
+    executeEdits(source: string | null | undefined, edits: IIdentifiedSingleEditOperation[], cursorStateComputer: ICursorStateComputer, reason: TextModelEditReason): void;
     startComposition(): void;
     endComposition(source?: string | null | undefined): void;
     type(text: string, source?: string | null | undefined): void;