@codingame/monaco-vscode-api 16.1.1 → 17.1.0

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

@@ -10,10 +10,11 @@ import { IVisibleRangeProvider } from "../textArea/textAreaEditContext.js";
 import { IAccessibilityService } from "../../../../../platform/accessibility/common/accessibility.service.js";
 import { IEditorAriaOptions } from "../../../editorBrowser.js";
 export declare class NativeEditContext extends AbstractEditContext {
+    private readonly _viewController;
     private readonly _visibleRangeProvider;
     private readonly _accessibilityService;
-    private readonly _textArea;
     readonly domNode: FastDomNode<HTMLDivElement>;
+    private readonly _imeTextArea;
     private readonly _editContext;
     private readonly _screenReaderSupport;
     private _editContextPrimarySelection;
@@ -25,7 +26,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     private _scrollLeft;
     private readonly _focusTracker;
     private readonly _selectionChangeListener;
-    constructor(ownerID: string, context: ViewContext, overflowGuardContainer: FastDomNode<HTMLElement>, viewController: ViewController, _visibleRangeProvider: IVisibleRangeProvider, instantiationService: IInstantiationService, _accessibilityService: IAccessibilityService);
+    constructor(ownerID: string, context: ViewContext, overflowGuardContainer: FastDomNode<HTMLElement>, _viewController: ViewController, _visibleRangeProvider: IVisibleRangeProvider, instantiationService: IInstantiationService, _accessibilityService: IAccessibilityService);
     dispose(): void;
     setAriaOptions(options: IEditorAriaOptions): void;
     getLastRenderData(): Position | null;
@@ -40,13 +41,15 @@ export declare class NativeEditContext extends AbstractEditContext {
     onLinesInserted(e: ViewLinesInsertedEvent): boolean;
     onScrollChanged(e: ViewScrollChangedEvent): boolean;
     onZonesChanged(e: ViewZonesChangedEvent): boolean;
-    executePaste(): boolean;
+    onWillPaste(): void;
     private _onWillPaste;
     writeScreenReaderContent(): void;
     isFocused(): boolean;
     focus(): void;
     refreshFocusState(): void;
     setEditContextOnDomNode(): void;
+    private _onKeyUp;
+    private _onKeyDown;
     private _updateDomAttributes;
     private _updateEditContext;
     private _emitTypeEvent;

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

@@ -22,6 +22,8 @@ import { MutableDisposable } from '../../../../../base/common/lifecycle.js';
 import { EditContext } from './editContextFactory.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
 import { NativeEditContextRegistry } from './nativeEditContextRegistry.js';
+import { isHighSurrogate, isLowSurrogate } from '../../../../../base/common/strings.js';
+import { IME } from '../../../../../base/common/ime.js';
 
 registerCss(nativeEditContext);
 var CompositionClassName;
@@ -31,8 +33,9 @@ var CompositionClassName;
     CompositionClassName["PRIMARY"] = "edit-context-composition-primary";
 })(CompositionClassName || (CompositionClassName = {}));
 let NativeEditContext = class NativeEditContext extends AbstractEditContext {
-    constructor(ownerID, context, overflowGuardContainer, viewController, _visibleRangeProvider, instantiationService, _accessibilityService) {
+    constructor(ownerID, context, overflowGuardContainer, _viewController, _visibleRangeProvider, instantiationService, _accessibilityService) {
         super(context);
+        this._viewController = _viewController;
         this._visibleRangeProvider = _visibleRangeProvider;
         this._accessibilityService = _accessibilityService;
         this._editContextPrimarySelection = ( new Selection(1, 1, 1, 1));
@@ -43,21 +46,22 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._scrollLeft = 0;
         this.domNode = ( new FastDomNode(document.createElement('div')));
         this.domNode.setClassName(`native-edit-context`);
-        this._textArea = ( new FastDomNode(document.createElement('textarea')));
-        this._textArea.setClassName('native-edit-context-textarea');
-        this._textArea.setAttribute('tabindex', '-1');
+        this._imeTextArea = ( new FastDomNode(document.createElement('textarea')));
+        this._imeTextArea.setClassName(`ime-text-area`);
+        this._imeTextArea.setAttribute('readonly', 'true');
+        this._imeTextArea.setAttribute('tabindex', '-1');
         this.domNode.setAttribute('autocorrect', 'off');
         this.domNode.setAttribute('autocapitalize', 'off');
         this.domNode.setAttribute('autocomplete', 'off');
         this.domNode.setAttribute('spellcheck', 'false');
         this._updateDomAttributes();
         overflowGuardContainer.appendChild(this.domNode);
-        overflowGuardContainer.appendChild(this._textArea);
+        overflowGuardContainer.appendChild(this._imeTextArea);
         this._parent = overflowGuardContainer.domNode;
         this._selectionChangeListener = this._register(( new MutableDisposable()));
         this._focusTracker = this._register(( new FocusTracker(this.domNode.domNode, (newFocusValue) => {
             if (newFocusValue) {
-                this._selectionChangeListener.value = this._setSelectionChangeListener(viewController);
+                this._selectionChangeListener.value = this._setSelectionChangeListener(this._viewController);
                 this._screenReaderSupport.setIgnoreSelectionChangeTime('onFocus');
             }
             else {
@@ -73,36 +77,18 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._register(addDisposableListener(this.domNode.domNode, 'cut', (e) => {
             this._screenReaderSupport.setIgnoreSelectionChangeTime('onCut');
             this._ensureClipboardGetsEditorSelection(e);
-            viewController.cut();
-        }));
-        this._register(addDisposableListener(this.domNode.domNode, 'keyup', (e) => viewController.emitKeyUp(( new StandardKeyboardEvent(e)))));
-        this._register(addDisposableListener(this.domNode.domNode, 'keydown', async (e) => {
-            const standardKeyboardEvent = ( new StandardKeyboardEvent(e));
-            if (standardKeyboardEvent.keyCode === KeyCode.KEY_IN_COMPOSITION) {
-                standardKeyboardEvent.stopPropagation();
-            }
-            viewController.emitKeyDown(standardKeyboardEvent);
+            this._viewController.cut();
         }));
+        this._register(addDisposableListener(this.domNode.domNode, 'keyup', (e) => this._onKeyUp(e)));
+        this._register(addDisposableListener(this.domNode.domNode, 'keydown', async (e) => this._onKeyDown(e)));
+        this._register(addDisposableListener(this._imeTextArea.domNode, 'keyup', (e) => this._onKeyUp(e)));
+        this._register(addDisposableListener(this._imeTextArea.domNode, 'keydown', async (e) => this._onKeyDown(e)));
         this._register(addDisposableListener(this.domNode.domNode, 'beforeinput', async (e) => {
             if (e.inputType === 'insertParagraph' || e.inputType === 'insertLineBreak') {
-                this._onType(viewController, { text: '\n', replacePrevCharCnt: 0, replaceNextCharCnt: 0, positionDelta: 0 });
+                this._onType(this._viewController, { text: '\n', replacePrevCharCnt: 0, replaceNextCharCnt: 0, positionDelta: 0 });
             }
         }));
-        this._register(editContextAddDisposableListener(this._editContext, 'textformatupdate', (e) => this._handleTextFormatUpdate(e)));
-        this._register(editContextAddDisposableListener(this._editContext, 'characterboundsupdate', (e) => this._updateCharacterBounds(e)));
-        this._register(editContextAddDisposableListener(this._editContext, 'textupdate', (e) => {
-            this._emitTypeEvent(viewController, e);
-        }));
-        this._register(editContextAddDisposableListener(this._editContext, 'compositionstart', (e) => {
-            viewController.compositionStart();
-            this._context.viewModel.onCompositionStart();
-        }));
-        this._register(editContextAddDisposableListener(this._editContext, 'compositionend', (e) => {
-            viewController.compositionEnd();
-            this._context.viewModel.onCompositionEnd();
-        }));
-        this._register(addDisposableListener(this._textArea.domNode, 'paste', (e) => {
-            this._screenReaderSupport.setIgnoreSelectionChangeTime('onPaste');
+        this._register(addDisposableListener(this.domNode.domNode, 'paste', (e) => {
             e.preventDefault();
             if (!e.clipboardData) {
                 return;
@@ -122,14 +108,61 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
                 multicursorText = typeof metadata.multicursorText !== 'undefined' ? metadata.multicursorText : null;
                 mode = metadata.mode;
             }
-            viewController.paste(text, pasteOnNewLine, multicursorText, mode);
+            this._viewController.paste(text, pasteOnNewLine, multicursorText, mode);
+        }));
+        this._register(editContextAddDisposableListener(this._editContext, 'textformatupdate', (e) => this._handleTextFormatUpdate(e)));
+        this._register(editContextAddDisposableListener(this._editContext, 'characterboundsupdate', (e) => this._updateCharacterBounds(e)));
+        let highSurrogateCharacter;
+        this._register(editContextAddDisposableListener(this._editContext, 'textupdate', (e) => {
+            const text = e.text;
+            if (text.length === 1) {
+                const charCode = text.charCodeAt(0);
+                if (isHighSurrogate(charCode)) {
+                    highSurrogateCharacter = text;
+                    return;
+                }
+                if (isLowSurrogate(charCode) && highSurrogateCharacter) {
+                    const textUpdateEvent = {
+                        text: highSurrogateCharacter + text,
+                        selectionEnd: e.selectionEnd,
+                        selectionStart: e.selectionStart,
+                        updateRangeStart: e.updateRangeStart - 1,
+                        updateRangeEnd: e.updateRangeEnd - 1
+                    };
+                    highSurrogateCharacter = undefined;
+                    this._emitTypeEvent(this._viewController, textUpdateEvent);
+                    return;
+                }
+            }
+            this._emitTypeEvent(this._viewController, e);
+        }));
+        this._register(editContextAddDisposableListener(this._editContext, 'compositionstart', (e) => {
+            this._viewController.compositionStart();
+            this._context.viewModel.onCompositionStart();
+        }));
+        this._register(editContextAddDisposableListener(this._editContext, 'compositionend', (e) => {
+            this._viewController.compositionEnd();
+            this._context.viewModel.onCompositionEnd();
+        }));
+        let reenableTracking = false;
+        this._register(IME.onDidChange(() => {
+            if (IME.enabled && reenableTracking) {
+                this.domNode.focus();
+                this._focusTracker.resume();
+                reenableTracking = false;
+            }
+            if (!IME.enabled && this.isFocused()) {
+                this._focusTracker.pause();
+                this._imeTextArea.focus();
+                reenableTracking = true;
+            }
         }));
         this._register(NativeEditContextRegistry.register(ownerID, this));
     }
     dispose() {
         this.domNode.domNode.blur();
         this.domNode.domNode.remove();
-        this._textArea.domNode.remove();
+        this._imeTextArea.domNode.remove();
         super.dispose();
     }
     setAriaOptions(options) {
@@ -180,19 +213,8 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     onZonesChanged(e) {
         return true;
     }
-    executePaste() {
+    onWillPaste() {
         this._onWillPaste();
-        try {
-            this._focusTracker.pause();
-            this._textArea.focus();
-            const result = this._textArea.domNode.ownerDocument.execCommand('paste');
-            this._textArea.domNode.textContent = '';
-            this.domNode.focus();
-            return result;
-        }
-        finally {
-            this._focusTracker.resume();
-        }
     }
     _onWillPaste() {
         this._screenReaderSupport.setIgnoreSelectionChangeTime('onWillPaste');
@@ -218,6 +240,16 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             this._targetWindowId = targetWindowId;
         }
     }
+    _onKeyUp(e) {
+        this._viewController.emitKeyUp(( new StandardKeyboardEvent(e)));
+    }
+    _onKeyDown(e) {
+        const standardKeyboardEvent = ( new StandardKeyboardEvent(e));
+        if (standardKeyboardEvent.keyCode === KeyCode.KEY_IN_COMPOSITION) {
+            standardKeyboardEvent.stopPropagation();
+        }
+        this._viewController.emitKeyDown(standardKeyboardEvent);
+    }
     _updateDomAttributes() {
         const options = this._context.configuration.options;
         this.domNode.domNode.setAttribute('tabindex', String(options.get(EditorOption.tabIndex)));
@@ -348,18 +380,17 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             return;
         }
         const options = this._context.configuration.options;
-        const lineHeight = options.get(EditorOption.lineHeight);
         const contentLeft = options.get(EditorOption.layoutInfo).contentLeft;
         const parentBounds = this._parent.getBoundingClientRect();
-        const modelStartPosition = this._primarySelection.getStartPosition();
-        const viewStartPosition = this._context.viewModel.coordinatesConverter.convertModelPositionToViewPosition(modelStartPosition);
-        const verticalOffsetStart = this._context.viewLayout.getVerticalOffsetForLineNumber(viewStartPosition.lineNumber);
+        const viewSelection = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(this._primarySelection);
+        const verticalOffsetStart = this._context.viewLayout.getVerticalOffsetForLineNumber(viewSelection.startLineNumber);
         const top = parentBounds.top + verticalOffsetStart - this._scrollTop;
-        const height = (this._primarySelection.endLineNumber - this._primarySelection.startLineNumber + 1) * lineHeight;
+        const verticalOffsetEnd = this._context.viewLayout.getVerticalOffsetAfterLineNumber(viewSelection.endLineNumber);
+        const height = verticalOffsetEnd - verticalOffsetStart;
         let left = parentBounds.left + contentLeft - this._scrollLeft;
         let width;
         if (this._primarySelection.isEmpty()) {
-            const linesVisibleRanges = ctx.visibleRangeForPosition(viewStartPosition);
+            const linesVisibleRanges = ctx.visibleRangeForPosition(viewSelection.getStartPosition());
             if (linesVisibleRanges) {
                 left += linesVisibleRanges.left;
             }
@@ -378,7 +409,6 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         }
         const options = this._context.configuration.options;
         const typicalHalfWidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
-        const lineHeight = options.get(EditorOption.lineHeight);
         const contentLeft = options.get(EditorOption.layoutInfo).contentLeft;
         const parentBounds = this._parent.getBoundingClientRect();
         const characterBounds = [];
@@ -394,7 +424,8 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             const characterModelRange = Range.fromPositions(characterStartPosition, characterEndPosition);
             const characterViewRange = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(characterModelRange);
             const characterLinesVisibleRanges = this._visibleRangeProvider.linesVisibleRangesForRange(characterViewRange, true) ?? [];
-            const characterVerticalOffset = this._context.viewLayout.getVerticalOffsetForLineNumber(characterViewRange.startLineNumber);
+            const lineNumber = characterViewRange.startLineNumber;
+            const characterVerticalOffset = this._context.viewLayout.getVerticalOffsetForLineNumber(lineNumber);
             const top = parentBounds.top + characterVerticalOffset - this._scrollTop;
             let left = 0;
             let width = typicalHalfWidthCharacterWidth;
@@ -405,6 +436,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
                     break;
                 }
             }
+            const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(lineNumber);
             characterBounds.push(( new DOMRect(
                 parentBounds.left + contentLeft + left - this._scrollLeft,
                 top,
@@ -437,7 +469,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         let previousSelectionChangeEventTime = 0;
         return addDisposableListener(this.domNode.domNode.ownerDocument, 'selectionchange', () => {
             const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
-            if (!this.isFocused() || !isScreenReaderOptimized) {
+            if (!this.isFocused() || !isScreenReaderOptimized || !IME.enabled) {
                 return;
             }
             const screenReaderContentState = this._screenReaderSupport.screenReaderContentState;

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

@@ -15,7 +15,6 @@ export declare class ScreenReaderSupport {
     private _contentWidth;
     private _contentHeight;
     private _divWidth;
-    private _lineHeight;
     private _fontInfo;
     private _accessibilityPageSize;
     private _ignoreSelectionChangeTime;

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

@@ -20,7 +20,6 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         this._contentWidth = 1;
         this._contentHeight = 1;
         this._divWidth = 1;
-        this._lineHeight = 1;
         this._accessibilityPageSize = 1;
         this._ignoreSelectionChangeTime = 0;
         this._primarySelection = ( new Selection(1, 1, 1, 1));
@@ -52,7 +51,6 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         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);
     }
@@ -99,10 +97,10 @@ let ScreenReaderSupport = class ScreenReaderSupport {
             this._renderAtTopLeft();
             return;
         }
-        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);
+        const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(positionLineNumber);
+        const lineNumberWithinStateAboveCursor = positionLineNumber - this._screenReaderContentState.startPositionWithinEditor.lineNumber;
+        const scrollTop = lineNumberWithinStateAboveCursor * lineHeight;
+        this._doRender(scrollTop, top, this._contentLeft, this._divWidth, lineHeight);
     }
     _renderAtTopLeft() {
         this._doRender(0, 0, 0, this._contentWidth, 1);
@@ -113,6 +111,7 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         this._domNode.setLeft(left);
         this._domNode.setWidth(width);
         this._domNode.setHeight(height);
+        this._domNode.setLineHeight(height);
         this._domNode.domNode.scrollTop = scrollTop;
     }
     setAriaOptions(options) {
@@ -138,9 +137,14 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
         if (isScreenReaderOptimized) {
             this._screenReaderContentState = this._getScreenReaderContentState();
-            if (this._domNode.domNode.textContent !== this._screenReaderContentState.value) {
+            const endPosition = this._context.viewModel.model.getPositionAt(Infinity);
+            let value = this._screenReaderContentState.value;
+            if (endPosition.column === 1 && this._primarySelection.getEndPosition().equals(endPosition)) {
+                value += '\n';
+            }
+            if (this._domNode.domNode.textContent !== value) {
                 this.setIgnoreSelectionChangeTime('setValue');
-                this._domNode.domNode.textContent = this._screenReaderContentState.value;
+                this._domNode.domNode.textContent = value;
             }
             this._setSelectionOfScreenReaderContent(this._screenReaderContentState.selectionStart, this._screenReaderContentState.selectionEnd);
         }

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

@@ -28,7 +28,6 @@ export declare class TextAreaEditContext extends AbstractEditContext {
     private _contentWidth;
     private _contentHeight;
     private _fontInfo;
-    private _lineHeight;
     private _emptySelectionClipboard;
     private _copyWithSyntaxHighlighting;
     private _visibleTextArea;

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

@@ -102,7 +102,6 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         this._contentWidth = layoutInfo.contentWidth;
         this._contentHeight = layoutInfo.height;
         this._fontInfo = options.get(EditorOption.fontInfo);
-        this._lineHeight = options.get(EditorOption.lineHeight);
         this._emptySelectionClipboard = options.get(EditorOption.emptySelectionClipboard);
         this._copyWithSyntaxHighlighting = options.get(EditorOption.copyWithSyntaxHighlighting);
         this._visibleTextArea = null;
@@ -421,7 +420,6 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         this._contentWidth = layoutInfo.contentWidth;
         this._contentHeight = layoutInfo.height;
         this._fontInfo = options.get(EditorOption.fontInfo);
-        this._lineHeight = options.get(EditorOption.lineHeight);
         this._emptySelectionClipboard = options.get(EditorOption.emptySelectionClipboard);
         this._copyWithSyntaxHighlighting = options.get(EditorOption.copyWithSyntaxHighlighting);
         this.textArea.setAttribute('wrap', this._textAreaWrapping && !this._visibleTextArea ? 'on' : 'off');
@@ -534,19 +532,21 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
                 if (width > this._contentWidth) {
                     width = this._contentWidth;
                 }
+                const viewPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(( new Position(startPosition.lineNumber, 1)));
+                const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(viewPosition.lineNumber);
                 const viewLineData = this._context.viewModel.getViewLineData(startPosition.lineNumber);
                 const startTokenIndex = viewLineData.tokens.findTokenIndexAtOffset(startPosition.column - 1);
                 const endTokenIndex = viewLineData.tokens.findTokenIndexAtOffset(endPosition.column - 1);
                 const textareaSpansSingleToken = (startTokenIndex === endTokenIndex);
                 const presentation = this._visibleTextArea.definePresentation((textareaSpansSingleToken ? viewLineData.tokens.getPresentation(startTokenIndex) : null));
-                this.textArea.domNode.scrollTop = lineCount * this._lineHeight;
+                this.textArea.domNode.scrollTop = lineCount * lineHeight;
                 this.textArea.domNode.scrollLeft = scrollLeft;
                 this._doRender({
                     lastRenderPosition: null,
                     top: top,
                     left: left,
                     width: width,
-                    height: this._lineHeight,
+                    height: lineHeight,
                     useCover: false,
                     color: (TokenizationRegistry.getColorMap() || [])[presentation.foreground],
                     italic: presentation.italic,
@@ -572,17 +572,19 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
             return;
         }
         if (isMacintosh || this._accessibilitySupport === AccessibilitySupport.Enabled) {
+            const lineNumber = this._primaryCursorPosition.lineNumber;
+            const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(lineNumber);
             this._doRender({
                 lastRenderPosition: this._primaryCursorPosition,
                 top,
                 left: this._textAreaWrapping ? this._contentLeft : left,
                 width: this._textAreaWidth,
-                height: this._lineHeight,
+                height: lineHeight,
                 useCover: false
             });
             this.textArea.domNode.scrollLeft = this._primaryCursorVisibleRange.left;
             const lineCount = this._textAreaInput.textAreaState.newlineCountBeforeSelection ?? newlinecount(this.textArea.domNode.value.substring(0, this.textArea.domNode.selectionStart));
-            this.textArea.domNode.scrollTop = lineCount * this._lineHeight;
+            this.textArea.domNode.scrollTop = lineCount * lineHeight;
             return;
         }
         this._doRender({
@@ -613,6 +615,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         ta.setLeft(renderData.left);
         ta.setWidth(renderData.width);
         ta.setHeight(renderData.height);
+        ta.setLineHeight(renderData.height);
         ta.setColor(renderData.color ? Color.Format.CSS.formatHex(renderData.color) : '');
         ta.setFontStyle(renderData.italic ? 'italic' : '');
         if (renderData.bold) {

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

@@ -372,6 +372,9 @@ class TextAreaWrapper extends Disposable {
     constructor(_actual) {
         super();
         this._actual = _actual;
+        this._onSyntheticTap = this._register(( new Emitter()));
+        this.onSyntheticTap = this._onSyntheticTap.event;
+        this._ignoreSelectionChangeTime = 0;
         this.onKeyDown = this._register(( new DomEmitter(this._actual, 'keydown'))).event;
         this.onKeyPress = this._register(( new DomEmitter(this._actual, 'keypress'))).event;
         this.onKeyUp = this._register(( new DomEmitter(this._actual, 'keyup'))).event;
@@ -385,9 +388,6 @@ class TextAreaWrapper extends Disposable {
         this.onPaste = this._register(( new DomEmitter(this._actual, 'paste'))).event;
         this.onFocus = this._register(( new DomEmitter(this._actual, 'focus'))).event;
         this.onBlur = this._register(( new DomEmitter(this._actual, 'blur'))).event;
-        this._onSyntheticTap = this._register(( new Emitter()));
-        this.onSyntheticTap = this._onSyntheticTap.event;
-        this._ignoreSelectionChangeTime = 0;
         this._register(this.onKeyDown(() => inputLatency.onKeyDown()));
         this._register(this.onBeforeInput(() => inputLatency.onBeforeInput()));
         this._register(this.onInput(() => inputLatency.onInput()));

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

@@ -849,8 +849,8 @@ function shadowCaretRangeFromPoint(shadowRoot, x, y) {
                 pixelCursor += step;
             }
         }
-        range.setStart(el.firstChild, offset);
-        range.setEnd(el.firstChild, offset);
+        range.setStart(el.firstChild ?? el, offset);
+        range.setEnd(el.firstChild ?? el, offset);
     }
     return range;
 }

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

@@ -14,7 +14,7 @@ import { IDiffComputationResult, ILineChange } from "../common/diff/legacyLinesD
 import * as editorCommon from "../common/editorCommon.js";
 import { GlyphMarginLane, ICursorStateComputer, IIdentifiedSingleEditOperation, IModelDecoration, IModelDeltaDecoration, ITextModel, PositionAffinity } from "../common/model.js";
 import { InjectedText } from "../common/modelLineProjectionData.js";
-import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent } from "../common/textModelEvents.js";
+import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent, ModelLineHeightChangedEvent } from "../common/textModelEvents.js";
 import { IEditorWhitespace, IViewModel } from "../common/viewModel.js";
 import { OverviewRulerZone } from "../common/viewModel/overviewZoneManager.js";
 import { MenuId } from "../../platform/actions/common/actions.js";

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

@@ -8,7 +8,7 @@ export type ObjectCollectionPropertyValues<T extends ObjectCollectionBufferPrope
     [K in T[number]["name"]]: number;
 };
 export interface IObjectCollectionBuffer<T extends ObjectCollectionBufferPropertySpec[]> extends IDisposable {
-    readonly buffer: ArrayBuffer;
+    readonly buffer: ArrayBufferLike;
     readonly view: Float32Array;
     readonly bufferUsedSize: number;
     readonly viewUsedSize: number;

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

@@ -388,6 +388,7 @@ class DecorationTypeOptionsProvider {
         this.glyphMarginClassName = createCSSRules(ModelDecorationCSSRuleType.GlyphMarginClassName);
         const options = providerArgs.options;
         this.isWholeLine = Boolean(options.isWholeLine);
+        this.lineHeight = options.lineHeight;
         this.stickiness = options.rangeBehavior;
         const lightOverviewRulerColor = options.light && options.light.overviewRulerColor || options.overviewRulerColor;
         const darkOverviewRulerColor = options.dark && options.dark.overviewRulerColor || options.overviewRulerColor;
@@ -412,6 +413,7 @@ class DecorationTypeOptionsProvider {
             className: this.className,
             glyphMarginClassName: this.glyphMarginClassName,
             isWholeLine: this.isWholeLine,
+            lineHeight: this.lineHeight,
             overviewRuler: this.overviewRuler,
             stickiness: this.stickiness,
             before: this.beforeInjectedText,

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

@@ -11,12 +11,20 @@
 	color: var(--vscode-editorHoverWidget-foreground);
 	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
 }
+.monaco-workbench .workbench-hover .monaco-action-bar .action-item .codicon {
+	width: 13px;
+	height: 13px;
+}
 .monaco-workbench .workbench-hover hr {
 	border-bottom: none;
 }
 .monaco-workbench .workbench-hover.compact {
 	font-size: 12px;
 }
+.monaco-workbench .workbench-hover.compact .monaco-action-bar .action-item .codicon {
+	width: 12px;
+	height: 12px;
+}
 .monaco-workbench .workbench-hover.compact .hover-contents {
 	padding: 2px 8px;
 }

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

@@ -28,6 +28,7 @@ export declare class HoverWidget extends Widget implements IHoverWidget {
     private _isLocked;
     private _enableFocusTraps;
     private _addedFocusTrap;
+    private _maxHeightRatioRelativeToWindow;
     private get _targetWindow();
     private get _targetDocumentElement();
     get isDisposed(): boolean;

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

@@ -69,6 +69,7 @@ let HoverWidget = class HoverWidget extends Widget {
         this._isLocked = false;
         this._enableFocusTraps = false;
         this._addedFocusTrap = false;
+        this._maxHeightRatioRelativeToWindow = 0.5;
         this._onDispose = this._register(( new Emitter()));
         this._onRequestLayout = this._register(( new Emitter()));
         this._linkHandler = options.linkHandler || (url => {
@@ -90,6 +91,10 @@ let HoverWidget = class HoverWidget extends Widget {
         if (options.trapFocus) {
             this._enableFocusTraps = true;
         }
+        const maxHeightRatio = options.appearance?.maxHeightRatio;
+        if (maxHeightRatio !== undefined && maxHeightRatio > 0 && maxHeightRatio <= 1) {
+            this._maxHeightRatioRelativeToWindow = maxHeightRatio;
+        }
         this._hoverPosition = options.position?.hoverPosition === undefined
             ? HoverPosition.ABOVE
             : isNumber(options.position.hoverPosition)
@@ -427,7 +432,7 @@ let HoverWidget = class HoverWidget extends Widget {
         }
     }
     adjustHoverMaxHeight(target) {
-        let maxHeight = this._targetWindow.innerHeight / 2;
+        let maxHeight = this._targetWindow.innerHeight * this._maxHeightRatioRelativeToWindow;
         if (this._forcePosition) {
             const padding = (this._hoverPointer ? Constants.PointerSize : 0) + Constants.HoverBorderWidth;
             if (this._hoverPosition === HoverPosition.ABOVE) {

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

@@ -22,6 +22,7 @@ export declare abstract class RestrictedRenderingContext {
     getScrolledTopFromAbsoluteTop(absoluteTop: number): number;
     getVerticalOffsetForLineNumber(lineNumber: number, includeViewZones?: boolean): number;
     getVerticalOffsetAfterLineNumber(lineNumber: number, includeViewZones?: boolean): number;
+    getLineHeightForLineNumber(lineNumber: number): number;
     getDecorationsInViewport(): ViewModelDecoration[];
 }
 export declare class RenderingContext extends RestrictedRenderingContext {

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

@@ -24,6 +24,9 @@ class RestrictedRenderingContext {
     getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones) {
         return this._viewLayout.getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones);
     }
+    getLineHeightForLineNumber(lineNumber) {
+        return this._viewLayout.getLineHeightForLineNumber(lineNumber);
+    }
     getDecorationsInViewport() {
         return this.viewportData.getDecorationsInViewport();
     }

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

@@ -2,6 +2,7 @@ import { FastDomNode } from "../../../base/browser/fastDomNode.js";
 import { StringBuilder } from "../../common/core/stringBuilder.js";
 import * as viewEvents from "../../common/viewEvents.js";
 import { ViewportData } from "../../common/viewLayout/viewLinesViewportData.js";
+import { ViewContext } from "../../common/viewModel/viewContext.js";
 export interface IVisibleLine extends ILine {
     getDomNode(): HTMLElement | null;
     setDomNode(domNode: HTMLElement): void;
@@ -39,10 +40,11 @@ export declare class RenderedLinesCollection<T extends ILine> {
     }[]): boolean;
 }
 export declare class VisibleLinesCollection<T extends IVisibleLine> {
+    private readonly _viewContext;
     private readonly _lineFactory;
     readonly domNode: FastDomNode<HTMLElement>;
     private readonly _linesCollection;
-    constructor(_lineFactory: ILineFactory<T>);
+    constructor(_viewContext: ViewContext, _lineFactory: ILineFactory<T>);
     private _createDomNode;
     onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean;
     onFlushed(e: viewEvents.ViewFlushedEvent, flushDom?: boolean): boolean;