@codingame/monaco-vscode-api 19.1.4 → 20.0.0

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

@@ -0,0 +1,48 @@
+import { Disposable, IDisposable } from "../../../base/common/lifecycle.js";
+import { ViewContext } from "../../common/viewModel/viewContext.js";
+import { NavigationCommandRevealType } from "../coreCommands.js";
+import { IMouseTarget, IMouseTargetOutsideEditor } from "../editorBrowser.js";
+import { EditorMouseEvent } from "../editorDom.js";
+import { IPointerHandlerHelper } from "./mouseHandler.js";
+import { MouseTargetFactory } from "./mouseTarget.js";
+export declare abstract class DragScrolling extends Disposable {
+    protected readonly _context: ViewContext;
+    protected readonly _viewHelper: IPointerHandlerHelper;
+    protected readonly _mouseTargetFactory: MouseTargetFactory;
+    protected readonly _dispatchMouse: (position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType) => void;
+    private _operation;
+    constructor(_context: ViewContext, _viewHelper: IPointerHandlerHelper, _mouseTargetFactory: MouseTargetFactory, _dispatchMouse: (position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType) => void);
+    dispose(): void;
+    start(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): void;
+    stop(): void;
+    protected abstract _createDragScrollingOperation(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): DragScrollingOperation;
+}
+export declare abstract class DragScrollingOperation extends Disposable {
+    protected readonly _context: ViewContext;
+    protected readonly _viewHelper: IPointerHandlerHelper;
+    protected readonly _mouseTargetFactory: MouseTargetFactory;
+    protected readonly _dispatchMouse: (position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType) => void;
+    protected _position: IMouseTargetOutsideEditor;
+    protected _mouseEvent: EditorMouseEvent;
+    private _lastTime;
+    protected _animationFrameDisposable: IDisposable;
+    constructor(_context: ViewContext, _viewHelper: IPointerHandlerHelper, _mouseTargetFactory: MouseTargetFactory, _dispatchMouse: (position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType) => void, position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent);
+    dispose(): void;
+    setPosition(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): void;
+    protected _tick(): number;
+    protected abstract _execute(): void;
+}
+export declare class TopBottomDragScrolling extends DragScrolling {
+    protected _createDragScrollingOperation(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): DragScrollingOperation;
+}
+export declare class TopBottomDragScrollingOperation extends DragScrollingOperation {
+    private _getScrollSpeed;
+    protected _execute(): void;
+}
+export declare class LeftRightDragScrolling extends DragScrolling {
+    protected _createDragScrollingOperation(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): DragScrollingOperation;
+}
+export declare class LeftRightDragScrollingOperation extends DragScrollingOperation {
+    private _getScrollSpeed;
+    protected _execute(): void;
+}

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

