@codingame/monaco-vscode-api 19.1.4 → 20.0.1

package/vscode/src/vs/editor/browser/controller/mouseHandler.js

@@ -1,11 +1,11 @@
 
-import { addDisposableListener, EventType, getWindow, getShadowRoot, isKeyboardEvent, scheduleAtNextAnimationFrame } from '../../../base/browser/dom.js';
+import { addDisposableListener, EventType, getWindow, getShadowRoot, isKeyboardEvent } from '../../../base/browser/dom.js';
 import { StandardWheelEvent } from '../../../base/browser/mouseEvent.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { isMacintosh } from '../../../base/common/platform.js';
 import { MouseTargetFactory, HitTestContext, MouseTarget } from './mouseTarget.js';
 import { MouseTargetType } from '../editorBrowser.js';
-import { EditorMouseEventFactory, EditorMouseEvent, ClientCoordinates, createEditorPagePosition, createCoordinatesRelativeToEditor, GlobalEditorPointerMoveMonitor, PageCoordinates } from '../editorDom.js';
+import { EditorMouseEventFactory, EditorMouseEvent, ClientCoordinates, createEditorPagePosition, createCoordinatesRelativeToEditor, GlobalEditorPointerMoveMonitor } from '../editorDom.js';
 import { EditorZoom } from '../../common/config/editorZoom.js';
 import { Position } from '../../common/core/position.js';
 import { Selection } from '../../common/core/selection.js';
@@ -13,6 +13,7 @@ import { ViewEventHandler } from '../../common/viewEventHandler.js';
 import { EditorOption } from '../../common/config/editorOptions.js';
 import { NavigationCommandRevealType } from '../coreCommands.js';
 import { MouseWheelClassifier } from '../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { TopBottomDragScrolling, LeftRightDragScrolling } from './dragScrolling.js';
 
 class MouseHandler extends ViewEventHandler {
     constructor(context, viewController, viewHelper) {
@@ -249,6 +250,12 @@ class MouseDownOperation extends Disposable {
             this._mouseTargetFactory,
             (position, inSelectionMode, revealType) => this._dispatchMouse(position, inSelectionMode, revealType)
         )));
+        this._leftRightDragScrolling = this._register(( new LeftRightDragScrolling(
+            this._context,
+            this._viewHelper,
+            this._mouseTargetFactory,
+            (position, inSelectionMode, revealType) => this._dispatchMouse(position, inSelectionMode, revealType)
+        )));
         this._mouseState = ( new MouseDownState());
         this._currentSelection = ( new Selection(1, 1, 1, 1));
         this._isActive = false;
@@ -274,11 +281,19 @@ class MouseDownOperation extends Disposable {
             });
         }
         else {
-            if (position.type === MouseTargetType.OUTSIDE_EDITOR && (position.outsidePosition === 'above' || position.outsidePosition === 'below')) {
-                this._topBottomDragScrolling.start(position, e);
+            if (position.type === MouseTargetType.OUTSIDE_EDITOR) {
+                if (position.outsidePosition === 'above' || position.outsidePosition === 'below') {
+                    this._topBottomDragScrolling.start(position, e);
+                    this._leftRightDragScrolling.stop();
+                }
+                else {
+                    this._leftRightDragScrolling.start(position, e);
+                    this._topBottomDragScrolling.stop();
+                }
             }
             else {
                 this._topBottomDragScrolling.stop();
+                this._leftRightDragScrolling.stop();
                 this._dispatchMouse(position, true, NavigationCommandRevealType.Minimal);
             }
         }
@@ -332,6 +347,7 @@ class MouseDownOperation extends Disposable {
     _stop() {
         this._isActive = false;
         this._topBottomDragScrolling.stop();
+        this._leftRightDragScrolling.stop();
     }
     onHeightChanged() {
         this._mouseMoveMonitor.stopMonitoring();
@@ -374,12 +390,19 @@ class MouseDownOperation extends Disposable {
             return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(belowLineNumber, model.getLineMaxColumn(belowLineNumber))), 'below', outsideDistance);
         }
         const possibleLineNumber = viewLayout.getLineNumberAtVerticalOffset(viewLayout.getCurrentScrollTop() + e.relativePos.y);
-        if (e.posx < editorContent.x) {
-            const outsideDistance = editorContent.x - e.posx;
+        const horizontalScrollPadding = 10;
+        const layoutInfo = this._context.configuration.options.get(EditorOption.layoutInfo);
+        const xLeftBoundary = layoutInfo.contentLeft + horizontalScrollPadding;
+        if (e.relativePos.x <= xLeftBoundary) {
+            const outsideDistance = xLeftBoundary - e.relativePos.x;
             return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(possibleLineNumber, 1)), 'left', outsideDistance);
         }
