@codingame/monaco-vscode-api 9.0.2 → 10.0.0

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineEditsAdapter.js

@@ -0,0 +1,83 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/arrays.js';
+import '../../../../../base/common/event.js';
+import { autorunWithStore } from '../../../../../base/common/observableInternal/autorun.js';
+import '../../../../../base/common/observableInternal/derived.js';
+import '../../../../../base/common/cancellation.js';
+import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/utils.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { observableConfigValue } from '../../../../../platform/observable/common/platformObservableUtils.js';
+import { InlineEditTriggerKind } from '../../../../common/languages.js';
+import { ILanguageFeaturesService } from '../../../../common/services/languageFeatures.js';
+var InlineEditsAdapterContribution_1, InlineEditsAdapter_1;
+let InlineEditsAdapterContribution = class InlineEditsAdapterContribution extends Disposable {
+    static { InlineEditsAdapterContribution_1 = this; }
+    static { this.ID = 'editor.contrib.inlineEditsAdapter'; }
+    static { this.isFirst = true; }
+    constructor(_editor, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        if (InlineEditsAdapterContribution_1.isFirst) {
+            InlineEditsAdapterContribution_1.isFirst = false;
+            this.instantiationService.createInstance(InlineEditsAdapter);
+        }
+    }
+};
+InlineEditsAdapterContribution = InlineEditsAdapterContribution_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], InlineEditsAdapterContribution));
+let InlineEditsAdapter = class InlineEditsAdapter extends Disposable {
+    static { InlineEditsAdapter_1 = this; }
+    static { this.experimentalInlineEditsEnabled = 'editor.inlineSuggest.experimentalInlineEditsEnabled'; }
+    constructor(_languageFeaturesService, _configurationService) {
+        super();
+        this._languageFeaturesService = _languageFeaturesService;
+        this._configurationService = _configurationService;
+        this._inlineCompletionInlineEdits = observableConfigValue(InlineEditsAdapter_1.experimentalInlineEditsEnabled, false, this._configurationService);
+        const didChangeSignal = observableSignalFromEvent('didChangeSignal', this._languageFeaturesService.inlineEditProvider.onDidChange);
+        this._register(autorunWithStore((reader, store) => {
+            if (!this._inlineCompletionInlineEdits.read(reader)) {
+                return;
+            }
+            didChangeSignal.read(reader);
+            store.add(this._languageFeaturesService.inlineCompletionsProvider.register('*', {
+                provideInlineCompletions: async (model, position, context, token) => {
+                    const allInlineEditProvider = _languageFeaturesService.inlineEditProvider.all(model);
+                    const inlineEdits = await Promise.all(( allInlineEditProvider.map(async (provider) => {
+                        const result = await provider.provideInlineEdit(model, {
+                            triggerKind: InlineEditTriggerKind.Automatic,
+                        }, token);
+                        if (!result) {
+                            return undefined;
+                        }
+                        return { result, provider };
+                    })));
+                    const definedEdits = inlineEdits.filter(e => !!e);
+                    return {
+                        edits: definedEdits,
+                        items: ( definedEdits.map(e => {
+                            return {
+                                range: e.result.range,
+                                insertText: e.result.text,
+                                command: e.result.accepted,
+                                isInlineEdit: true,
+                            };
+                        })),
+                    };
+                },
+                freeInlineCompletions: (c) => {
+                    for (const e of c.edits) {
+                        e.provider.freeInlineEdit(e.result);
+                    }
+                },
+            }));
+        }));
+    }
+};
+InlineEditsAdapter = InlineEditsAdapter_1 = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IConfigurationService))
+], InlineEditsAdapter));
+export { InlineEditsAdapter, InlineEditsAdapterContribution };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/provideInlineCompletions.js

@@ -9,6 +9,8 @@ import { fixBracketsInLine } from '../../../../common/model/bracketPairsTextMode
 import { SingleTextEdit } from '../../../../common/core/textEdit.js';
 import { getReadonlyEmptyArray } from '../utils.js';
 import { SnippetParser, Text } from '../../../snippet/browser/snippetParser.js';