@@ -0,0 +1,182 @@
+
+import { scheduleAtNextAnimationFrame, getWindow } from '../../../base/browser/dom.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { EditorOption } from '../../common/config/editorOptions.js';
+import { Position } from '../../common/core/position.js';
+import { NavigationCommandRevealType } from '../coreCommands.js';
+import { createEditorPagePosition, PageCoordinates, createCoordinatesRelativeToEditor } from '../editorDom.js';
+import { MouseTarget } from './mouseTarget.js';
+
+class DragScrolling 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 = this._createDragScrollingOperation(position, mouseEvent);
+        }
+    }
+    stop() {
+        if (this._operation) {
+            this._operation.dispose();
+            this._operation = null;
+        }
+    }
+}
+class DragScrollingOperation 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;
+    }
+}
+class TopBottomDragScrolling extends DragScrolling {
+    _createDragScrollingOperation(position, mouseEvent) {
+        return ( new TopBottomDragScrollingOperation(
+            this._context,
+            this._viewHelper,
+            this._mouseTargetFactory,
+            this._dispatchMouse,
+            position,
+            mouseEvent
+        ));
+    }
+}
+class TopBottomDragScrollingOperation extends DragScrollingOperation {
+    _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 LeftRightDragScrolling extends DragScrolling {
+    _createDragScrollingOperation(position, mouseEvent) {
+        return ( new LeftRightDragScrollingOperation(
+            this._context,
+            this._viewHelper,
+            this._mouseTargetFactory,
+            this._dispatchMouse,
+            position,
+            mouseEvent
+        ));
+    }
+}
+class LeftRightDragScrollingOperation extends DragScrollingOperation {
+    _getScrollSpeed() {
+        const charWidth = this._context.configuration.options.get(EditorOption.fontInfo).typicalFullwidthCharacterWidth;
+        const viewportInChars = this._context.configuration.options.get(EditorOption.layoutInfo).contentWidth / charWidth;
+        const outsideDistanceInChars = this._position.outsideDistance / charWidth;
+        if (outsideDistanceInChars <= 1.5) {
+            return Math.max(30, viewportInChars * (1 + outsideDistanceInChars));
+        }
+        if (outsideDistanceInChars <= 3) {
+            return Math.max(60, viewportInChars * (2 + outsideDistanceInChars));
+        }
+        return Math.max(200, viewportInChars * (7 + outsideDistanceInChars));
+    }
+    _execute() {
+        const charWidth = this._context.configuration.options.get(EditorOption.fontInfo).typicalFullwidthCharacterWidth;
+        const scrollSpeedInChars = this._getScrollSpeed();
+        const elapsed = this._tick();
+        const scrollInPixels = scrollSpeedInChars * (elapsed / 1000) * charWidth * 0.5;
+        const scrollValue = (this._position.outsidePosition === 'left' ? -scrollInPixels : scrollInPixels);
+        this._context.viewModel.viewLayout.deltaScrollNow(scrollValue, 0);
+        this._viewHelper.renderNow();
+        if (!this._position.position) {
+            return;
+        }
+        const edgeLineNumber = this._position.position.lineNumber;
+        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 (this._position.outsidePosition === 'left') {
+            mouseTarget = MouseTarget.createOutsideEditor(mouseTarget.mouseColumn, ( new Position(edgeLineNumber, mouseTarget.mouseColumn)), 'left', this._position.outsideDistance);
+        }
+        else {
+            mouseTarget = MouseTarget.createOutsideEditor(mouseTarget.mouseColumn, ( new Position(edgeLineNumber, mouseTarget.mouseColumn)), 'right', this._position.outsideDistance);
+        }
+        this._dispatchMouse(mouseTarget, true, NavigationCommandRevealType.None);
+        this._animationFrameDisposable = scheduleAtNextAnimationFrame(getWindow(mouseTarget.element), () => this._execute());
+    }
+}
+
+export { DragScrolling, DragScrollingOperation, LeftRightDragScrolling, LeftRightDragScrollingOperation, TopBottomDragScrolling, TopBottomDragScrollingOperation };

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

@@ -17,6 +17,7 @@ export interface ClipboardDataToCopy {
 }
 export interface ClipboardStoredMetadata {
     version: 1;
+    id: string | undefined;
     isFromEmptySelection: boolean | undefined;
     multicursorText: string[] | null | undefined;
     mode: string | null;

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

@@ -7,12 +7,12 @@ import { ViewController } from "../../../view/viewController.js";
 import { AbstractEditContext } from "../editContext.js";
 import { Position } from "../../../../common/core/position.js";
 import { IVisibleRangeProvider } from "../textArea/textAreaEditContext.js";
-import { IAccessibilityService } from "../../../../../platform/accessibility/common/accessibility.service.js";
 import { IEditorAriaOptions } from "../../../editorBrowser.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
 export declare class NativeEditContext extends AbstractEditContext {
     private readonly _viewController;
     private readonly _visibleRangeProvider;
-    private readonly _accessibilityService;
+    private readonly logService;
     readonly domNode: FastDomNode<HTMLDivElement>;
     private readonly _imeTextArea;
     private readonly _editContext;
@@ -26,8 +26,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     private _scrollTop;
     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, logService: ILogService);
     dispose(): void;
     setAriaOptions(options: IEditorAriaOptions): void;
     getLastRenderData(): Position | null;
@@ -62,5 +61,4 @@ export declare class NativeEditContext extends AbstractEditContext {
     private _updateSelectionAndControlBounds;
     private _updateCharacterBounds;
     private _ensureClipboardGetsEditorSelection;
-    private _setSelectionChangeListener;
 }

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

@@ -3,13 +3,13 @@ import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import * as nativeEditContext from './nativeEditContext.css';
 import { isFirefox } from '../../../../../base/browser/browser.js';
-import { createElement, getWindow, addDisposableListener, getWindowId, getActiveWindow } from '../../../../../base/browser/dom.js';
+import { createElement, getWindow, addDisposableListener, getWindowId } from '../../../../../base/browser/dom.js';
 import { FastDomNode } from '../../../../../base/browser/fastDomNode.js';
 import { StandardKeyboardEvent } from '../../../../../base/browser/keyboardEvent.js';
 import { KeyCode } from '../../../../../base/common/keyCodes.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { EditorOption } from '../../../../common/config/editorOptions.js';
-import { EndOfLinePreference, EndOfLineSequence } from '../../../../common/model.js';
+import { EndOfLinePreference } from '../../../../common/model.js';
 import { ClipboardEventUtils, InMemoryClipboardMetadataManager, getDataToCopy } from '../clipboardUtils.js';
 import { AbstractEditContext } from '../editContext.js';
 import { FocusTracker, editContextAddDisposableListener } from './nativeEditContextUtils.js';
@@ -18,13 +18,14 @@ import { Range } from '../../../../common/core/range.js';
 import { Selection } from '../../../../common/core/selection.js';
 import { Position } from '../../../../common/core/position.js';
 import '../../../../common/core/text/positionToOffset.js';
-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';
 import { OffsetRange } from '../../../../common/core/ranges/offsetRange.js';
+import { LogLevel } from '../../../../../platform/log/common/log.js';
+import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { generateUuid } from '../../../../../base/common/uuid.js';
 import { PositionOffsetTransformer } from '../../../../common/core/text/positionToOffsetImpl.js';
 
 registerCss(nativeEditContext);
@@ -35,11 +36,11 @@ 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, logService) {
         super(context);
         this._viewController = _viewController;
         this._visibleRangeProvider = _visibleRangeProvider;
-        this._accessibilityService = _accessibilityService;
+        this.logService = logService;
         this._previousEditContextSelection = ( new OffsetRange(0, 0));
         this._editContextPrimarySelection = ( new Selection(1, 1, 1, 1));
         this._decorations = [];
@@ -53,6 +54,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._imeTextArea.setClassName(`ime-text-area`);
         this._imeTextArea.setAttribute('readonly', 'true');
         this._imeTextArea.setAttribute('tabindex', '-1');
+        this._imeTextArea.setAttribute('aria-hidden', 'true');
         this.domNode.setAttribute('autocorrect', 'off');
         this.domNode.setAttribute('autocapitalize', 'off');
         this.domNode.setAttribute('autocomplete', 'off');
@@ -61,25 +63,23 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         overflowGuardContainer.appendChild(this.domNode);
         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(this._viewController);
-                this._screenReaderSupport.setIgnoreSelectionChangeTime('onFocus');
-            }
-            else {
-                this._selectionChangeListener.value = undefined;
-            }
+            this._screenReaderSupport.handleFocusChange(newFocusValue);
             this._context.viewModel.setHasFocus(newFocusValue);
         })));
         const window = getWindow(this.domNode.domNode);
         this._editContext = EditContext.create(window);
         this.setEditContextOnDomNode();
