@codingame/monaco-vscode-api 13.1.7 → 14.0.1

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/gutterIndicatorView.js

@@ -0,0 +1,259 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { renderIcon } from '../../../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../../../../base/common/lifecycle.js';
+import { observableValue } from '../../../../../../base/common/observableInternal/base.js';
+import '../../../../../../base/common/arrays.js';
+import '../../../../../../base/common/event.js';
+import { autorun } from '../../../../../../base/common/observableInternal/autorun.js';
+import { derived } from '../../../../../../base/common/observableInternal/derived.js';
+import '../../../../../../base/common/cancellation.js';
+import { observableFromEvent, constObservable } from '../../../../../../base/common/observableInternal/utils.js';
+import { IHoverService } from '../../../../../../platform/hover/browser/hover.service.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { registerColor, transparent } from '../../../../../../platform/theme/common/colorUtils.js';
+import '../../../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../../../platform/theme/common/colors/editorColors.js';
+import { buttonForeground, buttonBackground, buttonSecondaryForeground, buttonSecondaryBackground } from '../../../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../../../platform/theme/common/colors/listColors.js';
+import '../../../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../../../platform/theme/common/colors/searchColors.js';
+import { Rect } from '../../../../../browser/rect.js';
+import { EditorOption } from '../../../../../common/config/editorOptions.js';
+import { OffsetRange } from '../../../../../common/core/offsetRange.js';
+import { StickyScrollController } from '../../../../stickyScroll/browser/stickyScrollController.js';
+import { GutterIndicatorMenuContent } from './gutterIndicatorMenu.js';
+import { mapOutFalsy, n, rectToProps } from './utils.js';
+import { localize } from '../../../../../../nls.js';
+import { trackFocus } from '../../../../../../base/browser/dom.js';
+import { IAccessibilityService } from '../../../../../../platform/accessibility/common/accessibility.service.js';
+
+registerColor('inlineEdit.gutterIndicator.primaryForeground', buttonForeground, ( localize(1236, 'Foreground color for the primary inline edit gutter indicator.')));
+registerColor('inlineEdit.gutterIndicator.primaryBackground', buttonBackground, ( localize(1237, 'Background color for the primary inline edit gutter indicator.')));
+registerColor('inlineEdit.gutterIndicator.secondaryForeground', buttonSecondaryForeground, ( localize(1238, 'Foreground color for the secondary inline edit gutter indicator.')));
+registerColor('inlineEdit.gutterIndicator.secondaryBackground', buttonSecondaryBackground, ( localize(1239, 'Background color for the secondary inline edit gutter indicator.')));
+registerColor('inlineEdit.gutterIndicator.successfulForeground', buttonForeground, ( localize(1240, 'Foreground color for the successful inline edit gutter indicator.')));
+registerColor('inlineEdit.gutterIndicator.successfulBackground', { light: '#2e825c', dark: '#2e825c', hcLight: '#2e825c', hcDark: '#2e825c' }, ( localize(1241, 'Background color for the successful inline edit gutter indicator.')));
+registerColor('inlineEdit.gutterIndicator.background', {
+    hcDark: ( transparent('tab.inactiveBackground', 0.5)),
+    hcLight: ( transparent('tab.inactiveBackground', 0.5)),
+    dark: ( transparent('tab.inactiveBackground', 0.5)),
+    light: '#5f5f5f18',
+}, ( localize(1242, 'Background color for the inline edit gutter indicator.')));
+let InlineEditsGutterIndicator = class InlineEditsGutterIndicator extends Disposable {
+    constructor(_editorObs, _originalRange, _verticalOffset, _model, _isHoveringOverInlineEdit, _focusIsInMenu, _hoverService, _instantiationService, accessibilityService) {
+        super();
+        this._editorObs = _editorObs;
+        this._originalRange = _originalRange;
+        this._verticalOffset = _verticalOffset;
+        this._model = _model;
+        this._isHoveringOverInlineEdit = _isHoveringOverInlineEdit;
+        this._focusIsInMenu = _focusIsInMenu;
+        this._hoverService = _hoverService;
+        this._instantiationService = _instantiationService;
+        this._originalRangeObs = mapOutFalsy(this._originalRange);
+        this._state = derived(reader => {
+            const range = this._originalRangeObs.read(reader);
+            if (!range) {
+                return undefined;
+            }
+            return {
+                range,
+                lineOffsetRange: this._editorObs.observeLineOffsetRange(range, this._store),
+            };
+        });
+        this._stickyScrollController = StickyScrollController.get(this._editorObs.editor);
+        this._stickyScrollHeight = this._stickyScrollController
+            ? observableFromEvent(this._stickyScrollController.onDidChangeStickyScrollHeight, () => this._stickyScrollController.stickyScrollWidgetHeight)
+            : constObservable(0);
+        this._layout = derived(reader => {
+            const s = this._state.read(reader);
+            if (!s) {
+                return undefined;
+            }
+            const layout = this._editorObs.layoutInfo.read(reader);
+            const bottomPadding = 1;
+            const fullViewPort = Rect.fromLeftTopRightBottom(0, 0, layout.width, layout.height - bottomPadding);
+            const viewPortWithStickyScroll = fullViewPort.withTop(this._stickyScrollHeight.read(reader));
+            const targetVertRange = s.lineOffsetRange.read(reader);
+            const space = 1;
+            const targetRect = Rect.fromRanges(OffsetRange.fromTo(space + layout.glyphMarginLeft, layout.lineNumbersLeft + layout.lineNumbersWidth + 4), targetVertRange);
+            const lineHeight = this._editorObs.getOption(EditorOption.lineHeight).read(reader);
+            const pillOffset = this._verticalOffset.read(reader);
+            const pillRect = targetRect.withHeight(lineHeight).withWidth(22).moveDown(pillOffset);
+            const pillRectMoved = pillRect.moveToBeContainedIn(viewPortWithStickyScroll);
+            const rect = targetRect;
+            const iconRect = (targetRect.containsRect(pillRectMoved))
+                ? pillRectMoved
+                : pillRectMoved.moveToBeContainedIn(fullViewPort.intersect(targetRect.union(fullViewPort.withHeight(lineHeight))));
+            return {
+                rect,
+                iconRect,
+                arrowDirection: (targetRect.containsRect(iconRect) ? 'right'
+                    : iconRect.top > targetRect.top ? 'top' : 'bottom'),
+                docked: rect.containsRect(iconRect) && viewPortWithStickyScroll.containsRect(iconRect),
+            };
+        });
+        this._tabAction = derived(this, reader => {
+            const m = this._model.read(reader);
+            if (this._editorObs.isFocused.read(reader)) {
+                if (m && m.tabShouldJumpToInlineEdit.read(reader)) {
+                    return 'jump';
+                }
+                if (m && m.tabShouldAcceptInlineEdit.read(reader)) {
+                    return 'accept';
+                }
+            }
+            return 'inactive';
+        });
+        this._iconRef = n.ref();
+        this._hoverVisible = false;
+        this._isHoveredOverIcon = observableValue(this, false);
+        this._indicator = n.div({
+            class: 'inline-edits-view-gutter-indicator',
+            onclick: () => {
+                const model = this._model.get();
+                if (!model) {
+                    return;
+                }
+                const docked = ( this._layout.map(l => l && l.docked)).get();
+                this._editorObs.editor.focus();
+                if (docked) {
+                    model.accept();
+                }
+                else {
+                    model.jump();
+                }
+            },
+            tabIndex: 0,
+            style: {
+                position: 'absolute',
+                overflow: 'visible',
+            },
+        }, ( mapOutFalsy(this._layout).map(layout => !layout ? [] : [
+            n.div({
+                style: {
+                    position: 'absolute',
+                    background: 'var(--vscode-inlineEdit-gutterIndicator-background)',
+                    borderRadius: '4px',
+                    ...rectToProps(reader => layout.read(reader).rect),
+                }
+            }),
+            n.div({
+                class: 'icon',
+                ref: this._iconRef,
+                onmouseenter: () => {
+                    this._isHoveredOverIcon.set(true, undefined);
+                    this._showHover();
+                },
+                onmouseleave: () => { this._isHoveredOverIcon.set(false, undefined); },
+                style: {
+                    cursor: 'pointer',
+                    zIndex: '1000',
+                    position: 'absolute',
+                    backgroundColor: ( this._tabAction.map(v => {
+                        switch (v) {
+                            case 'inactive': return 'var(--vscode-inlineEdit-gutterIndicator-secondaryBackground)';
+                            case 'jump': return 'var(--vscode-inlineEdit-gutterIndicator-primaryBackground)';
+                            case 'accept': return 'var(--vscode-inlineEdit-gutterIndicator-successfulBackground)';
+                        }
+                    })),
+                    ['--vscodeIconForeground']: ( this._tabAction.map(v => {
+                        switch (v) {
+                            case 'inactive': return 'var(--vscode-inlineEdit-gutterIndicator-secondaryForeground)';
+                            case 'jump': return 'var(--vscode-inlineEdit-gutterIndicator-primaryForeground)';
+                            case 'accept': return 'var(--vscode-inlineEdit-gutterIndicator-successfulForeground)';
+                        }
+                    })),
+                    borderRadius: '4px',
+                    display: 'flex',
+                    justifyContent: 'center',
+                    transition: 'background-color 0.2s ease-in-out',
+                    ...rectToProps(reader => layout.read(reader).iconRect),
+                }
+            }, [
+                n.div({
+                    style: {
+                        rotate: ( layout.map(l => {
+                            switch (l.arrowDirection) {
+                                case 'right': return '0deg';
+                                case 'bottom': return '90deg';
+                                case 'top': return '-90deg';
+                            }
+                        })),
+                        transition: 'rotate 0.2s ease-in-out',
+                        display: 'flex',
+                        alignItems: 'center',
+                        justifyContent: 'center',
+                    }
+                }, [
+                    ( this._tabAction.map(
+                        v => v === 'accept' ? renderIcon(Codicon.keyboardTab) : renderIcon(Codicon.arrowRight)
+                    ))
+                ])
+            ]),
+        ]))).keepUpdated(this._store);
+        this._register(this._editorObs.createOverlayWidget({
+            domNode: this._indicator.element,
+            position: constObservable(null),
+            allowEditorOverflow: false,
+            minContentWidthInPx: constObservable(0),
+        }));
+        this._register(autorun(reader => {
+            if (!accessibilityService.isMotionReduced()) {
+                this._indicator.element.classList.toggle('wiggle', this._isHoveringOverInlineEdit.read(reader));
+            }
+        }));
+    }
+    _showHover() {
+        if (this._hoverVisible) {
+            return;
+        }
+        const displayName = derived(this, reader => {
+            const state = this._model.read(reader)?.inlineEditState;
+            const item = state?.read(reader);
+            const completionSource = item?.inlineCompletion?.source;
+            const displayName = (completionSource?.inlineCompletions).edits[0]?.provider?.displayName ?? ( localize(1243, "Inline Edit"));
+            return displayName;
+        });
+        const disposableStore = ( new DisposableStore());
+        const content = disposableStore.add(this._instantiationService.createInstance(GutterIndicatorMenuContent, displayName, this._tabAction, (focusEditor) => {
+            if (focusEditor) {
+                this._editorObs.editor.focus();
+            }
+            h?.dispose();
+        }, ( this._model.map(
+            (m, r) => m?.state.read(r)?.inlineCompletion?.source.inlineCompletions.commands
+        ))).toDisposableLiveElement());
+        const focusTracker = disposableStore.add(trackFocus(content.element));
+        disposableStore.add(focusTracker.onDidBlur(() => this._focusIsInMenu.set(false, undefined)));
+        disposableStore.add(focusTracker.onDidFocus(() => this._focusIsInMenu.set(true, undefined)));
+        disposableStore.add(toDisposable(() => this._focusIsInMenu.set(false, undefined)));
+        const h = this._hoverService.showHover({
+            target: this._iconRef.element,
+            content: content.element,
+        });
+        if (h) {
+            this._hoverVisible = true;
+            h.onDispose(() => {
+                disposableStore.dispose();
+                this._hoverVisible = false;
+            });
+        }
+        else {
+            disposableStore.dispose();
+        }
+    }
+};
+InlineEditsGutterIndicator = ( __decorate([
+    ( __param(6, IHoverService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IAccessibilityService))
+], InlineEditsGutterIndicator));
+
+export { InlineEditsGutterIndicator };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/{inlineEditsIndicatorView.d.ts → indicatorView.d.ts}

