@codingame/monaco-vscode-api 13.1.7 → 14.0.0

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

@@ -1,26 +1,27 @@
-import { IReader } from "../../../../../../base/common/observable.js";
+import { DisposableStore, IDisposable } from "../../../../../../base/common/lifecycle.js";
+import { IObservable, IReader } from "../../../../../../base/common/observable.js";
 import { URI } from "../../../../../../base/common/uri.js";
 import { MenuEntryActionViewItem } from "../../../../../../platform/actions/browser/menuEntryActionViewItem.js";
+import { ICodeEditor } from "../../../../../browser/editorBrowser.js";
 import { ObservableCodeEditor } from "../../../../../browser/observableCodeEditor.js";
+import { Point } from "../../../../../browser/point.js";
+import { Rect } from "../../../../../browser/rect.js";
 import { LineRange } from "../../../../../common/core/lineRange.js";
+import { Position } from "../../../../../common/core/position.js";
+import { Range } from "../../../../../common/core/range.js";
 import { TextEdit } from "../../../../../common/core/textEdit.js";
 import { RangeMapping } from "../../../../../common/diff/rangeMapping.js";
-import { Position } from "../../../../../common/core/position.js";
-export declare function maxContentWidthInRange(editor: ObservableCodeEditor, range: LineRange, reader: IReader): number;
+export declare function maxContentWidthInRange(editor: ObservableCodeEditor, range: LineRange, reader: IReader | undefined): number;
 export declare function getOffsetForPos(editor: ObservableCodeEditor, pos: Position, reader: IReader): number;
+export declare function getPrefixTrim(diffRanges: Range[], originalLinesRange: LineRange, modifiedLines: string[], editor: ICodeEditor): {
+    prefixTrim: number;
+    prefixLeftOffset: number;
+};
 export declare class StatusBarViewItem extends MenuEntryActionViewItem {
-    protected readonly _updateLabelListener: import("../../../../../../base/common/lifecycle.js").IDisposable;
+    protected readonly _updateLabelListener: IDisposable;
     protected updateLabel(): void;
     protected updateTooltip(): void;
 }
