@codingame/monaco-vscode-api 15.0.2 → 16.0.0

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContextUtils.d.ts

@@ -9,7 +9,10 @@ export declare class FocusTracker extends Disposable {
     private readonly _domNode;
     private readonly _onFocusChange;
     private _isFocused;
+    private _isPaused;
     constructor(_domNode: HTMLElement, _onFocusChange: (newFocusValue: boolean) => void);
+    pause(): void;
+    resume(): void;
     private _handleFocusedChanged;
     focus(): void;
     refreshFocusState(): void;

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContextUtils.js

@@ -1,5 +1,5 @@
 
-import { addDisposableListener, getActiveWindow } from '../../../../../base/browser/dom.js';
+import { addDisposableListener, getShadowRoot, getActiveElement } from '../../../../../base/browser/dom.js';
 import { Disposable } from '../../../../../base/common/lifecycle.js';
 
 class FocusTracker extends Disposable {
@@ -8,8 +8,26 @@ class FocusTracker extends Disposable {
         this._domNode = _domNode;
         this._onFocusChange = _onFocusChange;
         this._isFocused = false;
-        this._register(addDisposableListener(this._domNode, 'focus', () => this._handleFocusedChanged(true)));
-        this._register(addDisposableListener(this._domNode, 'blur', () => this._handleFocusedChanged(false)));
+        this._isPaused = false;
+        this._register(addDisposableListener(this._domNode, 'focus', () => {
+            if (this._isPaused) {
+                return;
+            }
+            this.refreshFocusState();
+        }));
+        this._register(addDisposableListener(this._domNode, 'blur', () => {
+            if (this._isPaused) {
+                return;
+            }
+            this._handleFocusedChanged(false);
+        }));
+    }
+    pause() {
+        this._isPaused = true;
+    }
+    resume() {
+        this._isPaused = false;
+        this.refreshFocusState();
     }
     _handleFocusedChanged(focused) {
         if (this._isFocused === focused) {
@@ -19,11 +37,13 @@ class FocusTracker extends Disposable {
         this._onFocusChange(this._isFocused);
     }
     focus() {
-        this._handleFocusedChanged(true);
         this._domNode.focus();
+        this.refreshFocusState();
     }
     refreshFocusState() {
-        const focused = this._domNode === getActiveWindow().document.activeElement;
+        const shadowRoot = getShadowRoot(this._domNode);
+        const activeElement = shadowRoot ? shadowRoot.activeElement : getActiveElement();
+        const focused = this._domNode === activeElement;
         this._handleFocusedChanged(focused);
     }
     get isFocused() {

package/vscode/src/vs/editor/browser/controller/editContext/native/screenReaderSupport.d.ts

@@ -14,6 +14,7 @@ export declare class ScreenReaderSupport {
     private _contentLeft;
     private _contentWidth;
     private _contentHeight;
+    private _divWidth;
     private _lineHeight;
     private _fontInfo;
     private _accessibilityPageSize;
@@ -33,7 +34,6 @@ export declare class ScreenReaderSupport {
     render(ctx: RestrictedRenderingContext): void;
     private _renderAtTopLeft;
     private _doRender;
-    private _setScrollTop;
     setAriaOptions(options: IEditorAriaOptions): void;
     writeScreenReaderContent(): void;
     get screenReaderContentState(): ScreenReaderContentState | undefined;

package/vscode/src/vs/editor/browser/controller/editContext/native/screenReaderSupport.js

@@ -8,7 +8,7 @@ import { IKeybindingService } from '../../../../../platform/keybinding/common/ke
 import { EditorOption } from '../../../../common/config/editorOptions.js';
 import { Selection } from '../../../../common/core/selection.js';
 import { applyFontInfo } from '../../../config/domFontInfo.js';
-import { ariaLabelForScreenReaderContent, newlinecount, PagedScreenReaderStrategy } from '../screenReaderUtils.js';
+import { ariaLabelForScreenReaderContent, PagedScreenReaderStrategy } from '../screenReaderUtils.js';
 
 let ScreenReaderSupport = class ScreenReaderSupport {
     constructor(_domNode, _context, _keybindingService, _accessibilityService) {
@@ -19,6 +19,7 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         this._contentLeft = 1;
         this._contentWidth = 1;
         this._contentHeight = 1;
+        this._divWidth = 1;
         this._lineHeight = 1;
         this._accessibilityPageSize = 1;
         this._ignoreSelectionChangeTime = 0;
@@ -46,12 +47,14 @@ let ScreenReaderSupport = class ScreenReaderSupport {
     _updateConfigurationSettings() {
         const options = this._context.configuration.options;
         const layoutInfo = options.get(EditorOption.layoutInfo);
+        const wrappingColumn = layoutInfo.wrappingColumn;
         this._contentLeft = layoutInfo.contentLeft;
         this._contentWidth = layoutInfo.contentWidth;
         this._contentHeight = layoutInfo.height;
         this._fontInfo = options.get(EditorOption.fontInfo);
         this._lineHeight = options.get(EditorOption.lineHeight);
         this._accessibilityPageSize = options.get(EditorOption.accessibilityPageSize);
+        this._divWidth = Math.round(wrappingColumn * this._fontInfo.typicalHalfwidthCharacterWidth);
     }
     _updateDomAttributes() {
         const options = this._context.configuration.options;
@@ -64,6 +67,9 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         const tabSize = this._context.viewModel.model.getOptions().tabSize;
         const spaceWidth = options.get(EditorOption.fontInfo).spaceWidth;
         this._domNode.domNode.style.tabSize = `${tabSize * spaceWidth}px`;
+        const wordWrapOverride2 = options.get(EditorOption.wordWrapOverride2);
+        const wordWrapValue = wordWrapOverride2 !== 'inherit' ? wordWrapOverride2 : options.get(EditorOption.wordWrap);
+        this._domNode.domNode.style.textWrap = wordWrapValue === 'off' ? 'nowrap' : 'wrap';
     }
     onCursorStateChanged(e) {
         this._primarySelection = e.selections[0] ?? ( new Selection(1, 1, 1, 1));
@@ -87,31 +93,27 @@ let ScreenReaderSupport = class ScreenReaderSupport {
             return;
         }
         const editorScrollTop = this._context.viewLayout.getCurrentScrollTop();
-        const top = this._context.viewLayout.getVerticalOffsetForLineNumber(this._primarySelection.positionLineNumber) - editorScrollTop;
+        const positionLineNumber = this._primarySelection.positionLineNumber;
+        const top = this._context.viewLayout.getVerticalOffsetForLineNumber(positionLineNumber) - editorScrollTop;
         if (top < 0 || top > this._contentHeight) {
             this._renderAtTopLeft();
             return;
         }
-        this._doRender(top, this._contentLeft, this._contentWidth, this._lineHeight);
-        this._setScrollTop();
+        const offsetForStartPositionWithinEditor = this._context.viewLayout.getVerticalOffsetForLineNumber(this._screenReaderContentState.startPositionWithinEditor.lineNumber);
+        const offsetForPositionLineNumber = this._context.viewLayout.getVerticalOffsetForLineNumber(positionLineNumber);
+        const scrollTop = offsetForPositionLineNumber - offsetForStartPositionWithinEditor;
+        this._doRender(scrollTop, top, this._contentLeft, this._divWidth, this._lineHeight);
     }
     _renderAtTopLeft() {
-        this._doRender(0, 0, this._contentWidth, 1);
+        this._doRender(0, 0, 0, this._contentWidth, 1);
     }
-    _doRender(top, left, width, height) {
+    _doRender(scrollTop, top, left, width, height) {
         applyFontInfo(this._domNode, this._fontInfo);
         this._domNode.setTop(top);
         this._domNode.setLeft(left);
         this._domNode.setWidth(width);
         this._domNode.setHeight(height);
-    }
-    _setScrollTop() {
-        if (!this._screenReaderContentState) {
-            return;
-        }
-        const textContentBeforeSelection = this._screenReaderContentState.value.substring(0, this._screenReaderContentState.selectionStart);
-        const numberOfLinesOfContentBeforeSelection = newlinecount(textContentBeforeSelection);
-        this._domNode.domNode.scrollTop = numberOfLinesOfContentBeforeSelection * this._lineHeight;
+        this._domNode.domNode.scrollTop = scrollTop;
     }
     setAriaOptions(options) {
         if (options.activeDescendant) {

package/vscode/src/vs/editor/browser/controller/editContext/textArea/textAreaEditContext.css

@@ -0,0 +1,19 @@
+.monaco-editor .inputarea {
+	min-width: 0;
+	min-height: 0;
+	margin: 0;
+	padding: 0;
+	position: absolute;
+	outline: none !important;
+	resize: none;
+	border: none;
+	overflow: hidden;
+	color: transparent;
+	background-color: transparent;
+	z-index: -10;
+}
+.monaco-editor .inputarea.ime-input {
+	z-index: 10;
+	caret-color: var(--vscode-editorCursor-foreground);
+	color: var(--vscode-editor-foreground);
+}

package/vscode/src/vs/editor/browser/controller/editContext/textArea/textAreaEditContext.js

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import './textAreaEditContext.css.js';
+import './textAreaEditContext.css';
 import { localize } from '../../../../../nls.js';
 import { isFirefox, isSafari, isAndroid, isChrome } from '../../../../../base/browser/browser.js';
 import { createFastDomNode } from '../../../../../base/browser/fastDomNode.js';

package/vscode/src/vs/editor/browser/gpu/css/decorationCssRuleExtractor.js

@@ -1,7 +1,7 @@
 
 import { $, getActiveDocument } from '../../../../base/browser/dom.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
-import './media/decorationCssRuleExtractor.css.js';
+import './media/decorationCssRuleExtractor.css';
 
 class DecorationCssRuleExtractor extends Disposable {
     constructor() {

package/vscode/src/vs/editor/browser/gpu/css/media/decorationCssRuleExtractor.css

@@ -0,0 +1,4 @@
+.monaco-editor .monaco-decoration-css-rule-extractor {
+	visibility: hidden;
+	pointer-events: none;
+}

package/vscode/src/vs/editor/browser/rect.d.ts

@@ -16,7 +16,10 @@ export declare class Rect {
     get height(): number;
     constructor(left: number, top: number, right: number, bottom: number);
     withMargin(margin: number): Rect;
+    withMargin(marginVertical: number, marginHorizontal: number): Rect;
+    withMargin(marginTop: number, marginRight: number, marginBottom: number, marginLeft: number): Rect;
     intersectVertical(range: OffsetRange): Rect;
+    intersectHorizontal(range: OffsetRange): Rect;
     toString(): string;
     intersect(parent: Rect): Rect | undefined;
     union(other: Rect): Rect;
@@ -26,6 +29,7 @@ export declare class Rect {
     withWidth(width: number): Rect;
     withHeight(height: number): Rect;
     withTop(top: number): Rect;
+    withLeft(left: number): Rect;
     translateX(delta: number): Rect;
     translateY(delta: number): Rect;
     deltaRight(delta: number): Rect;
@@ -36,4 +40,11 @@ export declare class Rect {
     getRightBottom(): Point;
     getLeftTop(): Point;
     getRightTop(): Point;
+    toStyles(): {
+        position: string;
+        left: string;
+        top: string;
+        width: string;
+        height: string;
+    };
 }

package/vscode/src/vs/editor/browser/rect.js

@@ -50,21 +50,37 @@ class Rect {
             throw ( new BugIndicatingError('Invalid arguments'));
         }
     }
-    withMargin(margin) {
+    withMargin(marginOrVerticalOrTop, rightOrHorizontal, bottom, left) {
+        let marginLeft, marginRight, marginTop, marginBottom;
+        if (rightOrHorizontal === undefined && bottom === undefined && left === undefined) {
+            marginLeft = marginRight = marginTop = marginBottom = marginOrVerticalOrTop;
+        }
+        else if (bottom === undefined && left === undefined) {
+            marginLeft = marginRight = rightOrHorizontal;
+            marginTop = marginBottom = marginOrVerticalOrTop;
+        }
+        else {
+            marginLeft = left;
+            marginRight = rightOrHorizontal;
+            marginTop = marginOrVerticalOrTop;
+            marginBottom = bottom;
+        }
         return ( new Rect(
-            this.left - margin,
-            this.top - margin,
-            this.right + margin,
-            this.bottom + margin
+            this.left - marginLeft,
+            this.top - marginTop,
+            this.right + marginRight,
+            this.bottom + marginBottom
         ));
     }
     intersectVertical(range) {
-        return ( new Rect(
-            this.left,
-            Math.max(this.top, range.start),
-            this.right,
-            Math.min(this.bottom, range.endExclusive)
-        ));
+        const newTop = Math.max(this.top, range.start);
+        const newBottom = Math.min(this.bottom, range.endExclusive);
+        return ( new Rect(this.left, newTop, this.right, Math.max(newTop, newBottom)));
+    }
+    intersectHorizontal(range) {
+        const newLeft = Math.max(this.left, range.start);
+        const newRight = Math.min(this.right, range.endExclusive);
+        return ( new Rect(newLeft, this.top, Math.max(newLeft, newRight), this.bottom));
     }
     toString() {
         return `Rect{(${this.left},${this.top}), (${this.right},${this.bottom})}`;
@@ -127,6 +143,9 @@ class Rect {
     withTop(top) {
         return ( new Rect(this.left, top, this.right, this.bottom));
     }
+    withLeft(left) {
+        return ( new Rect(left, this.top, this.right, this.bottom));
+    }
     translateX(delta) {
         return ( new Rect(this.left + delta, this.top, this.right + delta, this.bottom));
     }
@@ -157,6 +176,15 @@ class Rect {
     getRightTop() {
         return ( new Point(this.right, this.top));
     }
+    toStyles() {
+        return {
+            position: 'absolute',
+            left: `${this.left}px`,
+            top: `${this.top}px`,
+            width: `${this.width}px`,
+            height: `${this.height}px`,
+        };
+    }
 }
 
 export { Rect };

package/vscode/src/vs/editor/browser/services/editorWorkerService.d.ts

@@ -1,10 +1,11 @@
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { URI } from "../../../base/common/uri.js";
-import { Proxied, IWorkerDescriptor } from "../../../base/common/worker/simpleWorker.js";
+import { Proxied } from "../../../base/common/worker/webWorker.js";
+import { IWebWorkerDescriptor } from "../../../base/browser/webWorkerFactory.js";
 import { IRange } from "../../common/core/range.js";
 import * as languages from "../../common/languages.js";
 import { ILanguageConfigurationService } from "../../common/languages/languageConfigurationRegistry.service.js";
-import { EditorSimpleWorker } from "../../common/services/editorSimpleWorker.js";
+import { EditorWorker } from "../../common/services/editorWebWorker.js";
 import { DiffAlgorithmName, IUnicodeHighlightsResult } from "../../common/services/editorWorker.js";
 import { IEditorWorkerService } from "../../common/services/editorWorker.service.js";
 import { IModelService } from "../../common/services/model.service.js";
@@ -13,7 +14,7 @@ import { ILogService } from "../../../platform/log/common/log.service.js";
 import { UnicodeHighlighterOptions } from "../../common/services/unicodeTextModelHighlighter.js";
 import { ILanguageFeaturesService } from "../../common/services/languageFeatures.service.js";
 import { IChange } from "../../common/diff/legacyLinesDiffComputer.js";
-import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
 import { SectionHeader, FindSectionHeaderOptions } from "../../common/services/findSectionHeaders.js";
 export declare abstract class EditorWorkerService extends Disposable implements IEditorWorkerService {
     private readonly _languageConfigurationService;
@@ -21,7 +22,7 @@ export declare abstract class EditorWorkerService extends Disposable implements
     private readonly _modelService;
     private readonly _workerManager;
     private readonly _logService;
-    constructor(workerDescriptor: IWorkerDescriptor, modelService: IModelService, configurationService: ITextResourceConfigurationService, logService: ILogService, _languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService);
+    constructor(workerDescriptor: IWebWorkerDescriptor, modelService: IModelService, configurationService: ITextResourceConfigurationService, logService: ILogService, _languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService);
     dispose(): void;
     canComputeUnicodeHighlights(uri: URI): boolean;
     computedUnicodeHighlights(uri: URI, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult>;
@@ -44,20 +45,20 @@ export interface IEditorWorkerClient {
     fhr(method: string, args: any[]): Promise<any>;
 }
 export declare class EditorWorkerClient extends Disposable implements IEditorWorkerClient {
-    private readonly _workerDescriptor;
+    private readonly _workerDescriptorOrWorker;
     private readonly _modelService;
     private readonly _keepIdleModels;
     private _worker;
     private _modelManager;
     private _disposed;
-    constructor(_workerDescriptor: IWorkerDescriptor, keepIdleModels: boolean, modelService: IModelService);
+    constructor(_workerDescriptorOrWorker: IWebWorkerDescriptor | Worker, keepIdleModels: boolean, modelService: IModelService);
     fhr(method: string, args: any[]): Promise<any>;
     private _getOrCreateWorker;
-    protected _getProxy(): Promise<Proxied<EditorSimpleWorker>>;
+    protected _getProxy(): Promise<Proxied<EditorWorker>>;
     private _createFallbackLocalWorker;
     private _createEditorWorkerHost;
     private _getOrCreateModelManager;
-    workerWithSyncedResources(resources: URI[], forceLargeModels?: boolean): Promise<Proxied<EditorSimpleWorker>>;
+    workerWithSyncedResources(resources: URI[], forceLargeModels?: boolean): Promise<Proxied<EditorWorker>>;
     textualSuggest(resources: URI[], leadingWord: string | undefined, wordDefRegExp: RegExp): Promise<{
         words: string[];
         duration: number;

package/vscode/src/vs/editor/browser/services/editorWorkerService.js

@@ -2,12 +2,12 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { timeout } from '../../../base/common/async.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
-import { logOnceWebWorkerWarning } from '../../../base/common/worker/simpleWorker.js';
-import { createWebWorker } from '../../../base/browser/defaultWorkerFactory.js';
+import { logOnceWebWorkerWarning } from '../../../base/common/worker/webWorker.js';
+import { createWebWorker } from '../../../base/browser/webWorkerFactory.js';
 import { Range } from '../../common/core/range.js';
 import { CompletionItemKind } from '../../common/languages.js';
 import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.service.js';
-import { EditorSimpleWorker } from '../../common/services/editorSimpleWorker.js';
+import { EditorWorker } from '../../common/services/editorWebWorker.js';
 import { IModelService } from '../../common/services/model.service.js';
 import { ITextResourceConfigurationService } from '../../common/services/textResourceConfiguration.service.js';
 import { isNonEmptyArray } from '../../../base/common/arrays.js';
@@ -296,9 +296,9 @@ class SynchronousWorkerClient {
     }
 }
 let EditorWorkerClient = class EditorWorkerClient extends Disposable {
-    constructor(_workerDescriptor, keepIdleModels, modelService) {
+    constructor(_workerDescriptorOrWorker, keepIdleModels, modelService) {
         super();
-        this._workerDescriptor = _workerDescriptor;
+        this._workerDescriptorOrWorker = _workerDescriptorOrWorker;
         this._disposed = false;
         this._modelService = modelService;
         this._keepIdleModels = keepIdleModels;
@@ -311,7 +311,7 @@ let EditorWorkerClient = class EditorWorkerClient extends Disposable {
     _getOrCreateWorker() {
         if (!this._worker) {
             try {
-                this._worker = this._register(createWebWorker(this._workerDescriptor));
+                this._worker = this._register(createWebWorker(this._workerDescriptorOrWorker));
                 EditorWorkerHost.setChannel(this._worker, this._createEditorWorkerHost());
             }
             catch (err) {
@@ -334,7 +334,7 @@ let EditorWorkerClient = class EditorWorkerClient extends Disposable {
         }
     }
     _createFallbackLocalWorker() {
-        return ( new SynchronousWorkerClient(( new EditorSimpleWorker(this._createEditorWorkerHost(), null))));
+        return ( new SynchronousWorkerClient(( new EditorWorker(null))));
     }
     _createEditorWorkerHost() {
         return {

package/vscode/src/vs/editor/browser/services/hoverService/hover.css

@@ -0,0 +1,97 @@
+.monaco-workbench .workbench-hover {
+	position: relative;
+	font-size: 13px;
+	line-height: 19px;
+	z-index: 40;
+	overflow: hidden;
+	max-width: 700px;
+	background: var(--vscode-editorHoverWidget-background);
+	border: 1px solid var(--vscode-editorHoverWidget-border);
+	border-radius: 3px;
+	color: var(--vscode-editorHoverWidget-foreground);
+	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
+}
+.monaco-workbench .workbench-hover hr {
+	border-bottom: none;
+}
+.monaco-workbench .workbench-hover.compact {
+	font-size: 12px;
+}
+.monaco-workbench .workbench-hover.compact .hover-contents {
+	padding: 2px 8px;
+}
+.monaco-workbench .workbench-hover-container.locked .workbench-hover {
+	outline: 1px solid var(--vscode-editorHoverWidget-border);
+}
+.monaco-workbench .workbench-hover-container:focus-within.locked .workbench-hover {
+	outline-color: var(--vscode-focusBorder);
+}
+.monaco-workbench .workbench-hover-pointer {
+	position: absolute;
+	z-index: 41;
+	pointer-events: none;
+}
+.monaco-workbench .workbench-hover-pointer:after {
+	content: '';
+	position: absolute;
+	width: 5px;
+	height: 5px;
+	background-color: var(--vscode-editorHoverWidget-background);
+	border-right: 1px solid var(--vscode-editorHoverWidget-border);
+	border-bottom: 1px solid var(--vscode-editorHoverWidget-border);
+}
+.monaco-workbench .workbench-hover-container:not(:focus-within).locked .workbench-hover-pointer:after {
+	width: 4px;
+	height: 4px;
+	border-right-width: 2px;
+	border-bottom-width: 2px;
+}
+.monaco-workbench .workbench-hover-container:focus-within .workbench-hover-pointer:after {
+	border-right: 1px solid var(--vscode-focusBorder);
+	border-bottom: 1px solid var(--vscode-focusBorder);
+}
+.monaco-workbench .workbench-hover-pointer.left   { left: -3px; }
+.monaco-workbench .workbench-hover-pointer.right  { right: 3px; }
+.monaco-workbench .workbench-hover-pointer.top    { top: -3px; }
+.monaco-workbench .workbench-hover-pointer.bottom { bottom: 3px; }
+.monaco-workbench .workbench-hover-pointer.left:after {
+	transform: rotate(135deg);
+}
+.monaco-workbench .workbench-hover-pointer.right:after {
+	transform: rotate(315deg);
+}
+.monaco-workbench .workbench-hover-pointer.top:after {
+	transform: rotate(225deg);
+}
+.monaco-workbench .workbench-hover-pointer.bottom:after {
+	transform: rotate(45deg);
+}
+.monaco-workbench .workbench-hover a {
+	color: var(--vscode-textLink-foreground);
+}
+.monaco-workbench .workbench-hover a:focus {
+	outline: 1px solid;
+	outline-offset: -1px;
+	text-decoration: underline;
+	outline-color: var(--vscode-focusBorder);
+}
+.monaco-workbench .workbench-hover a:hover,
+.monaco-workbench .workbench-hover a:active {
+	color: var(--vscode-textLink-activeForeground);
+}
+.monaco-workbench .workbench-hover code {
+	background: var(--vscode-textCodeBlock-background);
+}
+.monaco-workbench .workbench-hover .hover-row .actions {
+	background: var(--vscode-editorHoverWidget-statusBarBackground);
+}
+.monaco-workbench .workbench-hover.right-aligned {
+	left: 1px;
+}
+.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions {
+	flex-direction: row-reverse;
+}
+.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container {
+	margin-right: 0;
+	margin-left: 16px;
+}

package/vscode/src/vs/editor/browser/services/hoverService/hoverService.d.ts

@@ -5,7 +5,7 @@ import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
 import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.service.js";
 import { IAccessibilityService } from "../../../../platform/accessibility/common/accessibility.service.js";
 import { ILayoutService } from "../../../../platform/layout/browser/layoutService.service.js";
-import type { IHoverLifecycleOptions, IHoverOptions, IHoverWidget, IManagedHover, IManagedHoverContentOrFactory, IManagedHoverOptions } from "@codingame/monaco-vscode-view-status-bar-service-override/vscode/vs/base/browser/ui/hover/hover";
+import type { IHoverLifecycleOptions, IHoverOptions, IHoverWidget, IManagedHover, IManagedHoverContentOrFactory, IManagedHoverOptions } from "../../../../base/browser/ui/hover/hover.js";
 import type { IHoverDelegate } from "../../../../base/browser/ui/hover/hoverDelegate.js";
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
 export declare class HoverService extends Disposable implements IHoverService {
@@ -26,7 +26,7 @@ export declare class HoverService extends Disposable implements IHoverService {
     private readonly _delayedHovers;
     private readonly _managedHovers;
     constructor(_instantiationService: IInstantiationService, _configurationService: IConfigurationService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _layoutService: ILayoutService, _accessibilityService: IAccessibilityService);
-    showHover(options: IHoverOptions, focus?: boolean, skipLastFocusedUpdate?: boolean, dontShow?: boolean): IHoverWidget | undefined;
+    showInstantHover(options: IHoverOptions, focus?: boolean, skipLastFocusedUpdate?: boolean, dontShow?: boolean): IHoverWidget | undefined;
     showDelayedHover(options: IHoverOptions, lifecycleOptions: Pick<IHoverLifecycleOptions, "groupId">): IHoverWidget | undefined;
     setupDelayedHover(target: HTMLElement, options: (() => Omit<IHoverOptions, "target">) | Omit<IHoverOptions, "target">, lifecycleOptions?: IHoverLifecycleOptions): IDisposable;
     setupDelayedHoverAtMouse(target: HTMLElement, options: (() => Omit<IHoverOptions, "target" | "position">) | Omit<IHoverOptions, "target" | "position">, lifecycleOptions?: IHoverLifecycleOptions): IDisposable;

package/vscode/src/vs/editor/browser/services/hoverService/hoverService.js

@@ -54,7 +54,7 @@ let HoverService = class HoverService extends Disposable {
             handler: () => { this._showAndFocusHoverForActiveElement(); },
         }));
     }
-    showHover(options, focus, skipLastFocusedUpdate, dontShow) {
+    showInstantHover(options, focus, skipLastFocusedUpdate, dontShow) {
         const hover = this._createHover(options, skipLastFocusedUpdate);
         if (!hover) {
             return undefined;
@@ -63,6 +63,9 @@ let HoverService = class HoverService extends Disposable {
         return hover;
     }
     showDelayedHover(options, lifecycleOptions) {
+        if (options.id === undefined) {
+            options.id = getHoverIdFromContent(options.content);
+        }
         if (!this._currentDelayedHover || this._currentDelayedHoverWasShown) {
             if (this._currentHover?.isLocked) {
                 return undefined;
@@ -71,7 +74,7 @@ let HoverService = class HoverService extends Disposable {
                 return this._currentHover;
             }
             if (this._currentHover && !this._currentHover.isDisposed && this._currentDelayedHoverGroupId !== undefined && this._currentDelayedHoverGroupId === lifecycleOptions?.groupId) {
-                return this.showHover({
+                return this.showInstantHover({
                     ...options,
                     appearance: {
                         ...options.appearance,
@@ -80,6 +83,9 @@ let HoverService = class HoverService extends Disposable {
                 });
             }
         }
+        else if (this._currentDelayedHover && getHoverOptionsIdentity(this._currentHoverOptions) === getHoverOptionsIdentity(options)) {
+            return this._currentDelayedHover;
+        }
         const hover = this._createHover(options, undefined);
         if (!hover) {
             this._currentDelayedHover = undefined;
@@ -92,7 +98,6 @@ let HoverService = class HoverService extends Disposable {
         this._currentDelayedHoverGroupId = lifecycleOptions?.groupId;
         timeout(this._configurationService.getValue('workbench.hover.delay')).then(() => {
             if (hover && !hover.isDisposed) {
-                this._currentDelayedHoverWasShown = true;
                 this._currentDelayedHoverWasShown = true;
                 this._showHover(hover, options);
             }
@@ -127,11 +132,11 @@ let HoverService = class HoverService extends Disposable {
             store.add(addDisposableListener(target, EventType.KEY_DOWN, e => {
                 const evt = ( new StandardKeyboardEvent(e));
                 if (evt.equals(KeyCode.Space) || evt.equals(KeyCode.Enter)) {
-                    this.showHover(resolveHoverOptions(), true);
+                    this.showInstantHover(resolveHoverOptions(), true);
                 }
             }));
         }
-        this._delayedHovers.set(target, { show: (focus) => { this.showHover(resolveHoverOptions(), focus); } });
+        this._delayedHovers.set(target, { show: (focus) => { this.showInstantHover(resolveHoverOptions(), focus); } });
         store.add(toDisposable(() => this._delayedHovers.delete(target)));
         return store;
     }
@@ -140,6 +145,9 @@ let HoverService = class HoverService extends Disposable {
         if (this._currentHover?.isLocked) {
             return undefined;
         }
+        if (options.id === undefined) {
+            options.id = getHoverIdFromContent(options.content);
+        }
         if (getHoverOptionsIdentity(this._currentHoverOptions) === getHoverOptionsIdentity(options)) {
             return undefined;
         }
@@ -157,13 +165,6 @@ let HoverService = class HoverService extends Disposable {
                 this._lastFocusedElementBeforeOpen = undefined;
             }
         }
-        if (options.id === undefined) {
-            options.id = isHTMLElement(options.content)
-                ? undefined
-                : typeof options.content === 'string'
-                    ? ( options.content.toString())
-                    : options.content.value;
-        }
         const hoverDisposables = ( new DisposableStore());
         const hover = this._instantiationService.createInstance(HoverWidget, options);
         if (options.persistence?.sticky) {
@@ -248,7 +249,7 @@ let HoverService = class HoverService extends Disposable {
         if (!this._lastHoverOptions) {
             return;
         }
-        this.showHover(this._lastHoverOptions, true, true);
+        this.showInstantHover(this._lastHoverOptions, true, true);
     }
     _showAndFocusHoverForActiveElement() {
         let activeElement = getActiveElement();
@@ -416,6 +417,15 @@ function getHoverOptionsIdentity(options) {
     }
     return options?.id ?? options;
 }
+function getHoverIdFromContent(content) {
+    if (isHTMLElement(content)) {
+        return undefined;
+    }
+    if (typeof content === 'string') {
+        return ( content.toString());
+    }
+    return content.value;
+}
 class HoverContextViewDelegate {
     get anchorPosition() {
         return this._hover.anchor;

package/vscode/src/vs/editor/browser/services/hoverService/hoverWidget.d.ts

@@ -6,7 +6,7 @@ import { AnchorPosition } from "../../../../base/browser/ui/contextview/contextv
 import { IOpenerService } from "../../../../platform/opener/common/opener.service.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { IAccessibilityService } from "../../../../platform/accessibility/common/accessibility.service.js";
-import type { IHoverOptions, IHoverWidget } from "@codingame/monaco-vscode-view-status-bar-service-override/vscode/vs/base/browser/ui/hover/hover";
+import type { IHoverOptions, IHoverWidget } from "../../../../base/browser/ui/hover/hover.js";
 export declare class HoverWidget extends Widget implements IHoverWidget {
     private readonly _keybindingService;
     private readonly _configurationService;