@codingame/monaco-vscode-api 2.0.3 → 2.1.0

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.js

@@ -1,4 +1,4 @@
-import { clearNode, addDisposableListener, EventType } from '../../../../base/browser/dom.js';
+import { addDisposableListener, EventType } from '../../../../base/browser/dom.js';
 import { createTrustedTypesPolicy } from '../../../../base/browser/trustedTypes.js';
 import { equals } from '../../../../base/common/arrays.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
@@ -41,7 +41,7 @@ class StickyScrollWidget extends Disposable {
         this._linesDomNodeScrollable = document.createElement('div');
         this._linesDomNode = document.createElement('div');
         this._lineHeight = this._editor.getOption(66 );
-        this._stickyLines = [];
+        this._renderedStickyLines = [];
         this._lineNumbers = [];
         this._lastLineRelativePosition = 0;
         this._minContentWidthInPx = 0;
@@ -92,22 +92,26 @@ class StickyScrollWidget extends Disposable {
     get lineNumberCount() {
         return this._lineNumbers.length;
     }
-    getStickyLineForLine(lineNumber) {
-        return this._stickyLines.find(stickyLine => stickyLine.lineNumber === lineNumber);
+    getRenderedStickyLine(lineNumber) {
+        return this._renderedStickyLines.find(stickyLine => stickyLine.lineNumber === lineNumber);
     }
     getCurrentLines() {
         return this._lineNumbers;
     }
-    setState(state, foldingModel, rebuildFromLine = Infinity) {
-        if (((!this._previousState && !state) || (this._previousState && this._previousState.equals(state)))
-            && rebuildFromLine === Infinity) {
+    setState(_state, foldingModel, _rebuildFromLine) {
+        if (_rebuildFromLine === undefined &&
+            ((!this._previousState && !_state) || (this._previousState && this._previousState.equals(_state)))) {
             return;
         }
-        this._previousState = state;
-        const previousStickyLines = this._stickyLines;
-        this._clearStickyWidget();
-        if (!state || !this._editor._getViewModel()) {
-            return;
+        const isWidgetHeightZero = this._isWidgetHeightZero(_state);
+        const state = isWidgetHeightZero ? undefined : _state;
+        const rebuildFromLine = isWidgetHeightZero ? 0 : this._findLineToRebuildWidgetFrom(_state, _rebuildFromLine);
+        this._renderRootNode(state, foldingModel, rebuildFromLine);
+        this._previousState = _state;
+    }
+    _isWidgetHeightZero(state) {
+        if (!state) {
+            return true;
         }
         const futureWidgetHeight = state.startLineNumbers.length * this._lineHeight + state.lastLineRelativePosition;
         if (futureWidgetHeight > 0) {
@@ -122,7 +126,18 @@ class StickyScrollWidget extends Disposable {
             this._lastLineRelativePosition = 0;
             this._lineNumbers = [];
         }
-        this._renderRootNode(previousStickyLines, foldingModel, rebuildFromLine);
+        return futureWidgetHeight === 0;
+    }
+    _findLineToRebuildWidgetFrom(state, _rebuildFromLine) {
+        if (!state || !this._previousState) {
+            return 0;
+        }
+        if (_rebuildFromLine !== undefined) {
+            return _rebuildFromLine;
+        }
+        const previousState = this._previousState;
+        const indexOfLinesAlreadyRendered = state.startLineNumbers.findIndex(startLineNumber => !previousState.startLineNumbers.includes(startLineNumber));
+        return (indexOfLinesAlreadyRendered === -1) ? 0 : indexOfLinesAlreadyRendered;
     }
     _updateWidgetWidth() {
         const layoutInfo = this._editor.getLayoutInfo();
@@ -131,18 +146,21 @@ class StickyScrollWidget extends Disposable {
         this._linesDomNodeScrollable.style.setProperty('--vscode-editorStickyScroll-scrollableWidth', `${this._editor.getScrollWidth() - layoutInfo.verticalScrollbarWidth}px`);
         this._rootDomNode.style.width = `${layoutInfo.width - layoutInfo.verticalScrollbarWidth}px`;
     }
-    _clearStickyWidget() {
-        this._stickyLines = [];
+    _clearStickyLinesFromLine(clearFromLine) {
         this._foldingIconStore.clear();
-        clearNode(this._lineNumbersDomNode);
-        clearNode(this._linesDomNode);
+        for (let i = clearFromLine; i < this._renderedStickyLines.length; i++) {
+            const stickyLine = this._renderedStickyLines[i];
+            stickyLine.lineNumberDomNode.remove();
+            stickyLine.lineDomNode.remove();
+        }
+        this._renderedStickyLines = this._renderedStickyLines.slice(0, clearFromLine);
         this._rootDomNode.style.display = 'none';
     }
     _useFoldingOpacityTransition(requireTransitions) {
         this._lineNumbersDomNode.style.setProperty('--vscode-editorStickyScroll-foldingOpacityTransition', `opacity ${requireTransitions ? 0.5 : 0}s`);
     }
     _setFoldingIconsVisibility(allVisible) {
-        for (const line of this._stickyLines) {
+        for (const line of this._renderedStickyLines) {
             const foldingIcon = line.foldingIcon;
             if (!foldingIcon) {
                 continue;
@@ -150,35 +168,36 @@ class StickyScrollWidget extends Disposable {
             foldingIcon.setVisible(allVisible ? true : foldingIcon.isCollapsed);
         }
     }
-    async _renderRootNode(previousStickyLines, foldingModel, rebuildFromLine = Infinity) {
+    async _renderRootNode(state, foldingModel, rebuildFromLine) {
+        this._clearStickyLinesFromLine(rebuildFromLine);
+        if (!state) {
+            return;
+        }
+        for (const stickyLine of this._renderedStickyLines) {
+            this._updateTopAndZIndexOfStickyLine(stickyLine);
+        }
         const layoutInfo = this._editor.getLayoutInfo();
-        for (const [index, line] of this._lineNumbers.entries()) {
-            const previousStickyLine = previousStickyLines[index];
-            const stickyLine = (line >= rebuildFromLine || previousStickyLine?.lineNumber !== line)
-                ? this._renderChildNode(index, line, foldingModel, layoutInfo)
-                : this._updateTopAndZIndexOfStickyLine(previousStickyLine);
+        const linesToRender = this._lineNumbers.slice(rebuildFromLine);
+        for (const [index, line] of linesToRender.entries()) {
+            const stickyLine = this._renderChildNode(index + rebuildFromLine, line, foldingModel, layoutInfo);
             if (!stickyLine) {
                 continue;
             }
             this._linesDomNode.appendChild(stickyLine.lineDomNode);
             this._lineNumbersDomNode.appendChild(stickyLine.lineNumberDomNode);
-            this._stickyLines.push(stickyLine);
+            this._renderedStickyLines.push(stickyLine);
         }
         if (foldingModel) {
             this._setFoldingHoverListeners();
             this._useFoldingOpacityTransition(!this._isOnGlyphMargin);
         }
         const widgetHeight = this._lineNumbers.length * this._lineHeight + this._lastLineRelativePosition;
-        if (widgetHeight === 0) {
-            this._clearStickyWidget();
-            return;
-        }
         this._rootDomNode.style.display = 'block';
         this._lineNumbersDomNode.style.height = `${widgetHeight}px`;
         this._linesDomNodeScrollable.style.height = `${widgetHeight}px`;
         this._rootDomNode.style.height = `${widgetHeight}px`;
         this._rootDomNode.style.marginLeft = '0px';
-        this._updateMinContentWidth();
+        this._minContentWidthInPx = Math.max(...( this._renderedStickyLines.map(l => l.scrollWidth))) + layoutInfo.verticalScrollbarWidth;
         this._editor.layoutOverlayWidget(this);
     }
     _setFoldingHoverListeners() {
@@ -186,7 +205,7 @@ class StickyScrollWidget extends Disposable {
         if (showFoldingControls !== 'mouseover') {
             return;
         }
-        this._foldingIconStore.add(addDisposableListener(this._lineNumbersDomNode, EventType.MOUSE_ENTER, (e) => {
+        this._foldingIconStore.add(addDisposableListener(this._lineNumbersDomNode, EventType.MOUSE_ENTER, () => {
             this._isOnGlyphMargin = true;
             this._setFoldingIconsVisibility(true);
         }));
@@ -285,7 +304,8 @@ class StickyScrollWidget extends Disposable {
             lineHTMLNode,
             lineNumberHTMLNode,
             foldingIcon,
-            renderOutput.characterMapping
+            renderOutput.characterMapping,
+            lineHTMLNode.scrollWidth
         ));
         return this._updateTopAndZIndexOfStickyLine(renderedLine);
     }
@@ -327,15 +347,6 @@ class StickyScrollWidget extends Disposable {
         foldingIcon.domNode.setAttribute(STICKY_IS_FOLDING_ICON_ATTR, '');
         return foldingIcon;
     }
-    _updateMinContentWidth() {
-        this._minContentWidthInPx = 0;
-        for (const stickyLine of this._stickyLines) {
-            if (stickyLine.lineDomNode.scrollWidth > this._minContentWidthInPx) {
-                this._minContentWidthInPx = stickyLine.lineDomNode.scrollWidth;
-            }
-        }
-        this._minContentWidthInPx += this._editor.getLayoutInfo().verticalScrollbarWidth;
-    }
     getId() {
         return 'editor.contrib.stickyScrollWidget';
     }
@@ -351,8 +362,8 @@ class StickyScrollWidget extends Disposable {
         return this._minContentWidthInPx;
     }
     focusLineWithIndex(index) {
-        if (0 <= index && index < this._stickyLines.length) {
-            this._stickyLines[index].lineDomNode.focus();
+        if (0 <= index && index < this._renderedStickyLines.length) {
+            this._renderedStickyLines[index].lineDomNode.focus();
         }
     }
     getEditorPositionFromNode(spanDomNode) {
@@ -371,10 +382,10 @@ class StickyScrollWidget extends Disposable {
     }
     _getRenderedStickyLineFromChildDomNode(domNode) {
         const index = this.getLineIndexFromChildDomNode(domNode);
-        if (index === null || index < 0 || index >= this._stickyLines.length) {
+        if (index === null || index < 0 || index >= this._renderedStickyLines.length) {
             return null;
         }
-        return this._stickyLines[index];
+        return this._renderedStickyLines[index];
     }
     getLineIndexFromChildDomNode(domNode) {
         const lineIndex = this._getAttributeValue(domNode, STICKY_INDEX_ATTR);
@@ -400,13 +411,14 @@ class StickyScrollWidget extends Disposable {
     }
 }
 class RenderedStickyLine {
-    constructor(index, lineNumber, lineDomNode, lineNumberDomNode, foldingIcon, characterMapping) {
+    constructor(index, lineNumber, lineDomNode, lineNumberDomNode, foldingIcon, characterMapping, scrollWidth) {
         this.index = index;
         this.lineNumber = lineNumber;
         this.lineDomNode = lineDomNode;
         this.lineNumberDomNode = lineNumberDomNode;
         this.foldingIcon = foldingIcon;
         this.characterMapping = characterMapping;
+        this.scrollWidth = scrollWidth;
     }
 }
 class StickyFoldingIcon {

package/vscode/src/vs/editor/contrib/suggest/browser/suggestController.js

@@ -34,24 +34,34 @@ import { ITelemetryService } from '../../../../platform/telemetry/common/telemet
 import { basename, extname } from '../../../../base/common/resources.js';
 import { hash } from '../../../../base/common/hash.js';
 import { WindowIdleValue, getWindow } from '../../../../base/browser/dom.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 var SuggestController_1;
 class LineSuffix {
     constructor(_model, _position) {
         this._model = _model;
         this._position = _position;
+        this._decorationOptions = ModelDecorationOptions.register({
+            description: 'suggest-line-suffix',
+            stickiness: 1
+        });
         const maxColumn = _model.getLineMaxColumn(_position.lineNumber);
         if (maxColumn !== _position.column) {
             const offset = _model.getOffsetAt(_position);
             const end = _model.getPositionAt(offset + 1);
-            this._marker = _model.deltaDecorations([], [{
-                    range: Range.fromPositions(_position, end),
-                    options: { description: 'suggest-line-suffix', stickiness: 1  }
-                }]);
+            _model.changeDecorations(accessor => {
+                if (this._marker) {
+                    accessor.removeDecoration(this._marker);
+                }
+                this._marker = accessor.addDecoration(Range.fromPositions(_position, end), this._decorationOptions);
+            });
         }
     }
     dispose() {
         if (this._marker && !this._model.isDisposed()) {
-            this._model.deltaDecorations(this._marker, []);
+            this._model.changeDecorations(accessor => {
+                accessor.removeDecoration(this._marker);
+                this._marker = undefined;
+            });
         }
     }
     delta(position) {
@@ -59,7 +69,7 @@ class LineSuffix {
             return 0;
         }
         if (this._marker) {
-            const range = this._model.getDecorationRange(this._marker[0]);
+            const range = this._model.getDecorationRange(this._marker);
             const end = this._model.getOffsetAt(range.getStartPosition());
             return end - this._model.getOffsetAt(position);
         }
@@ -173,6 +183,9 @@ let SuggestController = class SuggestController {
             if (index === -1) {
                 index = 0;
             }
+            if (this.model.state === 0 ) {
+                return;
+            }
             let noFocus = false;
             if (e.triggerOptions.auto) {
                 const options = this.editor.getOption(117 );
@@ -246,7 +259,21 @@ let SuggestController = class SuggestController {
         if (Array.isArray(item.completion.additionalTextEdits)) {
             this.model.cancel();
             const scrollState = StableEditorScrollState.capture(this.editor);
-            this.editor.executeEdits('suggestController.additionalTextEdits.sync', ( item.completion.additionalTextEdits.map(edit => EditOperation.replaceMove(Range.lift(edit.range), edit.text))));
+            this.editor.executeEdits('suggestController.additionalTextEdits.sync', ( item.completion.additionalTextEdits.map(edit => {
+                let range = Range.lift(edit.range);
+                if (range.startLineNumber === item.position.lineNumber && range.startColumn > item.position.column) {
+                    const columnDelta = this.editor.getPosition().column - item.position.column;
+                    const startColumnDelta = columnDelta;
+                    const endColumnDelta = Range.spansMultipleLines(range) ? 0 : columnDelta;
+                    range = ( new Range(
+                        range.startLineNumber,
+                        range.startColumn + startColumnDelta,
+                        range.endLineNumber,
+                        range.endColumn + endColumnDelta
+                    ));
+                }
+                return EditOperation.replaceMove(range, edit.text);
+            })));
             scrollState.restoreRelativeVerticalPositionOfCursor(this.editor);
         }
         else if (!isResolved) {

package/vscode/src/vs/editor/contrib/suggest/browser/suggestInlineCompletions.js

@@ -2,18 +2,17 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { FuzzyScore } from '../../../../base/common/filters.js';
 import { Iterable } from '../../../../base/common/iterator.js';
-import { RefCountedDisposable } from '../../../../base/common/lifecycle.js';
-import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { Disposable, RefCountedDisposable } from '../../../../base/common/lifecycle.js';
 import { ICodeEditorService } from '../../../browser/services/codeEditorService.js';
 import { Range } from '../../../common/core/range.js';
+import { registerEditorFeature } from '../../../common/editorFeatures.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { CompletionModel, LineContext } from './completionModel.js';
 import { QuickSuggestionsOptions, provideSuggestionItems, CompletionOptions } from './suggest.js';
 import { ISuggestMemoryService } from './suggestMemory.js';
+import { SuggestModel } from './suggestModel.js';
 import { WordDistance } from './wordDistance.js';
 import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-var EditorContribution_1;
 class SuggestInlineCompletion {
     constructor(range, insertText, filterText, additionalTextEdits, command, completion) {
         this.range = range;
@@ -78,18 +77,30 @@ let InlineCompletionResults = class InlineCompletionResults extends RefCountedDi
 InlineCompletionResults = ( __decorate([
     ( __param(5, ISuggestMemoryService))
 ], InlineCompletionResults));
-let SuggestInlineCompletions = class SuggestInlineCompletions {
-    constructor(_getEditorOption, _languageFeatureService, _clipboardService, _suggestMemoryService) {
-        this._getEditorOption = _getEditorOption;
+let SuggestInlineCompletions = class SuggestInlineCompletions extends Disposable {
+    constructor(_languageFeatureService, _clipboardService, _suggestMemoryService, _editorService) {
+        super();
         this._languageFeatureService = _languageFeatureService;
         this._clipboardService = _clipboardService;
         this._suggestMemoryService = _suggestMemoryService;
+        this._editorService = _editorService;
+        this._store.add(_languageFeatureService.inlineCompletionsProvider.register('*', this));
     }
     async provideInlineCompletions(model, position, context, token) {
         if (context.selectedSuggestionInfo) {
             return;
         }
-        const config = this._getEditorOption(88 , model);
+        let editor;
+        for (const candidate of this._editorService.listCodeEditors()) {
+            if (candidate.getModel() === model) {
+                editor = candidate;
+                break;
+            }
+        }
+        if (!editor) {
+            return;
+        }
+        const config = editor.getOption(88 );
         if (QuickSuggestionsOptions.isAllOff(config)) {
             return;
         }
@@ -122,12 +133,16 @@ let SuggestInlineCompletions = class SuggestInlineCompletions {
             result = this._lastResult;
         }
         else {
-            const completions = await provideSuggestionItems(this._languageFeatureService.completionProvider, model, position, ( new CompletionOptions(undefined, undefined, triggerCharacterInfo?.providers)), triggerCharacterInfo && { triggerKind: 1 , triggerCharacter: triggerCharacterInfo.ch }, token);
+            const completions = await provideSuggestionItems(this._languageFeatureService.completionProvider, model, position, ( new CompletionOptions(
+                undefined,
+                SuggestModel.createSuggestFilter(editor).itemKind,
+                triggerCharacterInfo?.providers
+            )), triggerCharacterInfo && { triggerKind: 1 , triggerCharacter: triggerCharacterInfo.ch }, token);
             let clipboardText;
             if (completions.needsClipboard) {
                 clipboardText = await this._clipboardService.readText();
             }
-            const completionModel = ( new CompletionModel(completions.items, position.column, ( new LineContext(leadingLineContents, 0)), WordDistance.None, this._getEditorOption(117 , model), this._getEditorOption(111 , model), { boostFullMatch: false, firstMatchCanBeWeak: false }, clipboardText));
+            const completionModel = ( new CompletionModel(completions.items, position.column, ( new LineContext(leadingLineContents, 0)), WordDistance.None, editor.getOption(117 ), editor.getOption(111 ), { boostFullMatch: false, firstMatchCanBeWeak: false }, clipboardText));
             result = ( new InlineCompletionResults(
                 model,
                 position.lineNumber,
@@ -161,33 +176,10 @@ let SuggestInlineCompletions = class SuggestInlineCompletions {
     }
 };
 SuggestInlineCompletions = ( __decorate([
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, IClipboardService)),
-    ( __param(3, ISuggestMemoryService))
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IClipboardService)),
+    ( __param(2, ISuggestMemoryService)),
+    ( __param(3, ICodeEditorService))
 ], SuggestInlineCompletions));
-let EditorContribution = class EditorContribution {
-    static { EditorContribution_1 = this; }
-    static { this._counter = 0; }
-    constructor(_editor, languageFeatureService, editorService, instaService) {
-        if (++EditorContribution_1._counter === 1) {
-            const provider = instaService.createInstance(SuggestInlineCompletions, (id, model) => {
-                const editor = editorService.listCodeEditors().find(editor => editor.getModel() === model) ?? _editor;
-                return editor.getOption(id);
-            });
-            EditorContribution_1._disposable = languageFeatureService.inlineCompletionsProvider.register('*', provider);
-        }
-    }
-    dispose() {
-        if (--EditorContribution_1._counter === 0) {
-            EditorContribution_1._disposable?.dispose();
-            EditorContribution_1._disposable = undefined;
-        }
-    }
-};
-EditorContribution = EditorContribution_1 = ( __decorate([
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, IInstantiationService))
-], EditorContribution));
-registerEditorContribution('suggest.inlineCompletionsProvider', EditorContribution, 0 );
+registerEditorFeature(SuggestInlineCompletions);
 export { SuggestInlineCompletions };

package/vscode/src/vs/editor/contrib/suggest/browser/suggestModel.js

@@ -341,7 +341,7 @@ let SuggestModel = SuggestModel_1 = class SuggestModel {
                 snippetSortOrder = 2 ;
                 break;
         }
-        const { itemKind: itemKindFilter, showDeprecated } = SuggestModel_1._createSuggestFilter(this._editor);
+        const { itemKind: itemKindFilter, showDeprecated } = SuggestModel_1.createSuggestFilter(this._editor);
         const completionOptions = ( new CompletionOptions(
             snippetSortOrder,
             options.completionOptions?.kindFilter ?? itemKindFilter,
@@ -394,7 +394,7 @@ let SuggestModel = SuggestModel_1 = class SuggestModel {
             this._logService.debug('suggest.durations.json', durations);
         });
     }
-    static _createSuggestFilter(editor) {
+    static createSuggestFilter(editor) {
         const result = ( new Set());
         const snippetSuggestions = editor.getOption(111 );
         if (snippetSuggestions === 'none') {

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidget.js

@@ -260,6 +260,9 @@ let SuggestWidget = class SuggestWidget {
                 applyStatusBarStyle();
                 applyIconStyle();
             }
+            if (this._completionModel && (e.hasChanged(50 ) || e.hasChanged(118 ) || e.hasChanged(119 ))) {
+                this._list.splice(0, this._list.length, this._completionModel.items);
+            }
         }));
         this._ctxSuggestWidgetVisible = Context.Visible.bindTo(_contextKeyService);
         this._ctxSuggestWidgetDetailsVisible = Context.DetailsVisible.bindTo(_contextKeyService);
@@ -631,9 +634,14 @@ let SuggestWidget = class SuggestWidget {
             else {
                 this._details.widget.renderItem(this._list.getFocusedElements()[0], this._explainMode);
             }
-            this._positionDetails();
+            if (!this._details.widget.isEmpty) {
+                this._positionDetails();
+                this.element.domNode.classList.add('shows-details');
+            }
+            else {
+                this._details.hide();
+            }
             this.editor.focus();
-            this.element.domNode.classList.add('shows-details');
         });
     }
     toggleExplainMode() {
@@ -676,7 +684,7 @@ let SuggestWidget = class SuggestWidget {
         if (this._state === 2  || this._state === 1 ) {
             return;
         }
-        if (this._isDetailsVisible()) {
+        if (this._isDetailsVisible() && !this._details.widget.isEmpty) {
             this._details.show();
         }
         this._positionDetails();

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidgetDetails.js

@@ -6,7 +6,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { MarkdownString } from '../../../../base/common/htmlContent.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
-import { MarkdownRenderer } from '../../markdownRenderer/browser/markdownRenderer.js';
+import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { ResizableHTMLElement } from '../../../../base/browser/ui/resizable/resizable.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
@@ -161,6 +161,9 @@ let SuggestDetailsWidget = class SuggestDetailsWidget {
         this._type.textContent = '';
         this._docs.textContent = '';
     }
+    get isEmpty() {
+        return this.domNode.classList.contains('no-docs');
+    }
     get size() {
         return this._size;
     }
@@ -204,6 +207,7 @@ class SuggestDetailsOverlay {
     constructor(widget, _editor) {
         this.widget = widget;
         this._editor = _editor;
+        this.allowEditorOverflow = true;
         this._disposables = ( new DisposableStore());
         this._added = false;
         this._preferAlignAtTop = true;
@@ -264,12 +268,11 @@ class SuggestDetailsOverlay {
         return this._resizable.domNode;
     }
     getPosition() {
-        return null;
+        return this._topLeft ? { preference: this._topLeft } : null;
     }
     show() {
         if (!this._added) {
             this._editor.addOverlayWidget(this);
-            this.getDomNode().style.position = 'fixed';
             this._added = true;
         }
     }
@@ -347,8 +350,17 @@ class SuggestDetailsOverlay {
                 maxSize = placement.maxSizeTop;
             }
         }
-        this._applyTopLeft({ left: placement.left, top: alignAtTop ? placement.top : bottom - height });
-        this.getDomNode().style.position = 'fixed';
+        let { top, left } = placement;
+        if (!alignAtTop && height > anchorBox.height) {
+            top = bottom - height;
+        }
+        const editorDomNode = this._editor.getDomNode();
+        if (editorDomNode) {
+            const editorBoundingBox = editorDomNode.getBoundingClientRect();
+            top -= editorBoundingBox.top;
+            left -= editorBoundingBox.left;
+        }
+        this._applyTopLeft({ left, top });
         this._resizable.enableSashes(!alignAtTop, placement === eastPlacement, alignAtTop, placement !== eastPlacement);
         this._resizable.minSize = placement.minSize;
         this._resizable.maxSize = maxSize;
@@ -357,8 +369,7 @@ class SuggestDetailsOverlay {
     }
     _applyTopLeft(topLeft) {
         this._topLeft = topLeft;
-        this.getDomNode().style.left = `${this._topLeft.left}px`;
-        this.getDomNode().style.top = `${this._topLeft.top}px`;
+        this._editor.layoutOverlayWidget(this);
     }
 }
 export { SuggestDetailsOverlay, SuggestDetailsWidget, canExpandCompletionItem };

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidgetRenderer.js

@@ -36,9 +36,12 @@ const _completionItemColor = new (class ColorExtractor {
             out[0] = item.completion.detail;
             return true;
         }
-        if (typeof item.completion.documentation === 'string') {
-            const match = ColorExtractor._regexRelaxed.exec(item.completion.documentation);
-            if (match && (match.index === 0 || match.index + match[0].length === item.completion.documentation.length)) {
+        if (item.completion.documentation) {
+            const value = typeof item.completion.documentation === 'string'
+                ? item.completion.documentation
+                : item.completion.documentation.value;
+            const match = ColorExtractor._regexRelaxed.exec(value);
+            if (match && (match.index === 0 || match.index + match[0].length === value.length)) {
                 out[0] = match[0];
                 return true;
             }
@@ -104,15 +107,10 @@ let ItemRenderer = class ItemRenderer {
             readMore.style.height = lineHeightPx;
             readMore.style.width = lineHeightPx;
         };
-        configureFont();
-        disposables.add(this._editor.onDidChangeConfiguration(e => {
-            if (e.hasChanged(50 ) || e.hasChanged(118 ) || e.hasChanged(119 )) {
-                configureFont();
-            }
-        }));
-        return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, readMore, disposables };
+        return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, readMore, disposables, configureFont };
     }
     renderElement(element, index, data) {
+        data.configureFont();
         const { completion } = element;
         data.root.id = getAriaId(index);
         data.colorspan.style.backgroundColor = '';

package/vscode/src/vs/editor/contrib/unicodeHighlighter/browser/bannerController.js

@@ -4,7 +4,7 @@ import { $, clearNode, append } from '../../../../base/browser/dom.js';
 import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
 import { Action } from '../../../../base/common/actions.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { MarkdownRenderer } from '../../markdownRenderer/browser/markdownRenderer.js';
+import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { Link } from '../../../../platform/opener/browser/link.js';
 import { widgetClose } from '../../../../platform/theme/common/iconRegistry.js';

package/vscode/src/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js

@@ -337,6 +337,11 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
+const configureUnicodeHighlightOptionsStr = ( localizeWithPath(
+    'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
+    'unicodeHighlight.configureUnicodeHighlightOptions',
+    'Configure Unicode Highlight Options'
+));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _languageService, _openerService) {
         this._editor = _editor;
@@ -423,7 +428,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
             const markdown = ( new MarkdownString('', true))
                 .appendMarkdown(reason)
                 .appendText(' ')
-                .appendLink(uri, adjustSettings);
+                .appendLink(uri, adjustSettings, configureUnicodeHighlightOptionsStr);
             result.push(( new MarkdownHover(this, d.range, [markdown], false, index++)));
         }
         return result;
@@ -705,11 +710,7 @@ class ShowExcludeOptions extends EditorAction {
         else {
             expectNever(reason);
         }
-        const result = await quickPickService.pick(options, { title: ( localizeWithPath(
-            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-            'unicodeHighlight.configureUnicodeHighlightOptions',
-            'Configure Unicode Highlight Options'
-        )) });
+        const result = await quickPickService.pick(options, { title: configureUnicodeHighlightOptionsStr });
         if (result) {
             await result.run();
         }

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js

@@ -12,6 +12,7 @@ import { ICodeEditorService } from '../../../browser/services/codeEditorService.
 import { Range } from '../../../common/core/range.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { DocumentHighlightKind } from '../../../common/languages.js';
+import { shouldSynchronizeModel } from '../../../common/model.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { getHighlightDecorationOptions } from './highlightDecorations.js';
 import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
@@ -38,6 +39,8 @@ function getOccurrencesAcrossMultipleModels(registry, model, position, wordSepar
     const orderedByScore = registry.ordered(model);
     return first(( orderedByScore.map(provider => () => {
         const filteredModels = otherModels.filter(otherModel => {
+            return shouldSynchronizeModel(otherModel);
+        }).filter(otherModel => {
             return score(provider.selector, otherModel.uri, otherModel.getLanguageId(), true, undefined, undefined) > 0;
         });
         return Promise.resolve(provider.provideMultiDocumentHighlights(model, position, filteredModels, token))