+import { LineEditWithAdditionalLines } from '../../../../common/tokenizationTextModelPart.js';
+import { OffsetRange } from '../../../../common/core/offsetRange.js';
 async function provideInlineCompletions(registry, positionOrRange, model, context, token = CancellationToken.None, languageConfigurationService) {
     const defaultReplaceRange = positionOrRange instanceof Position ? getDefaultRange(positionOrRange, model) : positionOrRange;
     const providers = registry.all(model);
@@ -82,7 +84,7 @@ async function provideInlineCompletions(registry, positionOrRange, model, contex
                     return completions;
                 }
                 else {
-                    const completions = await provider.provideInlineEdits?.(model, positionOrRange, context, token);
+                    const completions = await provider.provideInlineEditsForRange?.(model, positionOrRange, context, token);
                     return completions;
                 }
             }
@@ -249,8 +251,9 @@ function getDefaultRange(position, model) {
 function closeBrackets(text, position, model, languageConfigurationService) {
     const lineStart = model.getLineContent(position.lineNumber).substring(0, position.column - 1);
     const newLine = lineStart + text;
-    const newTokens = model.tokenization.tokenizeLineWithEdit(position, newLine.length - (position.column - 1), text);
-    const slicedTokens = newTokens?.sliceAndInflate(position.column - 1, newLine.length, 0);
+    const edit = LineEditWithAdditionalLines.replace(OffsetRange.ofStartAndLength(position.column - 1, newLine.length - (position.column - 1)), text);
+    const newTokens = model.tokenization.tokenizeLineWithEdit(position.lineNumber, edit);
+    const slicedTokens = newTokens?.mainLineTokens?.sliceAndInflate(position.column - 1, newLine.length, 0);
     if (!slicedTokens) {
         return text;
     }

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/singleTextEditHelpers.js

@@ -0,0 +1,25 @@
+import { commonPrefixLength } from '../../../../../base/common/strings.js';
+import { Range } from '../../../../common/core/range.js';
+import { TextLength } from '../../../../common/core/textLength.js';
+import { SingleTextEdit } from '../../../../common/core/textEdit.js';
+function singleTextRemoveCommonPrefix(edit, model, validModelRange) {
+    const modelRange = validModelRange ? edit.range.intersectRanges(validModelRange) : edit.range;
+    if (!modelRange) {
+        return edit;
+    }
+    const normalizedText = edit.text.replaceAll('\r\n', '\n');
+    const valueToReplace = model.getValueInRange(modelRange, 1 );
+    const commonPrefixLen = commonPrefixLength(valueToReplace, normalizedText);
+    const start = TextLength.ofText(valueToReplace.substring(0, commonPrefixLen)).addToPosition(edit.range.getStartPosition());
+    const text = normalizedText.substring(commonPrefixLen);
+    const range = Range.fromPositions(start, edit.range.getEndPosition());
+    return ( new SingleTextEdit(range, text));
+}
+function singleTextEditAugments(edit, base) {
+    return edit.text.startsWith(base.text) && rangeExtends(edit.range, base.range);
+}
+function rangeExtends(extendingRange, rangeToExtend) {
+    return rangeToExtend.getStartPosition().equals(extendingRange.getStartPosition())
+        && rangeToExtend.getEndPosition().isBeforeOrEqual(extendingRange.getEndPosition());
+}
+export { singleTextEditAugments, singleTextRemoveCommonPrefix };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/suggestWidgetAdaptor.js

@@ -5,8 +5,8 @@ import { Disposable } from '../../../../../base/common/lifecycle.js';
 import { Position } from '../../../../common/core/position.js';
 import { Range } from '../../../../common/core/range.js';
 import { SingleTextEdit } from '../../../../common/core/textEdit.js';
-import { CompletionItemInsertTextRule, SelectedSuggestionInfo } from '../../../../common/languages.js';
-import { singleTextRemoveCommonPrefix, singleTextEditAugments } from './singleTextEdit.js';
+import { SelectedSuggestionInfo } from '../../../../common/languages.js';
+import { singleTextRemoveCommonPrefix, singleTextEditAugments } from './singleTextEditHelpers.js';
 import { SnippetParser } from '../../../snippet/browser/snippetParser.js';
 import { SnippetSession } from '../../../snippet/browser/snippetSession.js';
 import { SuggestController } from '../../../suggest/browser/suggestController.js';
@@ -132,7 +132,7 @@ class SuggestItemInfo {
     static fromSuggestion(suggestController, model, position, item, toggleMode) {
         let { insertText } = item.completion;
         let isSnippetText = false;
-        if (item.completion.insertTextRules & CompletionItemInsertTextRule.InsertAsSnippet) {
+        if (item.completion.insertTextRules & 4 ) {
             const snippet = ( new SnippetParser()).parse(insertText);
             if (snippet.children.length < 100) {
                 SnippetSession.adjustWhitespace(model, position, true, snippet);

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

@@ -1,12 +1,16 @@
+import { Permutation, compareBy } from '../../../../base/common/arrays.js';
 import { BugIndicatingError } from '../../../../base/common/errors.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
-import '../../../../base/common/arrays.js';
+import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
+import '../../../../base/common/event.js';
+import '../../../../base/common/lifecycle.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
 import '../../../../base/common/observableInternal/derived.js';
-import { autorunOpts } from '../../../../base/common/observableInternal/autorun.js';
-import '../../../../base/common/observableInternal/utils.js';
 import '../../../../base/common/cancellation.js';
+import '../../../../base/common/observableInternal/utils.js';
+import { splitLinesIncludeSeparators } from '../../../../base/common/strings.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
+import { TextEdit } from '../../../common/core/textEdit.js';
 const array = [];
 function getReadonlyEmptyArray() {
     return array;
@@ -29,20 +33,6 @@ class ColumnRange {
             && this.endColumnExclusive === other.endColumnExclusive;
     }
 }
-function applyObservableDecorations(editor, decorations) {
-    const d = ( new DisposableStore());
-    const decorationsCollection = editor.createDecorationsCollection();
-    d.add(autorunOpts({ debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
-        const d = decorations.read(reader);
-        decorationsCollection.set(d);
-    }));
-    d.add({
-        dispose: () => {
-            decorationsCollection.clear();
-        }
-    });
-    return d;
-}
 function addPositions(pos1, pos2) {
     return ( new Position(
         pos1.lineNumber + pos2.lineNumber - 1,
@@ -55,4 +45,39 @@ function subtractPositions(pos1, pos2) {
         pos1.lineNumber - pos2.lineNumber === 0 ? pos1.column - pos2.column + 1 : pos1.column
     ));
 }
-export { ColumnRange, addPositions, applyObservableDecorations, getReadonlyEmptyArray, subtractPositions };
+function substringPos(text, pos) {
+    let subtext = '';
+    const lines = splitLinesIncludeSeparators(text);
+    for (let i = pos.lineNumber - 1; i < lines.length; i++) {
+        subtext += lines[i].substring(i === pos.lineNumber - 1 ? pos.column - 1 : 0);
+    }
+    return subtext;
+}
+function getEndPositionsAfterApplying(edits) {
+    const sortPerm = Permutation.createSortPermutation(edits, compareBy(e => e.range, Range.compareRangesUsingStarts));
+    const edit = ( new TextEdit(sortPerm.apply(edits)));
+    const sortedNewRanges = edit.getNewRanges();
+    const newRanges = sortPerm.inverse().apply(sortedNewRanges);
+    return ( newRanges.map(range => range.getEndPosition()));
+}
+function convertItemsToStableObservables(items, store) {
+    const result = observableValue('result', []);
+    const innerObservables = [];
+    store.add(autorun(reader => {
+        const itemsValue = items.read(reader);
+        transaction(tx => {
+            if (itemsValue.length !== innerObservables.length) {
+                innerObservables.length = itemsValue.length;
+                for (let i = 0; i < innerObservables.length; i++) {
+                    if (!innerObservables[i]) {
+                        innerObservables[i] = observableValue('item', itemsValue[i]);
+                    }
+                }
+                result.set([...innerObservables], tx);
+            }
+            innerObservables.forEach((o, i) => o.set(itemsValue[i], tx));
+        });
+    }));
+    return result;
+}
+export { ColumnRange, addPositions, convertItemsToStableObservables, getEndPositionsAfterApplying, getReadonlyEmptyArray, substringPos, subtractPositions };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/{ghostTextView.css.js → ghostText/ghostTextView.css.js}

@@ -1,4 +1,4 @@
-import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".monaco-editor .suggest-preview-additional-widget{white-space:nowrap}.monaco-editor .suggest-preview-additional-widget .content-spacer{color:transparent;white-space:pre}.monaco-editor .suggest-preview-additional-widget .button{cursor:pointer;display:inline-block;text-decoration:underline;text-underline-position:under}.monaco-editor .ghost-text-hidden{font-size:0;opacity:0}.monaco-editor .ghost-text-decoration,.monaco-editor .suggest-preview-text .ghost-text{font-style:italic}.monaco-editor .inline-completion-text-to-replace{text-decoration:underline;text-underline-position:under}.monaco-editor .ghost-text-decoration,.monaco-editor .ghost-text-decoration-preview,.monaco-editor .suggest-preview-text .ghost-text{background-color:var(--vscode-editorGhostText-background);border:1px solid var(--vscode-editorGhostText-border);color:var(--vscode-editorGhostText-foreground)!important}";
+import n from '../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .suggest-preview-additional-widget{white-space:nowrap}.monaco-editor .suggest-preview-additional-widget .content-spacer{color:transparent;white-space:pre}.monaco-editor .suggest-preview-additional-widget .button{cursor:pointer;display:inline-block;text-decoration:underline;text-underline-position:under}.monaco-editor .ghost-text-hidden{font-size:0;opacity:0}.monaco-editor .ghost-text-decoration,.monaco-editor .suggest-preview-text .ghost-text{font-style:italic}.monaco-editor .inline-completion-text-to-replace{text-decoration:underline;text-underline-position:under}.monaco-editor .ghost-text-decoration,.monaco-editor .ghost-text-decoration-preview,.monaco-editor .suggest-preview-text .ghost-text{background-color:var(--vscode-editorGhostText-background);border:1px solid var(--vscode-editorGhostText-border);&.syntax-highlighted{opacity:.7}&:not(.syntax-highlighted){color:var(--vscode-editorGhostText-foreground)}}";
 n(css,{});
 export { css, css as default };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/view/ghostText/ghostTextView.js

@@ -0,0 +1,295 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { createTrustedTypesPolicy } from '../../../../../../base/browser/trustedTypes.js';
+import { Event } from '../../../../../../base/common/event.js';
+import { Disposable, toDisposable } from '../../../../../../base/common/lifecycle.js';
+import { observableValue } from '../../../../../../base/common/observableInternal/base.js';
+import '../../../../../../base/common/arrays.js';
+import { autorun } from '../../../../../../base/common/observableInternal/autorun.js';
+import { derived } from '../../../../../../base/common/observableInternal/derived.js';
+import '../../../../../../base/common/cancellation.js';
+import { observableSignalFromEvent } from '../../../../../../base/common/observableInternal/utils.js';
+import { containsRTL, isBasicASCII } from '../../../../../../base/common/strings.js';
+import { applyFontInfo } from '../../../../../browser/config/domFontInfo.js';
+import { observableCodeEditor } from '../../../../../browser/observableCodeEditor.js';
+import { EditorFontLigatures } from '../../../../../common/config/editorOptions.js';
+import { OffsetEdit, SingleOffsetEdit } from '../../../../../common/core/offsetEdit.js';
+import { Position } from '../../../../../common/core/position.js';
+import { Range } from '../../../../../common/core/range.js';
+import { StringBuilder } from '../../../../../common/core/stringBuilder.js';
+import { ILanguageService } from '../../../../../common/languages/language.js';
+import { InjectedTextCursorStops } from '../../../../../common/model.js';
+import { LineEditWithAdditionalLines } from '../../../../../common/tokenizationTextModelPart.js';
+import { LineTokens } from '../../../../../common/tokens/lineTokens.js';
+import { LineDecoration } from '../../../../../common/viewLayout/lineDecorations.js';
+import { renderViewLine, RenderLineInput } from '../../../../../common/viewLayout/viewLineRenderer.js';
+import { GhostTextReplacement } from '../../model/ghostText.js';
+import { ColumnRange } from '../../utils.js';
+import './ghostTextView.css.js';
+let GhostTextView = class GhostTextView extends Disposable {
+    constructor(_editor, _model, _languageService) {
+        super();
+        this._editor = _editor;
+        this._model = _model;
+        this._languageService = _languageService;
+        this._isDisposed = observableValue(this, false);
+        this._editorObs = observableCodeEditor(this._editor);
+        this._useSyntaxHighlighting = ( this._editorObs.getOption(64 ).map(v => v.syntaxHighlightingEnabled));
+        this.uiState = derived(this, reader => {
+            if (this._isDisposed.read(reader)) {
+                return undefined;
+            }
+            const textModel = this._editorObs.model.read(reader);
+            if (textModel !== this._model.targetTextModel.read(reader)) {
+                return undefined;
+            }
+            const ghostText = this._model.ghostText.read(reader);
+            if (!ghostText) {
+                return undefined;
+            }
+            const replacedRange = ghostText instanceof GhostTextReplacement ? ghostText.columnRange : undefined;
+            const syntaxHighlightingEnabled = this._useSyntaxHighlighting.read(reader);
+            const extraClassName = syntaxHighlightingEnabled ? ' syntax-highlighted' : '';
+            const { inlineTexts, additionalLines, hiddenRange } = computeGhostTextViewData(ghostText, textModel, 'ghost-text' + extraClassName);
+            const edit = ( new OffsetEdit(( inlineTexts.map(t => SingleOffsetEdit.insert(t.column - 1, t.text)))));
+            const tokens = syntaxHighlightingEnabled ? textModel.tokenization.tokenizeLineWithEdit(ghostText.lineNumber, ( new LineEditWithAdditionalLines(edit, ( additionalLines.map(l => l.content))))) : undefined;
+            const newRanges = edit.getNewTextRanges();
+            const inlineTextsWithTokens = ( inlineTexts.map(
+                (t, idx) => ({ ...t, tokens: tokens?.mainLineTokens?.getTokensInRange(newRanges[idx]) })
+            ));
+            const tokenizedAdditionalLines = ( additionalLines.map((l, idx) => ({
+                content: tokens?.additionalLines?.[idx] ?? LineTokens.createEmpty(l.content, this._languageService.languageIdCodec),
+                decorations: l.decorations,
+            })));
+            return {
+                replacedRange,
+                inlineTexts: inlineTextsWithTokens,
+                additionalLines: tokenizedAdditionalLines,
+                hiddenRange,
+                lineNumber: ghostText.lineNumber,
+                additionalReservedLineCount: this._model.minReservedLineCount.read(reader),
+                targetTextModel: textModel,
+                syntaxHighlightingEnabled,
+            };
+        });
+        this.decorations = derived(this, reader => {
+            const uiState = this.uiState.read(reader);
+            if (!uiState) {
+                return [];
+            }
+            const decorations = [];
+            const extraClassName = uiState.syntaxHighlightingEnabled ? ' syntax-highlighted' : '';
+            if (uiState.replacedRange) {
+                decorations.push({
+                    range: uiState.replacedRange.toRange(uiState.lineNumber),
+                    options: { inlineClassName: 'inline-completion-text-to-replace' + extraClassName, description: 'GhostTextReplacement' }
+                });
+            }
+            if (uiState.hiddenRange) {
+                decorations.push({
+                    range: uiState.hiddenRange.toRange(uiState.lineNumber),
+                    options: { inlineClassName: 'ghost-text-hidden', description: 'ghost-text-hidden', }
+                });
+            }
+            for (const p of uiState.inlineTexts) {
+                decorations.push({
+                    range: Range.fromPositions(( new Position(uiState.lineNumber, p.column))),
+                    options: {
+                        description: 'ghost-text-decoration',
+                        after: {
+                            content: p.text,
+                            tokens: p.tokens,
+                            inlineClassName: p.preview ? 'ghost-text-decoration-preview' : 'ghost-text-decoration' + extraClassName,
+                            cursorStops: InjectedTextCursorStops.Left
+                        },
+                        showIfCollapsed: true,
+                    }
+                });
+            }
+            return decorations;
+        });
+        this.additionalLinesWidget = this._register(( new AdditionalLinesWidget(this._editor, derived(reader => {
+            const uiState = this.uiState.read(reader);
+            return uiState ? {
+                lineNumber: uiState.lineNumber,
+                additionalLines: uiState.additionalLines,
+                minReservedLineCount: uiState.additionalReservedLineCount,
+                targetTextModel: uiState.targetTextModel,
+            } : undefined;
+        }))));
+        this._register(toDisposable(() => { this._isDisposed.set(true, undefined); }));
+        this._register(this._editorObs.setDecorations(this.decorations));
+    }
+    ownsViewZone(viewZoneId) {
+        return this.additionalLinesWidget.viewZoneId === viewZoneId;
+    }
+};
+GhostTextView = ( __decorate([
+    ( __param(2, ILanguageService))
+], GhostTextView));
+function computeGhostTextViewData(ghostText, textModel, ghostTextClassName) {
+    const inlineTexts = [];
+    const additionalLines = [];
+    function addToAdditionalLines(lines, className) {
+        if (additionalLines.length > 0) {
+            const lastLine = additionalLines[additionalLines.length - 1];
+            if (className) {
+                lastLine.decorations.push(( new LineDecoration(
+                    lastLine.content.length + 1,
+                    lastLine.content.length + 1 + lines[0].length,
+                    className,
+                    0
+                )));
+            }
+            lastLine.content += lines[0];
+            lines = lines.slice(1);
+        }
+        for (const line of lines) {
+            additionalLines.push({
+                content: line,
+                decorations: className ? [( new LineDecoration(1, line.length + 1, className, 0 ))] : []
+            });
+        }
+    }
+    const textBufferLine = textModel.getLineContent(ghostText.lineNumber);
+    let hiddenTextStartColumn = undefined;
+    let lastIdx = 0;
+    for (const part of ghostText.parts) {
+        let lines = part.lines;
+        if (hiddenTextStartColumn === undefined) {
+            inlineTexts.push({ column: part.column, text: lines[0], preview: part.preview });
+            lines = lines.slice(1);
+        }
+        else {
+            addToAdditionalLines([textBufferLine.substring(lastIdx, part.column - 1)], undefined);
+        }
+        if (lines.length > 0) {
+            addToAdditionalLines(lines, ghostTextClassName);
+            if (hiddenTextStartColumn === undefined && part.column <= textBufferLine.length) {
+                hiddenTextStartColumn = part.column;
+            }
+        }
+        lastIdx = part.column - 1;
+    }
+    if (hiddenTextStartColumn !== undefined) {
+        addToAdditionalLines([textBufferLine.substring(lastIdx)], undefined);
+    }
+    const hiddenRange = hiddenTextStartColumn !== undefined ? ( new ColumnRange(hiddenTextStartColumn, textBufferLine.length + 1)) : undefined;
+    return {
+        inlineTexts,
+        additionalLines,
+        hiddenRange,
+    };
+}
+class AdditionalLinesWidget extends Disposable {
+    get viewZoneId() { return this._viewZoneId; }
+    constructor(editor, lines) {
+        super();
+        this.editor = editor;
+        this.lines = lines;
+        this._viewZoneId = undefined;
+        this.editorOptionsChanged = observableSignalFromEvent('editorOptionChanged', Event.filter(this.editor.onDidChangeConfiguration, e => e.hasChanged(33 )
+            || e.hasChanged(120 )
+            || e.hasChanged(102 )
+            || e.hasChanged(97 )
+            || e.hasChanged(53 )
+            || e.hasChanged(52 )
+            || e.hasChanged(69 )));
+        this._register(autorun(reader => {
+            const lines = this.lines.read(reader);
+            this.editorOptionsChanged.read(reader);
+            if (lines) {
+                this.updateLines(lines.lineNumber, lines.additionalLines, lines.minReservedLineCount);
+            }
+            else {
+                this.clear();
+            }
+        }));
+    }
+    dispose() {
+        super.dispose();
+        this.clear();
+    }
+    clear() {
+        this.editor.changeViewZones((changeAccessor) => {
+            if (this._viewZoneId) {
+                changeAccessor.removeZone(this._viewZoneId);
+                this._viewZoneId = undefined;
+            }
+        });
+    }
+    updateLines(lineNumber, additionalLines, minReservedLineCount) {
+        const textModel = this.editor.getModel();
+        if (!textModel) {
+            return;
+        }
+        const { tabSize } = textModel.getOptions();
+        this.editor.changeViewZones((changeAccessor) => {
+            if (this._viewZoneId) {
+                changeAccessor.removeZone(this._viewZoneId);
+                this._viewZoneId = undefined;
+            }
+            const heightInLines = Math.max(additionalLines.length, minReservedLineCount);
+            if (heightInLines > 0) {
+                const domNode = document.createElement('div');
+                renderLines(domNode, tabSize, additionalLines, this.editor.getOptions());
+                this._viewZoneId = changeAccessor.addZone({
+                    afterLineNumber: lineNumber,
+                    heightInLines: heightInLines,
+                    domNode,
+                    afterColumnAffinity: 1
+                });
+            }
+        });
+    }
+}
+function renderLines(domNode, tabSize, lines, opts) {
+    const disableMonospaceOptimizations = opts.get(33 );
+    const stopRenderingLineAfter = opts.get(120 );
+    const renderWhitespace = 'none';
+    const renderControlCharacters = opts.get(97 );
+    const fontLigatures = opts.get(53 );
+    const fontInfo = opts.get(52 );
+    const lineHeight = opts.get(69 );
+    const sb = ( new StringBuilder(10000));
+    sb.appendString('<div class="suggest-preview-text">');
+    for (let i = 0, len = lines.length; i < len; i++) {
+        const lineData = lines[i];
+        const lineTokens = lineData.content;
+        sb.appendString('<div class="view-line');
+        sb.appendString('" style="top:');
+        sb.appendString(String(i * lineHeight));
+        sb.appendString('px;width:1000000px;">');
+        const line = lineTokens.getLineContent();
+        const isBasicASCII$1 = isBasicASCII(line);
+        const containsRTL$1 = containsRTL(line);
+        renderViewLine(( new RenderLineInput(
+            (fontInfo.isMonospace && !disableMonospaceOptimizations),
+            fontInfo.canUseHalfwidthRightwardsArrow,
+            line,
+            false,
+            isBasicASCII$1,
+            containsRTL$1,
+            0,
+            lineTokens,
+            lineData.decorations,
+            tabSize,
+            0,
+            fontInfo.spaceWidth,
+            fontInfo.middotWidth,
+            fontInfo.wsmiddotWidth,
+            stopRenderingLineAfter,
+            renderWhitespace,
+            renderControlCharacters,
+            fontLigatures !== EditorFontLigatures.OFF,
+            null
+        )), sb);
+        sb.appendString('</div>');
+    }
+    sb.appendString('</div>');
+    applyFontInfo(domNode, fontInfo);
+    const html = sb.build();
+    const trustedhtml = ttPolicy ? ttPolicy.createHTML(html) : html;
+    domNode.innerHTML = trustedhtml;
+}
+const ttPolicy = createTrustedTypesPolicy('editorGhostText', { createHTML: value => value });
+export { AdditionalLinesWidget, GhostTextView, ttPolicy };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor div.inline-edits-view-indicator{align-items:center;background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;color:var(--vscode-editorHoverWidget-foreground);display:flex;height:20px;margin:0 4px;opacity:0;padding:2px 10px 2px 2px;z-index:1000000;&.contained{transition:opacity .2s ease-in-out;transition-delay:.4s}&.top{opacity:1;.icon{transform:rotate(90deg)}}&.bottom{opacity:1;.icon{transform:rotate(-90deg)}}.icon{align-items:center;transform:none;transition:transform .2s ease-in-out}.icon,.label{display:flex;margin:0 2px}.label{justify-content:center;width:100%}}.monaco-editor div.inline-edits-view{--widget-color:var(--vscode-editorHoverWidget-background);&.toolbarDropdownVisible,.editorContainer:hover{.toolbar{display:block}}.editorContainer{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;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{--vscode-editor-background:var(--widget-color);.current-line-margin,.view-overlays .current-line-exact{border:none}}}}}";
+n(css,{});
+export { css, css as default };