-        this._screenReaderSupport = instantiationService.createInstance(ScreenReaderSupport, this.domNode, context);
-        this._register(addDisposableListener(this.domNode.domNode, 'copy', (e) => this._ensureClipboardGetsEditorSelection(e)));
+        this._screenReaderSupport = this._register(instantiationService.createInstance(ScreenReaderSupport, this.domNode, context, this._viewController));
+        this._register(addDisposableListener(this.domNode.domNode, 'copy', (e) => {
+            this.logService.trace('NativeEditContext#copy');
+            this._ensureClipboardGetsEditorSelection(e);
+        }));
         this._register(addDisposableListener(this.domNode.domNode, 'cut', (e) => {
-            this._screenReaderSupport.setIgnoreSelectionChangeTime('onCut');
+            this.logService.trace('NativeEditContext#cut');
+            this._screenReaderSupport.onWillCut();
             this._ensureClipboardGetsEditorSelection(e);
+            this.logService.trace('NativeEditContext#cut (before viewController.cut)');
             this._viewController.cut();
         }));
         this._register(addDisposableListener(this.domNode.domNode, 'keyup', (e) => this._onKeyUp(e)));
@@ -92,11 +92,13 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             }
         }));
         this._register(addDisposableListener(this.domNode.domNode, 'paste', (e) => {
+            this.logService.trace('NativeEditContext#paste');
             e.preventDefault();
             if (!e.clipboardData) {
                 return;
             }
             let [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
+            this.logService.trace('NativeEditContext#paste with id : ', metadata?.id, ' with text.length: ', text.length);
             if (!text) {
                 return;
             }
@@ -111,6 +113,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
                 multicursorText = typeof metadata.multicursorText !== 'undefined' ? metadata.multicursorText : null;
                 mode = metadata.mode;
             }
+            this.logService.trace('NativeEditContext#paste (before viewController.paste)');
             this._viewController.paste(text, pasteOnNewLine, multicursorText, mode);
         }));
         this._register(editContextAddDisposableListener(this._editContext, 'textformatupdate', (e) => this._handleTextFormatUpdate(e)));
