@codingame/monaco-vscode-api 19.1.3 → 20.0.0

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

@@ -0,0 +1,329 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { getActiveWindow, addDisposableListener, createElement, isHTMLElement } from '../../../../../base/browser/dom.js';
+import { createTrustedTypesPolicy } from '../../../../../base/browser/trustedTypes.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
+import { EditorOption, EditorFontLigatures } from '../../../../common/config/editorOptions.js';
+import { Range } from '../../../../common/core/range.js';
+import { Selection } from '../../../../common/core/selection.js';
+import { StringBuilder } from '../../../../common/core/stringBuilder.js';
+import { LineDecoration } from '../../../../common/viewLayout/lineDecorations.js';
+import { RenderLineInput, renderViewLine } from '../../../../common/viewLayout/viewLineRenderer.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { IME } from '../../../../../base/common/ime.js';
+import { getColumnOfNodeOffset } from '../../../viewParts/viewLines/viewLine.js';
+
+const ttPolicy = createTrustedTypesPolicy('richScreenReaderContent', { createHTML: value => value });
+const LINE_NUMBER_ATTRIBUTE = 'data-line-number';
+let RichScreenReaderContent = class RichScreenReaderContent extends Disposable {
+    constructor(_domNode, _context, _viewController, _accessibilityService) {
+        super();
+        this._domNode = _domNode;
+        this._context = _context;
+        this._viewController = _viewController;
+        this._accessibilityService = _accessibilityService;
+        this._selectionChangeListener = this._register(( new MutableDisposable()));
+        this._accessibilityPageSize = 1;
+        this._ignoreSelectionChangeTime = 0;
+        this._state = ( new RichScreenReaderState([]));
+        this._strategy = ( new RichPagedScreenReaderStrategy());
+        this._renderedLines = ( new Map());
+        this._renderedSelection = ( new Selection(1, 1, 1, 1));
+        this.onConfigurationChanged(this._context.configuration.options);
+    }
+    updateScreenReaderContent(primarySelection) {
+        const focusedElement = getActiveWindow().document.activeElement;
+        if (!focusedElement || focusedElement !== this._domNode.domNode) {
+            return;
+        }
+        const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+        if (isScreenReaderOptimized) {
+            const state = this._getScreenReaderContentLineIntervals(primarySelection);
+            if (!this._state.equals(state)) {
+                this._state = state;
+                this._renderedLines = this._renderScreenReaderContent(state);
+            }
+            if (!this._renderedSelection.equalsSelection(primarySelection)) {
+                this._renderedSelection = primarySelection;
+                this._setSelectionOnScreenReaderContent(this._context, this._renderedLines, primarySelection);
+            }
+        }
+        else {
+            this._state = ( new RichScreenReaderState([]));
+            this._setIgnoreSelectionChangeTime('setValue');
+            this._domNode.domNode.textContent = '';
+        }
+    }
+    updateScrollTop(primarySelection) {
+        const intervals = this._state.intervals;
+        if (!intervals.length) {
+            return;
+        }
+        const viewLayout = this._context.viewModel.viewLayout;
+        const stateStartLineNumber = intervals[0].startLine;
+        const verticalOffsetOfStateStartLineNumber = viewLayout.getVerticalOffsetForLineNumber(stateStartLineNumber);
+        const verticalOffsetOfPositionLineNumber = viewLayout.getVerticalOffsetForLineNumber(primarySelection.positionLineNumber);
+        this._domNode.domNode.scrollTop = verticalOffsetOfPositionLineNumber - verticalOffsetOfStateStartLineNumber;
+    }
+    onFocusChange(newFocusValue) {
+        if (newFocusValue) {
+            this._selectionChangeListener.value = this._setSelectionChangeListener();
+        }
+        else {
+            this._selectionChangeListener.value = undefined;
+        }
+    }
+    onConfigurationChanged(options) {
+        this._accessibilityPageSize = options.get(EditorOption.accessibilityPageSize);
+    }
+    onWillCut() {
+        this._setIgnoreSelectionChangeTime('onCut');
+    }
+    onWillPaste() {
+        this._setIgnoreSelectionChangeTime('onWillPaste');
+    }
+    _setIgnoreSelectionChangeTime(reason) {
+        this._ignoreSelectionChangeTime = Date.now();
+    }
+    _setSelectionChangeListener() {
+        let previousSelectionChangeEventTime = 0;
+        return addDisposableListener(this._domNode.domNode.ownerDocument, 'selectionchange', () => {
+            const activeElement = getActiveWindow().document.activeElement;
+            const isFocused = activeElement === this._domNode.domNode;
+            if (!isFocused) {
+                return;
+            }
+            const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+            if (!isScreenReaderOptimized || !IME.enabled) {
+                return;
+            }
+            const now = Date.now();
+            const delta1 = now - previousSelectionChangeEventTime;
+            previousSelectionChangeEventTime = now;
+            if (delta1 < 5) {
+                return;
+            }
+            const delta2 = now - this._ignoreSelectionChangeTime;
+            this._ignoreSelectionChangeTime = 0;
+            if (delta2 < 100) {
+                return;
+            }
+            const selection = this._getEditorSelectionFromDomRange();
+            if (!selection) {
+                return;
+            }
+            this._viewController.setSelection(selection);
+        });
+    }
+    _renderScreenReaderContent(state) {
+        const nodes = [];
+        const renderedLines = ( new Map());
+        for (const interval of state.intervals) {
+            for (let lineNumber = interval.startLine; lineNumber <= interval.endLine; lineNumber++) {
+                const renderedLine = this._renderLine(lineNumber);
+                renderedLines.set(lineNumber, renderedLine);
+                nodes.push(renderedLine.domNode);
+            }
+        }
+        this._setIgnoreSelectionChangeTime('setValue');
+        this._domNode.domNode.replaceChildren(...nodes);
+        return renderedLines;
+    }
+    _renderLine(viewLineNumber) {
+        const viewModel = this._context.viewModel;
+        const positionLineData = viewModel.getViewLineRenderingData(viewLineNumber);
+        const options = this._context.configuration.options;
+        const fontInfo = options.get(EditorOption.fontInfo);
+        const stopRenderingLineAfter = options.get(EditorOption.stopRenderingLineAfter);
+        const renderControlCharacters = options.get(EditorOption.renderControlCharacters);
+        const fontLigatures = options.get(EditorOption.fontLigatures);
+        const disableMonospaceOptimizations = options.get(EditorOption.disableMonospaceOptimizations);
+        const lineDecorations = LineDecoration.filter(positionLineData.inlineDecorations, viewLineNumber, positionLineData.minColumn, positionLineData.maxColumn);
+        const useMonospaceOptimizations = fontInfo.isMonospace && !disableMonospaceOptimizations;
+        const useFontLigatures = fontLigatures !== EditorFontLigatures.OFF;
+        let renderWhitespace;
+        const experimentalWhitespaceRendering = options.get(EditorOption.experimentalWhitespaceRendering);
+        if (experimentalWhitespaceRendering === 'off') {
+            renderWhitespace = options.get(EditorOption.renderWhitespace);
+        }
+        else {
+            renderWhitespace = 'none';
+        }
+        const renderLineInput = ( new RenderLineInput(
+            useMonospaceOptimizations,
+            fontInfo.canUseHalfwidthRightwardsArrow,
+            positionLineData.content,
+            positionLineData.continuesWithWrappedLine,
+            positionLineData.isBasicASCII,
+            positionLineData.containsRTL,
+            positionLineData.minColumn - 1,
+            positionLineData.tokens,
+            lineDecorations,
+            positionLineData.tabSize,
+            positionLineData.startVisibleColumn,
+            fontInfo.spaceWidth,
+            fontInfo.middotWidth,
+            fontInfo.wsmiddotWidth,
+            stopRenderingLineAfter,
+            renderWhitespace,
+            renderControlCharacters,
+            useFontLigatures,
+            null,
+            null,
+            0,
+            true
+        ));
+        const htmlBuilder = ( new StringBuilder(10000));
+        const renderOutput = renderViewLine(renderLineInput, htmlBuilder);
+        const html = htmlBuilder.build();
+        const trustedhtml = ttPolicy?.createHTML(html) ?? html;
+        const lineHeight = viewModel.viewLayout.getLineHeightForLineNumber(viewLineNumber) + 'px';
+        const domNode = createElement('div');
+        domNode.innerHTML = trustedhtml;
+        domNode.style.lineHeight = lineHeight;
+        domNode.style.height = lineHeight;
+        domNode.setAttribute(LINE_NUMBER_ATTRIBUTE, ( viewLineNumber.toString()));
+        return ( new RichRenderedScreenReaderLine(domNode, renderOutput.characterMapping));
+    }
+    _setSelectionOnScreenReaderContent(context, renderedLines, viewSelection) {
+        const activeDocument = getActiveWindow().document;
+        const activeDocumentSelection = activeDocument.getSelection();
+        if (!activeDocumentSelection) {
+            return;
+        }
+        const startLineNumber = viewSelection.startLineNumber;
+        const endLineNumber = viewSelection.endLineNumber;
+        const startRenderedLine = renderedLines.get(startLineNumber);
+        const endRenderedLine = renderedLines.get(endLineNumber);
+        if (!startRenderedLine || !endRenderedLine) {
+            return;
+        }
+        const viewModel = context.viewModel;
+        const model = viewModel.model;
+        const coordinatesConverter = viewModel.coordinatesConverter;
+        const startRange = ( new Range(startLineNumber, 1, startLineNumber, viewSelection.selectionStartColumn));
+        const modelStartRange = coordinatesConverter.convertViewRangeToModelRange(startRange);
+        const characterCountForStart = model.getCharacterCountInRange(modelStartRange);
+        const endRange = ( new Range(endLineNumber, 1, endLineNumber, viewSelection.positionColumn));
+        const modelEndRange = coordinatesConverter.convertViewRangeToModelRange(endRange);
+        const characterCountForEnd = model.getCharacterCountInRange(modelEndRange);
+        const startDomPosition = startRenderedLine.characterMapping.getDomPosition(characterCountForStart);
+        const endDomPosition = endRenderedLine.characterMapping.getDomPosition(characterCountForEnd);
+        const startDomNode = startRenderedLine.domNode.firstChild;
+        const endDomNode = endRenderedLine.domNode.firstChild;
+        const startChildren = startDomNode.childNodes;
+        const endChildren = endDomNode.childNodes;
+        const startNode = startChildren.item(startDomPosition.partIndex);
+        const endNode = endChildren.item(endDomPosition.partIndex);
+        if (!startNode.firstChild || !endNode.firstChild) {
+            return;
+        }
+        this._setIgnoreSelectionChangeTime('setRange');
+        activeDocumentSelection.setBaseAndExtent(startNode.firstChild, viewSelection.startColumn === 1 ? 0 : startDomPosition.charIndex + 1, endNode.firstChild, viewSelection.endColumn === 1 ? 0 : endDomPosition.charIndex + 1);
+    }
+    _getScreenReaderContentLineIntervals(primarySelection) {
+        return this._strategy.fromEditorSelection(this._context.viewModel, primarySelection, this._accessibilityPageSize);
+    }
+    _getEditorSelectionFromDomRange() {
+        if (!this._renderedLines) {
+            return;
+        }
+        const selection = getActiveWindow().document.getSelection();
+        if (!selection) {
+            return;
+        }
+        const rangeCount = selection.rangeCount;
+        if (rangeCount === 0) {
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        const startContainer = range.startContainer;
+        const endContainer = range.endContainer;
+        const startSpanElement = startContainer.parentElement;
+        const endSpanElement = endContainer.parentElement;
+        if (!startSpanElement || !isHTMLElement(startSpanElement) || !endSpanElement || !isHTMLElement(endSpanElement)) {
+            return;
+        }
+        const startLineDomNode = startSpanElement.parentElement?.parentElement;
+        const endLineDomNode = endSpanElement.parentElement?.parentElement;
+        if (!startLineDomNode || !endLineDomNode) {
+            return;
+        }
+        const startLineNumberAttribute = startLineDomNode.getAttribute(LINE_NUMBER_ATTRIBUTE);
+        const endLineNumberAttribute = endLineDomNode.getAttribute(LINE_NUMBER_ATTRIBUTE);
+        if (!startLineNumberAttribute || !endLineNumberAttribute) {
+            return;
+        }
+        const startLineNumber = parseInt(startLineNumberAttribute);
+        const endLineNumber = parseInt(endLineNumberAttribute);
+        const startMapping = this._renderedLines.get(startLineNumber)?.characterMapping;
+        const endMapping = this._renderedLines.get(endLineNumber)?.characterMapping;
+        if (!startMapping || !endMapping) {
+            return;
+        }
+        const startColumn = getColumnOfNodeOffset(startMapping, startSpanElement, range.startOffset);
+        const endColumn = getColumnOfNodeOffset(endMapping, endSpanElement, range.endOffset);
+        if (selection.direction === 'forward') {
+            return ( new Selection(startLineNumber, startColumn, endLineNumber, endColumn));
+        }
+        else {
+            return ( new Selection(endLineNumber, endColumn, startLineNumber, startColumn));
+        }
+    }
+};
+RichScreenReaderContent = ( __decorate([
+    ( __param(3, IAccessibilityService))
+], RichScreenReaderContent));
+class RichRenderedScreenReaderLine {
+    constructor(domNode, characterMapping) {
+        this.domNode = domNode;
+        this.characterMapping = characterMapping;
+    }
+}
+class LineInterval {
+    constructor(startLine, endLine) {
+        this.startLine = startLine;
+        this.endLine = endLine;
+    }
+}
+class RichScreenReaderState {
+    constructor(intervals) {
+        this.intervals = intervals;
+    }
+    equals(other) {
+        if (this.intervals.length !== other.intervals.length) {
+            return false;
+        }
+        for (let i = 0; i < this.intervals.length; i++) {
+            if (this.intervals[i].startLine !== other.intervals[i].startLine || this.intervals[i].endLine !== other.intervals[i].endLine) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+class RichPagedScreenReaderStrategy {
+    constructor() { }
+    _getPageOfLine(lineNumber, linesPerPage) {
+        return Math.floor((lineNumber - 1) / linesPerPage);
+    }
+    _getRangeForPage(context, page, linesPerPage) {
+        const offset = page * linesPerPage;
+        const startLineNumber = offset + 1;
+        const endLineNumber = Math.min(offset + linesPerPage, context.getLineCount());
+        return ( new LineInterval(startLineNumber, endLineNumber));
+    }
+    fromEditorSelection(context, viewSelection, linesPerPage) {
+        const selectionStartPage = this._getPageOfLine(viewSelection.startLineNumber, linesPerPage);
+        const selectionStartPageRange = this._getRangeForPage(context, selectionStartPage, linesPerPage);
+        const selectionEndPage = this._getPageOfLine(viewSelection.endLineNumber, linesPerPage);
+        const selectionEndPageRange = this._getRangeForPage(context, selectionEndPage, linesPerPage);
+        const lineIntervals = [{ startLine: selectionStartPageRange.startLine, endLine: selectionStartPageRange.endLine }];
+        if (selectionStartPage + 1 < selectionEndPage) {
+            lineIntervals.push({ startLine: selectionEndPageRange.startLine, endLine: selectionEndPageRange.endLine });
+        }
+        return ( new RichScreenReaderState(lineIntervals));
+    }
+}
+
+export { RichScreenReaderContent };

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

@@ -0,0 +1,31 @@
+import { FastDomNode } from "../../../../../base/browser/fastDomNode.js";
+import { IAccessibilityService } from "../../../../../platform/accessibility/common/accessibility.service.js";
+import { IComputedEditorOptions } from "../../../../common/config/editorOptions.js";
+import { ViewContext } from "../../../../common/viewModel/viewContext.js";
+import { Selection } from "../../../../common/core/selection.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { ViewController } from "../../../view/viewController.js";
+import { IScreenReaderContent } from "./screenReaderUtils.js";
+export declare class SimpleScreenReaderContent 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;
+    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;
+    _setIgnoreSelectionChangeTime(reason: string): void;
+    private _setSelectionChangeListener;
+    private _getScreenReaderContentState;
+    private _getScreenReaderRange;
+    private _getEditorSelectionFromDomRange;
+}

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

@@ -0,0 +1,176 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { getActiveWindow, addDisposableListener } from '../../../../../base/browser/dom.js';
+import { AccessibilitySupport } from '../../../../../platform/accessibility/common/accessibility.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
+import { EditorOption } from '../../../../common/config/editorOptions.js';
+import { EndOfLineSequence } from '../../../../common/model.js';
+import { Selection } from '../../../../common/core/selection.js';
+import { SimplePagedScreenReaderStrategy } from '../screenReaderUtils.js';
+import '../../../../common/core/text/positionToOffset.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { IME } from '../../../../../base/common/ime.js';
+import { PositionOffsetTransformer } from '../../../../common/core/text/positionToOffsetImpl.js';
+
+let SimpleScreenReaderContent = class SimpleScreenReaderContent extends Disposable {
+    constructor(_domNode, _context, _viewController, _accessibilityService) {
+        super();
+        this._domNode = _domNode;
+        this._context = _context;
+        this._viewController = _viewController;
+        this._accessibilityService = _accessibilityService;
+        this._selectionChangeListener = this._register(( new MutableDisposable()));
+        this._accessibilityPageSize = 1;
+        this._ignoreSelectionChangeTime = 0;
+        this._strategy = ( new SimplePagedScreenReaderStrategy());
+        this.onConfigurationChanged(this._context.configuration.options);
+    }
+    updateScreenReaderContent(primarySelection) {
+        const domNode = this._domNode.domNode;
+        const focusedElement = getActiveWindow().document.activeElement;
+        if (!focusedElement || focusedElement !== domNode) {
+            return;
+        }
+        const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+        if (isScreenReaderOptimized) {
+            this._state = this._getScreenReaderContentState(primarySelection);
+            if (domNode.textContent !== this._state.value) {
+                this._setIgnoreSelectionChangeTime('setValue');
+                domNode.textContent = this._state.value;
+            }
+            const selection = getActiveWindow().document.getSelection();
+            if (!selection) {
+                return;
+            }
+            const data = this._getScreenReaderRange(this._state.selectionStart, this._state.selectionEnd);
+            if (!data) {
+                return;
+            }
+            this._setIgnoreSelectionChangeTime('setRange');
+            selection.setBaseAndExtent(data.anchorNode, data.anchorOffset, data.focusNode, data.focusOffset);
+        }
+        else {
+            this._state = undefined;
+            this._setIgnoreSelectionChangeTime('setValue');
+            this._domNode.domNode.textContent = '';
+        }
+    }
+    updateScrollTop(primarySelection) {
+        if (!this._state) {
+            return;
+        }
+        const viewLayout = this._context.viewModel.viewLayout;
+        const stateStartLineNumber = this._state.startPositionWithinEditor.lineNumber;
+        const verticalOffsetOfStateStartLineNumber = viewLayout.getVerticalOffsetForLineNumber(stateStartLineNumber);
+        const verticalOffsetOfPositionLineNumber = viewLayout.getVerticalOffsetForLineNumber(primarySelection.positionLineNumber);
+        this._domNode.domNode.scrollTop = verticalOffsetOfPositionLineNumber - verticalOffsetOfStateStartLineNumber;
+    }
+    onFocusChange(newFocusValue) {
+        if (newFocusValue) {
+            this._selectionChangeListener.value = this._setSelectionChangeListener();
+        }
+        else {
+            this._selectionChangeListener.value = undefined;
+        }
+    }
+    onConfigurationChanged(options) {
+        this._accessibilityPageSize = options.get(EditorOption.accessibilityPageSize);
+    }
+    onWillCut() {
+        this._setIgnoreSelectionChangeTime('onCut');
+    }
+    onWillPaste() {
+        this._setIgnoreSelectionChangeTime('onWillPaste');
+    }
+    _setIgnoreSelectionChangeTime(reason) {
+        this._ignoreSelectionChangeTime = Date.now();
+    }
+    _setSelectionChangeListener() {
+        let previousSelectionChangeEventTime = 0;
+        return addDisposableListener(this._domNode.domNode.ownerDocument, 'selectionchange', () => {
+            const isScreenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+            if (!this._state || !isScreenReaderOptimized || !IME.enabled) {
+                return;
+            }
+            const activeElement = getActiveWindow().document.activeElement;
+            const isFocused = activeElement === this._domNode.domNode;
+            if (!isFocused) {
+                return;
+            }
+            const selection = getActiveWindow().document.getSelection();
+            if (!selection) {
+                return;
+            }
+            const rangeCount = selection.rangeCount;
+            if (rangeCount === 0) {
+                return;
+            }
+            const range = selection.getRangeAt(0);
+            const now = Date.now();
+            const delta1 = now - previousSelectionChangeEventTime;
+            previousSelectionChangeEventTime = now;
+            if (delta1 < 5) {
+                return;
+            }
+            const delta2 = now - this._ignoreSelectionChangeTime;
+            this._ignoreSelectionChangeTime = 0;
+            if (delta2 < 100) {
+                return;
+            }
+            this._viewController.setSelection(this._getEditorSelectionFromDomRange(this._context, this._state, selection.direction, range));
+        });
+    }
+    _getScreenReaderContentState(primarySelection) {
+        const state = this._strategy.fromEditorSelection(this._context.viewModel, primarySelection, this._accessibilityPageSize, this._accessibilityService.getAccessibilitySupport() === AccessibilitySupport.Unknown);
+        const endPosition = this._context.viewModel.model.getPositionAt(Infinity);
+        let value = state.value;
+        if (endPosition.column === 1 && primarySelection.getEndPosition().equals(endPosition)) {
+            value += '\n';
+        }
+        state.value = value;
+        return state;
+    }
+    _getScreenReaderRange(selectionOffsetStart, selectionOffsetEnd) {
+        const textContent = this._domNode.domNode.firstChild;
+        if (!textContent) {
+            return;
+        }
+        const range = new globalThis.Range();
+        range.setStart(textContent, selectionOffsetStart);
+        range.setEnd(textContent, selectionOffsetEnd);
+        return {
+            anchorNode: textContent,
+            anchorOffset: selectionOffsetStart,
+            focusNode: textContent,
+            focusOffset: selectionOffsetEnd
+        };
+    }
+    _getEditorSelectionFromDomRange(context, state, direction, range) {
+        const viewModel = context.viewModel;
+        const model = viewModel.model;
+        const coordinatesConverter = viewModel.coordinatesConverter;
+        const modelScreenReaderContentStartPositionWithinEditor = coordinatesConverter.convertViewPositionToModelPosition(state.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 = state.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 selectionStart = direction === 'forward' ? positionOfSelectionStart : positionOfSelectionEnd;
+        const selectionEnd = direction === 'forward' ? positionOfSelectionEnd : positionOfSelectionStart;
+        return Selection.fromPositions(selectionStart, selectionEnd);
+    }
+};
+SimpleScreenReaderContent = ( __decorate([
+    ( __param(3, IAccessibilityService))
+], SimpleScreenReaderContent));
+
+export { SimpleScreenReaderContent };

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

@@ -1,14 +1,16 @@
 import { FastDomNode } from "../../../../../base/browser/fastDomNode.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
 import { IAccessibilityService } from "../../../../../platform/accessibility/common/accessibility.service.js";
 import { IKeybindingService } from "../../../../../platform/keybinding/common/keybinding.service.js";
 import { ViewConfigurationChangedEvent, ViewCursorStateChangedEvent } from "../../../../common/viewEvents.js";
 import { ViewContext } from "../../../../common/viewModel/viewContext.js";
 import { IEditorAriaOptions } from "../../../editorBrowser.js";
 import { RestrictedRenderingContext, RenderingContext } from "../../../view/renderingContext.js";
-import { ScreenReaderContentState } from "../screenReaderUtils.js";
-export declare class ScreenReaderSupport {
+import { ViewController } from "../../../view/viewController.js";
+export declare class ScreenReaderSupport extends Disposable {
     private readonly _domNode;
     private readonly _context;
+    private readonly _viewController;
     private readonly _keybindingService;
     private readonly _accessibilityService;
     private _contentLeft;
@@ -16,16 +18,17 @@ export declare class ScreenReaderSupport {
     private _contentHeight;
     private _divWidth;
     private _fontInfo;
-    private _accessibilityPageSize;
-    private _ignoreSelectionChangeTime;
+    private _renderRichContent;
     private _primarySelection;
     private _primaryCursorVisibleRange;
-    private _screenReaderContentState;
-    constructor(_domNode: FastDomNode<HTMLElement>, _context: ViewContext, _keybindingService: IKeybindingService, _accessibilityService: IAccessibilityService);
-    setIgnoreSelectionChangeTime(reason: string): void;
-    getIgnoreSelectionChangeTime(): number;
-    resetSelectionChangeTime(): void;
+    private readonly _state;
+    constructor(_domNode: FastDomNode<HTMLElement>, _context: ViewContext, _viewController: ViewController, _keybindingService: IKeybindingService, _accessibilityService: IAccessibilityService);
+    onWillPaste(): void;
+    onWillCut(): void;
+    handleFocusChange(newFocusValue: boolean): void;
     onConfigurationChanged(e: ViewConfigurationChangedEvent): void;
+    private _instantiateScreenReaderContent;
+    private _createScreenReaderContent;
     private _updateConfigurationSettings;
     private _updateDomAttributes;
     onCursorStateChanged(e: ViewCursorStateChangedEvent): void;
@@ -35,7 +38,4 @@ export declare class ScreenReaderSupport {
     private _doRender;
     setAriaOptions(options: IEditorAriaOptions): void;
     writeScreenReaderContent(): void;
-    get screenReaderContentState(): ScreenReaderContentState | undefined;
-    private _getScreenReaderContentState;
-    private _setSelectionOfScreenReaderContent;
 }