@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -0,0 +1,315 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './nativeEditContext.css.js';
+import { isFirefox } from '../../../../../base/browser/browser.js';
+import { addDisposableListener } from '../../../../../base/browser/dom.js';
+import { FastDomNode } from '../../../../../base/browser/fastDomNode.js';
+import { StandardKeyboardEvent } from '../../../../../base/browser/keyboardEvent.js';
+import { IClipboardService } from '../../../../../platform/clipboard/common/clipboardService.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { getDataToCopy, InMemoryClipboardMetadataManager } from '../clipboardUtils.js';
+import { AbstractEditContext } from '../editContextUtils.js';
+import { FocusTracker, editContextAddDisposableListener } from './nativeEditContextUtils.js';
+import { ScreenReaderSupport } from './screenReaderSupport.js';
+import { Range } from '../../../../common/core/range.js';
+import { Selection } from '../../../../common/core/selection.js';
+import { Position } from '../../../../common/core/position.js';
+import { PositionOffsetTransformer } from '../../../../common/core/positionToOffset.js';
+var CompositionClassName;
+( (function(CompositionClassName) {
+    CompositionClassName["NONE"] = "edit-context-composition-none";
+    CompositionClassName["SECONDARY"] = "edit-context-composition-secondary";
+    CompositionClassName["PRIMARY"] = "edit-context-composition-primary";
+})(CompositionClassName || (CompositionClassName = {})));
+let NativeEditContext = class NativeEditContext extends AbstractEditContext {
+    constructor(context, viewController, _visibleRangeProvider, instantiationService, clipboardService) {
+        super(context);
+        this._visibleRangeProvider = _visibleRangeProvider;
+        this._decorations = [];
+        this._primarySelection = ( new Selection(1, 1, 1, 1));
+        this._textStartPositionWithinEditor = ( new Position(1, 1));
+        this.domNode = ( new FastDomNode(document.createElement('div')));
+        this.domNode.setClassName(`native-edit-context`);
+        this._updateDomAttributes();
+        this._focusTracker = this._register(( new FocusTracker(
+            this.domNode.domNode,
+            (newFocusValue) => this._context.viewModel.setHasFocus(newFocusValue)
+        )));
+        this._editContext = ( new EditContext());
+        this.domNode.domNode.editContext = this._editContext;
+        this._screenReaderSupport = instantiationService.createInstance(ScreenReaderSupport, this.domNode, context);
+        this._register(addDisposableListener(this.domNode.domNode, 'copy', () => this._ensureClipboardGetsEditorSelection(clipboardService)));
+        this._register(addDisposableListener(this.domNode.domNode, 'cut', () => {
+            this._ensureClipboardGetsEditorSelection(clipboardService);
+            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 === 114 ) {
+                standardKeyboardEvent.stopPropagation();
+            }
+            viewController.emitKeyDown(standardKeyboardEvent);
+        }));
+        this._register(addDisposableListener(this.domNode.domNode, 'beforeinput', async (e) => {
+            if (e.inputType === 'insertParagraph') {
+                this._onType(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();
+        }));
+    }
+    dispose() {
+        this.domNode.domNode.blur();
+        this.domNode.domNode.remove();
+        super.dispose();
+    }
+    appendTo(overflowGuardContainer) {
+        overflowGuardContainer.appendChild(this.domNode);
+        this._parent = overflowGuardContainer.domNode;
+    }
+    setAriaOptions() {
+        this._screenReaderSupport.setAriaOptions();
+    }
+    getLastRenderData() {
+        return this._primarySelection.getPosition();
+    }
+    prepareRender(ctx) {
+        this._screenReaderSupport.prepareRender(ctx);
+        this._updateEditContext();
+        this._updateSelectionAndControlBounds(ctx);
+    }
+    render(ctx) {
+        this._screenReaderSupport.render(ctx);
+    }
+    onCursorStateChanged(e) {
+        this._primarySelection = e.modelSelections[0] ?? ( new Selection(1, 1, 1, 1));
+        this._screenReaderSupport.onCursorStateChanged(e);
+        return true;
+    }
+    onConfigurationChanged(e) {
+        this._screenReaderSupport.onConfigurationChanged(e);
+        this._updateDomAttributes();
+        return true;
+    }
+    writeScreenReaderContent() {
+        this._screenReaderSupport.writeScreenReaderContent();
+    }
+    isFocused() { return this._focusTracker.isFocused; }
+    focus() { this._focusTracker.focus(); }
+    refreshFocusState() { }
+    _updateDomAttributes() {
+        const options = this._context.configuration.options;
+        this.domNode.domNode.setAttribute('tabindex', String(options.get(127 )));
+    }
+    _updateEditContext() {
+        const editContextState = this._getNewEditContextState();
+        this._editContext.updateText(0, Number.MAX_SAFE_INTEGER, editContextState.text);
+        this._editContext.updateSelection(editContextState.selectionStartOffset, editContextState.selectionEndOffset);
+        this._textStartPositionWithinEditor = editContextState.textStartPositionWithinEditor;
+    }
+    _emitTypeEvent(viewController, e) {
+        if (!this._editContext) {
+            return;
+        }
+        const model = this._context.viewModel.model;
+        const offsetOfStartOfText = model.getOffsetAt(this._textStartPositionWithinEditor);
+        const offsetOfSelectionEnd = model.getOffsetAt(this._primarySelection.getEndPosition());
+        const offsetOfSelectionStart = model.getOffsetAt(this._primarySelection.getStartPosition());
+        const selectionEndOffset = offsetOfSelectionEnd - offsetOfStartOfText;
+        const selectionStartOffset = offsetOfSelectionStart - offsetOfStartOfText;
+        let replaceNextCharCnt = 0;
+        let replacePrevCharCnt = 0;
+        if (e.updateRangeEnd > selectionEndOffset) {
+            replaceNextCharCnt = e.updateRangeEnd - selectionEndOffset;
+        }
+        if (e.updateRangeStart < selectionStartOffset) {
+            replacePrevCharCnt = selectionStartOffset - e.updateRangeStart;
+        }
+        let text = '';
+        if (selectionStartOffset < e.updateRangeStart) {
+            text += this._editContext.text.substring(selectionStartOffset, e.updateRangeStart);
+        }
+        text += e.text;
+        if (selectionEndOffset > e.updateRangeEnd) {
+            text += this._editContext.text.substring(e.updateRangeEnd, selectionEndOffset);
+        }
+        const typeInput = {
+            text,
+            replacePrevCharCnt,
+            replaceNextCharCnt,
+            positionDelta: 0,
+        };
+        this._onType(viewController, typeInput);
+        this._updateEditContext();
+    }
+    _onType(viewController, typeInput) {
+        if (typeInput.replacePrevCharCnt || typeInput.replaceNextCharCnt || typeInput.positionDelta) {
+            viewController.compositionType(typeInput.text, typeInput.replacePrevCharCnt, typeInput.replaceNextCharCnt, typeInput.positionDelta);
+        }
+        else {
+            viewController.type(typeInput.text);
+        }
+    }
+    _getNewEditContextState() {
+        const model = this._context.viewModel.model;
+        const primarySelectionStartLine = this._primarySelection.startLineNumber;
+        const primarySelectionEndLine = this._primarySelection.endLineNumber;
+        const endColumnOfEndLineNumber = model.getLineMaxColumn(primarySelectionEndLine);
+        const rangeOfText = ( new Range(
+            primarySelectionStartLine,
+            1,
+            primarySelectionEndLine,
+            endColumnOfEndLineNumber
+        ));
+        const text = model.getValueInRange(rangeOfText, 0 );
+        const selectionStartOffset = this._primarySelection.startColumn - 1;
+        const selectionEndOffset = text.length + this._primarySelection.endColumn - endColumnOfEndLineNumber;
+        const textStartPositionWithinEditor = rangeOfText.getStartPosition();
+        return {
+            text,
+            selectionStartOffset,
+            selectionEndOffset,
+            textStartPositionWithinEditor
+        };
+    }
+    _handleTextFormatUpdate(e) {
+        if (!this._editContext) {
+            return;
+        }
+        const formats = e.getTextFormats();
+        const textStartPositionWithinEditor = this._textStartPositionWithinEditor;
+        const decorations = [];
+        formats.forEach(f => {
+            const textModel = this._context.viewModel.model;
+            const offsetOfEditContextText = textModel.getOffsetAt(textStartPositionWithinEditor);
+            const startPositionOfDecoration = textModel.getPositionAt(offsetOfEditContextText + f.rangeStart);
+            const endPositionOfDecoration = textModel.getPositionAt(offsetOfEditContextText + f.rangeEnd);
+            const decorationRange = Range.fromPositions(startPositionOfDecoration, endPositionOfDecoration);
+            const thickness = f.underlineThickness.toLowerCase();
+            let decorationClassName = CompositionClassName.NONE;
+            switch (thickness) {
+                case 'thin':
+                    decorationClassName = CompositionClassName.SECONDARY;
+                    break;
+                case 'thick':
+                    decorationClassName = CompositionClassName.PRIMARY;
+                    break;
+            }
+            decorations.push({
+                range: decorationRange,
+                options: {
+                    description: 'textFormatDecoration',
+                    inlineClassName: decorationClassName,
+                }
+            });
+        });
+        this._decorations = this._context.viewModel.model.deltaDecorations(this._decorations, decorations);
+    }
+    _updateSelectionAndControlBounds(ctx) {
+        if (!this._parent) {
+            return;
+        }
+        const options = this._context.configuration.options;
+        const lineHeight = options.get(69 );
+        const contentLeft = options.get(148 ).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 editorScrollTop = this._context.viewLayout.getCurrentScrollTop();
+        const editorScrollLeft = this._context.viewLayout.getCurrentScrollLeft();
+        const top = parentBounds.top + verticalOffsetStart - editorScrollTop;
+        const height = (this._primarySelection.endLineNumber - this._primarySelection.startLineNumber + 1) * lineHeight;
+        let left = parentBounds.left + contentLeft - editorScrollLeft;
+        let width;
+        if (this._primarySelection.isEmpty()) {
+            const linesVisibleRanges = ctx.visibleRangeForPosition(viewStartPosition);
+            if (linesVisibleRanges) {
+                left += linesVisibleRanges.left;
+            }
+            width = 0;
+        }
+        else {
+            width = parentBounds.width - contentLeft;
+        }
+        const selectionBounds = ( new DOMRect(left, top, width, height));
+        this._editContext.updateSelectionBounds(selectionBounds);
+        this._editContext.updateControlBounds(selectionBounds);
+    }
+    _updateCharacterBounds(e) {
+        if (!this._parent) {
+            return;
+        }
+        const options = this._context.configuration.options;
+        const typicalHalfWidthCharacterWidth = options.get(52 ).typicalHalfwidthCharacterWidth;
+        const lineHeight = options.get(69 );
+        const contentLeft = options.get(148 ).contentLeft;
+        const parentBounds = this._parent.getBoundingClientRect();
+        const characterBounds = [];
+        const offsetTransformer = ( new PositionOffsetTransformer(this._editContext.text));
+        for (let offset = e.rangeStart; offset < e.rangeEnd; offset++) {
+            const editContextStartPosition = offsetTransformer.getPosition(offset);
+            const textStartLineOffsetWithinEditor = this._textStartPositionWithinEditor.lineNumber - 1;
+            const characterStartPosition = ( new Position(
+                textStartLineOffsetWithinEditor + editContextStartPosition.lineNumber,
+                editContextStartPosition.column
+            ));
+            const characterEndPosition = characterStartPosition.delta(0, 1);
+            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 editorScrollTop = this._context.viewLayout.getCurrentScrollTop();
+            const editorScrollLeft = this._context.viewLayout.getCurrentScrollLeft();
+            const top = parentBounds.top + characterVerticalOffset - editorScrollTop;
+            let left = 0;
+            let width = typicalHalfWidthCharacterWidth;
+            if (characterLinesVisibleRanges.length > 0) {
+                for (const visibleRange of characterLinesVisibleRanges[0].ranges) {
+                    left = visibleRange.left;
+                    width = visibleRange.width;
+                    break;
+                }
+            }
+            characterBounds.push(( new DOMRect(
+                parentBounds.left + contentLeft + left - editorScrollLeft,
+                top,
+                width,
+                lineHeight
+            )));
+        }
+        this._editContext.updateCharacterBounds(e.rangeStart, characterBounds);
+    }
+    _ensureClipboardGetsEditorSelection(clipboardService) {
+        const options = this._context.configuration.options;
+        const emptySelectionClipboard = options.get(38 );
+        const copyWithSyntaxHighlighting = options.get(25 );
+        const selections = ( this._context.viewModel.getCursorStates().map(cursorState => cursorState.modelState.selection));
+        const dataToCopy = getDataToCopy(this._context.viewModel, selections, emptySelectionClipboard, copyWithSyntaxHighlighting);
+        const storedMetadata = {
+            version: 1,
+            isFromEmptySelection: dataToCopy.isFromEmptySelection,
+            multicursorText: dataToCopy.multicursorText,
+            mode: dataToCopy.mode
+        };
+        InMemoryClipboardMetadataManager.INSTANCE.set(
+        (isFirefox ? dataToCopy.text.replace(/\r\n/g, '\n') : dataToCopy.text), storedMetadata);
+        clipboardService.writeText(dataToCopy.text);
+    }
+};
+NativeEditContext = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IClipboardService))
+], NativeEditContext));
+export { NativeEditContext };

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

