@codingame/monaco-vscode-api 16.1.0 → 17.0.0

package/vscode/src/vs/editor/common/config/editorOptions.d.ts

@@ -74,6 +74,7 @@ export interface IEnvironmentalOptions {
     readonly inputMode: "insert" | "overtype";
     readonly accessibilitySupport: AccessibilitySupport;
     readonly glyphMarginDecorationLaneCount: number;
+    readonly editContextSupported: boolean;
 }
 export declare class ComputeOptionsMemory {
     stableMinimapLayoutInput: IMinimapLayoutInput | null;
@@ -721,20 +722,20 @@ export declare enum EditorOption {
 }
 export declare const EditorOptions: {
     acceptSuggestionOnCommitCharacter: IEditorOption<EditorOption.acceptSuggestionOnCommitCharacter, boolean>;
-    acceptSuggestionOnEnter: IEditorOption<EditorOption.acceptSuggestionOnEnter, "off" | "on" | "smart">;
+    acceptSuggestionOnEnter: IEditorOption<EditorOption.acceptSuggestionOnEnter, "on" | "off" | "smart">;
     accessibilitySupport: IEditorOption<EditorOption.accessibilitySupport, AccessibilitySupport>;
     accessibilityPageSize: IEditorOption<EditorOption.accessibilityPageSize, number>;
     ariaLabel: IEditorOption<EditorOption.ariaLabel, string>;
     ariaRequired: IEditorOption<EditorOption.ariaRequired, boolean>;
     screenReaderAnnounceInlineSuggestion: IEditorOption<EditorOption.screenReaderAnnounceInlineSuggestion, boolean>;
-    autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, "always" | "never" | "languageDefined" | "beforeWhitespace">;
-    autoClosingComments: IEditorOption<EditorOption.autoClosingComments, "always" | "never" | "languageDefined" | "beforeWhitespace">;
+    autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, "always" | "languageDefined" | "beforeWhitespace" | "never">;
+    autoClosingComments: IEditorOption<EditorOption.autoClosingComments, "always" | "languageDefined" | "beforeWhitespace" | "never">;
     autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, "auto" | "always" | "never">;
     autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, "auto" | "always" | "never">;
-    autoClosingQuotes: IEditorOption<EditorOption.autoClosingQuotes, "always" | "never" | "languageDefined" | "beforeWhitespace">;
+    autoClosingQuotes: IEditorOption<EditorOption.autoClosingQuotes, "always" | "languageDefined" | "beforeWhitespace" | "never">;
     autoIndent: IEditorOption<EditorOption.autoIndent, EditorAutoIndentStrategy>;
     automaticLayout: IEditorOption<EditorOption.automaticLayout, boolean>;
-    autoSurround: IEditorOption<EditorOption.autoSurround, "quotes" | "never" | "languageDefined" | "brackets">;
+    autoSurround: IEditorOption<EditorOption.autoSurround, "quotes" | "languageDefined" | "never" | "brackets">;
     bracketPairColorization: IEditorOption<EditorOption.bracketPairColorization, Readonly<Required<IBracketPairColorizationOptions>>>;
     bracketPairGuides: IEditorOption<EditorOption.guides, Readonly<Required<IGuidesOptions>>>;
     stickyTabStops: IEditorOption<EditorOption.stickyTabStops, boolean>;
@@ -742,14 +743,14 @@ export declare const EditorOptions: {
     codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
     codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
     colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
-    colorDecoratorActivatedOn: IEditorOption<EditorOption.colorDecoratorsActivatedOn, "click" | "clickAndHover" | "hover">;
+    colorDecoratorActivatedOn: IEditorOption<EditorOption.colorDecoratorsActivatedOn, "click" | "hover" | "clickAndHover">;
     colorDecoratorsLimit: IEditorOption<EditorOption.colorDecoratorsLimit, number>;
     columnSelection: IEditorOption<EditorOption.columnSelection, boolean>;
     comments: IEditorOption<EditorOption.comments, Readonly<Required<IEditorCommentsOptions>>>;
     contextmenu: IEditorOption<EditorOption.contextmenu, boolean>;
     copyWithSyntaxHighlighting: IEditorOption<EditorOption.copyWithSyntaxHighlighting, boolean>;
     cursorBlinking: IEditorOption<EditorOption.cursorBlinking, TextEditorCursorBlinkingStyle>;
-    cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, "explicit" | "off" | "on">;
+    cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, "on" | "off" | "explicit">;
     cursorStyle: IEditorOption<EditorOption.cursorStyle, TextEditorCursorStyle>;
     overtypeCursorStyle: IEditorOption<EditorOption.overtypeCursorStyle, TextEditorCursorStyle>;
     cursorSurroundingLines: IEditorOption<EditorOption.cursorSurroundingLines, number>;
@@ -763,8 +764,8 @@ export declare const EditorOptions: {
     dropIntoEditor: IEditorOption<EditorOption.dropIntoEditor, Readonly<Required<IDropIntoEditorOptions>>>;
     experimentalEditContextEnabled: IEditorOption<EditorOption.experimentalEditContextEnabled, boolean>;
     stickyScroll: IEditorOption<EditorOption.stickyScroll, Readonly<Required<IEditorStickyScrollOptions>>>;
-    experimentalGpuAcceleration: IEditorOption<EditorOption.experimentalGpuAcceleration, "off" | "on">;
-    experimentalWhitespaceRendering: IEditorOption<EditorOption.experimentalWhitespaceRendering, "font" | "svg" | "off">;
+    experimentalGpuAcceleration: IEditorOption<EditorOption.experimentalGpuAcceleration, "on" | "off">;
+    experimentalWhitespaceRendering: IEditorOption<EditorOption.experimentalWhitespaceRendering, "svg" | "font" | "off">;
     extraEditorClassName: IEditorOption<EditorOption.extraEditorClassName, string>;
     fastScrollSensitivity: IEditorOption<EditorOption.fastScrollSensitivity, number>;
     find: IEditorOption<EditorOption.find, Readonly<Required<IEditorFindOptions>>>;
@@ -798,12 +799,12 @@ export declare const EditorOptions: {
     links: IEditorOption<EditorOption.links, boolean>;
     matchBrackets: IEditorOption<EditorOption.matchBrackets, "always" | "never" | "near">;
     minimap: IEditorOption<EditorOption.minimap, Readonly<Required<IEditorMinimapOptions>>>;
-    mouseStyle: IEditorOption<EditorOption.mouseStyle, "default" | "copy" | "text">;
+    mouseStyle: IEditorOption<EditorOption.mouseStyle, "text" | "copy" | "default">;
     mouseWheelScrollSensitivity: IEditorOption<EditorOption.mouseWheelScrollSensitivity, number>;
     mouseWheelZoom: IEditorOption<EditorOption.mouseWheelZoom, boolean>;
     multiCursorMergeOverlapping: IEditorOption<EditorOption.multiCursorMergeOverlapping, boolean>;
-    multiCursorModifier: IEditorOption<EditorOption.multiCursorModifier, "altKey" | "ctrlKey" | "metaKey">;
-    multiCursorPaste: IEditorOption<EditorOption.multiCursorPaste, "full" | "spread">;
+    multiCursorModifier: IEditorOption<EditorOption.multiCursorModifier, "ctrlKey" | "altKey" | "metaKey">;
+    multiCursorPaste: IEditorOption<EditorOption.multiCursorPaste, "spread" | "full">;
     multiCursorLimit: IEditorOption<EditorOption.multiCursorLimit, number>;
     occurrencesHighlight: IEditorOption<EditorOption.occurrencesHighlight, "off" | "singleFile" | "multiFile">;
     occurrencesHighlightDelay: IEditorOption<EditorOption.occurrencesHighlightDelay, number>;
@@ -822,11 +823,11 @@ export declare const EditorOptions: {
     readOnlyMessage: IEditorOption<EditorOption.readOnlyMessage, IMarkdownString | undefined>;
     renameOnType: IEditorOption<EditorOption.renameOnType, boolean>;
     renderControlCharacters: IEditorOption<EditorOption.renderControlCharacters, boolean>;
-    renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, "off" | "on" | "dimmed">;
-    renderLineHighlight: IEditorOption<EditorOption.renderLineHighlight, "all" | "none" | "line" | "gutter">;
+    renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, "on" | "off" | "dimmed">;
+    renderLineHighlight: IEditorOption<EditorOption.renderLineHighlight, "line" | "all" | "none" | "gutter">;
     renderLineHighlightOnlyWhenFocus: IEditorOption<EditorOption.renderLineHighlightOnlyWhenFocus, boolean>;
-    renderValidationDecorations: IEditorOption<EditorOption.renderValidationDecorations, "off" | "on" | "editable">;
-    renderWhitespace: IEditorOption<EditorOption.renderWhitespace, "all" | "none" | "boundary" | "selection" | "trailing">;
+    renderValidationDecorations: IEditorOption<EditorOption.renderValidationDecorations, "on" | "off" | "editable">;
+    renderWhitespace: IEditorOption<EditorOption.renderWhitespace, "all" | "none" | "selection" | "boundary" | "trailing">;
     revealHorizontalRightPadding: IEditorOption<EditorOption.revealHorizontalRightPadding, number>;
     roundedSelection: IEditorOption<EditorOption.roundedSelection, boolean>;
     rulers: IEditorOption<EditorOption.rulers, IRulerOption[]>;
@@ -841,7 +842,7 @@ export declare const EditorOptions: {
     showUnused: IEditorOption<EditorOption.showUnused, boolean>;
     showDeprecated: IEditorOption<EditorOption.showDeprecated, boolean>;
     inlayHints: IEditorOption<EditorOption.inlayHints, Readonly<Required<IEditorInlayHintsOptions>>>;
-    snippetSuggestions: IEditorOption<EditorOption.snippetSuggestions, "inline" | "none" | "top" | "bottom">;
+    snippetSuggestions: IEditorOption<EditorOption.snippetSuggestions, "top" | "bottom" | "none" | "inline">;
     smartSelect: IEditorOption<EditorOption.smartSelect, Readonly<Required<ISmartSelectOptions>>>;
     smoothScrolling: IEditorOption<EditorOption.smoothScrolling, boolean>;
     stopRenderingLineAfter: IEditorOption<EditorOption.stopRenderingLineAfter, number>;
@@ -852,21 +853,21 @@ export declare const EditorOptions: {
     suggestLineHeight: IEditorOption<EditorOption.suggestLineHeight, number>;
     suggestOnTriggerCharacters: IEditorOption<EditorOption.suggestOnTriggerCharacters, boolean>;
     suggestSelection: IEditorOption<EditorOption.suggestSelection, "first" | "recentlyUsed" | "recentlyUsedByPrefix">;
-    tabCompletion: IEditorOption<EditorOption.tabCompletion, "off" | "on" | "onlySnippets">;
+    tabCompletion: IEditorOption<EditorOption.tabCompletion, "on" | "off" | "onlySnippets">;
     tabIndex: IEditorOption<EditorOption.tabIndex, number>;
     unicodeHighlight: IEditorOption<EditorOption.unicodeHighlighting, Required<Readonly<IUnicodeHighlightOptions>>>;
-    unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, "auto" | "off" | "prompt">;
+    unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, "prompt" | "auto" | "off">;
     useShadowDOM: IEditorOption<EditorOption.useShadowDOM, boolean>;
     useTabStops: IEditorOption<EditorOption.useTabStops, boolean>;
     wordBreak: IEditorOption<EditorOption.wordBreak, "normal" | "keepAll">;
     wordSegmenterLocales: IEditorOption<EditorOption.wordSegmenterLocales, string[]>;
     wordSeparators: IEditorOption<EditorOption.wordSeparators, string>;
-    wordWrap: IEditorOption<EditorOption.wordWrap, "off" | "on" | "wordWrapColumn" | "bounded">;
+    wordWrap: IEditorOption<EditorOption.wordWrap, "on" | "off" | "wordWrapColumn" | "bounded">;
     wordWrapBreakAfterCharacters: IEditorOption<EditorOption.wordWrapBreakAfterCharacters, string>;
     wordWrapBreakBeforeCharacters: IEditorOption<EditorOption.wordWrapBreakBeforeCharacters, string>;
     wordWrapColumn: IEditorOption<EditorOption.wordWrapColumn, number>;
-    wordWrapOverride1: IEditorOption<EditorOption.wordWrapOverride1, "inherit" | "off" | "on">;
-    wordWrapOverride2: IEditorOption<EditorOption.wordWrapOverride2, "inherit" | "off" | "on">;
+    wordWrapOverride1: IEditorOption<EditorOption.wordWrapOverride1, "on" | "inherit" | "off">;
+    wordWrapOverride2: IEditorOption<EditorOption.wordWrapOverride2, "on" | "inherit" | "off">;
     effectiveCursorStyle: IEditorOption<EditorOption.effectiveCursorStyle, TextEditorCursorStyle>;
     editorClassName: IEditorOption<EditorOption.editorClassName, string>;
     defaultColorDecorators: IEditorOption<EditorOption.defaultColorDecorators, "auto" | "always" | "never">;
@@ -875,7 +876,7 @@ export declare const EditorOptions: {
     layoutInfo: IEditorOption<EditorOption.layoutInfo, EditorLayoutInfo>;
     wrappingInfo: IEditorOption<EditorOption.wrappingInfo, EditorWrappingInfo>;
     wrappingIndent: IEditorOption<EditorOption.wrappingIndent, WrappingIndent>;
-    wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, "advanced" | "simple">;
+    wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, "simple" | "advanced">;
     effectiveExperimentalEditContextEnabled: IEditorOption<EditorOption.effectiveExperimentalEditContextEnabled, boolean>;
 };
 type EditorOptionsType = typeof EditorOptions;

package/vscode/src/vs/editor/common/config/editorOptions.js

@@ -8,7 +8,7 @@ import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
 import { USUAL_WORD_SEPARATORS } from '../core/wordHelper.js';
 import { localize } from '../../../nls.js';
 import { AccessibilitySupport } from '../../../platform/accessibility/common/accessibility.js';
-import product$1 from '../../../platform/product/common/product.js';
+import product from '../../../platform/product/common/product.js';
 
 var EditorAutoIndentStrategy;
 (function (EditorAutoIndentStrategy) {
@@ -667,8 +667,7 @@ class EffectiveExperimentalEditContextEnabled extends ComputedEditorOption {
         super(EditorOption.effectiveExperimentalEditContextEnabled);
     }
     compute(env, options) {
-        const editContextSupported = typeof globalThis.EditContext === 'function';
-        return editContextSupported && options.get(EditorOption.experimentalEditContextEnabled);
+        return env.editContextSupported && options.get(EditorOption.experimentalEditContextEnabled);
     }
 }
 class EditorFontSize extends SimpleEditorOption {
@@ -3560,7 +3559,7 @@ const EditorOptions = {
     experimentalEditContextEnabled: register(( new EditorBooleanOption(
         EditorOption.experimentalEditContextEnabled,
         'experimentalEditContextEnabled',
-        product$1.quality !== 'stable',
+        product.quality !== 'stable',
         {
             description: ( localize(
                 537,

package/vscode/src/vs/editor/common/core/columnRange.d.ts

@@ -0,0 +1,11 @@
+import { OffsetRange } from "./offsetRange.js";
+import { Range } from "./range.js";
+export declare class ColumnRange {
+    readonly startColumn: number;
+    readonly endColumnExclusive: number;
+    static fromOffsetRange(offsetRange: OffsetRange): ColumnRange;
+    constructor(startColumn: number, endColumnExclusive: number);
+    toRange(lineNumber: number): Range;
+    equals(other: ColumnRange): boolean;
+    toZeroBasedOffsetRange(): OffsetRange;
+}

package/vscode/src/vs/editor/common/core/columnRange.js

@@ -0,0 +1,32 @@
+
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { OffsetRange } from './offsetRange.js';
+import { Range } from './range.js';
+
+class ColumnRange {
+    static fromOffsetRange(offsetRange) {
+        return ( new ColumnRange(offsetRange.start + 1, offsetRange.endExclusive + 1));
+    }
+    constructor(
+    startColumn, endColumnExclusive) {
+        this.startColumn = startColumn;
+        this.endColumnExclusive = endColumnExclusive;
+        if (startColumn > endColumnExclusive) {
+            throw ( new BugIndicatingError(
+                `startColumn ${startColumn} cannot be after endColumnExclusive ${endColumnExclusive}`
+            ));
+        }
+    }
+    toRange(lineNumber) {
+        return ( new Range(lineNumber, this.startColumn, lineNumber, this.endColumnExclusive));
+    }
+    equals(other) {
+        return this.startColumn === other.startColumn
+            && this.endColumnExclusive === other.endColumnExclusive;
+    }
+    toZeroBasedOffsetRange() {
+        return ( new OffsetRange(this.startColumn - 1, this.endColumnExclusive - 1));
+    }
+}
+
+export { ColumnRange };

package/vscode/src/vs/editor/common/core/offsetEdit.d.ts

@@ -1,6 +1,7 @@
 import { OffsetRange } from "./offsetRange.js";
 export declare class OffsetEdit {
     readonly edits: readonly SingleOffsetEdit[];
+    static join(edits: readonly OffsetEdit[]): OffsetEdit;
     static readonly empty: OffsetEdit;
     static fromJson(data: IOffsetEdit): OffsetEdit;
     static replace(range: OffsetRange, newText: string): OffsetEdit;

package/vscode/src/vs/editor/common/core/offsetEdit.js

@@ -3,6 +3,16 @@ import { BugIndicatingError } from '../../../base/common/errors.js';
 import { OffsetRange } from './offsetRange.js';
 
 class OffsetEdit {
+    static join(edits) {
+        if (edits.length === 0) {
+            return OffsetEdit.empty;
+        }
+        let result = edits[0];
+        for (let i = 1; i < edits.length; i++) {
+            result = result.compose(edits[i]);
+        }
+        return result;
+    }
     static { this.empty = ( new OffsetEdit([])); }
     static fromJson(data) {
         return ( new OffsetEdit(( data.map(SingleOffsetEdit.fromJson))));

package/vscode/src/vs/editor/common/core/offsetRange.d.ts

@@ -37,6 +37,7 @@ export declare class OffsetRange implements IOffsetRange {
 }
 export declare class OffsetRangeSet {
     private readonly _sortedRanges;
+    get ranges(): OffsetRange[];
     addRange(range: OffsetRange): void;
     toString(): string;
     intersectsStrict(other: OffsetRange): boolean;

package/vscode/src/vs/editor/common/core/offsetRange.js

@@ -148,6 +148,9 @@ class OffsetRangeSet {
     constructor() {
         this._sortedRanges = [];
     }
+    get ranges() {
+        return [...this._sortedRanges];
+    }
     addRange(range) {
         let i = 0;
         while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) {

package/vscode/src/vs/editor/common/core/positionToOffset.d.ts

@@ -1,18 +1,30 @@
+import { ITextModel } from "../model.js";
+import { OffsetEdit, SingleOffsetEdit } from "./offsetEdit.js";
 import { OffsetRange } from "./offsetRange.js";
 import { Position } from "./position.js";
 import { Range } from "./range.js";
+import { SingleTextEdit, TextEdit } from "./textEdit.js";
 import { TextLength } from "./textLength.js";
-export declare class PositionOffsetTransformer {
+export declare abstract class PositionOffsetTransformerBase {
+    abstract getOffset(position: Position): number;
+    getOffsetRange(range: Range): OffsetRange;
+    abstract getPosition(offset: number): Position;
+    getRange(offsetRange: OffsetRange): Range;
+    getOffsetEdit(edit: TextEdit): OffsetEdit;
+    getSingleOffsetEdit(edit: SingleTextEdit): SingleOffsetEdit;
+    getSingleTextEdit(edit: SingleOffsetEdit): SingleTextEdit;
+    getTextEdit(edit: OffsetEdit): TextEdit;
+}
+export declare class PositionOffsetTransformer extends PositionOffsetTransformerBase {
     readonly text: string;
     private readonly lineStartOffsetByLineIdx;
     private readonly lineEndOffsetByLineIdx;
     constructor(text: string);
     getOffset(position: Position): number;
     private _validatePosition;
-    getOffsetRange(range: Range): OffsetRange;
     getPosition(offset: number): Position;
-    getRange(offsetRange: OffsetRange): Range;
     getTextLength(offsetRange: OffsetRange): TextLength;
     get textLength(): TextLength;
     getLineLength(lineNumber: number): number;
 }
+export declare function getPositionOffsetTransformerFromTextModel(textModel: ITextModel): PositionOffsetTransformerBase;

package/vscode/src/vs/editor/common/core/positionToOffset.js

@@ -1,12 +1,40 @@
 
 import { findLastIdxMonotonous } from '../../../base/common/arraysFind.js';
+import { OffsetEdit, SingleOffsetEdit } from './offsetEdit.js';
 import { OffsetRange } from './offsetRange.js';
 import { Position } from './position.js';
 import { Range } from './range.js';
+import { SingleTextEdit, TextEdit } from './textEdit.js';
 import { TextLength } from './textLength.js';
 
-class PositionOffsetTransformer {
+class PositionOffsetTransformerBase {
+    getOffsetRange(range) {
+        return ( new OffsetRange(
+            this.getOffset(range.getStartPosition()),
+            this.getOffset(range.getEndPosition())
+        ));
+    }
+    getRange(offsetRange) {
+        return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
+    }
+    getOffsetEdit(edit) {
+        const edits = ( edit.edits.map(e => this.getSingleOffsetEdit(e)));
+        return ( new OffsetEdit(edits));
+    }
+    getSingleOffsetEdit(edit) {
+        return ( new SingleOffsetEdit(this.getOffsetRange(edit.range), edit.text));
+    }
+    getSingleTextEdit(edit) {
+        return ( new SingleTextEdit(this.getRange(edit.replaceRange), edit.newText));
+    }
+    getTextEdit(edit) {
+        const edits = ( edit.edits.map(e => this.getSingleTextEdit(e)));
+        return ( new TextEdit(edits));
+    }
+}
+class PositionOffsetTransformer extends PositionOffsetTransformerBase {
     constructor(text) {
+        super();
         this.text = text;
         this.lineStartOffsetByLineIdx = [];
         this.lineEndOffsetByLineIdx = [];
@@ -46,21 +74,12 @@ class PositionOffsetTransformer {
         }
         return position;
     }
-    getOffsetRange(range) {
-        return ( new OffsetRange(
-            this.getOffset(range.getStartPosition()),
-            this.getOffset(range.getEndPosition())
-        ));
-    }
     getPosition(offset) {
         const idx = findLastIdxMonotonous(this.lineStartOffsetByLineIdx, i => i <= offset);
         const lineNumber = idx + 1;
         const column = offset - this.lineStartOffsetByLineIdx[idx] + 1;
         return ( new Position(lineNumber, column));
     }
-    getRange(offsetRange) {
-        return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
-    }
     getTextLength(offsetRange) {
         return TextLength.ofRange(this.getRange(offsetRange));
     }
@@ -72,5 +91,20 @@ class PositionOffsetTransformer {
         return this.lineEndOffsetByLineIdx[lineNumber - 1] - this.lineStartOffsetByLineIdx[lineNumber - 1];
     }
 }
+function getPositionOffsetTransformerFromTextModel(textModel) {
+    return ( new PositionOffsetTransformerWithTextModel(textModel));
+}
+class PositionOffsetTransformerWithTextModel extends PositionOffsetTransformerBase {
+    constructor(_textModel) {
+        super();
+        this._textModel = _textModel;
+    }
+    getOffset(position) {
+        return this._textModel.getOffsetAt(position);
+    }
+    getPosition(offset) {
+        return this._textModel.getPositionAt(offset);
+    }
+}
 
-export { PositionOffsetTransformer };
+export { PositionOffsetTransformer, PositionOffsetTransformerBase, getPositionOffsetTransformerFromTextModel };

package/vscode/src/vs/editor/common/core/rangeSingleLine.d.ts

@@ -0,0 +1,9 @@
+import { ColumnRange } from "./columnRange.js";
+import { Range } from "./range.js";
+export declare class RangeSingleLine {
+    readonly lineNumber: number;
+    readonly columnRange: ColumnRange;
+    static fromRange(range: Range): RangeSingleLine | undefined;
+    constructor(lineNumber: number, columnRange: ColumnRange);
+    toRange(): Range;
+}

package/vscode/src/vs/editor/common/core/rangeSingleLine.js

@@ -0,0 +1,27 @@
+
+import { ColumnRange } from './columnRange.js';
+import { Range } from './range.js';
+
+class RangeSingleLine {
+    static fromRange(range) {
+        if (range.endLineNumber !== range.startLineNumber) {
+            return undefined;
+        }
+        return ( new RangeSingleLine(range.startLineNumber, ( new ColumnRange(range.startColumn, range.endColumn))));
+    }
+    constructor(
+    lineNumber, columnRange) {
+        this.lineNumber = lineNumber;
+        this.columnRange = columnRange;
+    }
+    toRange() {
+        return ( new Range(
+            this.lineNumber,
+            this.columnRange.startColumn,
+            this.lineNumber,
+            this.columnRange.endColumnExclusive
+        ));
+    }
+}
+
+export { RangeSingleLine };

package/vscode/src/vs/editor/common/core/textEdit.d.ts

@@ -22,6 +22,7 @@ export declare class TextEdit {
     getNewRanges(): Range[];
     toSingle(text: AbstractText): SingleTextEdit;
     equals(other: TextEdit): boolean;
+    toString(text: AbstractText | string | undefined): string;
 }
 export declare class SingleTextEdit {
     readonly range: Range;

package/vscode/src/vs/editor/common/core/textEdit.js

@@ -168,6 +168,47 @@ class TextEdit {
     equals(other) {
         return equals(this.edits, other.edits, (a, b) => a.equals(b));
     }
+    toString(text) {
+        if (text === undefined) {
+            return ( this.edits.map(edit => ( edit.toString()))).join('\n');
+        }
+        if (typeof text === 'string') {
+            return ( this.toString(( new StringText(text))));
+        }
+        if (this.edits.length === 0) {
+            return '';
+        }
+        return ( this.edits.map(edit => {
+            const maxLength = 10;
+            const originalText = text.getValueOfRange(edit.range);
+            const beforeRange = Range.fromPositions(( new Position(Math.max(1, edit.range.startLineNumber - 1), 1)), edit.range.getStartPosition());
+            let beforeText = text.getValueOfRange(beforeRange);
+            if (beforeText.length > maxLength) {
+                beforeText = '...' + beforeText.substring(beforeText.length - maxLength);
+            }
+            const afterRange = Range.fromPositions(edit.range.getEndPosition(), ( new Position(edit.range.endLineNumber + 1, 1)));
+            let afterText = text.getValueOfRange(afterRange);
+            if (afterText.length > maxLength) {
+                afterText = afterText.substring(0, maxLength) + '...';
+            }
+            let replacedText = originalText;
+            if (replacedText.length > maxLength) {
+                const halfMax = Math.floor(maxLength / 2);
+                replacedText = replacedText.substring(0, halfMax) + '...' +
+                    replacedText.substring(replacedText.length - halfMax);
+            }
+            let newText = edit.text;
+            if (newText.length > maxLength) {
+                const halfMax = Math.floor(maxLength / 2);
+                newText = newText.substring(0, halfMax) + '...' +
+                    newText.substring(newText.length - halfMax);
+            }
+            if (replacedText.length === 0) {
+                return `${beforeText}❰${newText}❱${afterText}`;
+            }
+            return `${beforeText}❰${replacedText}↦${newText}❱${afterText}`;
+        })).join('\n');
+    }
 }
 class SingleTextEdit {
     static joinEdits(edits, initialValue) {

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

@@ -144,6 +144,7 @@ export interface IThemeDecorationRenderOptions {
     fontStyle?: string;
     fontWeight?: string;
     fontSize?: string;
+    lineHeight?: number;
     textDecoration?: string;
     cursor?: string;
     color?: string | ThemeColor;

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

@@ -1,10 +1,10 @@
 import { Event } from "../../../base/common/event.js";
 import { ILanguageExtensionPoint } from "./language.js";
-import { IDisposable } from "../../../base/common/lifecycle.js";
+import { Disposable, IDisposable } from "../../../base/common/lifecycle.js";
 export declare const Extensions: {
     ModesRegistry: string;
 };
-export declare class EditorModesRegistry {
+export declare class EditorModesRegistry extends Disposable {
     private readonly _languages;
     private readonly _onDidChangeLanguages;
     readonly onDidChangeLanguages: Event<void>;

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

@@ -2,15 +2,17 @@
 import { localize } from '../../../nls.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Registry } from '../../../platform/registry/common/platform.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
 import { Mimes } from '../../../base/common/mime.js';
 import { Extensions as Extensions$1 } from '../../../platform/configuration/common/configurationRegistry.js';
 
 const Extensions = {
     ModesRegistry: 'editor.modesRegistry'
 };
-class EditorModesRegistry {
+class EditorModesRegistry extends Disposable {
     constructor() {
-        this._onDidChangeLanguages = ( new Emitter());
+        super();
+        this._onDidChangeLanguages = this._register(( new Emitter()));
         this.onDidChangeLanguages = this._onDidChangeLanguages.event;
         this._languages = [];
     }

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

@@ -291,11 +291,16 @@ export interface InlineCompletion {
     readonly showInlineEditMenu?: boolean;
     readonly showRange?: IRange;
     readonly warning?: InlineCompletionWarning;
+    readonly displayLocation?: InlineCompletionDisplayLocation;
 }
 export interface InlineCompletionWarning {
     message: IMarkdownString | string;
     icon?: IconPath;
 }
+export interface InlineCompletionDisplayLocation {
+    range: IRange;
+    label: string;
+}
 export type IconPath = ThemeIcon;
 export interface InlineCompletions<TItem extends InlineCompletion = InlineCompletion> {
     readonly items: readonly TItem[];
@@ -310,13 +315,29 @@ export interface InlineCompletionsProvider<T extends InlineCompletions = InlineC
     handleItemDidShow?(completions: T, item: T["items"][number], updatedInsertText: string): void;
     handlePartialAccept?(completions: T, item: T["items"][number], acceptedCharacters: number, info: PartialAcceptInfo): void;
     handleRejection?(completions: T, item: T["items"][number]): void;
+    handleEndOfLifetime?(completions: T, item: T["items"][number], reason: InlineCompletionEndOfLifeReason<T["items"][number]>): void;
     freeInlineCompletions(completions: T): void;
+    onDidChangeInlineCompletions?: Event<void>;
     groupId?: InlineCompletionProviderGroupId;
     yieldsToGroupIds?: InlineCompletionProviderGroupId[];
     displayName?: string;
     debounceDelayMs?: number;
     toString?(): string;
 }
+export declare enum InlineCompletionEndOfLifeReasonKind {
+    Accepted = 0,
+    Rejected = 1,
+    Ignored = 2
+}
+export type InlineCompletionEndOfLifeReason<TInlineCompletion = InlineCompletion> = {
+    kind: InlineCompletionEndOfLifeReasonKind.Accepted;
+} | {
+    kind: InlineCompletionEndOfLifeReasonKind.Rejected;
+} | {
+    kind: InlineCompletionEndOfLifeReasonKind.Ignored;
+    supersededBy?: TInlineCompletion;
+    userTypingDisagreed: boolean;
+};
 export interface CodeAction {
     title: string;
     command?: Command;
@@ -759,7 +780,7 @@ export interface CommentThread<T = IRange> {
     onDidChangeInitialCollapsibleState: Event<CommentThreadCollapsibleState | undefined>;
     state?: CommentThreadState;
     applicability?: CommentThreadApplicability;
-    canReply: boolean;
+    canReply: boolean | CommentAuthorInformation;
     input?: CommentInput;
     onDidChangeInput: Event<CommentInput | undefined>;
     onDidChangeLabel: Event<string | undefined>;

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

@@ -224,6 +224,12 @@ class SelectedSuggestionInfo {
             && this.isSnippetText === other.isSnippetText;
     }
 }
+var InlineCompletionEndOfLifeReasonKind;
+(function (InlineCompletionEndOfLifeReasonKind) {
+    InlineCompletionEndOfLifeReasonKind[InlineCompletionEndOfLifeReasonKind["Accepted"] = 0] = "Accepted";
+    InlineCompletionEndOfLifeReasonKind[InlineCompletionEndOfLifeReasonKind["Rejected"] = 1] = "Rejected";
+    InlineCompletionEndOfLifeReasonKind[InlineCompletionEndOfLifeReasonKind["Ignored"] = 2] = "Ignored";
+})(InlineCompletionEndOfLifeReasonKind || (InlineCompletionEndOfLifeReasonKind = {}));
 var CodeActionTriggerType;
 (function (CodeActionTriggerType) {
     CodeActionTriggerType[CodeActionTriggerType["Invoke"] = 1] = "Invoke";
@@ -507,4 +513,4 @@ var InlineEditTriggerKind;
     InlineEditTriggerKind[InlineEditTriggerKind["Automatic"] = 1] = "Automatic";
 })(InlineEditTriggerKind || (InlineEditTriggerKind = {}));
 
-export { CodeActionTriggerType, Command, CommentMode, CommentState, CommentThreadApplicability, CommentThreadCollapsibleState, CommentThreadState, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemKinds, CompletionItemTag, CompletionTriggerKind, DocumentHighlightKind, DocumentPasteTriggerKind, EncodedTokenizationResult, ExternalUriOpenerPriority, FoldingRangeKind, HoverVerbosityAction, InlayHintKind, InlineCompletionTriggerKind, InlineEditTriggerKind, LazyTokenizationSupport, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, SelectedSuggestionInfo, SignatureHelpTriggerKind, SymbolKind, SymbolKinds, SymbolTag, TextEdit, Token, TokenizationRegistry, TokenizationResult, TreeSitterTokenizationRegistry, getAriaLabelForSymbol, isLocation, isLocationLink, symbolKindNames };
+export { CodeActionTriggerType, Command, CommentMode, CommentState, CommentThreadApplicability, CommentThreadCollapsibleState, CommentThreadState, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemKinds, CompletionItemTag, CompletionTriggerKind, DocumentHighlightKind, DocumentPasteTriggerKind, EncodedTokenizationResult, ExternalUriOpenerPriority, FoldingRangeKind, HoverVerbosityAction, InlayHintKind, InlineCompletionEndOfLifeReasonKind, InlineCompletionTriggerKind, InlineEditTriggerKind, LazyTokenizationSupport, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, SelectedSuggestionInfo, SignatureHelpTriggerKind, SymbolKind, SymbolKinds, SymbolTag, TextEdit, Token, TokenizationRegistry, TokenizationResult, TreeSitterTokenizationRegistry, getAriaLabelForSymbol, isLocation, isLocationLink, symbolKindNames };

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

@@ -16,7 +16,7 @@ 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 } from "../textModelEvents.js";
+import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelOptionsChangedEvent, InternalModelContentChangeEvent, ModelInjectedTextChangedEvent, ModelLineHeightChangedEvent } from "../textModelEvents.js";
 import { IGuidesTextModelPart } from "../textModelGuides.js";
 import { ITokenizationTextModelPart } from "../tokenizationTextModelPart.js";
 import { IInstantiationService } from "../../../platform/instantiation/common/instantiation.js";
@@ -61,6 +61,8 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     private readonly _onDidChangeAttached;
     readonly onDidChangeAttached: Event<void>;
     private readonly _onDidChangeInjectedText;
+    private readonly _onDidChangeLineHeight;
+    readonly onDidChangeLineHeight: Event<ModelLineHeightChangedEvent>;
     private readonly _eventEmitter;
     onDidChangeContent(listener: (e: IModelContentChangedEvent) => void): IDisposable;
     onDidChangeContentOrInjectedText(listener: (e: InternalModelContentChangeEvent | ModelInjectedTextChangedEvent) => void): IDisposable;
@@ -201,6 +203,7 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): model.IModelDecoration[];
     getOverviewRulerDecorations(ownerId?: number, filterOutValidation?: boolean): model.IModelDecoration[];
     getInjectedTextDecorations(ownerId?: number): model.IModelDecoration[];
+    getCustomLineHeightsDecorations(ownerId?: number): model.IModelDecoration[];
     private _getInjectedTextInLine;
     getAllDecorations(ownerId?: number, filterOutValidation?: boolean): model.IModelDecoration[];
     getAllMarginDecorations(ownerId?: number): model.IModelDecoration[];
@@ -283,6 +286,7 @@ export declare class ModelDecorationOptions implements model.IModelDecorationOpt
     readonly hoverMessage: IMarkdownString | IMarkdownString[] | null;
     readonly glyphMarginHoverMessage: IMarkdownString | IMarkdownString[] | null;
     readonly isWholeLine: boolean;
+    readonly lineHeight: number | null;
     readonly showIfCollapsed: boolean;
     readonly collapseOnReplaceEdit: boolean;
     readonly overviewRuler: ModelDecorationOverviewRulerOptions | null;