@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -15,6 +15,7 @@ import { ITelemetryService } from '../../platform/telemetry/common/telemetry.ser
 import { assertType } from '../../base/common/types.js';
 import { ILogService } from '../../platform/log/common/log.service.js';
 import { getActiveElement } from '../../base/browser/dom.js';
+const _moduleId = "vs/editor/browser/editorExtensions";
 class Command {
     constructor(opts) {
         this.id = opts.id;
@@ -36,7 +37,7 @@ class Command {
                 let kbWhen = kbOpts.kbExpr;
                 if (this.precondition) {
                     if (kbWhen) {
-                        kbWhen = ( ContextKeyExpr.and(kbWhen, this.precondition));
+                        kbWhen = ( (ContextKeyExpr.and(kbWhen, this.precondition)));
                     }
                     else {
                         kbWhen = this.precondition;
@@ -180,11 +181,11 @@ class EditorAction extends EditorCommand {
             if (!item.title) {
                 item.title = opts.label;
             }
-            item.when = ( ContextKeyExpr.and(opts.precondition, item.when));
+            item.when = ( (ContextKeyExpr.and(opts.precondition, item.when)));
             return item;
         }
         if (Array.isArray(opts.contextMenuOpts)) {
-            menuOpts.push(...( opts.contextMenuOpts.map(withDefaults)));
+            menuOpts.push(...( (opts.contextMenuOpts.map(withDefaults))));
         }
         else if (opts.contextMenuOpts) {
             menuOpts.push(withDefaults(opts.contextMenuOpts));
@@ -267,7 +268,7 @@ function registerModelAndPositionCommand(id, handler) {
             return instaService.invokeFunction(handler, model, editorPosition, ...args.slice(2));
         }
         return accessor.get(ITextModelService).createModelReference(resource).then(reference => {
-            return ( new Promise((resolve, reject) => {
+            return ( (new Promise((resolve, reject) => {
                 try {
                     const result = instaService.invokeFunction(handler, reference.object.textEditorModel, Position.lift(position), args.slice(2));
                     resolve(result);
@@ -275,7 +276,7 @@ function registerModelAndPositionCommand(id, handler) {
                 catch (err) {
                     reject(err);
                 }
-            })).finally(() => {
+            }))).finally(() => {
                 reference.dispose();
             });
         });
@@ -286,7 +287,7 @@ function registerEditorCommand(editorCommand) {
     return editorCommand;
 }
 function registerEditorAction(ctor) {
-    const action = ( new ctor());
+    const action = ( (new ctor()));
     EditorContributionRegistry.INSTANCE.registerEditorAction(action);
     return action;
 }
@@ -304,7 +305,7 @@ function registerDiffEditorContribution(id, ctor) {
     EditorContributionRegistry.INSTANCE.registerDiffEditorContribution(id, ctor);
 }
 var EditorExtensionsRegistry;
-( (function(EditorExtensionsRegistry) {
+( ((function(EditorExtensionsRegistry) {
     function getEditorCommand(commandId) {
         return EditorContributionRegistry.INSTANCE.getEditorCommand(commandId);
     }
@@ -325,12 +326,12 @@ var EditorExtensionsRegistry;
         return EditorContributionRegistry.INSTANCE.getDiffEditorContributions();
     }
     EditorExtensionsRegistry.getDiffEditorContributions = getDiffEditorContributions;
-})(EditorExtensionsRegistry || (EditorExtensionsRegistry = {})));
+})(EditorExtensionsRegistry || (EditorExtensionsRegistry = {}))));
 const Extensions = {
     EditorCommonContributions: 'editor.contributions'
 };
 class EditorContributionRegistry {
-    static { this.INSTANCE = ( new EditorContributionRegistry()); }
+    static { this.INSTANCE = ( (new EditorContributionRegistry())); }
     constructor() {
         this.editorContributions = [];
         this.diffEditorContributions = [];
@@ -369,7 +370,7 @@ function registerCommand(command) {
     command.register();
     return command;
 }
-const UndoCommand = registerCommand(( new MultiCommand({
+const UndoCommand = registerCommand(( (new MultiCommand({
     id: 'undo',
     precondition: undefined,
     kbOpts: {
@@ -379,21 +380,17 @@ const UndoCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localizeWithPath(
-                'vs/editor/browser/editorExtensions',
-                { key: 'miUndo', comment: ['&& denotes a mnemonic'] },
-                "&&Undo"
-            )),
+            title: ( localizeWithPath(_moduleId, 0, "&&Undo")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localizeWithPath('vs/editor/browser/editorExtensions', 'undo', "Undo")),
+            title: ( localizeWithPath(_moduleId, 1, "Undo")),
             order: 1
         }]
-})));
-registerCommand(( new ProxyCommand(UndoCommand, { id: 'default:undo', precondition: undefined })));
-const RedoCommand = registerCommand(( new MultiCommand({
+}))));
+registerCommand(( (new ProxyCommand(UndoCommand, { id: 'default:undo', precondition: undefined }))));
+const RedoCommand = registerCommand(( (new MultiCommand({
     id: 'redo',
     precondition: undefined,
     kbOpts: {
@@ -405,21 +402,17 @@ const RedoCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localizeWithPath(
-                'vs/editor/browser/editorExtensions',
-                { key: 'miRedo', comment: ['&& denotes a mnemonic'] },
-                "&&Redo"
-            )),
+            title: ( localizeWithPath(_moduleId, 2, "&&Redo")),
             order: 2
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localizeWithPath('vs/editor/browser/editorExtensions', 'redo', "Redo")),
+            title: ( localizeWithPath(_moduleId, 3, "Redo")),
             order: 1
         }]
-})));
-registerCommand(( new ProxyCommand(RedoCommand, { id: 'default:redo', precondition: undefined })));
-const SelectAllCommand = registerCommand(( new MultiCommand({
+}))));
+registerCommand(( (new ProxyCommand(RedoCommand, { id: 'default:redo', precondition: undefined }))));
+const SelectAllCommand = registerCommand(( (new MultiCommand({
     id: 'editor.action.selectAll',
     precondition: undefined,
     kbOpts: {
@@ -430,17 +423,13 @@ const SelectAllCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarSelectionMenu,
             group: '1_basic',
-            title: ( localizeWithPath(
-                'vs/editor/browser/editorExtensions',
-                { key: 'miSelectAll', comment: ['&& denotes a mnemonic'] },
-                "&&Select All"
-            )),
+            title: ( localizeWithPath(_moduleId, 4, "&&Select All")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localizeWithPath('vs/editor/browser/editorExtensions', 'selectAll', "Select All")),
+            title: ( localizeWithPath(_moduleId, 5, "Select All")),
             order: 1
         }]
-})));
+}))));
 export { Command, EditorAction, EditorAction2, EditorCommand, EditorExtensionsRegistry, MultiCommand, MultiEditorAction, ProxyCommand, RedoCommand, SelectAllCommand, UndoCommand, registerDiffEditorContribution, registerEditorAction, registerEditorCommand, registerEditorContribution, registerInstantiatedEditorAction, registerModelAndPositionCommand, registerMultiEditorAction };

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

@@ -0,0 +1,58 @@
+import { DisposableStore } from '../../base/common/lifecycle.js';
+import '../../base/common/arrays.js';
+import { derivedOpts } from '../../base/common/observableInternal/derived.js';
+import { autorunOpts } from '../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../base/common/observableInternal/utils.js';
+import '../../base/common/cancellation.js';
+import { Position } from '../common/core/position.js';
+function obsCodeEditor(editor) {
+    return ObservableCodeEditor.get(editor);
+}
+class ObservableCodeEditor {
+    static { this._map = ( new Map()); }
+    static get(editor) {
+        let result = ObservableCodeEditor._map.get(editor);
+        if (!result) {
+            result = ( new ObservableCodeEditor(editor));
+            ObservableCodeEditor._map.set(editor, result);
+            const d = editor.onDidDispose(() => {
+                ObservableCodeEditor._map.delete(editor);
+                d.dispose();
+            });
+        }
+        return result;
+    }
+    constructor(editor) {
+        this.editor = editor;
+        this.model = observableFromEvent(this.editor.onDidChangeModel, () => this.editor.getModel());
+        this.value = observableFromEvent(this.editor.onDidChangeModelContent, () => this.editor.getValue());
+        this.valueIsEmpty = observableFromEvent(this.editor.onDidChangeModelContent, () => this.editor.getModel()?.getValueLength() === 0);
+        this.selections = observableFromEvent(this.editor.onDidChangeCursorSelection, () => this.editor.getSelections());
+        this.cursorPosition = derivedOpts({ owner: this, equalsFn: Position.equals }, reader => this.selections.read(reader)?.[0]?.getPosition() ?? null);
+        this.isFocused = observableFromEvent(e => {
+            const d1 = this.editor.onDidFocusEditorWidget(e);
+            const d2 = this.editor.onDidBlurEditorWidget(e);
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.hasWidgetFocus());
+    }
+    setDecorations(decorations) {
+        const d = ( new DisposableStore());
+        const decorationsCollection = this.editor.createDecorationsCollection();
+        d.add(autorunOpts({ owner: this, debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
+            const d = decorations.read(reader);
+            decorationsCollection.set(d);
+        }));
+        d.add({
+            dispose: () => {
+                decorationsCollection.clear();
+            }
+        });
+        return d;
+    }
+}
+export { obsCodeEditor };

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

@@ -150,7 +150,7 @@ let AbstractCodeEditorService = class AbstractCodeEditorService extends Disposab
     resolveDecorationOptions(decorationTypeKey, writable) {
         const provider = this._decorationOptionProviders.get(decorationTypeKey);
         if (!provider) {
-            throw new Error('Unknown decoration type key: ' + decorationTypeKey);
+            throw ( new Error('Unknown decoration type key: ' + decorationTypeKey));
         }
         return provider.getOptions(this, writable);
     }
@@ -538,7 +538,7 @@ class DecorationCSSRules {
                 darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.afterInjectedText);
                 break;
             default:
-                throw new Error('Unknown rule type: ' + this._ruleType);
+                throw ( new Error('Unknown rule type: ' + this._ruleType));
         }
         const sheet = this._providerArgs.styleSheet;
         let hasContent = false;

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

@@ -14,7 +14,7 @@ class ResourceEdit {
             if (ResourceFileEdit.is(edit)) {
                 return ResourceFileEdit.lift(edit);
             }
-            throw new Error('Unsupported edit');
+            throw ( new Error('Unsupported edit'));
         }));
     }
 }

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

@@ -357,7 +357,7 @@ class EditorWorkerClient extends Disposable {
         this._modelManager = null;
     }
     fhr(method, args) {
-        throw new Error(`Not implemented!`);
+        throw ( new Error(`Not implemented!`));
     }
     _getOrCreateWorker() {
         if (!this._worker) {

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

@@ -24,6 +24,8 @@ import { IAccessibilityService } from '../../../../platform/accessibility/common
 import { ILayoutService } from '../../../../platform/layout/browser/layoutService.service.js';
 import { mainWindow } from '../../../../base/browser/window.js';
 import { ContextViewHandler } from '../../../../platform/contextview/browser/contextViewService.js';
+import { UpdatableHoverWidget } from './updatableHoverWidget.js';
+import { TimeoutTimer } from '../../../../base/common/async.js';
 let HoverService = class HoverService extends Disposable {
     constructor(_instantiationService, contextMenuService, _keybindingService, _layoutService, _accessibilityService) {
         super();
@@ -67,13 +69,13 @@ let HoverService = class HoverService extends Disposable {
                 this._currentHoverOptions = undefined;
             }
             hoverDisposables.dispose();
-        });
+        }, undefined, hoverDisposables);
         if (!options.container) {
             const targetElement = options.target instanceof HTMLElement ? options.target : options.target.targetElements[0];
             options.container = this._layoutService.getContainer(getWindow(targetElement));
         }
         this._contextViewHandler.showContextView(( new HoverContextViewDelegate(hover, focus)), options.container);
-        hover.onRequestLayout(() => this._contextViewHandler.layout());
+        hover.onRequestLayout(() => this._contextViewHandler.layout(), undefined, hoverDisposables);
         if (options.persistence?.sticky) {
             hoverDisposables.add(addDisposableListener(getWindow(options.container).document, EventType.MOUSE_DOWN, e => {
                 if (!isAncestor(e.target, hover.domNode)) {
@@ -155,6 +157,116 @@ let HoverService = class HoverService extends Disposable {
             }
         }
     }
+    setupUpdatableHover(hoverDelegate, htmlElement, content, options) {
+        htmlElement.setAttribute('custom-hover', 'true');
+        if (htmlElement.title !== '') {
+            console.warn('HTML element already has a title attribute, which will conflict with the custom hover. Please remove the title attribute.');
+            console.trace('Stack trace:', htmlElement.title);
+            htmlElement.title = '';
+        }
+        let hoverPreparation;
+        let hoverWidget;
+        const hideHover = (disposeWidget, disposePreparation) => {
+            const hadHover = hoverWidget !== undefined;
+            if (disposeWidget) {
+                hoverWidget?.dispose();
+                hoverWidget = undefined;
+            }
+            if (disposePreparation) {
+                hoverPreparation?.dispose();
+                hoverPreparation = undefined;
+            }
+            if (hadHover) {
+                hoverDelegate.onDidHideHover?.();
+                hoverWidget = undefined;
+            }
+        };
+        const triggerShowHover = (delay, focus, target) => {
+            return ( new TimeoutTimer(async () => {
+                if (!hoverWidget || hoverWidget.isDisposed) {
+                    hoverWidget = ( new UpdatableHoverWidget(hoverDelegate, target || htmlElement, delay > 0));
+                    await hoverWidget.update(typeof content === 'function' ? content() : content, focus, options);
+                }
+            }, delay));
+        };
+        let isMouseDown = false;
+        const mouseDownEmitter = addDisposableListener(htmlElement, EventType.MOUSE_DOWN, () => {
+            isMouseDown = true;
+            hideHover(true, true);
+        }, true);
+        const mouseUpEmitter = addDisposableListener(htmlElement, EventType.MOUSE_UP, () => {
+            isMouseDown = false;
+        }, true);
+        const mouseLeaveEmitter = addDisposableListener(htmlElement, EventType.MOUSE_LEAVE, (e) => {
+            isMouseDown = false;
+            hideHover(false, e.fromElement === htmlElement);
+        }, true);
+        const onMouseOver = (e) => {
+            if (hoverPreparation) {
+                return;
+            }
+            const toDispose = ( new DisposableStore());
+            const target = {
+                targetElements: [htmlElement],
+                dispose: () => { }
+            };
+            if (hoverDelegate.placement === undefined || hoverDelegate.placement === 'mouse') {
+                const onMouseMove = (e) => {
+                    target.x = e.x + 10;
+                    if ((e.target instanceof HTMLElement) && getHoverTargetElement(e.target, htmlElement) !== htmlElement) {
+                        hideHover(true, true);
+                    }
+                };
+                toDispose.add(addDisposableListener(htmlElement, EventType.MOUSE_MOVE, onMouseMove, true));
+            }
+            hoverPreparation = toDispose;
+            if ((e.target instanceof HTMLElement) && getHoverTargetElement(e.target, htmlElement) !== htmlElement) {
+                return;
+            }
+            toDispose.add(triggerShowHover(hoverDelegate.delay, false, target));
+        };
+        const mouseOverDomEmitter = addDisposableListener(htmlElement, EventType.MOUSE_OVER, onMouseOver, true);
+        const onFocus = () => {
+            if (isMouseDown || hoverPreparation) {
+                return;
+            }
+            const target = {
+                targetElements: [htmlElement],
+                dispose: () => { }
+            };
+            const toDispose = ( new DisposableStore());
+            const onBlur = () => hideHover(true, true);
+            toDispose.add(addDisposableListener(htmlElement, EventType.BLUR, onBlur, true));
+            toDispose.add(triggerShowHover(hoverDelegate.delay, false, target));
+            hoverPreparation = toDispose;
+        };
+        let focusDomEmitter;
+        const tagName = htmlElement.tagName.toLowerCase();
+        if (tagName !== 'input' && tagName !== 'textarea') {
+            focusDomEmitter = addDisposableListener(htmlElement, EventType.FOCUS, onFocus, true);
+        }
+        const hover = {
+            show: focus => {
+                hideHover(false, true);
+            },
+            hide: () => {
+                hideHover(true, true);
+            },
+            update: async (newContent, hoverOptions) => {
+                content = newContent;
+                await hoverWidget?.update(content, undefined, hoverOptions);
+            },
+            dispose: () => {
+                mouseOverDomEmitter.dispose();
+                mouseLeaveEmitter.dispose();
+                mouseDownEmitter.dispose();
+                mouseUpEmitter.dispose();
+                focusDomEmitter?.dispose();
+                hideHover(true, true);
+            }
+        };
+        return hover;
+    }
 };
 HoverService = ( __decorate([
     ( __param(0, IInstantiationService)),
@@ -195,6 +307,13 @@ class HoverContextViewDelegate {
         this._hover.layout();
     }
 }
+function getHoverTargetElement(element, stopElement) {
+    stopElement = stopElement ?? getWindow(element).document.body;
+    while (!element.hasAttribute('custom-hover') && element !== stopElement) {
+        element = element.parentElement;
+    }
+    return element;
+}
 registerSingleton(IHoverService, HoverService, 1 );
 registerThemingParticipant((theme, collector) => {
     const hoverBorder = theme.getColor(editorHoverBorder);

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

@@ -16,6 +16,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { isMacintosh } from '../../../../base/common/platform.js';
 import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
 import { status } from '../../../../base/browser/ui/aria/aria.js';
+const _moduleId = "vs/editor/browser/services/hoverService/hoverWidget";
 const $ = $$1;
 let HoverWidget = class HoverWidget extends Widget {
     get _targetWindow() {
@@ -47,7 +48,7 @@ let HoverWidget = class HoverWidget extends Widget {
         this._openerService = _openerService;
         this._instantiationService = _instantiationService;
         this._accessibilityService = _accessibilityService;
-        this._messageListeners = ( new DisposableStore());
+        this._messageListeners = ( (new DisposableStore()));
         this._isDisposed = false;
         this._forcePosition = false;
         this._x = 0;
@@ -55,14 +56,14 @@ let HoverWidget = class HoverWidget extends Widget {
         this._isLocked = false;
         this._enableFocusTraps = false;
         this._addedFocusTrap = false;
-        this._onDispose = this._register(( new Emitter()));
-        this._onRequestLayout = this._register(( new Emitter()));
+        this._onDispose = this._register(( (new Emitter())));
+        this._onRequestLayout = this._register(( (new Emitter())));
         this._linkHandler = options.linkHandler || (url => {
             return openLinkFromMarkdown(this._openerService, url, isMarkdownString(options.content) ? options.content.isTrusted : undefined);
         });
-        this._target = 'targetElements' in options.target ? options.target : ( new ElementHoverTarget(options.target));
+        this._target = 'targetElements' in options.target ? options.target : ( (new ElementHoverTarget(options.target)));
         this._hoverPointer = options.appearance?.showPointer ? $('div.workbench-hover-pointer') : undefined;
-        this._hover = this._register(( new HoverWidget$1()));
+        this._hover = this._register(( (new HoverWidget$1())));
         this._hover.containerDomNode.classList.add('workbench-hover', 'fadeIn');
         if (options.appearance?.compact) {
             this._hover.containerDomNode.classList.add('workbench-hover', 'compact');
@@ -146,12 +147,7 @@ let HoverWidget = class HoverWidget extends Widget {
         if (hideOnHover && options.appearance?.showHoverHint) {
             const statusBarElement = $('div.hover-row.status-bar');
             const infoElement = $('div.info');
-            infoElement.textContent = ( localizeWithPath(
-                'vs/editor/browser/services/hoverService/hoverWidget',
-                'hoverhint',
-                'Hold {0} key to mouse over',
-                isMacintosh ? 'Option' : 'Alt'
-            ));
+            infoElement.textContent = ( localizeWithPath(_moduleId, 0, 'Hold {0} key to mouse over', isMacintosh ? 'Option' : 'Alt'));
             statusBarElement.appendChild(infoElement);
             this._hover.containerDomNode.appendChild(statusBarElement);
         }
@@ -159,7 +155,7 @@ let HoverWidget = class HoverWidget extends Widget {
         if (!hideOnHover) {
             mouseTrackerTargets.push(this._hoverContainer);
         }
-        const mouseTracker = this._register(( new CompositeMouseTracker(mouseTrackerTargets)));
+        const mouseTracker = this._register(( (new CompositeMouseTracker(mouseTrackerTargets))));
         this._register(mouseTracker.onMouseOut(() => {
             if (!this._isLocked) {
                 this.dispose();
@@ -167,7 +163,7 @@ let HoverWidget = class HoverWidget extends Widget {
         }));
         if (hideOnHover) {
             const mouseTracker2Targets = [...this._target.targetElements, this._hoverContainer];
-            this._lockMouseTracker = this._register(( new CompositeMouseTracker(mouseTracker2Targets)));
+            this._lockMouseTracker = this._register(( (new CompositeMouseTracker(mouseTracker2Targets))));
             this._register(this._lockMouseTracker.onMouseOut(() => {
                 if (!this._isLocked) {
                     this.dispose();
@@ -241,7 +237,7 @@ let HoverWidget = class HoverWidget extends Widget {
                 left: boundingRect.left * zoom,
             };
         };
-        const targetBounds = ( this._target.targetElements.map(e => getZoomAccountedBoundingClientRect(e)));
+        const targetBounds = ( (this._target.targetElements.map(e => getZoomAccountedBoundingClientRect(e))));
         const { top, right, bottom, left } = targetBounds[0];
         const width = right - left;
         const height = bottom - top;
@@ -473,13 +469,13 @@ let HoverWidget = class HoverWidget extends Widget {
         this._isDisposed = true;
     }
 };
-HoverWidget = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IOpenerService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IAccessibilityService))
-], HoverWidget));
+HoverWidget = ( (__decorate([
+    ( (__param(1, IKeybindingService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IOpenerService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IAccessibilityService)))
+], HoverWidget)));
 class CompositeMouseTracker extends Widget {
     get onMouseOut() { return this._onMouseOut.event; }
     get isMouseIn() { return this._isMouseIn; }
@@ -487,7 +483,7 @@ class CompositeMouseTracker extends Widget {
         super();
         this._elements = _elements;
         this._isMouseIn = true;
-        this._onMouseOut = this._register(( new Emitter()));
+        this._onMouseOut = this._register(( (new Emitter())));
         this._elements.forEach(n => this.onmouseover(n, () => this._onTargetMouseOver(n)));
         this._elements.forEach(n => this.onmouseleave(n, () => this._onTargetMouseLeave(n)));
     }

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

@@ -0,0 +1,80 @@
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { isMarkdownString } from '../../../../base/common/htmlContent.js';
+import { isString, isFunction } from '../../../../base/common/types.js';
+import { localizeWithPath } from '../../../../nls.js';
+const _moduleId = "vs/editor/browser/services/hoverService/updatableHoverWidget";
+class UpdatableHoverWidget {
+    constructor(hoverDelegate, target, fadeInAnimation) {
+        this.hoverDelegate = hoverDelegate;
+        this.target = target;
+        this.fadeInAnimation = fadeInAnimation;
+    }
+    async update(content, focus, options) {
+        if (this._cancellationTokenSource) {
+            this._cancellationTokenSource.dispose(true);
+            this._cancellationTokenSource = undefined;
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        let resolvedContent;
+        if (content === undefined || isString(content) || content instanceof HTMLElement) {
+            resolvedContent = content;
+        }
+        else if (!isFunction(content.markdown)) {
+            resolvedContent = content.markdown ?? content.markdownNotSupportedFallback;
+        }
+        else {
+            if (!this._hoverWidget) {
+                this.show(( localizeWithPath(_moduleId, 0, "Loading...")), focus);
+            }
+            this._cancellationTokenSource = ( (new CancellationTokenSource()));
+            const token = this._cancellationTokenSource.token;
+            resolvedContent = await content.markdown(token);
+            if (resolvedContent === undefined) {
+                resolvedContent = content.markdownNotSupportedFallback;
+            }
+            if (this.isDisposed || token.isCancellationRequested) {
+                return;
+            }
+        }
+        this.show(resolvedContent, focus, options);
+    }
+    show(content, focus, options) {
+        const oldHoverWidget = this._hoverWidget;
+        if (this.hasContent(content)) {
+            const hoverOptions = {
+                content,
+                target: this.target,
+                appearance: {
+                    showPointer: this.hoverDelegate.placement === 'element',
+                    skipFadeInAnimation: !this.fadeInAnimation || !!oldHoverWidget,
+                },
+                position: {
+                    hoverPosition: 2 ,
+                },
+                ...options
+            };
+            this._hoverWidget = this.hoverDelegate.showHover(hoverOptions, focus);
+        }
+        oldHoverWidget?.dispose();
+    }
+    hasContent(content) {
+        if (!content) {
+            return false;
+        }
+        if (isMarkdownString(content)) {
+            return !!content.value;
+        }
+        return true;
+    }
+    get isDisposed() {
+        return this._hoverWidget?.isDisposed;
+    }
+    dispose() {
+        this._hoverWidget?.dispose();
+        this._cancellationTokenSource?.dispose(true);
+        this._cancellationTokenSource = undefined;
+    }
+}
+export { UpdatableHoverWidget };

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

@@ -158,7 +158,7 @@ let OpenerService = class OpenerService {
             catch {
             }
         }
-        throw new Error('Could not resolve external URI: ' + resource.toString());
+        throw ( new Error('Could not resolve external URI: ' + ( resource.toString())));
     }
     async _doOpenExternal(resource, options) {
         const uri = typeof resource === 'string' ? ( URI.parse(resource)) : resource;

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

@@ -47,4 +47,40 @@ class StableEditorScrollState {
         editor.setScrollTop(editor.getScrollTop() + offset);
     }
 }
-export { StableEditorScrollState };
+class StableEditorBottomScrollState {
+    static capture(editor) {
+        if (editor.hasPendingScrollAnimation()) {
+            return ( new StableEditorBottomScrollState(editor.getScrollTop(), editor.getContentHeight(), null, 0));
+        }
+        let visiblePosition = null;
+        let visiblePositionScrollDelta = 0;
+        const visibleRanges = editor.getVisibleRanges();
+        if (visibleRanges.length > 0) {
+            visiblePosition = visibleRanges.at(-1).getEndPosition();
+            const visiblePositionScrollBottom = editor.getBottomForLineNumber(visiblePosition.lineNumber);
+            visiblePositionScrollDelta = (editor.getScrollTop() + editor.getLayoutInfo().height) - visiblePositionScrollBottom;
+        }
+        return ( new StableEditorBottomScrollState(
+            editor.getScrollTop(),
+            editor.getContentHeight(),
+            visiblePosition,
+            visiblePositionScrollDelta
+        ));
+    }
+    constructor(_initialScrollTop, _initialContentHeight, _visiblePosition, _visiblePositionScrollDelta) {
+        this._initialScrollTop = _initialScrollTop;
+        this._initialContentHeight = _initialContentHeight;
+        this._visiblePosition = _visiblePosition;
+        this._visiblePositionScrollDelta = _visiblePositionScrollDelta;
+    }
+    restore(editor) {
+        if (this._initialContentHeight === editor.getContentHeight() && this._initialScrollTop === editor.getScrollTop()) {
+            return;
+        }
+        if (this._visiblePosition) {
+            const visiblePositionScrollBottom = editor.getBottomForLineNumber(this._visiblePosition.lineNumber);
+            editor.setScrollTop(visiblePositionScrollBottom - (this._visiblePositionScrollDelta + editor.getLayoutInfo().height));
+        }
+    }
+}
+export { StableEditorBottomScrollState, StableEditorScrollState };

package/vscode/src/vs/editor/browser/view/viewLayer.js

@@ -32,7 +32,7 @@ class RenderedLinesCollection {
     getLine(lineNumber) {
         const lineIndex = lineNumber - this._rendLineNumberStart;
         if (lineIndex < 0 || lineIndex >= this._lines.length) {
-            throw new BugIndicatingError('Illegal value for lineNumber');
+            throw ( new BugIndicatingError('Illegal value for lineNumber'));
         }
         return this._lines[lineIndex];
     }