@@ -2,9 +2,8 @@ import { Disposable } from "../../../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../../../base/common/observable.js";
 import { ObservableCodeEditor } from "../../../../../browser/observableCodeEditor.js";
 import { InlineCompletionsModel } from "../../model/inlineCompletionsModel.js";
-import { Point } from "./utils.js";
 export interface IInlineEditsIndicatorState {
-    editTopLeft: Point;
+    editTop: number;
     showAlways: boolean;
 }
 export declare const inlineEditIndicatorForeground: string;

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/{inlineEditsIndicatorView.js → indicatorView.js}

@@ -21,10 +21,11 @@ import '../../../../../../platform/theme/common/colors/miscColors.js';
 import '../../../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../../../platform/theme/common/colors/searchColors.js';
 import { OffsetRange } from '../../../../../common/core/offsetRange.js';
+import { localize } from '../../../../../../nls.js';
 
-registerColor('inlineEdit.indicator.foreground', buttonForeground, '');
-registerColor('inlineEdit.indicator.background', buttonBackground, '');
-registerColor('inlineEdit.indicator.border', buttonSeparator, '');
+registerColor('inlineEdit.indicator.foreground', buttonForeground, ( localize(1244, 'Foreground color for the inline edit indicator.')));
+registerColor('inlineEdit.indicator.background', buttonBackground, ( localize(1245, 'Background color for the inline edit indicator.')));
+registerColor('inlineEdit.indicator.border', buttonSeparator, ( localize(1246, 'Border color for the inline edit indicator.')));
 class InlineEditsIndicator extends Disposable {
     constructor(_editorObs, _state, _model) {
         super();
@@ -63,13 +64,13 @@ class InlineEditsIndicator extends Disposable {
             this._indicator.root.style.visibility = '';
             const i = this._editorObs.layoutInfo.read(reader);
             const range = ( new OffsetRange(0, i.height - 30));
-            const topEdit = state.editTopLeft;
-            this._indicator.root.classList.toggle('top', topEdit.y < range.start);
-            this._indicator.root.classList.toggle('bottom', topEdit.y > range.endExclusive);
+            const topEdit = state.editTop;
+            this._indicator.root.classList.toggle('top', topEdit < range.start);
+            this._indicator.root.classList.toggle('bottom', topEdit > range.endExclusive);
             const showAnyway = state.showAlways;
             this._indicator.root.classList.toggle('visible', showAnyway);
-            this._indicator.root.classList.toggle('contained', range.contains(topEdit.y));
-            this._indicator.root.style.top = `${range.clip(topEdit.y)}px`;
+            this._indicator.root.classList.toggle('contained', range.contains(topEdit));
+            this._indicator.root.style.top = `${range.clip(topEdit)}px`;
             this._indicator.root.style.right = `${i.minimap.minimapWidth + i.verticalScrollbarWidth}px`;
         }));
     }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineDiffView.d.ts

