@codingame/monaco-vscode-api 19.1.4 → 20.0.1

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

@@ -1,48 +1,77 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { getActiveWindow } from '../../../../../base/browser/dom.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
 import { localize } from '../../../../../nls.js';
-import { AccessibilitySupport } from '../../../../../platform/accessibility/common/accessibility.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
 import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
 import { EditorOption } from '../../../../common/config/editorOptions.js';
 import { Selection } from '../../../../common/core/selection.js';
 import { applyFontInfo } from '../../../config/domFontInfo.js';
-import { ariaLabelForScreenReaderContent, PagedScreenReaderStrategy } from '../screenReaderUtils.js';
+import { ariaLabelForScreenReaderContent } from '../screenReaderUtils.js';
+import { RichScreenReaderContent } from './screenReaderContentRich.js';
+import { SimpleScreenReaderContent } from './screenReaderContentSimple.js';
 
-let ScreenReaderSupport = class ScreenReaderSupport {
-    constructor(_domNode, _context, _keybindingService, _accessibilityService) {
+let ScreenReaderSupport = class ScreenReaderSupport extends Disposable {
+    constructor(_domNode, _context, _viewController, _keybindingService, _accessibilityService) {
+        super();
         this._domNode = _domNode;
         this._context = _context;
+        this._viewController = _viewController;
         this._keybindingService = _keybindingService;
         this._accessibilityService = _accessibilityService;
         this._contentLeft = 1;
         this._contentWidth = 1;
         this._contentHeight = 1;
         this._divWidth = 1;
-        this._accessibilityPageSize = 1;
-        this._ignoreSelectionChangeTime = 0;
         this._primarySelection = ( new Selection(1, 1, 1, 1));
         this._primaryCursorVisibleRange = null;
+        this._state = this._register(( new MutableDisposable()));
+        this._instantiateScreenReaderContent();
         this._updateConfigurationSettings();
         this._updateDomAttributes();
     }
-    setIgnoreSelectionChangeTime(reason) {
-        this._ignoreSelectionChangeTime = Date.now();
+    onWillPaste() {
+        this._state.value?.onWillPaste();
     }
-    getIgnoreSelectionChangeTime() {
-        return this._ignoreSelectionChangeTime;
+    onWillCut() {
+        this._state.value?.onWillCut();
     }
-    resetSelectionChangeTime() {
-        this._ignoreSelectionChangeTime = 0;
+    handleFocusChange(newFocusValue) {
+        this._state.value?.onFocusChange(newFocusValue);
     }
     onConfigurationChanged(e) {
+        this._instantiateScreenReaderContent();
         this._updateConfigurationSettings();
         this._updateDomAttributes();
         if (e.hasChanged(EditorOption.accessibilitySupport)) {
             this.writeScreenReaderContent();
         }
     }
+    _instantiateScreenReaderContent() {
+        const renderRichContent = this._context.configuration.options.get(EditorOption.renderRichScreenReaderContent);
+        if (this._renderRichContent !== renderRichContent) {
+            this._renderRichContent = renderRichContent;
+            this._state.value = this._createScreenReaderContent(renderRichContent);
+        }
+    }
+    _createScreenReaderContent(renderRichContent) {
+        if (renderRichContent) {
+            return ( new RichScreenReaderContent(
+                this._domNode,
+                this._context,
+                this._viewController,
+                this._accessibilityService
+            ));
+        }
+        else {
+            return ( new SimpleScreenReaderContent(
+                this._domNode,
+                this._context,
+                this._viewController,
+                this._accessibilityService
+            ));
+        }
+    }
     _updateConfigurationSettings() {
         const options = this._context.configuration.options;
         const layoutInfo = options.get(EditorOption.layoutInfo);
@@ -51,8 +80,8 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         this._contentWidth = layoutInfo.contentWidth;
         this._contentHeight = layoutInfo.height;
         this._fontInfo = options.get(EditorOption.fontInfo);
-        this._accessibilityPageSize = options.get(EditorOption.accessibilityPageSize);
         this._divWidth = Math.round(wrappingColumn * this._fontInfo.typicalHalfwidthCharacterWidth);
+        this._state.value?.onConfigurationChanged(options);
     }
     _updateDomAttributes() {
         const options = this._context.configuration.options;
@@ -78,9 +107,6 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         this._primaryCursorVisibleRange = ctx.visibleRangeForPosition(this._primarySelection.getPosition());
     }
     render(ctx) {
-        if (!this._screenReaderContentState) {
-            return;
-        }
         if (!this._primaryCursorVisibleRange) {
             this._renderAtTopLeft();
             return;
@@ -99,21 +125,19 @@ let ScreenReaderSupport = class ScreenReaderSupport {
             return;
         }
         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);
+        this._doRender(top, this._contentLeft, this._divWidth, lineHeight);
+        this._state.value?.updateScrollTop(this._primarySelection);
     }
     _renderAtTopLeft() {
-        this._doRender(0, 0, 0, this._contentWidth, 1);
+        this._doRender(0, 0, this._contentWidth, 1);
     }
-    _doRender(scrollTop, top, left, width, height) {
+    _doRender(top, left, width, height) {
         applyFontInfo(this._domNode, this._fontInfo);
         this._domNode.setTop(top);
         this._domNode.setLeft(left);
         this._domNode.setWidth(width);
         this._domNode.setHeight(height);
         this._domNode.setLineHeight(height);
-        this._domNode.domNode.scrollTop = scrollTop;
     }
     setAriaOptions(options) {
         if (options.activeDescendant) {
@@ -131,74 +155,12 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         }
     }
     writeScreenReaderContent() {
-        const focusedElement = getActiveWindow().document.activeElement;
-        if (!focusedElement || focusedElement !== this._domNode.domNode) {
-            return;
-        }
-        const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
-        if (isScreenReaderOptimized) {
-            this._screenReaderContentState = this._getScreenReaderContentState();
-            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 = value;
-            }
-            this._setSelectionOfScreenReaderContent(this._screenReaderContentState.selectionStart, this._screenReaderContentState.selectionEnd);
-        }
-        else {
-            this._screenReaderContentState = undefined;
-            this.setIgnoreSelectionChangeTime('setValue');
-            this._domNode.domNode.textContent = '';
-        }
-    }
-    get screenReaderContentState() {
-        return this._screenReaderContentState;
-    }
-    _getScreenReaderContentState() {
-        const simpleModel = {
-            getLineCount: () => {
-                return this._context.viewModel.getLineCount();
-            },
-            getLineMaxColumn: (lineNumber) => {
-                return this._context.viewModel.getLineMaxColumn(lineNumber);
-            },
-            getValueInRange: (range, eol) => {
-                return this._context.viewModel.getValueInRange(range, eol);
-            },
-            getValueLengthInRange: (range, eol) => {
-                return this._context.viewModel.getValueLengthInRange(range, eol);
-            },
-            modifyPosition: (position, offset) => {
-                return this._context.viewModel.modifyPosition(position, offset);
-            }
-        };
-        return PagedScreenReaderStrategy.fromEditorSelection(simpleModel, this._primarySelection, this._accessibilityPageSize, this._accessibilityService.getAccessibilitySupport() === AccessibilitySupport.Unknown);
-    }
-    _setSelectionOfScreenReaderContent(selectionOffsetStart, selectionOffsetEnd) {
-        const activeDocument = getActiveWindow().document;
-        const activeDocumentSelection = activeDocument.getSelection();
-        if (!activeDocumentSelection) {
-            return;
-        }
-        const textContent = this._domNode.domNode.firstChild;
-        if (!textContent) {
-            return;
-        }
-        const range = new globalThis.Range();
-        range.setStart(textContent, selectionOffsetStart);
-        range.setEnd(textContent, selectionOffsetEnd);
-        this.setIgnoreSelectionChangeTime('setRange');
-        activeDocumentSelection.removeAllRanges();
-        activeDocumentSelection.addRange(range);
+        this._state.value?.updateScreenReaderContent(this._primarySelection);
     }
 };
 ScreenReaderSupport = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IAccessibilityService))
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IAccessibilityService))
 ], ScreenReaderSupport));
 
 export { ScreenReaderSupport };

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