-        if (e.posx > editorContent.x + editorContent.width) {
-            const outsideDistance = e.posx - editorContent.x - editorContent.width;
+        const contentRight = (layoutInfo.minimap.minimapLeft === 0
+            ? layoutInfo.width - layoutInfo.verticalScrollbarWidth
+            : layoutInfo.minimap.minimapLeft);
+        const xRightBoundary = contentRight - horizontalScrollPadding;
+        if (e.relativePos.x >= xRightBoundary) {
+            const outsideDistance = e.relativePos.x - xRightBoundary;
             return MouseTarget.createOutsideEditor(mouseColumn, ( new Position(possibleLineNumber, model.getLineMaxColumn(possibleLineNumber))), 'right', outsideDistance);
         }
         return null;
@@ -440,112 +463,6 @@ class MouseDownOperation extends Disposable {
         });
     }
 }
-class TopBottomDragScrolling extends Disposable {
-    constructor(_context, _viewHelper, _mouseTargetFactory, _dispatchMouse) {
-        super();
-        this._context = _context;
-        this._viewHelper = _viewHelper;
-        this._mouseTargetFactory = _mouseTargetFactory;
-        this._dispatchMouse = _dispatchMouse;
-        this._operation = null;
-    }
-    dispose() {
-        super.dispose();
-        this.stop();
-    }
-    start(position, mouseEvent) {
-        if (this._operation) {
-            this._operation.setPosition(position, mouseEvent);
-        }
-        else {
-            this._operation = ( new TopBottomDragScrollingOperation(
-                this._context,
-                this._viewHelper,
-                this._mouseTargetFactory,
-                this._dispatchMouse,
-                position,
-                mouseEvent
-            ));
-        }
-    }
-    stop() {
-        if (this._operation) {
-            this._operation.dispose();
-            this._operation = null;
-        }
-    }
-}
-class TopBottomDragScrollingOperation extends Disposable {
-    constructor(_context, _viewHelper, _mouseTargetFactory, _dispatchMouse, position, mouseEvent) {
-        super();
-        this._context = _context;
-        this._viewHelper = _viewHelper;
-        this._mouseTargetFactory = _mouseTargetFactory;
-        this._dispatchMouse = _dispatchMouse;
-        this._position = position;
-        this._mouseEvent = mouseEvent;
-        this._lastTime = Date.now();
-        this._animationFrameDisposable = scheduleAtNextAnimationFrame(getWindow(mouseEvent.browserEvent), () => this._execute());
-    }
-    dispose() {
-        this._animationFrameDisposable.dispose();
-        super.dispose();
-    }
-    setPosition(position, mouseEvent) {
-        this._position = position;
-        this._mouseEvent = mouseEvent;
-    }
-    _tick() {
-        const now = Date.now();
-        const elapsed = now - this._lastTime;
-        this._lastTime = now;
-        return elapsed;
-    }
-    _getScrollSpeed() {
-        const lineHeight = this._context.configuration.options.get(EditorOption.lineHeight);
-        const viewportInLines = this._context.configuration.options.get(EditorOption.layoutInfo).height / lineHeight;
-        const outsideDistanceInLines = this._position.outsideDistance / lineHeight;
-        if (outsideDistanceInLines <= 1.5) {
-            return Math.max(30, viewportInLines * (1 + outsideDistanceInLines));
-        }
-        if (outsideDistanceInLines <= 3) {
-            return Math.max(60, viewportInLines * (2 + outsideDistanceInLines));
-        }
-        return Math.max(200, viewportInLines * (7 + outsideDistanceInLines));
-    }
-    _execute() {
-        const lineHeight = this._context.configuration.options.get(EditorOption.lineHeight);
-        const scrollSpeedInLines = this._getScrollSpeed();
-        const elapsed = this._tick();
-        const scrollInPixels = scrollSpeedInLines * (elapsed / 1000) * lineHeight;
-        const scrollValue = (this._position.outsidePosition === 'above' ? -scrollInPixels : scrollInPixels);
-        this._context.viewModel.viewLayout.deltaScrollNow(0, scrollValue);
-        this._viewHelper.renderNow();
-        const viewportData = this._context.viewLayout.getLinesViewportData();
-        const edgeLineNumber = (this._position.outsidePosition === 'above' ? viewportData.startLineNumber : viewportData.endLineNumber);
-        let mouseTarget;
-        {
-            const editorPos = createEditorPagePosition(this._viewHelper.viewDomNode);
-            const horizontalScrollbarHeight = this._context.configuration.options.get(EditorOption.layoutInfo).horizontalScrollbarHeight;
-            const pos = ( new PageCoordinates(
-                this._mouseEvent.pos.x,
-                editorPos.y + editorPos.height - horizontalScrollbarHeight - 0.1
-            ));
-            const relativePos = createCoordinatesRelativeToEditor(this._viewHelper.viewDomNode, editorPos, pos);
-            mouseTarget = this._mouseTargetFactory.createMouseTarget(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
-        }
-        if (!mouseTarget.position || mouseTarget.position.lineNumber !== edgeLineNumber) {
-            if (this._position.outsidePosition === 'above') {
-                mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, ( new Position(edgeLineNumber, 1)), 'above', this._position.outsideDistance);
-            }
-            else {
-                mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, ( new Position(edgeLineNumber, this._context.viewModel.getLineMaxColumn(edgeLineNumber))), 'below', this._position.outsideDistance);
-            }
-        }
-        this._dispatchMouse(mouseTarget, true, NavigationCommandRevealType.None);
-        this._animationFrameDisposable = scheduleAtNextAnimationFrame(getWindow(mouseTarget.element), () => this._execute());
-    }
-}
 class MouseDownState {
     static { this.CLEAR_MOUSE_DOWN_COUNT_TIME = 400; }
     get altKey() { return this._altKey; }

package/vscode/src/vs/editor/browser/controller/mouseTarget.d.ts

@@ -77,6 +77,7 @@ export declare class HitTestContext {
     findAttribute(element: Element, attr: string): string | null;
     private static _findAttribute;
     getLineWidth(lineNumber: number): number;
+    isRtl(lineNumber: number): boolean;
     visibleRangeForPosition(lineNumber: number, column: number): HorizontalPosition | null;
     getPositionFromDOMInfo(spanNode: HTMLElement, offset: number): Position | null;
     getCurrentScrollTop(): number;

package/vscode/src/vs/editor/browser/controller/mouseTarget.js

@@ -9,7 +9,7 @@ import { Range } from '../../common/core/range.js';
 import { CursorColumns } from '../../common/core/cursorColumns.js';
 import { getRootContainer, getWindow, getShadowRoot, createElement } from '../../../base/browser/dom.js';
 import { AtomicTabMoveOperations, Direction } from '../../common/cursor/cursorAtomicMoveOperations.js';
-import { PositionAffinity } from '../../common/model.js';
+import { TextDirection, PositionAffinity } from '../../common/model.js';
 import { Lazy } from '../../../base/common/lazy.js';
 
 var HitTestResultType;
@@ -283,6 +283,9 @@ class HitTestContext {
     getLineWidth(lineNumber) {
         return this._viewHelper.getLineWidth(lineNumber);
     }
+    isRtl(lineNumber) {
+        return this.viewModel.getTextDirection(lineNumber) === TextDirection.RTL;
+    }
     visibleRangeForPosition(lineNumber, column) {
         return this._viewHelper.visibleRangeForPosition(lineNumber, column);
     }
@@ -551,13 +554,21 @@ class MouseTargetFactory {
         }
         if (ElementPath.isStrictChildOfViewLines(request.targetPath)) {
             const lineNumber = ctx.getLineNumberAtVerticalOffset(request.mouseVerticalOffset);
-            if (ctx.viewModel.getLineLength(lineNumber) === 0) {
-                const lineWidth = ctx.getLineWidth(lineNumber);
+            const lineLength = ctx.viewModel.getLineLength(lineNumber);
+            const lineWidth = ctx.getLineWidth(lineNumber);
+            if (lineLength === 0) {
                 const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
                 return request.fulfillContentEmpty(( new Position(lineNumber, 1)), detail);
             }
-            const lineWidth = ctx.getLineWidth(lineNumber);
-            if (request.mouseContentHorizontalOffset >= lineWidth) {
+            const isRtl = ctx.isRtl(lineNumber);
+            if (isRtl) {
+                if (request.mouseContentHorizontalOffset + lineWidth <= ctx.layoutInfo.contentWidth - ctx.layoutInfo.verticalScrollbarWidth) {
+                    const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
+                    const pos = ( new Position(lineNumber, ctx.viewModel.getLineMaxColumn(lineNumber)));
+                    return request.fulfillContentEmpty(pos, detail);
+                }
+            }
+            else if (request.mouseContentHorizontalOffset >= lineWidth) {
                 const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
                 const pos = ( new Position(lineNumber, ctx.viewModel.getLineMaxColumn(lineNumber)));
                 return request.fulfillContentEmpty(pos, detail);
@@ -572,7 +583,15 @@ class MouseTargetFactory {
                     return request.fulfillContentEmpty(( new Position(lineNumber, 1)), detail);
                 }
                 const lineWidth = ctx.getLineWidth(lineNumber);
-                if (request.mouseContentHorizontalOffset >= lineWidth) {
+                const isRtl = ctx.isRtl(lineNumber);
+                if (isRtl) {
+                    if (request.mouseContentHorizontalOffset + lineWidth <= ctx.layoutInfo.contentWidth - ctx.layoutInfo.verticalScrollbarWidth) {
+                        const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
+                        const pos = ( new Position(lineNumber, ctx.viewModel.getLineMaxColumn(lineNumber)));
+                        return request.fulfillContentEmpty(pos, detail);
+                    }
+                }
+                else if (request.mouseContentHorizontalOffset >= lineWidth) {
                     const detail = createEmptyContentDataInLines(request.mouseContentHorizontalOffset - lineWidth);
                     const pos = ( new Position(lineNumber, ctx.viewModel.getLineMaxColumn(lineNumber)));
                     return request.fulfillContentEmpty(pos, detail);
@@ -817,7 +836,7 @@ class MouseTargetFactory {
 function shadowCaretRangeFromPoint(shadowRoot, x, y) {
     const range = document.createRange();
     let el = shadowRoot.elementFromPoint(x, y);
-    if (el !== null) {
+    if (el?.hasChildNodes()) {
         while (el && el.firstChild && el.firstChild.nodeType !== el.firstChild.TEXT_NODE && el.lastChild && el.lastChild.firstChild) {
             el = el.lastChild;
         }

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

@@ -7,7 +7,7 @@ import { ServicesAccessor } from "../../platform/instantiation/common/instantiat
 import { IViewModel } from "../common/viewModel.js";
 import { ISelection } from "../common/core/selection.js";
 export declare abstract class CoreEditorCommand<T> extends EditorCommand {
-    runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args?: Partial<T> | null): void;
+    runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args?: Partial<T> | null): void;
     abstract runCoreEditorCommand(viewModel: IViewModel, args: Partial<T>): void;
 }
 export declare namespace EditorScroll_ {
@@ -192,12 +192,12 @@ export declare namespace CoreEditingCommands {
     const DeleteRight: EditorCommand;
     const Undo: {
         runDOMCommand(activeElement: Element): void;
-        runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args: unknown): void | Promise<void>;
+        runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: unknown): void | Promise<void>;
         _runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args: unknown): boolean | Promise<void>;
     };
     const Redo: {
         runDOMCommand(activeElement: Element): void;
-        runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args: unknown): void | Promise<void>;
+        runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: unknown): void | Promise<void>;
         _runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args: unknown): boolean | Promise<void>;
     };
 }

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

@@ -21,7 +21,7 @@ import { MenuId } from "../../platform/actions/common/actions.js";
 import { IContextKeyService } from "../../platform/contextkey/common/contextkey.service.js";
 import { ServicesAccessor } from "../../platform/instantiation/common/instantiation.js";
 import { TextEdit } from "../common/core/edits/textEdit.js";
-import { TextModelEditReason } from "../common/textModelEditReason.js";
+import { TextModelEditSource } from "../common/textModelEditSource.js";
 export interface IViewZone {
     afterLineNumber: number;
     afterColumn?: number;

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

@@ -83,9 +83,9 @@ export interface EditorControllerCommand<T extends IEditorContribution> {
 }
 export declare abstract class EditorCommand extends Command {
     static bindToContribution<T extends IEditorContribution>(controllerGetter: (editor: ICodeEditor) => T | null): EditorControllerCommand<T>;
-    static runEditorCommand(accessor: ServicesAccessor, args: any, precondition: ContextKeyExpression | undefined, runner: (accessor: ServicesAccessor | null, editor: ICodeEditor, args: any) => void | Promise<void>): void | Promise<void>;
+    static runEditorCommand(accessor: ServicesAccessor, args: any, precondition: ContextKeyExpression | undefined, runner: (accessor: ServicesAccessor, editor: ICodeEditor, args: any) => void | Promise<void>): void | Promise<void>;
     runCommand(accessor: ServicesAccessor, args: any): void | Promise<void>;
-    abstract runEditorCommand(accessor: ServicesAccessor | null, editor: ICodeEditor, args: any): void | Promise<void>;
+    abstract runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void | Promise<void>;
 }
 export interface IEditorActionContextMenuOptions {
     group: string;

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlas.js

@@ -100,7 +100,7 @@ let TextureAtlas = class TextureAtlas extends Disposable {
             throw ( new BugIndicatingError('Cannot warm atlas without color map'));
         }
         this._warmUpTask.value?.clear();
-        const taskQueue = this._warmUpTask.value = ( new IdleTaskQueue());
+        const taskQueue = this._warmUpTask.value = this._instantiationService.createInstance(IdleTaskQueue);
         for (let code = CharCode.A; code <= CharCode.Z; code++) {
             for (const fgColor of ( colorMap.keys())) {
                 taskQueue.enqueue(() => {

package/vscode/src/vs/editor/browser/gpu/taskQueue.d.ts

@@ -1,4 +1,6 @@
 import { Disposable, type IDisposable } from "../../../base/common/lifecycle.js";
+import { IInstantiationService } from "../../../platform/instantiation/common/instantiation.js";
+import { ILogService } from "../../../platform/log/common/log.service.js";
 export interface ITaskQueue extends IDisposable {
     enqueue(task: () => boolean | void): void;
     flush(): void;
@@ -9,10 +11,11 @@ interface ITaskDeadline {
 }
 type CallbackWithDeadline = (deadline: ITaskDeadline) => void;
 declare abstract class TaskQueue extends Disposable implements ITaskQueue {
+    private readonly _logService;
     private _tasks;
     private _idleCallback?;
     private _i;
-    constructor();
+    constructor(_logService: ILogService);
     protected abstract _requestCallback(callback: CallbackWithDeadline): number;
     protected abstract _cancelCallback(identifier: number): void;
     enqueue(task: () => boolean | void): void;
@@ -33,7 +36,7 @@ declare class IdleTaskQueueInternal extends TaskQueue {
 export declare const IdleTaskQueue: typeof PriorityTaskQueue | typeof IdleTaskQueueInternal;
 export declare class DebouncedIdleTask {
     private _queue;
-    constructor();
+    constructor(instantiationService: IInstantiationService);
     set(task: () => boolean | void): void;
     flush(): void;
 }

package/vscode/src/vs/editor/browser/gpu/taskQueue.js

@@ -1,10 +1,14 @@
 
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { getActiveWindow } from '../../../base/browser/dom.js';
 import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import '../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../platform/log/common/log.service.js';
 
-class TaskQueue extends Disposable {
-    constructor() {
+let TaskQueue = class TaskQueue extends Disposable {
+    constructor(_logService) {
         super();
+        this._logService = _logService;
         this._tasks = [];
         this._i = 0;
         this._register(toDisposable(() => this.clear()));
@@ -50,7 +54,7 @@ class TaskQueue extends Disposable {
             deadlineRemaining = deadline.timeRemaining();
             if (longestTask * 1.5 > deadlineRemaining) {
                 if (lastDeadlineRemaining - taskDuration < -20) {
-                    console.warn(`task queue exceeded allotted deadline by ${Math.abs(Math.round(lastDeadlineRemaining - taskDuration))}ms`);
+                    this._logService.warn(`task queue exceeded allotted deadline by ${Math.abs(Math.round(lastDeadlineRemaining - taskDuration))}ms`);
                 }
                 this._start();
                 return;
@@ -59,7 +63,10 @@ class TaskQueue extends Disposable {
         }
         this.clear();
     }
-}
+};
+TaskQueue = ( __decorate([
+    ( __param(0, ILogService))
+], TaskQueue));
 class PriorityTaskQueue extends TaskQueue {
     _requestCallback(callback) {
         return getActiveWindow().setTimeout(() => callback(this._createDeadline(16)));

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.js

@@ -17,8 +17,8 @@ import { RectangleRenderer } from './rectangleRenderer.js';
 import { DecorationCssRuleExtractor } from './css/decorationCssRuleExtractor.js';
 import { Event } from '../../../base/common/event.js';
 import { EditorOption } from '../../common/config/editorOptions.js';
-import { InlineDecorationType } from '../../common/viewModel.js';
 import { DecorationStyleCache } from './css/decorationStyleCache.js';
+import { InlineDecorationType } from '../../common/viewModel/inlineDecorations.js';
 import Severity$1 from '../../../base/common/severity.js';
 import { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
 import { runOnChange } from '../../../base/common/observableInternal/utils/runOnChange.js';

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

@@ -4,7 +4,7 @@ import { IProgress, IProgressStep } from "../../../platform/progress/common/prog
 import { URI } from "../../../base/common/uri.js";
 import { UndoRedoSource } from "../../../platform/undoRedo/common/undoRedo.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
-import { TextModelEditReason } from "../../common/textModelEditReason.js";
+import { TextModelEditSource } from "../../common/textModelEditSource.js";
 export declare class ResourceEdit {
     readonly metadata?: WorkspaceEditMetadata | undefined;
     protected constructor(metadata?: WorkspaceEditMetadata | undefined);
@@ -44,7 +44,7 @@ export interface IBulkEditOptions {
     undoRedoGroupId?: number;
     confirmBeforeUndo?: boolean;
     respectAutoSaveConfig?: boolean;
-    reason?: TextModelEditReason;
+    reason?: TextModelEditSource;
 }
 export interface IBulkEditResult {
     ariaSummary: string;

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

@@ -55,7 +55,7 @@ export declare class EditorWorkerClient extends Disposable implements IEditorWor
     private _worker;
     private _modelManager;
     private _disposed;
-    constructor(_workerDescriptorOrWorker: IWebWorkerDescriptor | Worker, keepIdleModels: boolean, modelService: IModelService);
+    constructor(_workerDescriptorOrWorker: IWebWorkerDescriptor | Worker | Promise<Worker>, keepIdleModels: boolean, modelService: IModelService);
     fhr(method: string, args: any[]): Promise<any>;
     private _getOrCreateWorker;
     protected _getProxy(): Promise<Proxied<EditorWorker>>;

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 "../../../../base/browser/ui/hover/hover.js";
+import { type IHoverLifecycleOptions, type IHoverOptions, type IHoverWidget, type IManagedHover, type IManagedHoverContentOrFactory, type 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 {

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

@@ -25,13 +25,15 @@ 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 { isManagedHoverTooltipMarkdownString } from '../../../../base/browser/ui/hover/hover.js';
 import { ManagedHoverWidget } from './updatableHoverWidget.js';
 import { timeout, TimeoutTimer } from '../../../../base/common/async.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
-import { isNumber } from '../../../../base/common/types.js';
+import { isNumber, isString } from '../../../../base/common/types.js';
 import { KeyChord, KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
 import { KeybindingsRegistry, KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { stripIcons } from '../../../../base/common/iconLabels.js';
 
 let HoverService = class HoverService extends Disposable {
     constructor(_instantiationService, _configurationService, contextMenuService, _keybindingService, _layoutService, _accessibilityService) {
@@ -287,6 +289,9 @@ let HoverService = class HoverService extends Disposable {
         }
     }
     setupManagedHover(hoverDelegate, targetElement, content, options) {
+        if (hoverDelegate.showNativeHover) {
+            return setupNativeHover(targetElement, content);
+        }
         targetElement.setAttribute('custom-hover', 'true');
         if (targetElement.title !== '') {
             console.warn('HTML element already has a title attribute, which will conflict with the custom hover. Please remove the title attribute.');
@@ -426,6 +431,33 @@ function getHoverIdFromContent(content) {
     }
     return content.value;
 }
+function getStringContent(contentOrFactory) {
+    const content = typeof contentOrFactory === 'function' ? contentOrFactory() : contentOrFactory;
+    if (isString(content)) {
+        return stripIcons(content);
+    }
+    if (isManagedHoverTooltipMarkdownString(content)) {
+        return content.markdownNotSupportedFallback;
+    }
+    return undefined;
+}
+function setupNativeHover(targetElement, content) {
+    function updateTitle(title) {
+        if (title) {
+            targetElement.setAttribute('title', title);
+        }
+        else {
+            targetElement.removeAttribute('title');
+        }
+    }
+    updateTitle(getStringContent(content));
+    return {
+        update: (content) => updateTitle(getStringContent(content)),
+        show: () => { },
+        hide: () => { },
+        dispose: () => updateTitle(undefined),
+    };
+}
 class HoverContextViewDelegate {
     get anchorPosition() {
         return this._hover.anchor;

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

@@ -8,6 +8,7 @@ export declare class ManagedHoverWidget implements IDisposable {
     private _hoverWidget;
     private _cancellationTokenSource;
     constructor(hoverDelegate: IHoverDelegate, target: IHoverDelegateTarget | HTMLElement, fadeInAnimation: boolean);
+    onDidHide(): void;
     update(content: IManagedHoverContent, focus?: boolean, options?: IManagedHoverOptions): Promise<void>;
     private show;
     private hasContent;

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

@@ -13,6 +13,12 @@ class ManagedHoverWidget {
         this.target = target;
         this.fadeInAnimation = fadeInAnimation;
     }
+    onDidHide() {
+        if (this._cancellationTokenSource) {
+            this._cancellationTokenSource.dispose(true);
+            this._cancellationTokenSource = undefined;
+        }
+    }
     async update(content, focus, options) {
         if (this._cancellationTokenSource) {
             this._cancellationTokenSource.dispose(true);

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

@@ -3,9 +3,11 @@ import { Disposable } from "../../../base/common/lifecycle.js";
 import { Action2 } from "../../../platform/actions/common/actions.js";
 import { IContextKeyService } from "../../../platform/contextkey/common/contextkey.service.js";
 import { ServicesAccessor } from "../../../platform/instantiation/common/instantiation.js";
+import { ITelemetryService } from "../../../platform/telemetry/common/telemetry.service.js";
 import { IInlineCompletionsService } from "./inlineCompletionsService.service.js";
 export declare class InlineCompletionsService extends Disposable implements IInlineCompletionsService {
     private _contextKeyService;
+    private _telemetryService;
     readonly _serviceBrand: undefined;
     private _onDidChangeIsSnoozing;
     readonly onDidChangeIsSnoozing: Event<boolean>;
@@ -13,11 +15,12 @@ export declare class InlineCompletionsService extends Disposable implements IInl
     private _snoozeTimeEnd;
     get snoozeTimeLeft(): number;
     private _timer;
-    constructor(_contextKeyService: IContextKeyService);
+    constructor(_contextKeyService: IContextKeyService, _telemetryService: ITelemetryService);
     snooze(durationMs?: number): void;
     setSnoozeDuration(durationMs: number): void;
     isSnoozing(): boolean;
     cancelSnooze(): void;
+    private _reportSnooze;
 }
 export declare class SnoozeInlineCompletion extends Action2 {
     static ID: string;

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

@@ -12,6 +12,7 @@ import '../../../platform/instantiation/common/extensions.js';
 import { IQuickInputService } from '../../../platform/quickinput/common/quickInput.service.js';
 import { StorageScope, StorageTarget } from '../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../platform/storage/common/storage.service.js';
+import { ITelemetryService } from '../../../platform/telemetry/common/telemetry.service.js';
 import { IInlineCompletionsService } from './inlineCompletionsService.service.js';
 
 var InlineCompletionsService_1;
@@ -25,9 +26,10 @@ let InlineCompletionsService = class InlineCompletionsService extends Disposable
         }
         return Math.max(0, this._snoozeTimeEnd - Date.now());
     }
-    constructor(_contextKeyService) {
+    constructor(_contextKeyService, _telemetryService) {
         super();
         this._contextKeyService = _contextKeyService;
+        this._telemetryService = _telemetryService;
         this._onDidChangeIsSnoozing = this._register(( new Emitter()));
         this.onDidChangeIsSnoozing = this._onDidChangeIsSnoozing.event;
         this._snoozeTimeEnd = undefined;
@@ -47,6 +49,7 @@ let InlineCompletionsService = class InlineCompletionsService extends Disposable
             return;
         }
         const wasSnoozing = this.isSnoozing();
+        const timeLeft = this.snoozeTimeLeft;
         this._snoozeTimeEnd = Date.now() + durationMs;
         if (!wasSnoozing) {
             this._onDidChangeIsSnoozing.fire(true);
@@ -59,20 +62,28 @@ let InlineCompletionsService = class InlineCompletionsService extends Disposable
                 throw ( new BugIndicatingError('Snooze timer did not fire as expected'));
             }
         }, this.snoozeTimeLeft + 1);
+        this._reportSnooze(durationMs - timeLeft, durationMs);
     }
     isSnoozing() {
         return this.snoozeTimeLeft > 0;
     }
     cancelSnooze() {
         if (this.isSnoozing()) {
+            this._reportSnooze(-this.snoozeTimeLeft, 0);
             this._snoozeTimeEnd = undefined;
             this._timer.cancel();
             this._onDidChangeIsSnoozing.fire(false);
         }
     }
+    _reportSnooze(deltaMs, totalMs) {
+        const deltaSeconds = Math.round(deltaMs / 1000);
+        const totalSeconds = Math.round(totalMs / 1000);
+        this._telemetryService.publicLog2('inlineCompletions.snooze', { deltaSeconds, totalSeconds });
+    }
 };
 InlineCompletionsService = InlineCompletionsService_1 = ( __decorate([
-    ( __param(0, IContextKeyService))
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ITelemetryService))
 ], InlineCompletionsService));
 const snoozeInlineSuggestId = 'editor.action.inlineSuggest.snooze';
 const cancelSnoozeInlineSuggestId = 'editor.action.inlineSuggest.cancelSnooze';

package/vscode/src/vs/editor/browser/view/domLineBreaksComputer.d.ts

@@ -5,5 +5,5 @@ export declare class DOMLineBreaksComputerFactory implements ILineBreaksComputer
     private targetWindow;
     static create(targetWindow: Window): DOMLineBreaksComputerFactory;
     constructor(targetWindow: WeakRef<Window>);
-    createLineBreaksComputer(fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll"): ILineBreaksComputer;
+    createLineBreaksComputer(fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll", wrapOnEscapedLineFeeds: boolean): ILineBreaksComputer;
 }