@@ -163,6 +166,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._register(NativeEditContextRegistry.register(ownerID, this));
     }
     dispose() {
+        this.domNode.domNode.editContext = undefined;
         this.domNode.domNode.blur();
         this.domNode.domNode.remove();
         this._imeTextArea.domNode.remove();
@@ -225,10 +229,11 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         return true;
     }
     onWillPaste() {
+        this.logService.trace('NativeEditContext#onWillPaste');
         this._onWillPaste();
     }
     _onWillPaste() {
-        this._screenReaderSupport.setIgnoreSelectionChangeTime('onWillPaste');
+        this._screenReaderSupport.onWillPaste();
     }
     writeScreenReaderContent() {
         this._screenReaderSupport.writeScreenReaderContent();
@@ -456,8 +461,13 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         const copyWithSyntaxHighlighting = options.get(EditorOption.copyWithSyntaxHighlighting);
         const selections = ( this._context.viewModel.getCursorStates().map(cursorState => cursorState.modelState.selection));
         const dataToCopy = getDataToCopy(this._context.viewModel, selections, emptySelectionClipboard, copyWithSyntaxHighlighting);
+        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
@@ -468,65 +478,12 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         if (e.clipboardData) {
             ClipboardEventUtils.setTextData(e.clipboardData, dataToCopy.text, dataToCopy.html, storedMetadata);
         }
-    }
-    _setSelectionChangeListener(viewController) {
-        let previousSelectionChangeEventTime = 0;
-        return addDisposableListener(this.domNode.domNode.ownerDocument, 'selectionchange', () => {
-            const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
-            if (!this.isFocused() || !isScreenReaderOptimized || !IME.enabled) {
-                return;
-            }
-            const screenReaderContentState = this._screenReaderSupport.screenReaderContentState;
-            if (!screenReaderContentState) {
-                return;
-            }
-            const now = Date.now();
-            const delta1 = now - previousSelectionChangeEventTime;
-            previousSelectionChangeEventTime = now;
-            if (delta1 < 5) {
-                return;
-            }
-            const delta2 = now - this._screenReaderSupport.getIgnoreSelectionChangeTime();
-            this._screenReaderSupport.resetSelectionChangeTime();
-            if (delta2 < 100) {
-                return;
-            }
-            const activeDocument = getActiveWindow().document;
-            const activeDocumentSelection = activeDocument.getSelection();
-            if (!activeDocumentSelection) {
-                return;
-            }
-            const rangeCount = activeDocumentSelection.rangeCount;
-            if (rangeCount === 0) {
-                return;
-            }
-            const range = activeDocumentSelection.getRangeAt(0);
-            const viewModel = this._context.viewModel;
-            const model = viewModel.model;
-            const coordinatesConverter = viewModel.coordinatesConverter;
-            const modelScreenReaderContentStartPositionWithinEditor = coordinatesConverter.convertViewPositionToModelPosition(screenReaderContentState.startPositionWithinEditor);
-            const offsetOfStartOfScreenReaderContent = model.getOffsetAt(modelScreenReaderContentStartPositionWithinEditor);
-            let offsetOfSelectionStart = range.startOffset + offsetOfStartOfScreenReaderContent;
-            let offsetOfSelectionEnd = range.endOffset + offsetOfStartOfScreenReaderContent;
-            const modelUsesCRLF = model.getEndOfLineSequence() === EndOfLineSequence.CRLF;
-            if (modelUsesCRLF) {
-                const screenReaderContentText = screenReaderContentState.value;
-                const offsetTransformer = ( new PositionOffsetTransformer(screenReaderContentText));
-                const positionOfStartWithinText = offsetTransformer.getPosition(range.startOffset);
-                const positionOfEndWithinText = offsetTransformer.getPosition(range.endOffset);
-                offsetOfSelectionStart += positionOfStartWithinText.lineNumber - 1;
-                offsetOfSelectionEnd += positionOfEndWithinText.lineNumber - 1;
-            }
-            const positionOfSelectionStart = model.getPositionAt(offsetOfSelectionStart);
-            const positionOfSelectionEnd = model.getPositionAt(offsetOfSelectionEnd);
-            const newSelection = Selection.fromPositions(positionOfSelectionStart, positionOfSelectionEnd);
-            viewController.setSelection(newSelection);
-        });
+        this.logService.trace('NativeEditContext#_ensureClipboardGetsEditorSelectios with id : ', id, ' with text.length: ', dataToCopy.text.length);
     }
 };
 NativeEditContext = ( __decorate([
     ( __param(5, IInstantiationService)),
-    ( __param(6, IAccessibilityService))
+    ( __param(6, ILogService))
 ], NativeEditContext));
 
 export { NativeEditContext };

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