@@ -0,0 +1,35 @@
+import { addDisposableListener } from '../../../../../base/browser/dom.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+class FocusTracker extends Disposable {
+    constructor(_domNode, _onFocusChange) {
+        super();
+        this._domNode = _domNode;
+        this._onFocusChange = _onFocusChange;
+        this._isFocused = false;
+        this._register(addDisposableListener(this._domNode, 'focus', () => this._handleFocusedChanged(true)));
+        this._register(addDisposableListener(this._domNode, 'blur', () => this._handleFocusedChanged(false)));
+    }
+    _handleFocusedChanged(focused) {
+        if (this._isFocused === focused) {
+            return;
+        }
+        this._isFocused = focused;
+        this._onFocusChange(this._isFocused);
+    }
+    focus() {
+        this._handleFocusedChanged(true);
+        this._domNode.focus();
+    }
+    get isFocused() {
+        return this._isFocused;
+    }
+}
+function editContextAddDisposableListener(target, type, listener, options) {
+    target.addEventListener(type, listener, options);
+    return {
+        dispose() {
+            target.removeEventListener(type, listener);
+        }
+    };
+}
+export { FocusTracker, editContextAddDisposableListener };

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

@@ -0,0 +1,131 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { getActiveWindow } from '../../../../../base/browser/dom.js';
+import { localize } from '../../../../../nls.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
+import { Selection } from '../../../../common/core/selection.js';
+import { applyFontInfo } from '../../../config/domFontInfo.js';
+import { ariaLabelForScreenReaderContent, newlinecount, PagedScreenReaderStrategy } from '../screenReaderUtils.js';
+let ScreenReaderSupport = class ScreenReaderSupport {
+    constructor(_domNode, _context, _keybindingService) {
+        this._domNode = _domNode;
+        this._context = _context;
+        this._keybindingService = _keybindingService;
+        this._contentLeft = 1;
+        this._contentWidth = 1;
+        this._lineHeight = 1;
+        this._accessibilitySupport = 0 ;
+        this._accessibilityPageSize = 1;
+        this._primarySelection = ( (new Selection(1, 1, 1, 1)));
+        this._updateConfigurationSettings();
+        this._updateDomAttributes();
+    }
+    onConfigurationChanged(e) {
+        this._updateConfigurationSettings();
+        this._updateDomAttributes();
+        if (e.hasChanged(2 )) {
+            this.writeScreenReaderContent();
+        }
+    }
+    _updateConfigurationSettings() {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(148 );
+        this._contentLeft = layoutInfo.contentLeft;
+        this._contentWidth = layoutInfo.contentWidth;
+        this._fontInfo = options.get(52 );
+        this._lineHeight = options.get(69 );
+        this._accessibilitySupport = options.get(2 );
+        this._accessibilityPageSize = options.get(3 );
+    }
+    _updateDomAttributes() {
+        const options = this._context.configuration.options;
+        this._domNode.domNode.setAttribute('role', 'textbox');
+        this._domNode.domNode.setAttribute('aria-required', options.get(5 ) ? 'true' : 'false');
+        this._domNode.domNode.setAttribute('aria-multiline', 'true');
+        this._domNode.domNode.setAttribute('aria-autocomplete', options.get(94 ) ? 'none' : 'both');
+        this._domNode.domNode.setAttribute('aria-roledescription', ( localize(11405, "editor")));
+        this._domNode.domNode.setAttribute('aria-label', ariaLabelForScreenReaderContent(options, this._keybindingService));
+        const tabSize = this._context.viewModel.model.getOptions().tabSize;
+        const spaceWidth = options.get(52 ).spaceWidth;
+        this._domNode.domNode.style.tabSize = `${tabSize * spaceWidth}px`;
+    }
+    onCursorStateChanged(e) {
+        this._primarySelection = e.selections[0] ?? ( (new Selection(1, 1, 1, 1)));
+    }
+    prepareRender(ctx) {
+        this.writeScreenReaderContent();
+    }
+    render(ctx) {
+        if (!this._screenReaderContentState) {
+            return;
+        }
+        applyFontInfo(this._domNode, this._fontInfo);
+        const verticalOffsetForPrimaryLineNumber = this._context.viewLayout.getVerticalOffsetForLineNumber(this._primarySelection.positionLineNumber);
+        const editorScrollTop = this._context.viewLayout.getCurrentScrollTop();
+        const top = verticalOffsetForPrimaryLineNumber - editorScrollTop;
+        this._domNode.setTop(top);
+        this._domNode.setLeft(this._contentLeft);
+        this._domNode.setWidth(this._contentWidth);
+        this._domNode.setHeight(this._lineHeight);
+        const textContentBeforeSelection = this._screenReaderContentState.value.substring(0, this._screenReaderContentState.selectionStart);
+        const numberOfLinesOfContentBeforeSelection = newlinecount(textContentBeforeSelection);
+        this._domNode.domNode.scrollTop = numberOfLinesOfContentBeforeSelection * this._lineHeight;
+    }
+    setAriaOptions() { }
+    writeScreenReaderContent() {
+        const focusedElement = getActiveWindow().document.activeElement;
+        if (!focusedElement || focusedElement !== this._domNode.domNode) {
+            return;
+        }
+        this._screenReaderContentState = this._getScreenReaderContentState();
+        if (!this._screenReaderContentState) {
+            return;
+        }
+        if (this._domNode.domNode.textContent !== this._screenReaderContentState.value) {
+            this._domNode.domNode.textContent = this._screenReaderContentState.value;
+        }
+        this._setSelectionOfScreenReaderContent(this._screenReaderContentState.selectionStart, this._screenReaderContentState.selectionEnd);
+    }
+    _getScreenReaderContentState() {
+        if (this._accessibilitySupport === 1 ) {
+            return;
+        }
+        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._accessibilitySupport === 0 );
+    }
+    _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);
+        activeDocumentSelection.removeAllRanges();
+        activeDocumentSelection.addRange(range);
+    }
+};
+ScreenReaderSupport = ( (__decorate([
+    ( (__param(2, IKeybindingService)))
+], ScreenReaderSupport)));
+export { ScreenReaderSupport };

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