@@ -0,0 +1,11 @@
+import { IComputedEditorOptions } from "../../../../common/config/editorOptions.js";
+import { Selection } from "../../../../common/core/selection.js";
+export interface IScreenReaderContent {
+    dispose(): void;
+    onWillCut(): void;
+    onWillPaste(): void;
+    onFocusChange(newFocusValue: boolean): void;
+    onConfigurationChanged(options: IComputedEditorOptions): void;
+    updateScreenReaderContent(primarySelection: Selection): void;
+    updateScrollTop(primarySelection: Selection): void;
+}

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

@@ -1,16 +1,13 @@
-import { EndOfLinePreference } from "../../../common/model.js";
 import { Position } from "../../../common/core/position.js";
 import { Range } from "../../../common/core/range.js";
+import { Selection } from "../../../common/core/selection.js";
 import { IComputedEditorOptions } from "../../../common/config/editorOptions.js";
 import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.service.js";
-export interface ISimpleModel {
-    getLineCount(): number;
-    getLineMaxColumn(lineNumber: number): number;
-    getValueInRange(range: Range, eol: EndOfLinePreference): string;
-    getValueLengthInRange(range: Range, eol: EndOfLinePreference): number;
-    modifyPosition(position: Position, offset: number): Position;
+import { ISimpleModel } from "../../../common/viewModel/screenReaderSimpleModel.js";
+export interface IPagedScreenReaderStrategy<T> {
+    fromEditorSelection(model: ISimpleModel, selection: Selection, linesPerPage: number, trimLongText: boolean): T;
 }
-export interface ScreenReaderContentState {
+export interface ISimpleScreenReaderContentState {
     value: string;
     selectionStart: number;
     selectionEnd: number;
@@ -18,10 +15,10 @@ export interface ScreenReaderContentState {
     startPositionWithinEditor: Position;
     newlineCountBeforeSelection: number;
 }
-export declare class PagedScreenReaderStrategy {
-    private static _getPageOfLine;
-    private static _getRangeForPage;
-    static fromEditorSelection(model: ISimpleModel, selection: Range, linesPerPage: number, trimLongText: boolean): ScreenReaderContentState;
+export declare class SimplePagedScreenReaderStrategy implements IPagedScreenReaderStrategy<ISimpleScreenReaderContentState> {
+    private _getPageOfLine;
+    private _getRangeForPage;
+    fromEditorSelection(model: ISimpleModel, selection: Selection, linesPerPage: number, trimLongText: boolean): ISimpleScreenReaderContentState;
 }
 export declare function ariaLabelForScreenReaderContent(options: IComputedEditorOptions, keybindingService: IKeybindingService): string;
 export declare function newlinecount(text: string): number;

package/vscode/src/vs/editor/browser/controller/editContext/screenReaderUtils.js

@@ -1,26 +1,27 @@
 
 import { EndOfLinePreference } from '../../../common/model.js';
 import { Range } from '../../../common/core/range.js';
+import { SelectionDirection } from '../../../common/core/selection.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { AccessibilitySupport } from '../../../../platform/accessibility/common/accessibility.js';
 import { localize } from '../../../../nls.js';
 
-class PagedScreenReaderStrategy {
-    static _getPageOfLine(lineNumber, linesPerPage) {
+class SimplePagedScreenReaderStrategy {
+    _getPageOfLine(lineNumber, linesPerPage) {
         return Math.floor((lineNumber - 1) / linesPerPage);
     }
-    static _getRangeForPage(page, linesPerPage) {
+    _getRangeForPage(page, linesPerPage) {
         const offset = page * linesPerPage;
         const startLineNumber = offset + 1;
         const endLineNumber = offset + linesPerPage;
         return ( new Range(startLineNumber, 1, endLineNumber + 1, 1));
     }
-    static fromEditorSelection(model, selection, linesPerPage, trimLongText) {
+    fromEditorSelection(model, selection, linesPerPage, trimLongText) {
         const LIMIT_CHARS = 500;
-        const selectionStartPage = PagedScreenReaderStrategy._getPageOfLine(selection.startLineNumber, linesPerPage);
-        const selectionStartPageRange = PagedScreenReaderStrategy._getRangeForPage(selectionStartPage, linesPerPage);
-        const selectionEndPage = PagedScreenReaderStrategy._getPageOfLine(selection.endLineNumber, linesPerPage);
-        const selectionEndPageRange = PagedScreenReaderStrategy._getRangeForPage(selectionEndPage, linesPerPage);
+        const selectionStartPage = this._getPageOfLine(selection.startLineNumber, linesPerPage);
+        const selectionStartPageRange = this._getRangeForPage(selectionStartPage, linesPerPage);
+        const selectionEndPage = this._getPageOfLine(selection.endLineNumber, linesPerPage);
+        const selectionEndPageRange = this._getRangeForPage(selectionEndPage, linesPerPage);
         let pretextRange = selectionStartPageRange.intersectRanges(( new Range(1, 1, selection.startLineNumber, selection.startColumn)));
         if (trimLongText && model.getValueLengthInRange(pretextRange, EndOfLinePreference.LF) > LIMIT_CHARS) {
             const pretextStart = model.modifyPosition(pretextRange.getEndPosition(), -LIMIT_CHARS);
@@ -49,11 +50,21 @@ class PagedScreenReaderStrategy {
         if (trimLongText && text.length > 2 * LIMIT_CHARS) {
             text = text.substring(0, LIMIT_CHARS) + String.fromCharCode(8230) + text.substring(text.length - LIMIT_CHARS, text.length);
         }
+        let selectionStart;
+        let selectionEnd;
+        if (selection.getDirection() === SelectionDirection.LTR) {
+            selectionStart = pretext.length;
+            selectionEnd = pretext.length + text.length;
+        }
+        else {
+            selectionEnd = pretext.length;
+            selectionStart = pretext.length + text.length;
+        }
         return {
             value: pretext + text + posttext,
             selection: selection,
-            selectionStart: pretext.length,
-            selectionEnd: pretext.length + text.length,
+            selectionStart,
+            selectionEnd,
             startPositionWithinEditor: pretextRange.getStartPosition(),
             newlineCountBeforeSelection: pretextRange.endLineNumber - pretextRange.startLineNumber,
         };
@@ -109,4 +120,4 @@ function newlinecount(text) {
     return result;
 }
 
-export { PagedScreenReaderStrategy, ariaLabelForScreenReaderContent, newlinecount };
+export { SimplePagedScreenReaderStrategy, ariaLabelForScreenReaderContent, newlinecount };

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

@@ -28,7 +28,7 @@ import { IKeybindingService } from '../../../../../platform/keybinding/common/ke
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { AbstractEditContext } from '../editContext.js';
 import { TextAreaWrapper, TextAreaInput } from './textAreaEditContextInput.js';
-import { ariaLabelForScreenReaderContent, PagedScreenReaderStrategy, newlinecount } from '../screenReaderUtils.js';
+import { ariaLabelForScreenReaderContent, SimplePagedScreenReaderStrategy, newlinecount } from '../screenReaderUtils.js';
 import { getDataToCopy } from '../clipboardUtils.js';
 import { TextAreaState } from './textAreaEditContextState.js';
 import { getMapForWordSeparators, WordCharacterClass } from '../../../../common/core/wordCharacterClassifier.js';
@@ -131,23 +131,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         this.textAreaCover.setPosition('absolute');
         overflowGuardContainer.appendChild(this.textArea);
         overflowGuardContainer.appendChild(this.textAreaCover);
-        const simpleModel = {
-            getLineCount: () => {
-                return this._context.viewModel.getLineCount();
-            },
-            getLineMaxColumn: (lineNumber) => {
-                return this._context.viewModel.getLineMaxColumn(lineNumber);
-            },
-            getValueInRange: (range, eol) => {
-                return this._context.viewModel.getValueInRange(range, eol);
-            },
-            getValueLengthInRange: (range, eol) => {
-                return this._context.viewModel.getValueLengthInRange(range, eol);
-            },
-            modifyPosition: (position, offset) => {
-                return this._context.viewModel.modifyPosition(position, offset);
-            }
-        };
+        const simplePagedScreenReaderStrategy = ( new SimplePagedScreenReaderStrategy());
         const textAreaInputHost = {
             getDataToCopy: () => {
                 return getDataToCopy(this._context.viewModel, this._modelSelections, this._emptySelectionClipboard, this._copyWithSyntaxHighlighting);
@@ -172,8 +156,8 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
                         }
                     }
                     const LIMIT_CHARS = 500;
-                    if (isMacintosh && !selection.isEmpty() && simpleModel.getValueLengthInRange(selection, EndOfLinePreference.TextDefined) < LIMIT_CHARS) {
-                        const text = simpleModel.getValueInRange(selection, EndOfLinePreference.TextDefined);
+                    if (isMacintosh && !selection.isEmpty() && this._context.viewModel.getValueLengthInRange(selection, EndOfLinePreference.TextDefined) < LIMIT_CHARS) {
+                        const text = this._context.viewModel.getValueInRange(selection, EndOfLinePreference.TextDefined);
                         return ( new TextAreaState(text, 0, text.length, selection, 0));
                     }
                     if (isSafari && !selection.isEmpty()) {
@@ -199,7 +183,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
                     }
                     return TextAreaState.EMPTY;
                 }
-                const screenReaderContentState = PagedScreenReaderStrategy.fromEditorSelection(simpleModel, this._selections[0], this._accessibilityPageSize, this._accessibilitySupport === AccessibilitySupport.Unknown);
+                const screenReaderContentState = simplePagedScreenReaderStrategy.fromEditorSelection(this._context.viewModel, this._selections[0], this._accessibilityPageSize, this._accessibilitySupport === AccessibilitySupport.Unknown);
                 return TextAreaState.fromScreenReaderContentState(screenReaderContentState);
             },
             deduceModelPosition: (viewAnchorPosition, deltaOffset, lineFeedCnt) => {

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

@@ -13,9 +13,11 @@ import { OperatingSystem } from '../../../../../base/common/platform.js';
 import { isHighSurrogate } from '../../../../../base/common/strings.js';
 import { Selection } from '../../../../common/core/selection.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
+import { LogLevel } from '../../../../../platform/log/common/log.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
-import { ClipboardEventUtils, InMemoryClipboardMetadataManager } from '../clipboardUtils.js';
+import { InMemoryClipboardMetadataManager, ClipboardEventUtils } from '../clipboardUtils.js';
 import { TextAreaState } from './textAreaEditContextState.js';
+import { generateUuid } from '../../../../../base/common/uuid.js';
 
 var TextAreaSyntethicEvents;
 (function (TextAreaSyntethicEvents) {
@@ -184,28 +186,41 @@ let TextAreaInput = class TextAreaInput extends Disposable {
                 || typeInput.replacePrevCharCnt !== 0
                 || typeInput.replaceNextCharCnt !== 0
                 || typeInput.positionDelta !== 0) {
-                this._onType.fire(typeInput);
+                if (e.inputType === 'insertFromPaste') {
+                    this._onPaste.fire({
+                        text: typeInput.text,
+                        metadata: InMemoryClipboardMetadataManager.INSTANCE.get(typeInput.text)
+                    });
+                }
+                else {
+                    this._onType.fire(typeInput);
+                }
             }
         }));
         this._register(this._textArea.onCut((e) => {
+            this._logService.trace(`TextAreaInput#onCut`, e);
             this._textArea.setIgnoreSelectionChangeTime('received cut event');
             this._ensureClipboardGetsEditorSelection(e);
             this._asyncTriggerCut.schedule();
         }));
         this._register(this._textArea.onCopy((e) => {
+            this._logService.trace(`TextAreaInput#onCopy`, e);
             this._ensureClipboardGetsEditorSelection(e);
         }));
         this._register(this._textArea.onPaste((e) => {
+            this._logService.trace(`TextAreaInput#onPaste`, e);
             this._textArea.setIgnoreSelectionChangeTime('received paste event');
             e.preventDefault();
             if (!e.clipboardData) {
                 return;
             }
             let [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
+            this._logService.trace(`TextAreaInput#onPaste with id : `, metadata?.id, ' with text.length: ', text.length);
             if (!text) {
                 return;
             }
             metadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
+            this._logService.trace(`TextAreaInput#onPaste (before onPaste)`);
             this._onPaste.fire({
                 text: text,
                 metadata: metadata
@@ -347,8 +362,13 @@ let TextAreaInput = class TextAreaInput extends Disposable {
     }
     _ensureClipboardGetsEditorSelection(e) {
         const dataToCopy = this._host.getDataToCopy();
+        let id = undefined;
+        if (this._logService.getLevel() === LogLevel.Trace) {
+            id = generateUuid();
+        }
         const storedMetadata = {
             version: 1,
+            id,
             isFromEmptySelection: dataToCopy.isFromEmptySelection,
             multicursorText: dataToCopy.multicursorText,
             mode: dataToCopy.mode
@@ -359,6 +379,7 @@ let TextAreaInput = class TextAreaInput extends Disposable {
         if (e.clipboardData) {
             ClipboardEventUtils.setTextData(e.clipboardData, dataToCopy.text, dataToCopy.html, storedMetadata);
         }
+        this._logService.trace('TextAreaEditContextInput#_ensureClipboardGetsEditorSelection with id : ', id, ' with text.length: ', dataToCopy.text.length);
     }
 };
 TextAreaInput = ( __decorate([

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

@@ -1,6 +1,6 @@
 import { Position } from "../../../../common/core/position.js";
 import { Range } from "../../../../common/core/range.js";
-import { ScreenReaderContentState } from "../screenReaderUtils.js";
+import { ISimpleScreenReaderContentState } from "../screenReaderUtils.js";
 export declare const _debugComposition = false;
 export interface ITextAreaWrapper {
     getValue(): string;
@@ -36,5 +36,5 @@ export declare class TextAreaState {
     private _finishDeduceEditorPosition;
     static deduceInput(previousState: TextAreaState, currentState: TextAreaState, couldBeEmojiInput: boolean): ITypeData;
     static deduceAndroidCompositionInput(previousState: TextAreaState, currentState: TextAreaState): ITypeData;
-    static fromScreenReaderContentState(screenReaderContentState: ScreenReaderContentState): TextAreaState;
+    static fromScreenReaderContentState(screenReaderContentState: ISimpleScreenReaderContentState): TextAreaState;
 }

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

@@ -59,6 +59,7 @@ declare class MouseDownOperation extends Disposable {
     private readonly _getMouseColumn;
     private readonly _mouseMoveMonitor;
     private readonly _topBottomDragScrolling;
+    private readonly _leftRightDragScrolling;
     private readonly _mouseState;
     private _currentSelection;
     private _isActive;