@@ -4,17 +4,20 @@ import { ICodeEditor } from "../../../../../browser/editorBrowser.js";
 import { AbstractText } from "../../../../../common/core/textEdit.js";
 import { DetailedLineRangeMapping } from "../../../../../common/diff/rangeMapping.js";
 import { ITextModel } from "../../../../../common/model.js";
+import { IInlineEditsView } from "./sideBySideDiff.js";
 export interface IOriginalEditorInlineDiffViewState {
     diff: DetailedLineRangeMapping[];
     modifiedText: AbstractText;
-    mode: "mixedLines" | "interleavedLines" | "sideBySide";
+    mode: "mixedLines" | "insertionInline" | "interleavedLines" | "sideBySide" | "deletion";
     modifiedCodeEditor: ICodeEditor;
 }
-export declare class OriginalEditorInlineDiffView extends Disposable {
+export declare class OriginalEditorInlineDiffView extends Disposable implements IInlineEditsView {
     private readonly _originalEditor;
     private readonly _state;
     private readonly _modifiedTextModel;
     static supportsInlineDiffRendering(mapping: DetailedLineRangeMapping): boolean;
+    readonly isHovered: IObservable<boolean>;
+    private readonly _tokenizationFinished;
     constructor(_originalEditor: ICodeEditor, _state: IObservable<IOriginalEditorInlineDiffViewState | undefined>, _modifiedTextModel: ITextModel);
     private readonly _decorations;
 }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/inlineDiffView.js

@@ -5,14 +5,16 @@ import '../../../../../../base/common/event.js';
 import { autorunWithStore } from '../../../../../../base/common/observableInternal/autorun.js';
 import { derived } from '../../../../../../base/common/observableInternal/derived.js';
 import '../../../../../../base/common/cancellation.js';
-import { observableFromEvent } from '../../../../../../base/common/observableInternal/utils.js';
+import { constObservable, observableFromEvent } from '../../../../../../base/common/observableInternal/utils.js';
 import { observableCodeEditor } from '../../../../../browser/observableCodeEditor.js';
 import { rangeIsSingleLine } from '../../../../../browser/widget/diffEditor/components/diffEditorViewZones/diffEditorViewZones.js';
 import { RenderOptions, LineSource, renderLines } from '../../../../../browser/widget/diffEditor/components/diffEditorViewZones/renderLines.js';
 import { diffAddDecoration } from '../../../../../browser/widget/diffEditor/registrations.contribution.js';
 import { applyViewZones } from '../../../../../browser/widget/diffEditor/utils.js';
 import { EditorOption } from '../../../../../common/config/editorOptions.js';
+import { OffsetRange } from '../../../../../common/core/offsetRange.js';
 import { Range } from '../../../../../common/core/range.js';
+import { EndOfLinePreference } from '../../../../../common/model.js';
 import { ModelDecorationOptions } from '../../../../../common/model/textModel.js';
 import { InlineDecoration, InlineDecorationType } from '../../../../../common/viewModel.js';
 import { classNames } from './utils.js';
@@ -26,13 +28,15 @@ class OriginalEditorInlineDiffView extends Disposable {
         this._originalEditor = _originalEditor;
         this._state = _state;
         this._modifiedTextModel = _modifiedTextModel;
+        this.isHovered = constObservable(false);
+        this._tokenizationFinished = modelTokenizationFinished(this._modifiedTextModel);
         this._decorations = derived(this, reader => {
             const diff = this._state.read(reader);
             if (!diff) {
                 return undefined;
             }
             const modified = diff.modifiedText;
-            const showInline = diff.mode === 'mixedLines';
+            const showInline = diff.mode === 'mixedLines' || diff.mode === 'insertionInline';
             const showEmptyDecorations = true;
             const originalDecorations = [];
             const modifiedDecorations = [];
@@ -68,7 +72,8 @@ class OriginalEditorInlineDiffView extends Disposable {
                 description: 'char-insert diff-range-empty',
             });
             for (const m of diff.diff) {
-                {
+                const showFullLineDecorations = diff.mode !== 'sideBySide';
+                if (showFullLineDecorations) {
                     if (!m.original.isEmpty) {
                         originalDecorations.push({
                             range: m.original.toInclusiveRange(),
@@ -94,13 +99,14 @@ class OriginalEditorInlineDiffView extends Disposable {
                     const useInlineDiff = showInline && allowsTrueInlineDiffRendering(m);
                     for (const i of m.innerChanges || []) {
                         if (m.original.contains(i.originalRange.startLineNumber)) {
+                            const replacedText = this._originalEditor.getModel()?.getValueInRange(i.originalRange, EndOfLinePreference.LF);
                             originalDecorations.push({
                                 range: i.originalRange,
                                 options: {
                                     description: 'char-delete',
                                     shouldFillLineOnLineBreak: false,
-                                    className: classNames('inlineCompletions-char-delete', (i.originalRange.isEmpty() && showEmptyDecorations && !useInlineDiff) && 'diff-range-empty'),
-                                    inlineClassName: useInlineDiff ? 'strike-through' : null,
+                                    className: classNames('inlineCompletions-char-delete', i.originalRange.isSingleLine() && diff.mode === 'insertionInline' && 'single-line-inline', i.originalRange.isEmpty() && 'empty', ((i.originalRange.isEmpty() || diff.mode === 'deletion' && replacedText === '\n') && showEmptyDecorations && !useInlineDiff) && 'diff-range-empty'),
+                                    inlineClassName: useInlineDiff ? classNames('strike-through', 'inlineCompletions') : null,
                                     zIndex: 1
                                 }
                             });
@@ -115,18 +121,33 @@ class OriginalEditorInlineDiffView extends Disposable {
                         }
                         if (useInlineDiff) {
                             const insertedText = modified.getValueOfRange(i.modifiedRange);
-                            originalDecorations.push({
-                                range: Range.fromPositions(i.originalRange.getEndPosition()),
-                                options: {
-                                    description: 'inserted-text',
-                                    before: {
-                                        content: insertedText,
-                                        inlineClassName: 'inlineCompletions-char-insert',
-                                    },
-                                    zIndex: 2,
-                                    showIfCollapsed: true,
-                                }
-                            });
+                            const textSegments = insertedText.length > 3 ?
+                                [
+                                    { text: insertedText.slice(0, 1), extraClasses: ['start'], offsetRange: ( new OffsetRange(i.modifiedRange.startColumn - 1, i.modifiedRange.startColumn)) },
+                                    { text: insertedText.slice(1, -1), extraClasses: [], offsetRange: ( new OffsetRange(i.modifiedRange.startColumn, i.modifiedRange.endColumn - 2)) },
+                                    { text: insertedText.slice(-1), extraClasses: ['end'], offsetRange: ( new OffsetRange(i.modifiedRange.endColumn - 2, i.modifiedRange.endColumn - 1)) }
+                                ] :
+                                [
+                                    { text: insertedText, extraClasses: ['start', 'end'], offsetRange: ( new OffsetRange(i.modifiedRange.startColumn - 1, i.modifiedRange.endColumn)) }
+                                ];
+                            this._tokenizationFinished.read(reader);
+                            const lineTokens = this._modifiedTextModel.tokenization.getLineTokens(i.modifiedRange.startLineNumber);
+                            for (const { text, extraClasses, offsetRange } of textSegments) {
+                                originalDecorations.push({
+                                    range: Range.fromPositions(i.originalRange.getEndPosition()),
+                                    options: {
+                                        description: 'inserted-text',
+                                        before: {
+                                            tokens: lineTokens.getTokensInRange(offsetRange),
+                                            content: text,
+                                            inlineClassName: classNames('inlineCompletions-char-insert', i.modifiedRange.isSingleLine() && diff.mode === 'insertionInline' && 'single-line-inline', ...extraClasses
+                                            ),
+                                        },
+                                        zIndex: 2,
+                                        showIfCollapsed: true,
+                                    }
+                                });
+                            }
                         }
                     }
                 }
@@ -142,7 +163,6 @@ class OriginalEditorInlineDiffView extends Disposable {
             }
         }));
         const editor = observableCodeEditor(this._originalEditor);
-        const tokenizationFinished = modelTokenizationFinished(_modifiedTextModel);
         const originalViewZones = derived(this, (reader) => {
             const originalModel = editor.model.read(reader);
             if (!originalModel) {
@@ -159,7 +179,7 @@ class OriginalEditorInlineDiffView extends Disposable {
                 if (s.mode !== 'interleavedLines') {
                     continue;
                 }
-                tokenizationFinished.read(reader);
+                this._tokenizationFinished.read(reader);
                 const source = ( new LineSource(
                     diff.modified.mapToLineArray(l => this._modifiedTextModel.tokenization.getLineTokens(l))
                 ));

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/inlineEdits/insertionView.d.ts

@@ -0,0 +1,32 @@
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../../../base/common/observable.js";
+import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { ICodeEditor } from "../../../../../browser/editorBrowser.js";
+import { LineRange } from "../../../../../common/core/lineRange.js";
+import { ILanguageService } from "../../../../../common/languages/language.js";
+import { GhostTextView } from "../ghostText/ghostTextView.js";
+import { IInlineEditsView } from "./sideBySideDiff.js";
+export declare class InlineEditsInsertionView extends Disposable implements IInlineEditsView {
+    private readonly _editor;
+    private readonly _input;
+    private readonly _instantiationService;
+    private readonly _languageService;
+    private readonly _editorObs;
+    private readonly _state;
+    private readonly _ghostText;
+    protected readonly _ghostTextView: GhostTextView;
+    constructor(_editor: ICodeEditor, _input: IObservable<{
+        lineNumber: number;
+        startColumn: number;
+        text: string;
+    } | undefined>, _instantiationService: IInstantiationService, _languageService: ILanguageService);
+    private readonly _display;
+    private readonly _editorMaxContentWidthInRange;
+    private readonly _trimVertically;
+    readonly startLineOffset: IObservable<number>;
+    readonly originalLines: IObservable<LineRange | undefined>;
+    private readonly _overlayLayout;
+    private readonly _foregroundSvg;
+    private readonly _nonOverflowView;
+    readonly isHovered: IObservable<boolean>;
+}