-export declare class Point {
-    readonly x: number;
-    readonly y: number;
-    constructor(x: number, y: number);
-    add(other: Point): Point;
-    deltaX(delta: number): Point;
-    deltaY(delta: number): Point;
-}
 export declare class UniqueUriGenerator {
     readonly scheme: string;
     private static _modelId;
@@ -38,3 +39,113 @@ export declare class PathBuilder {
     curveTo2(cp1: Point, cp2: Point, to: Point): this;
     build(): string;
 }
+export declare function createRectangle(layout: {
+    topLeft: Point;
+    width: number;
+    height: number;
+}, padding: number | {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}, borderRadius: number | {
+    topLeft: number;
+    topRight: number;
+    bottomLeft: number;
+    bottomRight: number;
+}, options?: {
+    hideLeft?: boolean;
+    hideRight?: boolean;
+    hideTop?: boolean;
+    hideBottom?: boolean;
+}): string;
+type Value<T> = T | IObservable<T>;
+type ValueOrList<T> = Value<T> | ValueOrList<T>[];
+type ValueOrList2<T> = ValueOrList<T> | ValueOrList<ValueOrList<T>>;
+type Element = HTMLElement | SVGElement;
+type SVGElementTagNameMap2 = {
+    svg: SVGElement & {
+        width: number;
+        height: number;
+        transform: string;
+        viewBox: string;
+        fill: string;
+    };
+    path: SVGElement & {
+        d: string;
+        stroke: string;
+        fill: string;
+    };
+    linearGradient: SVGElement & {
+        id: string;
+        x1: string | number;
+        x2: string | number;
+    };
+    stop: SVGElement & {
+        offset: string;
+    };
+    rect: SVGElement & {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+    };
+    defs: SVGElement;
+};
+type DomTagCreateFn<TMap extends Record<string, any>> = <TTag extends keyof TMap>(tag: TTag, attributes: ElementAttributeKeys<TMap[TTag]> & {
+    class?: ValueOrList<string | false | undefined>;
+    ref?: IRef<TMap[TTag]>;
+}, children?: ChildNode) => ObserverNode<TMap[TTag]>;
+type DomCreateFn<TAttributes, TResult extends Element> = (attributes: ElementAttributeKeys<TAttributes> & {
+    class?: ValueOrList<string | false | undefined>;
+    ref?: IRef<TResult>;
+}, children?: ChildNode) => ObserverNode<TResult>;
+export type ChildNode = ValueOrList2<Element | string | ObserverNode | undefined>;
+export declare namespace n {
+    const div: DomCreateFn<HTMLDivElement, HTMLDivElement>;
+    const elem: DomTagCreateFn<HTMLElementTagNameMap>;
+    const svg: DomCreateFn<SVGElementTagNameMap2["svg"], SVGElement>;
+    const svgElem: DomTagCreateFn<SVGElementTagNameMap2>;
+    function ref<T = Element>(): IRefWithVal<T>;
+}
+export type IRef<T> = (value: T) => void;
+export interface IRefWithVal<T> extends IRef<T> {
+    readonly element: T;
+}
+export declare abstract class ObserverNode<T extends Element = Element> {
+    private readonly _deriveds;
+    protected readonly _element: T;
+    constructor(tag: string, ref: IRef<T> | undefined, ns: string | undefined, className: ValueOrList<string | undefined | false> | undefined, attributes: ElementAttributeKeys<T>, children: ChildNode);
+    readEffect(reader: IReader | undefined): void;
+    keepUpdated(store: DisposableStore): ObserverNodeWithElement<T>;
+    toDisposableLiveElement(): LiveElement<T>;
+}
+export declare class LiveElement<T extends Element = HTMLElement> {
+    readonly element: T;
+    private readonly _disposable;
+    constructor(element: T, _disposable: IDisposable);
+    dispose(): void;
+}
+export declare class ObserverNodeWithElement<T extends Element = Element> extends ObserverNode<T> {
+    get element(): T;
+    getIsHovered(store: DisposableStore): IObservable<boolean>;
+}
+type ElementAttributeKeys<T> = Partial<{
+    [K in keyof T]: T[K] extends Function ? never : T[K] extends object ? ElementAttributeKeys<T[K]> : Value<number | T[K] | undefined | null>;
+}>;
+type RemoveFalsy<T> = T extends false | undefined | null ? never : T;
+type Falsy<T> = T extends false | undefined | null ? T : never;
+export declare function mapOutFalsy<T>(obs: IObservable<T>): IObservable<IObservable<RemoveFalsy<T>> | Falsy<T>>;
+export declare function observeElementPosition(element: HTMLElement, store: DisposableStore): {
+    top: import("../../../../../../base/common/observable.js").ISettableObservable<number, void>;
+    left: import("../../../../../../base/common/observable.js").ISettableObservable<number, void>;
+};
+export declare function rectToProps(fn: (reader: IReader) => Rect): {
+    left: IObservable<number>;
+    top: IObservable<number>;
+    width: IObservable<number>;
+    height: IObservable<number>;
+};
+export type FirstFnArg<T> = T extends (arg: infer U) => any ? U : never;
+export {};

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

@@ -1,17 +1,27 @@
 
-import { h } from '../../../../../../base/browser/dom.js';
+import { h, isSVGElement, addDisposableListener } from '../../../../../../base/browser/dom.js';
 import { KeybindingLabel, unthemedKeybindingLabelOptions } from '../../../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
 import { numberComparator } from '../../../../../../base/common/arrays.js';
 import { findFirstMin } from '../../../../../../base/common/arraysFind.js';
+import { BugIndicatingError } from '../../../../../../base/common/errors.js';
+import { DisposableStore } from '../../../../../../base/common/lifecycle.js';
+import { observableValue } from '../../../../../../base/common/observableInternal/base.js';
+import '../../../../../../base/common/event.js';
+import '../../../../../../base/common/observableInternal/autorun.js';
+import { derived } from '../../../../../../base/common/observableInternal/derived.js';
+import '../../../../../../base/common/cancellation.js';
+import { derivedObservableWithCache } from '../../../../../../base/common/observableInternal/utils.js';
 import { OS } from '../../../../../../base/common/platform.js';
 import { splitLines, getIndentationLength } from '../../../../../../base/common/strings.js';
 import { URI } from '../../../../../../base/common/uri.js';
 import { MenuEntryActionViewItem } from '../../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { EditorOption } from '../../../../../common/config/editorOptions.js';
 import { OffsetRange } from '../../../../../common/core/offsetRange.js';
+import { Position } from '../../../../../common/core/position.js';
+import { Range } from '../../../../../common/core/range.js';
 import { SingleTextEdit, TextEdit } from '../../../../../common/core/textEdit.js';
 import { RangeMapping } from '../../../../../common/diff/rangeMapping.js';
-import { Range } from '../../../../../common/core/range.js';
-import { Position } from '../../../../../common/core/position.js';
+import { indentOfLine } from '../../../../../common/model/textModel.js';
 
 function maxContentWidthInRange(editor, range, reader) {
     editor.layoutInfo.read(reader);
@@ -24,7 +34,12 @@ function maxContentWidthInRange(editor, range, reader) {
     editor.scrollTop.read(reader);
     for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
         const column = model.getLineMaxColumn(i);
-        const lineContentWidth = editor.editor.getOffsetForColumn(i, column);
+        let lineContentWidth = editor.editor.getOffsetForColumn(i, column);
+        if (lineContentWidth === -1) {
+            const typicalHalfwidthCharacterWidth = editor.editor.getOption(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
+            const approximation = column * typicalHalfwidthCharacterWidth;
+            lineContentWidth = approximation;
+        }
         maxContentWidth = Math.max(maxContentWidth, lineContentWidth);
     }
     const lines = range.mapToLineArray(l => model.getLineContent(l));
@@ -44,6 +59,18 @@ function getOffsetForPos(editor, pos, reader) {
     const lineContentWidth = editor.editor.getOffsetForColumn(pos.lineNumber, pos.column);
     return lineContentWidth;
 }
+function getPrefixTrim(diffRanges, originalLinesRange, modifiedLines, editor) {
+    const textModel = editor.getModel();
+    if (!textModel) {
+        return { prefixTrim: 0, prefixLeftOffset: 0 };
+    }
+    const replacementStart = ( diffRanges.map(r => r.isSingleLine() ? r.startColumn - 1 : 0));
+    const originalIndents = originalLinesRange.mapToLineArray(line => indentOfLine(textModel.getLineContent(line)));
+    const modifiedIndents = ( modifiedLines.map(line => indentOfLine(line)));
+    const prefixTrim = Math.min(...replacementStart, ...originalIndents, ...modifiedIndents);
+    const prefixLeftOffset = editor.getOffsetForColumn(originalLinesRange.startLineNumber, prefixTrim + 1);
+    return { prefixTrim, prefixLeftOffset };
+}
 class StatusBarViewItem extends MenuEntryActionViewItem {
     constructor() {
         super(...arguments);
@@ -68,21 +95,6 @@ class StatusBarViewItem extends MenuEntryActionViewItem {
     updateTooltip() {
     }
 }
-class Point {
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-    }
-    add(other) {
-        return ( new Point(this.x + other.x, this.y + other.y));
-    }
-    deltaX(delta) {
-        return ( new Point(this.x + delta, this.y));
-    }
-    deltaY(delta) {
-        return ( new Point(this.x, this.y + delta));
-    }
-}
 class UniqueUriGenerator {
     static { this._modelId = 0; }
     constructor(scheme) {
@@ -144,5 +156,321 @@ class PathBuilder {
         return this._data;
     }
 }
+function createRectangle(layout, padding, borderRadius, options = {}) {
+    const topLeftInner = layout.topLeft;
+    const topRightInner = topLeftInner.deltaX(layout.width);
+    const bottomLeftInner = topLeftInner.deltaY(layout.height);
+    const bottomRightInner = bottomLeftInner.deltaX(layout.width);
+    const { top: paddingTop, bottom: paddingBottom, left: paddingLeft, right: paddingRight } = typeof padding === 'number' ?
+        { top: padding, bottom: padding, left: padding, right: padding }
+        : padding;
+    const { topLeft: radiusTL, topRight: radiusTR, bottomLeft: radiusBL, bottomRight: radiusBR } = typeof borderRadius === 'number' ?
+        { topLeft: borderRadius, topRight: borderRadius, bottomLeft: borderRadius, bottomRight: borderRadius } :
+        borderRadius;
+    const totalHeight = layout.height + paddingTop + paddingBottom;
+    const totalWidth = layout.width + paddingLeft + paddingRight;
+    const topLeft = topLeftInner.deltaX(-paddingLeft).deltaY(-paddingTop);
+    const topRight = topRightInner.deltaX(paddingRight).deltaY(-paddingTop);
+    const topLeftBefore = topLeft.deltaY(Math.min(radiusTL, totalHeight / 2));
+    const topLeftAfter = topLeft.deltaX(Math.min(radiusTL, totalWidth / 2));
+    const topRightBefore = topRight.deltaX(-Math.min(radiusTR, totalWidth / 2));
+    const topRightAfter = topRight.deltaY(Math.min(radiusTR, totalHeight / 2));
+    const bottomLeft = bottomLeftInner.deltaX(-paddingLeft).deltaY(paddingBottom);
+    const bottomRight = bottomRightInner.deltaX(paddingRight).deltaY(paddingBottom);
+    const bottomLeftBefore = bottomLeft.deltaX(Math.min(radiusBL, totalWidth / 2));
+    const bottomLeftAfter = bottomLeft.deltaY(-Math.min(radiusBL, totalHeight / 2));
+    const bottomRightBefore = bottomRight.deltaY(-Math.min(radiusBR, totalHeight / 2));
+    const bottomRightAfter = bottomRight.deltaX(-Math.min(radiusBR, totalWidth / 2));
+    const path = ( new PathBuilder());
+    if (!options.hideLeft) {
+        path.moveTo(bottomLeftAfter).lineTo(topLeftBefore);
+    }
+    if (!options.hideLeft && !options.hideTop) {
+        path.curveTo(topLeft, topLeftAfter);
+    }
+    else {
+        path.moveTo(topLeftAfter);
+    }
+    if (!options.hideTop) {
+        path.lineTo(topRightBefore);
+    }
+    if (!options.hideTop && !options.hideRight) {
+        path.curveTo(topRight, topRightAfter);
+    }
+    else {
+        path.moveTo(topRightAfter);
+    }
+    if (!options.hideRight) {
+        path.lineTo(bottomRightBefore);
+    }
+    if (!options.hideRight && !options.hideBottom) {
+        path.curveTo(bottomRight, bottomRightAfter);
+    }
+    else {
+        path.moveTo(bottomRightAfter);
+    }
+    if (!options.hideBottom) {
+        path.lineTo(bottomLeftBefore);
+    }
+    if (!options.hideBottom && !options.hideLeft) {
+        path.curveTo(bottomLeft, bottomLeftAfter);
+    }
+    else {
+        path.moveTo(bottomLeftAfter);
+    }
+    return path.build();
+}
+var n;
+(function (n) {
+    function nodeNs(elementNs = undefined) {
+        return (tag, attributes, children) => {
+            const className = attributes.class;
+            delete attributes.class;
+            const ref = attributes.ref;
+            delete attributes.ref;
+            return ( new ObserverNodeWithElement(tag, ref, elementNs, className, attributes, children));
+        };
+    }
+    function node(tag, elementNs = undefined) {
+        const f = nodeNs(elementNs);
+        return (attributes, children) => {
+            return f(tag, attributes, children);
+        };
+    }
+    n.div = node('div');
+    n.elem = nodeNs(undefined);
+    n.svg = node('svg', 'http://www.w3.org/2000/svg');
+    n.svgElem = nodeNs('http://www.w3.org/2000/svg');
+    function ref() {
+        let value = undefined;
+        const result = function (val) {
+            value = val;
+        };
+        Object.defineProperty(result, 'element', {
+            get() {
+                if (!value) {
+                    throw ( new BugIndicatingError(
+                        'Make sure the ref is set before accessing the element. Maybe wrong initialization order?'
+                    ));
+                }
+                return value;
+            }
+        });
+        return result;
+    }
+    n.ref = ref;
+})(n || (n = {}));
+class ObserverNode {
+    constructor(tag, ref, ns, className, attributes, children) {
+        this._deriveds = [];
+        this._element = (ns ? document.createElementNS(ns, tag) : document.createElement(tag));
+        if (ref) {
+            ref(this._element);
+        }
+        if (className) {
+            if (hasObservable(className)) {
+                this._deriveds.push(derived(this, reader => {
+                    setClassName(this._element, getClassName(className, reader));
+                }));
+            }
+            else {
+                setClassName(this._element, getClassName(className, undefined));
+            }
+        }
+        for (const [key, value] of Object.entries(attributes)) {
+            if (key === 'style') {
+                for (const [cssKey, cssValue] of Object.entries(value)) {
+                    const key = camelCaseToHyphenCase(cssKey);
+                    if (isObservable(cssValue)) {
+                        this._deriveds.push(derived(this, reader => {
+                            this._element.style.setProperty(key, convertCssValue(cssValue.read(reader)));
+                        }));
+                    }
+                    else {
+                        this._element.style.setProperty(key, convertCssValue(cssValue));
+                    }
+                }
+            }
+            else if (key === 'tabIndex') {
+                if (isObservable(value)) {
+                    this._deriveds.push(derived(this, reader => {
+                        this._element.tabIndex = value.read(reader);
+                    }));
+                }
+                else {
+                    this._element.tabIndex = value;
+                }
+            }
+            else if (key.startsWith('on')) {
+                this._element[key] = value;
+            }
+            else {
+                if (isObservable(value)) {
+                    this._deriveds.push(derived(this, reader => {
+                        setOrRemoveAttribute(this._element, key, value.read(reader));
+                    }));
+                }
+                else {
+                    setOrRemoveAttribute(this._element, key, value);
+                }
+            }
+        }
+        if (children) {
+            function getChildren(reader, children) {
+                if (isObservable(children)) {
+                    return getChildren(reader, children.read(reader));
+                }
+                if (Array.isArray(children)) {
+                    return children.flatMap(c => getChildren(reader, c));
+                }
+                if (children instanceof ObserverNode) {
+                    if (reader) {
+                        children.readEffect(reader);
+                    }
+                    return [children._element];
+                }
+                if (children) {
+                    return [children];
+                }
+                return [];
+            }
+            const d = derived(this, reader => {
+                this._element.replaceChildren(...getChildren(reader, children));
+            });
+            this._deriveds.push(d);
+            if (!childrenIsObservable(children)) {
+                d.get();
+            }
+        }
+    }
+    readEffect(reader) {
+        for (const d of this._deriveds) {
+            d.read(reader);
+        }
+    }
+    keepUpdated(store) {
+        derived(reader => {
+            this.readEffect(reader);
+        }).recomputeInitiallyAndOnChange(store);
+        return this;
+    }
+    toDisposableLiveElement() {
+        const store = ( new DisposableStore());
+        this.keepUpdated(store);
+        return ( new LiveElement(this._element, store));
+    }
+}
+function setClassName(domNode, className) {
+    if (isSVGElement(domNode)) {
+        domNode.setAttribute('class', className);
+    }
+    else {
+        domNode.className = className;
+    }
+}
+function resolve(value, reader, cb) {
+    if (isObservable(value)) {
+        cb(value.read(reader));
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const v of value) {
+            resolve(v, reader, cb);
+        }
+        return;
+    }
+    cb(value);
+}
+function getClassName(className, reader) {
+    let result = '';
+    resolve(className, reader, val => {
+        if (val) {
+            if (result.length === 0) {
+                result = val;
+            }
+            else {
+                result += ' ' + val;
+            }
+        }
+    });
+    return result;
+}
+function hasObservable(value) {
+    if (isObservable(value)) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return ( value.some(v => hasObservable(v)));
+    }
+    return false;
+}
+function convertCssValue(value) {
+    if (typeof value === 'number') {
+        return value + 'px';
+    }
+    return value;
+}
+function childrenIsObservable(children) {
+    if (isObservable(children)) {
+        return true;
+    }
+    if (Array.isArray(children)) {
+        return ( children.some(c => childrenIsObservable(c)));
+    }
+    return false;
+}
+class LiveElement {
+    constructor(element, _disposable) {
+        this.element = element;
+        this._disposable = _disposable;
+    }
+    dispose() {
+        this._disposable.dispose();
+    }
+}
+class ObserverNodeWithElement extends ObserverNode {
+    get element() {
+        return this._element;
+    }
+    getIsHovered(store) {
+        const hovered = observableValue('hovered', false);
+        store.add(addDisposableListener(this._element, 'mouseenter', () => hovered.set(true, undefined)));
+        store.add(addDisposableListener(this._element, 'mouseleave', () => hovered.set(false, undefined)));
+        return hovered;
+    }
+}
+function setOrRemoveAttribute(element, key, value) {
+    if (value === null || value === undefined) {
+        element.removeAttribute(camelCaseToHyphenCase(key));
+    }
+    else {
+        element.setAttribute(camelCaseToHyphenCase(key), String(value));
+    }
+}
+function camelCaseToHyphenCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function isObservable(obj) {
+    return obj && typeof obj === 'object' && obj['read'] !== undefined && obj['reportChanges'] !== undefined;
+}
+function mapOutFalsy(obs) {
+    const nonUndefinedObs = derivedObservableWithCache(undefined, (reader, lastValue) => obs.read(reader) || lastValue);
+    return derived(reader => {
+        nonUndefinedObs.read(reader);
+        const val = obs.read(reader);
+        if (!val) {
+            return undefined;
+        }
+        return nonUndefinedObs;
+    });
+}
+function rectToProps(fn) {
+    return {
+        left: derived(reader => fn(reader).left),
+        top: derived(reader => fn(reader).top),
+        width: derived(reader => fn(reader).right - fn(reader).left),
+        height: derived(reader => fn(reader).bottom - fn(reader).top),
+    };
+}
 
-export { PathBuilder, Point, StatusBarViewItem, UniqueUriGenerator, applyEditToModifiedRangeMappings, classNames, createReindentEdit, getOffsetForPos, maxContentWidthInRange };
+export { LiveElement, ObserverNode, ObserverNodeWithElement, PathBuilder, StatusBarViewItem, UniqueUriGenerator, applyEditToModifiedRangeMappings, classNames, createRectangle, createReindentEdit, getOffsetForPos, getPrefixTrim, mapOutFalsy, maxContentWidthInRange, n, rectToProps };

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

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-editor{.inline-edits-view-indicator{align-items:center;background-color:var(--vscode-inlineEdit-indicator-background);border:1px solid var(--vscode-inlineEdit-indicator-border);border-radius:3px;color:var(--vscode-inlineEdit-indicator-foreground);display:flex;height:20px;margin:0 4px;opacity:0;padding:2px 10px 2px 2px;z-index:34;&.contained{transition:opacity .2s ease-in-out;transition-delay:.4s}&.top,&.visible{opacity:1;.icon{transform:rotate(90deg)}}&.bottom{opacity:1;.icon{transform:rotate(-90deg)}}.icon{align-items:center;display:flex;margin:0 2px;transform:none;transition:transform .2s ease-in-out;.codicon{color:var(--vscode-inlineEdit-indicator-foreground)}}.label{display:flex;justify-content:center;margin:0 2px;width:100%}}.inline-edits-view{&.toolbarDropdownVisible,.editorContainer.showHover:hover{.toolbar{display:block}}.editorContainer{color:var(--vscode-editorHoverWidget-foreground);.toolbar{background-color:var(--vscode-editorHoverWidget-statusBarBackground);border-top:1px solid rgba(69,69,69,.5);display:none;a,a:hover{color:var(--vscode-foreground)}.keybinding{display:flex;margin-left:4px;opacity:.6}.keybinding .monaco-keybinding-key{font-size:8px;padding:2px 3px}.availableSuggestionCount a{display:flex;justify-content:center;min-width:19px}.inlineSuggestionStatusBarItemLabel{margin-right:2px}}.preview{.monaco-editor{.current-line-margin,.view-overlays .current-line-exact{border:none}}.monaco-editor-background{background-color:var(--vscode-inlineEdit-modifiedChangedLineBackground)}}.inline-edits-view-zone.diagonal-fill{opacity:.5}}}.strike-through{text-decoration:line-through}.inlineCompletions-line-insert{background:var(--vscode-inlineEdit-modifiedChangedLineBackground)}.inlineCompletions-line-delete{background:var(--vscode-inlineEdit-originalChangedLineBackground)}.inlineCompletions-char-insert{background:var(--vscode-inlineEdit-modifiedChangedTextBackground)}.inlineCompletions-char-delete{background:var(--vscode-inlineEdit-originalChangedTextBackground)}.inlineCompletions-char-delete.diff-range-empty{border-left:3px solid var(--vscode-inlineEdit-originalChangedTextBackground);margin-left:-1px}.inlineCompletions-char-insert.diff-range-empty{border-left:3px solid var(--vscode-inlineEdit-modifiedChangedTextBackground)}.inlineCompletions-char-delete.single-line-inline{border:1px solid var(--vscode-editorHoverWidget-border);border-radius:4px;margin:-2px 0 0 -2px}.inlineCompletions-char-insert.single-line-inline{border-bottom:1px solid var(--vscode-editorHoverWidget-border);border-top:1px solid var(--vscode-editorHoverWidget-border);padding:1px 0}.inlineCompletions-char-insert.single-line-inline.start{border-bottom-left-radius:4px;border-left:1px solid var(--vscode-editorHoverWidget-border);border-top-left-radius:4px}.inlineCompletions-char-insert.single-line-inline.end{border-bottom-right-radius:4px;border-right:1px solid var(--vscode-editorHoverWidget-border);border-top-right-radius:4px}.inlineCompletions-char-delete.single-line-inline.empty,.inlineCompletions-char-insert.single-line-inline.empty{display:none}.inlineCompletions.strike-through{text-decoration-thickness:1px}.inlineCompletions-modified-bubble{background:var(--vscode-inlineEdit-modifiedChangedTextBackground)}.inlineCompletions-original-bubble{background:var(--vscode-inlineEdit-originalChangedTextBackground);border-radius:4px}.inlineCompletions-modified-bubble,.inlineCompletions-original-bubble{display:inline-block;pointer-events:none}.inlineCompletions-modified-bubble.start{border-bottom-left-radius:4px;border-top-left-radius:4px}.inlineCompletions-modified-bubble.end{border-bottom-right-radius:4px;border-top-right-radius:4px}.inline-edit.ghost-text,.inline-edit.ghost-text-decoration,.inline-edit.ghost-text-decoration-preview,.inline-edit.suggest-preview-text .ghost-text{background:var(--vscode-inlineEdit-modifiedChangedTextBackground)!important;display:inline-block!important;font-style:normal!important;&.syntax-highlighted{opacity:1!important}}}.monaco-menu-option{align-items:center;border-radius:4px;color:var(--vscode-editorActionList-foreground);cursor:pointer;display:flex;font-size:13px;gap:8px;line-height:26px;padding:0 10px;&.active{background:var(--vscode-editorActionList-focusBackground);color:var(--vscode-editorActionList-focusForeground);outline:1px solid var(--vscode-menu-selectionBorder,transparent);outline-offset:-1px}}@keyframes wiggle{0%{transform:rotate(0) scale(1)}15%,45%{transform:rotate(.04turn) scale(1.1)}30%,60%{transform:rotate(-.04turn) scale(1.2)}to{transform:rotate(0) scale(1)}}.inline-edits-view-gutter-indicator.wiggle .icon{animation-duration:.8s;animation-iteration-count:1;animation-name:wiggle}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,41 @@
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { IObservable, ISettableObservable } from "../../../../../../base/common/observable.js";
+import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { ICodeEditor } from "../../../../../browser/editorBrowser.js";
+import { InlineCompletionsModel } from "../../model/inlineCompletionsModel.js";
+import { InlineEditsDeletionView } from "./deletionView.js";
+import { OriginalEditorInlineDiffView } from "./inlineDiffView.js";
+import { InlineEditsInsertionView } from "./insertionView.js";
+import { InlineEditWithChanges } from "./viewAndDiffProducer.js";
+import { LineReplacementView, WordReplacementView } from "./wordReplacementView.js";
+export declare class InlineEditsView extends Disposable {
+    private readonly _editor;
+    private readonly _edit;
+    private readonly _model;
+    private readonly _focusIsInMenu;
+    private readonly _instantiationService;
+    private readonly _editorObs;
+    private readonly _useMixedLinesDiff;
+    private readonly _useInterleavedLinesDiff;
+    private readonly _useCodeShifting;
+    private readonly _renderSideBySide;
+    private readonly _useMultiLineGhostText;
+    private _previousView;
+    constructor(_editor: ICodeEditor, _edit: IObservable<InlineEditWithChanges | undefined>, _model: IObservable<InlineCompletionsModel | undefined>, _focusIsInMenu: ISettableObservable<boolean>, _instantiationService: IInstantiationService);
+    private readonly _uiState;
+    private readonly _previewTextModel;
+    private readonly _sideBySide;
+    protected readonly _deletion: InlineEditsDeletionView;
+    protected readonly _insertion: InlineEditsInsertionView;
+    private readonly _inlineDiffViewState;
+    protected readonly _inlineDiffView: OriginalEditorInlineDiffView;
+    protected readonly _wordReplacementViews: IObservable<readonly WordReplacementView[]>;
+    protected readonly _lineReplacementView: IObservable<readonly LineReplacementView[]>;
+    private readonly _useGutterIndicator;
+    private readonly _inlineEditsIsHovered;
+    private readonly _gutterIndicatorOffset;
+    private readonly _originalDisplayRange;
+    protected readonly _indicator: import("../../../../../../base/common/lifecycle.js").IDisposable;
+    private determineView;
+    private determineRenderState;
+}