@@ -0,0 +1,107 @@
+import { Range } from '../../../common/core/range.js';
+import { localize } from '../../../../nls.js';
+class PagedScreenReaderStrategy {
+    static _getPageOfLine(lineNumber, linesPerPage) {
+        return Math.floor((lineNumber - 1) / linesPerPage);
+    }
+    static _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) {
+        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);
+        let pretextRange = selectionStartPageRange.intersectRanges(( (new Range(1, 1, selection.startLineNumber, selection.startColumn))));
+        if (trimLongText && model.getValueLengthInRange(pretextRange, 1 ) > LIMIT_CHARS) {
+            const pretextStart = model.modifyPosition(pretextRange.getEndPosition(), -LIMIT_CHARS);
+            pretextRange = Range.fromPositions(pretextStart, pretextRange.getEndPosition());
+        }
+        const pretext = model.getValueInRange(pretextRange, 1 );
+        const lastLine = model.getLineCount();
+        const lastLineMaxColumn = model.getLineMaxColumn(lastLine);
+        let posttextRange = selectionEndPageRange.intersectRanges(( (new Range(selection.endLineNumber, selection.endColumn, lastLine, lastLineMaxColumn))));
+        if (trimLongText && model.getValueLengthInRange(posttextRange, 1 ) > LIMIT_CHARS) {
+            const posttextEnd = model.modifyPosition(posttextRange.getStartPosition(), LIMIT_CHARS);
+            posttextRange = Range.fromPositions(posttextRange.getStartPosition(), posttextEnd);
+        }
+        const posttext = model.getValueInRange(posttextRange, 1 );
+        let text;
+        if (selectionStartPage === selectionEndPage || selectionStartPage + 1 === selectionEndPage) {
+            text = model.getValueInRange(selection, 1 );
+        }
+        else {
+            const selectionRange1 = selectionStartPageRange.intersectRanges(selection);
+            const selectionRange2 = selectionEndPageRange.intersectRanges(selection);
+            text = (model.getValueInRange(selectionRange1, 1 )
+                + String.fromCharCode(8230)
+                + model.getValueInRange(selectionRange2, 1 ));
+        }
+        if (trimLongText && text.length > 2 * LIMIT_CHARS) {
+            text = text.substring(0, LIMIT_CHARS) + String.fromCharCode(8230) + text.substring(text.length - LIMIT_CHARS, text.length);
+        }
+        return {
+            value: pretext + text + posttext,
+            selection: selection,
+            selectionStart: pretext.length,
+            selectionEnd: pretext.length + text.length,
+            newlineCountBeforeSelection: pretextRange.endLineNumber - pretextRange.startLineNumber,
+        };
+    }
+}
+function ariaLabelForScreenReaderContent(options, keybindingService) {
+    const accessibilitySupport = options.get(2 );
+    if (accessibilitySupport === 1 ) {
+        const toggleKeybindingLabel = keybindingService.lookupKeybinding('editor.action.toggleScreenReaderAccessibilityMode')?.getAriaLabel();
+        const runCommandKeybindingLabel = keybindingService.lookupKeybinding('workbench.action.showCommands')?.getAriaLabel();
+        const keybindingEditorKeybindingLabel = keybindingService.lookupKeybinding('workbench.action.openGlobalKeybindings')?.getAriaLabel();
+        const editorNotAccessibleMessage = ( localize(11401, "The editor is not accessible at this time."));
+        if (toggleKeybindingLabel) {
+            return ( localize(
+                11402,
+                "{0} To enable screen reader optimized mode, use {1}",
+                editorNotAccessibleMessage,
+                toggleKeybindingLabel
+            ));
+        }
+        else if (runCommandKeybindingLabel) {
+            return ( localize(
+                11403,
+                "{0} To enable screen reader optimized mode, open the quick pick with {1} and run the command Toggle Screen Reader Accessibility Mode, which is currently not triggerable via keyboard.",
+                editorNotAccessibleMessage,
+                runCommandKeybindingLabel
+            ));
+        }
+        else if (keybindingEditorKeybindingLabel) {
+            return ( localize(
+                11404,
+                "{0} Please assign a keybinding for the command Toggle Screen Reader Accessibility Mode by accessing the keybindings editor with {1} and run it.",
+                editorNotAccessibleMessage,
+                keybindingEditorKeybindingLabel
+            ));
+        }
+        else {
+            return editorNotAccessibleMessage;
+        }
+    }
+    return options.get(4 );
+}
+function newlinecount(text) {
+    let result = 0;
+    let startIndex = -1;
+    do {
+        startIndex = text.indexOf('\n', startIndex + 1);
+        if (startIndex === -1) {
+            break;
+        }
+        result++;
+    } while (true);
+    return result;
+}
+export { PagedScreenReaderStrategy, ariaLabelForScreenReaderContent, newlinecount };

package/vscode/src/vs/editor/browser/controller/{textAreaHandler.css.js → editContext/textArea/textAreaEditContext.css.js}

@@ -1,4 +1,4 @@
-import n from '../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
 var css = ".monaco-editor .inputarea{background-color:transparent;border:none;color:transparent;margin:0;min-height:0;min-width:0;outline:none!important;overflow:hidden;padding:0;position:absolute;resize:none;z-index:-10}.monaco-editor .inputarea.ime-input{caret-color:var(--vscode-editorCursor-foreground);color:var(--vscode-editor-foreground);z-index:10}";
 n(css,{});
 export { css, css as default };