devexpress-richedit 25.2.7 → 26.1.2-beta

package/lib/common/model/sub-document.js

@@ -5,13 +5,15 @@ import { SearchUtils } from '@devexpress/utils/lib/utils/search';
 import { SpellCheckerIntervalsManager } from '../spelling/intervals-manager';
 import { RunIterator } from './character/run-iterator';
 import { ResetFormattingCacheType } from './document-model';
-import { Field } from './fields/field';
 import { FullChunkAndRunInfo } from './full-chunk-and-run-info';
 import { BookmarksManipulator } from './manipulators/bookmarks-manipulator';
 import { ModelIterator } from './model-iterator';
 import { PositionManager } from './position/position-manager';
 import { RichUtils } from './rich-utils';
 import { RunType } from './runs/run-type';
+import { ParagraphIterator } from '../layout-formatter/box/generator/one-dimension-itertors';
+import { isDefined } from '@devexpress/utils/lib/utils/common';
+import { FieldIterator } from '../layout-formatter/box/generator/recursive-objects-iterators';
 export class SubDocument {
     static { this.AUTOGENERATE_ID = -1; }
     static { this.MAIN_SUBDOCUMENT_ID = 0; }
@@ -63,36 +65,78 @@ export class SubDocument {
         return buffer;
     }
     getSimpleText(interval) {
-        let result = "";
+        return this.getVisibleText(interval, {
+            useFieldResult: true,
+            charMap: {
+                [RichUtils.specialCharacters.LineBreak]: ' ',
+                [RichUtils.specialCharacters.SectionMark]: '\r\n',
+                [RichUtils.specialCharacters.ParagraphMark]: '\r\n'
+            }
+        });
+    }
+    getVisibleText(interval, options = {}) {
+        let result = [];
         let pos = interval.start;
-        let nested = 0;
-        const fieldIndex = Field.normedBinaryIndexOf(this.fields, pos);
-        if (fieldIndex > -1) {
-            let field = this.fields[fieldIndex];
-            while (field.parent)
-                field = field.parent;
-            pos = field.getFieldStartPosition();
-        }
+        const { charMap = {}, useFieldResult = false, includeNumberedListMarks = false, inlinePictureAltText = null, resolveAdditionalText = undefined, } = options;
         const iterator = new ModelIterator(this, true);
         iterator.setPosition(pos);
+        const fieldIterator = new FieldIterator(this.fields);
+        fieldIterator.init(pos);
+        const paragraphIterator = new ParagraphIterator(this.paragraphs);
+        paragraphIterator.init(pos);
         while (pos < interval.end) {
-            switch (iterator.run.getType()) {
-                case RunType.FieldCodeStartRun:
-                    nested++;
-                    break;
-                case RunType.FieldCodeEndRun:
-                    nested--;
-                    break;
-                case RunType.TextRun:
-                    if (pos >= interval.start && nested == 0)
-                        result += iterator.getCurrentChar();
+            if (this.isPositionVisible(pos, fieldIterator.indexes, useFieldResult)) {
+                const paragraph = this.paragraphs[paragraphIterator.index];
+                if (includeNumberedListMarks && pos === paragraph.startLogPosition.value && paragraph.isInList())
+                    result.push(paragraph.getNumberingListText() + paragraph.getNumberingListSeparatorChar());
+                if (resolveAdditionalText) {
+                    const resolved = resolveAdditionalText(fieldIterator.indexes, pos);
+                    if (resolved)
+                        result.push(resolved);
+                }
+                switch (iterator.run.getType()) {
+                    case RunType.InlinePictureRun:
+                        if (inlinePictureAltText != null) {
+                            let placeholder;
+                            if (typeof inlinePictureAltText === "function")
+                                placeholder = inlinePictureAltText(iterator.run);
+                            else
+                                placeholder = inlinePictureAltText;
+                            if (isDefined(placeholder))
+                                result.push(placeholder);
+                        }
+                        break;
+                    case RunType.SectionRun:
+                    case RunType.ParagraphRun:
+                    case RunType.FieldCodeStartRun:
+                    case RunType.FieldCodeEndRun:
+                    case RunType.TextRun:
+                        const char = iterator.getCurrentChar();
+                        result.push(charMap[char] ?? char);
+                        break;
+                }
+                if (!iterator.moveToNextChar())
                     break;
             }
-            if (!iterator.moveToNextChar())
+            else if (!iterator.moveToNextRun())
                 break;
             pos = iterator.getAbsolutePosition();
+            paragraphIterator.update(pos);
+            fieldIterator.update(pos);
+        }
+        return result.join("");
+    }
+    isPositionVisible(pos, fieldIndexes, useFieldResult) {
+        for (const index of fieldIndexes) {
+            const field = this.fields[index];
+            const isCodeView = !useFieldResult && field.showCode;
+            const invisibleInterval = isCodeView
+                ? field.getResultIntervalWithBorders()
+                : field.getCodeIntervalWithBorders();
+            if (invisibleInterval.contains(pos))
+                return false;
         }
-        return result.replace(RichUtils.specialCharacters.LineBreak, " ");
+        return true;
     }
     splitRun(position) {
         var info = this.getRunAndIndexesByPosition(position);

package/lib/common/rich-edit-core.d.ts

@@ -38,6 +38,7 @@ import { RulerSettings } from './ui/ruler/settings';
 import { SearchManager } from './ui/search-manager';
 import { IExportModelOptions } from './formats/i-document-exporter';
 import { ModelScrollManager } from './scroll/model-scroll-manager';
+import { ScreenReaderManager } from './screen-reader-manager';
 export declare abstract class RichEditCore implements IRichEditControl {
     modelManager: IModelManager;
     barHolder: IBarHolder;
@@ -71,6 +72,7 @@ export declare abstract class RichEditCore implements IRichEditControl {
     owner: IControlOwner;
     selectionModelChangesListener: SelectionModelChangesListener;
     readonly pdfHelperFrame: PdfHelperFrame;
+    screenReaderManager: ScreenReaderManager;
     private closed;
     sessionGuid: string;
     private clientGuid;
@@ -119,6 +121,7 @@ export declare abstract class RichEditCore implements IRichEditControl {
     getExportModelOptions(initOptions?: Partial<IExportModelOptions>): IExportModelOptions;
     ensureDocumentIsFullyFormatted(): void;
     protected abstract createSpellChecker(): any;
+    protected createAriaLiveElement(element: HTMLElement): HTMLDivElement;
     protected createViewElement(id: string, element: HTMLElement): HTMLDivElement;
     private isUsedInnerClipboard;
     getExportDocumentFormat(): DocumentFormat;

package/lib/common/rich-edit-core.js

@@ -44,6 +44,7 @@ import { HorizontalRulerControl } from './ui/ruler/ruler';
 import { SearchManager } from './ui/search-manager';
 import { isDefined } from '@devexpress/utils/lib/utils/common';
 import { ModelScrollManager } from './scroll/model-scroll-manager';
+import { ScreenReaderManager } from './screen-reader-manager';
 export class RichEditCore {
     get isReadOnlyPersistent() { return this.readOnly === ReadOnlyMode.Persistent; }
     get model() { return this.modelManager.model; }
@@ -84,6 +85,7 @@ export class RichEditCore {
         this.commandManager = this.createCommandManager();
         this.shortcutManager = this.createShortcutManager();
         this.searchManager = new SearchManager(this);
+        this.screenReaderManager = new ScreenReaderManager(this, this.createAriaLiveElement(element));
         this.boxVisualizerManager.initListeners(this.viewManager);
         this.autoCorrectService = new AutoCorrectService(this, this.modelManager.richOptions.autoCorrect);
         this.clientSideEvents = new ClientSideEvents(this.owner);
@@ -142,6 +144,7 @@ export class RichEditCore {
         this.selection.onChanged.add(this.boxVisualizerManager.resizeBoxVisualizer);
         this.selection.onChanged.add(this.boxVisualizerManager.anchorVisualizer);
         this.selection.onChanged.add(this.barHolder.contextMenu);
+        this.selection.onChanged.add(this.screenReaderManager);
         if (this.barHolder.ribbon)
             this.selection.onChanged.add(this.barHolder.ribbon);
         this.selection.onSearchChanged.add(this.selectionFormatter);
@@ -191,6 +194,7 @@ export class RichEditCore {
         this.spellChecker.dispose();
         this.selection.dispose();
         this.barHolder.dispose?.();
+        this.screenReaderManager.dispose?.();
         this.modelManager = null;
         this.commandManager = null;
         this.shortcutManager = null;
@@ -401,6 +405,20 @@ export class RichEditCore {
                 this.layoutFormatterManager.forceFormatPage(this.layout.validPageCount + 1);
         }
     }
+    createAriaLiveElement(element) {
+        const ariaLiveElement = document.createElement("DIV");
+        ariaLiveElement.setAttribute('aria-live', 'polite');
+        ariaLiveElement.setAttribute('aria-atomic', 'true');
+        ariaLiveElement.style.position = 'absolute';
+        ariaLiveElement.style.width = '1px';
+        ariaLiveElement.style.height = '1px';
+        ariaLiveElement.style.overflow = 'hidden';
+        ariaLiveElement.style.whiteSpace = 'nowrap';
+        ariaLiveElement.style.border = '0';
+        ariaLiveElement.style.whiteSpace = 'pre-line';
+        element.appendChild(ariaLiveElement);
+        return ariaLiveElement;
+    }
     createViewElement(id, element) {
         const viewElement = document.createElement("DIV");
         viewElement.id = id + "_View";

package/lib/common/screen-reader-manager.d.ts

@@ -0,0 +1,45 @@
+import { RichEditClientCommand } from "./commands/client-command";
+import { IRichEditControl } from "./interfaces/i-rich-edit-core";
+import { LayoutPosition } from "./layout/layout-position";
+import { ISelectionChangesListener } from "./selection/i-selection-changes-listener";
+import { Selection } from "./selection/selection";
+export declare class ScreenReaderManager implements ISelectionChangesListener {
+    private static _maxAnnouncedTextLength;
+    private static _spaceSeparatorRegex;
+    private static _specialCharSubstitutionTable;
+    private _charNames;
+    readonly _handlers: Map<RichEditClientCommand, (selection: Selection, lp: LayoutPosition) => string>;
+    private _selectionIntervals;
+    private _commandId;
+    private _control;
+    private _liveRegion;
+    private _announceTimeoutId;
+    private _pageIndex;
+    private _tableInfo;
+    private _prevNavInHyperlink;
+    constructor(control: IRichEditControl, liveRegion: HTMLDivElement);
+    private _announce;
+    private _clearAnnouncement;
+    beginExecute(commandId: RichEditClientCommand): void;
+    endExecute(): void;
+    NotifySelectionChanged(selection: Selection): void;
+    private _processTable;
+    private _processExtendSelectionCommand;
+    private _getTextByIntervals;
+    private _updateHyperlinkState;
+    private _getLinkTransitionPrefix;
+    private _getCurrentCharacterAnnouncement;
+    private _buildContextualAnnouncement;
+    private _getCurrentLineAnnouncement;
+    private _getCurrentWordAnnouncement;
+    private _getCurrentParagraphAnnouncement;
+    private _getHyperlinkField;
+    private _onHyperlinkFieldStart;
+    private _getVisibleText;
+    private static _getInlinePictureText;
+    private _getPageChangePrefix;
+    private _getCharName;
+    private _resolveListMarker;
+    private _getListItemAnnouncement;
+    dispose(): void;
+}

package/lib/common/screen-reader-manager.js

@@ -0,0 +1,309 @@
+import { FixedInterval } from "@devexpress/utils/lib/intervals/fixed";
+import { RichEditClientCommand } from "./commands/client-command";
+import { LayoutPositionCreator } from "./layout-engine/layout-position-creator";
+import { DocumentLayoutDetailsLevel } from "./layout/document-layout-details-level";
+import { LayoutWordBounds } from "./word-bounds-engine/layout-word-bounds";
+import { IntervalUtils } from "./utils/interval-utils";
+import { NumberingType } from "./model/numbering-lists/numbering-list";
+import { TablePositionIndexes } from "./model/tables/main-structures/table";
+import { InlinePictureRun } from "./model/runs/inline-picture-run";
+import { RichUtils } from "./model/rich-utils";
+import { formatMessage } from "devextreme/localization";
+import { RunType } from "./model/runs/run-type";
+import { SubDocumentPosition } from "./model/sub-document";
+class TableInfo {
+    constructor(index, columnIndex, rowIndex) {
+        this.index = index;
+        this.columnIndex = columnIndex;
+        this.rowIndex = rowIndex;
+    }
+}
+export class ScreenReaderManager {
+    static { this._maxAnnouncedTextLength = 500; }
+    static { this._spaceSeparatorRegex = /^\p{Zs}$/u; }
+    static { this._specialCharSubstitutionTable = {
+        [RichUtils.specialCharacters.SectionMark]: RichUtils.specialCharacters.PageBreak + "\u200C",
+        [RichUtils.specialCharacters.PageBreak]: RichUtils.specialCharacters.PageBreak + "\u200C",
+    }; }
+    constructor(control, liveRegion) {
+        this._charNames = Object.assign({
+            [RichUtils.specialCharacters.TabMark]: getString("TabAnnouncement"),
+            [RichUtils.specialCharacters.ParagraphMark]: getString("CarriageReturnAnnouncement"),
+            [RichUtils.specialCharacters.LineBreak]: getString("LineBreakAnnouncement"),
+        }, ScreenReaderManager._specialCharSubstitutionTable);
+        this._handlers = new Map([
+            [RichEditClientCommand.NextCharacter, (selection, lp) => this._getCurrentCharacterAnnouncement(selection, lp)],
+            [RichEditClientCommand.PreviousCharacter, (selection, lp) => this._getCurrentCharacterAnnouncement(selection, lp)],
+            [RichEditClientCommand.LineUp, (selection, lp) => this._getCurrentLineAnnouncement(selection, lp)],
+            [RichEditClientCommand.LineDown, (selection, lp) => this._getCurrentLineAnnouncement(selection, lp)],
+            [RichEditClientCommand.GoToNextWord, (selection, lp) => this._getCurrentWordAnnouncement(selection, lp)],
+            [RichEditClientCommand.GoToPrevWord, (selection, lp) => this._getCurrentWordAnnouncement(selection, lp)],
+            [RichEditClientCommand.GoToStartParagraph, (selection, lp) => this._getCurrentParagraphAnnouncement(selection, lp)],
+            [RichEditClientCommand.GoToEndParagraph, (selection, lp) => this._getCurrentParagraphAnnouncement(selection, lp)],
+            [RichEditClientCommand.NextPage, (selection, lp) => this._getCurrentLineAnnouncement(selection, lp)],
+            [RichEditClientCommand.PreviousPage, (selection, lp) => this._getCurrentLineAnnouncement(selection, lp)],
+            [RichEditClientCommand.GoToStartNextPage, (selection, lp) => this._getCurrentLineAnnouncement(selection, lp)],
+            [RichEditClientCommand.GoToStartPrevPage, (selection, lp) => this._getCurrentLineAnnouncement(selection, lp)],
+        ]);
+        this._selectionIntervals = [];
+        this._commandId = null;
+        this._announceTimeoutId = null;
+        this._pageIndex = null;
+        this._tableInfo = null;
+        this._prevNavInHyperlink = false;
+        this._control = control;
+        this._liveRegion = liveRegion;
+    }
+    _announce(...announcment) {
+        this._clearAnnouncement();
+        this._liveRegion.textContent = '';
+        this._announceTimeoutId = setTimeout(() => {
+            const textContent = announcment.join(' ');
+            this._liveRegion.textContent = textContent;
+            this._announceTimeoutId = null;
+        }, 50);
+    }
+    _clearAnnouncement() {
+        if (this._announceTimeoutId !== null) {
+            clearTimeout(this._announceTimeoutId);
+            this._announceTimeoutId = null;
+        }
+    }
+    beginExecute(commandId) {
+        this._commandId = commandId;
+    }
+    endExecute() {
+        this._commandId = null;
+    }
+    NotifySelectionChanged(selection) {
+        const currentIntervals = !selection.isCollapsed() ? [...selection.intervals].sort((x, y) => x.start - y.start) : [];
+        if (this._commandId != null) {
+            let announcments = [];
+            const handler = this._handlers.get(this._commandId);
+            if (handler) {
+                const pos = selection.intervals[0].start;
+                const subDocument = selection.activeSubDocument;
+                const lp = LayoutPositionCreator.createLightLayoutPosition(this._control.layout, subDocument, pos, selection.pageIndex, DocumentLayoutDetailsLevel.Box, selection.endOfLine, false);
+                const pagePrefix = this._getPageChangePrefix(lp.pageIndex);
+                if (pagePrefix)
+                    announcments.push(pagePrefix);
+                const tableAnnouncements = this._processTable(selection.tableInfo);
+                if (tableAnnouncements.length > 0)
+                    announcments.push(...tableAnnouncements);
+                const content = handler(selection, lp);
+                this._updateHyperlinkState(lp);
+                if (content)
+                    announcments.push(content);
+            }
+            if ((!handler && currentIntervals.length > 0) || this._selectionIntervals.length > 0)
+                announcments.push(...this._processExtendSelectionCommand(currentIntervals));
+            if (announcments.length > 0)
+                this._announce(...announcments);
+        }
+        this._selectionIntervals = currentIntervals;
+    }
+    _processTable(tableInfo) {
+        const result = [];
+        if (!tableInfo.table) {
+            if (this._tableInfo) {
+                result.push(getString("OutOfTableAnnouncement"));
+                this._tableInfo = null;
+            }
+            return result;
+        }
+        const extendedData = tableInfo.extendedData;
+        const tableCellGridInfos = tableInfo.gridInfoManager.tableCellGridInfos;
+        const cellGridInfo = tableInfo.gridInfoManager.gridInfosByTablePosition(new TablePositionIndexes(extendedData.firstRowInfo.rowIndex, extendedData.firstCellInfo.cellIndex));
+        const colIndex = cellGridInfo.getGridCellIndex();
+        const rowIndex = cellGridInfo.getStartRowIndex();
+        const currentTableInfo = new TableInfo(tableInfo.table.index, colIndex, rowIndex);
+        if (!this._tableInfo || this._tableInfo.index !== currentTableInfo.index)
+            result.push(getString("InTableAnnouncement", tableCellGridInfos.length, tableCellGridInfos[0].length));
+        if (!this._tableInfo || this._tableInfo.rowIndex !== currentTableInfo.rowIndex)
+            result.push(getString("TableRowAnnouncement", rowIndex + 1));
+        if (!this._tableInfo || this._tableInfo.columnIndex !== currentTableInfo.columnIndex)
+            result.push(getString("TableColumnAnnouncement", colIndex + 1));
+        this._tableInfo = currentTableInfo;
+        return result;
+    }
+    _processExtendSelectionCommand(intervals) {
+        let announcments = [];
+        if (this._commandId === RichEditClientCommand.SelectAll)
+            announcments.push(getString("SelectAllAnnouncement"), "\n");
+        const selectedIntervals = IntervalUtils.subtractIntervals(intervals, this._selectionIntervals);
+        if (selectedIntervals.length > 0)
+            announcments.push(getString("TextSelectedAnnouncement", this._getTextByIntervals(selectedIntervals)));
+        const unselectedIntervals = IntervalUtils.subtractIntervals(this._selectionIntervals, intervals);
+        if (unselectedIntervals.length > 0)
+            announcments.push(getString("TextUnselectedAnnouncement", this._getTextByIntervals(unselectedIntervals)));
+        return announcments;
+    }
+    _getTextByIntervals(intervals) {
+        const length = intervals.reduce((total, interval) => total + interval.length, 0);
+        if (length > ScreenReaderManager._maxAnnouncedTextLength)
+            return `${length} characters`;
+        const subDocument = this._control.selection.activeSubDocument;
+        return intervals.map(i => subDocument.getVisibleText(i, {
+            includeNumberedListMarks: true,
+            charMap: ScreenReaderManager._specialCharSubstitutionTable
+        })).join('');
+    }
+    _updateHyperlinkState(lp) {
+        this._prevNavInHyperlink = lp.box?.hyperlinkTip != null;
+    }
+    _getLinkTransitionPrefix(lp) {
+        const inHyperlink = lp.box?.hyperlinkTip != null;
+        const prevInHyperlink = this._prevNavInHyperlink;
+        if (inHyperlink && !prevInHyperlink)
+            return getString("LinkAnnouncement");
+        if (!inHyperlink && prevInHyperlink)
+            return getString("OutOfLinkAnnouncement");
+        return null;
+    }
+    _getCurrentCharacterAnnouncement(selection, lp) {
+        const pos = selection.intervals[0].start;
+        const subDocument = selection.activeSubDocument;
+        const info = subDocument.getRunAndIndexesByPosition(pos);
+        if (info.run instanceof InlinePictureRun)
+            return ScreenReaderManager._getInlinePictureText(info.run);
+        const isFieldCodeStartRun = info.run.getType() === RunType.FieldCodeStartRun;
+        const charInfo = isFieldCodeStartRun
+            ? subDocument.getRunAndIndexesByPosition(lp.getLogPosition(DocumentLayoutDetailsLevel.Box))
+            : info;
+        const char = charInfo.getCurrentChar();
+        let content = this._getCharName(char);
+        return this._buildContextualAnnouncement(content, new SubDocumentPosition(subDocument, pos), lp);
+    }
+    _buildContextualAnnouncement(content, pos, lp) {
+        const paragraph = pos.subDocument.getParagraphByPosition(pos.position);
+        const linkPrefix = this._getLinkTransitionPrefix(lp);
+        if (linkPrefix)
+            content = `${linkPrefix} ${content}`;
+        const listContent = this._getListItemAnnouncement(paragraph, pos.position, lp, content);
+        return listContent ? listContent : content;
+    }
+    _getCurrentLineAnnouncement(selection, lp) {
+        const pos = selection.intervals[0].start;
+        const subDocument = selection.activeSubDocument;
+        const rowStart = lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
+        const rowEnd = rowStart + lp.row.getLastBoxEndPositionInRow();
+        const intervalStart = rowStart;
+        const text = this._getVisibleText(subDocument, FixedInterval.fromPositions(intervalStart, rowEnd));
+        const listMarker = lp.row.numberingListBox
+            ? this._resolveListMarker(subDocument.getParagraphByPosition(pos))
+            : null;
+        return listMarker ? `${listMarker} ${text}`.trim() : text;
+    }
+    _getCurrentWordAnnouncement(selection, lp) {
+        const pos = selection.intervals[0].start;
+        const subDocument = selection.activeSubDocument;
+        const wordEnd = LayoutWordBounds.getLayoutWordEndBound(this._control.layout, subDocument, selection, pos, false);
+        let text = subDocument.getVisibleText(FixedInterval.fromPositions(pos, wordEnd), {
+            inlinePictureAltText: ScreenReaderManager._getInlinePictureText,
+            charMap: ScreenReaderManager._specialCharSubstitutionTable
+        });
+        return this._buildContextualAnnouncement(text, new SubDocumentPosition(subDocument, pos), lp);
+    }
+    _getCurrentParagraphAnnouncement(selection, _lp) {
+        const pos = selection.intervals[0].start;
+        const subDocument = selection.activeSubDocument;
+        const paragraph = subDocument.getParagraphByPosition(pos);
+        const text = this._getVisibleText(subDocument, FixedInterval.fromPositions(paragraph.startLogPosition.value, paragraph.getEndPosition()), true);
+        return text;
+    }
+    _getHyperlinkField(fieldIndexes, _subDocument) {
+        return fieldIndexes
+            .map(index => _subDocument.fields[index])
+            .find(field => field.isHyperlinkField());
+    }
+    _onHyperlinkFieldStart(fieldIndexes, subDocument, pos) {
+        const field = this._getHyperlinkField(fieldIndexes, subDocument);
+        return field && pos === field.getResultStartPosition() ? ` ${getString("LinkAnnouncement")} ` : null;
+    }
+    _getVisibleText(subDocument, interval, includeNumberedListMarks = false) {
+        const result = subDocument.getVisibleText(interval, {
+            includeNumberedListMarks,
+            inlinePictureAltText: ScreenReaderManager._getInlinePictureText,
+            charMap: ScreenReaderManager._specialCharSubstitutionTable,
+            resolveAdditionalText: (fieldIndexes, pos) => this._onHyperlinkFieldStart(fieldIndexes, subDocument, pos)
+        });
+        return result === RichUtils.specialCharacters.ParagraphMark
+            ? getString("BlankAnnouncement")
+            : result;
+    }
+    static _getInlinePictureText(run) {
+        const nonVisualProps = run.info.nonVisualDrawingProperties;
+        return getString("PictureAnnouncement", nonVisualProps.description ?? nonVisualProps.name ?? '');
+    }
+    _getPageChangePrefix(pageIndex) {
+        if (this._pageIndex === null) {
+            this._pageIndex = pageIndex;
+            return '';
+        }
+        if (pageIndex !== this._pageIndex) {
+            this._pageIndex = pageIndex;
+            return getString("PageAnnouncement", pageIndex + 1);
+        }
+        return '';
+    }
+    _getCharName(char) {
+        if (char in this._charNames)
+            return this._charNames[char];
+        return ScreenReaderManager._spaceSeparatorRegex.test(char) ? getString("SpaceAnnouncement") : char;
+    }
+    _resolveListMarker(paragraph) {
+        const levelIndex = paragraph.getListLevelIndex();
+        const levelType = paragraph.getNumberingList().getLevelType(levelIndex);
+        if (levelType === NumberingType.Bullet)
+            return getString("BulletAnnouncement");
+        return paragraph.getNumberingListText();
+    }
+    _getListItemAnnouncement(paragraph, pos, lp, content) {
+        if (!paragraph.isInList() || pos !== paragraph.startLogPosition.value || !lp?.row?.numberingListBox)
+            return null;
+        const level = paragraph.getListLevelIndex() + 1;
+        const listMarker = this._resolveListMarker(paragraph);
+        return `${getString("ListItemAnnouncement", level, listMarker)} ${content}`;
+    }
+    dispose() {
+        this._clearAnnouncement();
+        this._liveRegion.remove();
+    }
+}
+const stringCache = {};
+function createFormatter(template) {
+    const tokens = [];
+    let lastIndex = 0;
+    template.replace(/\{(\d+)\}/g, (match, p1, offset) => {
+        if (lastIndex < offset)
+            tokens.push(template.slice(lastIndex, offset));
+        tokens.push(Number(p1));
+        lastIndex = offset + match.length;
+        return match;
+    });
+    if (lastIndex < template.length)
+        tokens.push(template.slice(lastIndex));
+    return (args) => {
+        let result = '';
+        for (const token of tokens) {
+            if (typeof token === 'string')
+                result += token;
+            else {
+                const value = args[token];
+                result += value ?? '';
+            }
+        }
+        return result;
+    };
+}
+function getString(key, ...args) {
+    let entry = stringCache[key];
+    if (!entry) {
+        const str = formatMessage(`AspNetCoreRichEditStringId.${key}`);
+        entry = args.length > 0 ? createFormatter(str) : str;
+        stringCache[key] = entry;
+    }
+    if (typeof entry === "function")
+        return entry(args);
+    return entry;
+}

package/lib/common/utils/interval-utils.d.ts

@@ -0,0 +1,4 @@
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
+export declare class IntervalUtils {
+    static subtractIntervals(a: FixedInterval[], b: FixedInterval[]): FixedInterval[];
+}

package/lib/common/utils/interval-utils.js

@@ -0,0 +1,25 @@
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
+export class IntervalUtils {
+    static subtractIntervals(a, b) {
+        const result = [];
+        let bIndex = 0;
+        for (const interval of a) {
+            let currentFrom = interval.start;
+            const currentTo = interval.end;
+            for (; bIndex < b.length && b[bIndex].start < currentTo; bIndex++) {
+                if (b[bIndex].end <= currentFrom)
+                    continue;
+                if (b[bIndex].start > currentFrom)
+                    result.push(FixedInterval.fromPositions(currentFrom, Math.min(b[bIndex].start, currentTo)));
+                currentFrom = Math.max(currentFrom, b[bIndex].end);
+                if (currentFrom >= currentTo) {
+                    bIndex++;
+                    break;
+                }
+            }
+            if (currentFrom < currentTo)
+                result.push(FixedInterval.fromPositions(currentFrom, currentTo));
+        }
+        return result;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devexpress-richedit",
-  "version": "25.2.7",
+  "version": "26.1.2-beta",
   "homepage": "https://www.devexpress.com/",
   "bugs": "https://www.devexpress.com/support/",
   "author": "Developer Express Inc.",
@@ -11,8 +11,8 @@
     "build-nspell": "webpack --mode production --config=bin/nspell.webpack.config.js"
   },
   "peerDependencies": {
-    "devextreme": "25.2.7",
-    "devextreme-dist": "25.2.7"
+    "devextreme": "26.1.2-beta",
+    "devextreme-dist": "26.1.2-beta"
   },
   "devDependencies": {
     "dictionary-en": "3.2.0",