@@ -0,0 +1,35 @@
+import { FastDomNode } from "../../../../../base/browser/fastDomNode.js";
+import { IAccessibilityService } from "../../../../../platform/accessibility/common/accessibility.service.js";
+import { IComputedEditorOptions } from "../../../../common/config/editorOptions.js";
+import { Selection } from "../../../../common/core/selection.js";
+import { ViewContext } from "../../../../common/viewModel/viewContext.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { ViewController } from "../../../view/viewController.js";
+import { IScreenReaderContent } from "./screenReaderUtils.js";
+export declare class RichScreenReaderContent extends Disposable implements IScreenReaderContent {
+    private readonly _domNode;
+    private readonly _context;
+    private readonly _viewController;
+    private readonly _accessibilityService;
+    private readonly _selectionChangeListener;
+    private _accessibilityPageSize;
+    private _ignoreSelectionChangeTime;
+    private _state;
+    private _strategy;
+    private _renderedLines;
+    private _renderedSelection;
+    constructor(_domNode: FastDomNode<HTMLElement>, _context: ViewContext, _viewController: ViewController, _accessibilityService: IAccessibilityService);
+    updateScreenReaderContent(primarySelection: Selection): void;
+    updateScrollTop(primarySelection: Selection): void;
+    onFocusChange(newFocusValue: boolean): void;
+    onConfigurationChanged(options: IComputedEditorOptions): void;
+    onWillCut(): void;
+    onWillPaste(): void;
+    private _setIgnoreSelectionChangeTime;
+    private _setSelectionChangeListener;
+    private _renderScreenReaderContent;
+    private _renderLine;
+    private _setSelectionOnScreenReaderContent;
+    private _getScreenReaderContentLineIntervals;
+    private _getEditorSelectionFromDomRange;
+}