@talrace/ngx-noder 0.0.8 → 0.0.10

package/esm2022/lib/editor/content/display-data/display-data.mjs

@@ -0,0 +1,839 @@
+import { BreakHelper } from '../../gadgets/page-break/break.helper';
+import { BreakTypes } from '../../gadgets/page-break/break-types.enum';
+import { ContentStyleHelper } from '../helpers/content-style.helper';
+import { CursorParagraph } from '../../positioning/cursor-paragraph';
+import { DEFAULT_FONT_SIZE, DEFAULT_PARAGRAPH_STYLE, NEW_LINE_MARKUP } from '../constants/editor.const';
+import { DisplayToken } from './display-token.model';
+import { DisplayTokenHelper } from '../helpers/display-token.helper';
+import { DisplayValue } from '../constants/display-values.const';
+import { EdgeType } from '../../components/edges/edge-type.enum';
+import { EventEmitting } from '../../core/event-emitting';
+import { FontMetrics } from '../../gadgets/font-metrics/font-metrics.helper';
+import { FormatStyleHelper } from '../../execution/helpers/format-style.helper';
+import { IndentModel } from './indent.model';
+import { LineInfoModel } from './line-info.model';
+import { NoderTableComponent } from '../../components/table/components/table.component';
+import { NumberingHelper } from '../../gadgets/numbering/numbering.helper';
+import { PageHelper } from '../../execution/helpers/page.helper';
+import { PageType } from '../../components/edges/page-type.enum';
+import { PageVerticalDataModel } from '../page-vertical-data.model';
+import { Paragraph } from './paragraph';
+import { ParagraphHelper } from '../../execution/helpers/paragraph.helper';
+import { ParagraphInfoModel } from './models/paragraph-info.model';
+import { ParagraphStyleHelper } from '../../execution/helpers/paragraph-style.helper';
+import { Range } from '../../positioning/range';
+import { TabHelper } from '../../components/tab/tab.helper';
+export class DisplayData extends EventEmitting {
+    get defaultVerticalData() {
+        return this.pagesVerticalData.find(x => x.pageType === PageType.Default);
+    }
+    constructor(model, generalProperties, sessionId, pageMargin, pagesSpace, pageWidth, pageHeight, customComponents, customContentService, editorService) {
+        super();
+        this.model = model;
+        this.generalProperties = generalProperties;
+        this.sessionId = sessionId;
+        this.pageMargin = pageMargin;
+        this.pagesSpace = pagesSpace;
+        this.pageWidth = pageWidth;
+        this.pageHeight = pageHeight;
+        this.customComponents = customComponents;
+        this.customContentService = customContentService;
+        this.editorService = editorService;
+        this.paragraphs = [];
+        this.allPagesHeight = 0;
+        this.minHeight = 0;
+        this.tabTokens = [];
+        this.paragraphs = this.splitByParagraphs(this.model.content).map(x => new ParagraphInfoModel({ content: x }));
+        this.minHeight = this.pageHeight + 2 * this.pagesSpace;
+        this.contentWidth = this.pageWidth - this.pageMargin.left - this.pageMargin.right;
+        this.initPagesVerticalData();
+        this.processTextLinesProperties = !this.pageHeight
+            ? ParagraphHelper.processTextLinesPropertiesForSinglePage
+            : ParagraphHelper.processTextLinesProperties;
+    }
+    insertText(position, text) {
+        const endPoint = this.insertTextAndReturnEndCursorPosition(text, position);
+        return endPoint;
+    }
+    removeRange(range) {
+        const paragraphText = this.paragraphs[range.start.row].content.slice(0, range.start.column) +
+            this.paragraphs[range.end.row].content.slice(range.end.column);
+        const paragraphSettings = this.getParagraphSettings(range.start.row);
+        this.paragraphs.splice(range.start.row, range.end.row - range.start.row + 1, new ParagraphInfoModel({ content: paragraphText }));
+        this.paragraphs[range.start.row].paragraphSettings = paragraphSettings;
+    }
+    getParagraphContent(index) {
+        return this.paragraphs[index]?.content || '';
+    }
+    getAllParagraphsContent() {
+        return this.paragraphs.map(x => x.content);
+    }
+    getParagraphSettings(index) {
+        return this.paragraphs[index]?.paragraphSettings || null;
+    }
+    getParagraphsContentForRange(range) {
+        if (range.isSingleLine) {
+            const line = this.getParagraphContent(range.start.row);
+            const linePartInRange = line.slice(range.start.column, range.end.column);
+            return [linePartInRange];
+        }
+        const paragraphsContent = this.paragraphs.slice(range.start.row, range.end.row + 1).map(x => x.content);
+        paragraphsContent[0] = (paragraphsContent[0] || '').slice(range.start.column);
+        const lastIndex = paragraphsContent.length - 1;
+        paragraphsContent[lastIndex] = paragraphsContent[lastIndex].slice(0, range.end.column);
+        return paragraphsContent;
+    }
+    getTextRange(range) {
+        return this.getParagraphsContentForRange(range).join(NEW_LINE_MARKUP);
+    }
+    positionToIndex(position, startRow = 0) {
+        let index = 0;
+        const endRow = Math.min(position.row, this.paragraphs.length);
+        for (let i = startRow || 0; i < endRow; i++) {
+            index += this.paragraphs[i].content.length + 1;
+        }
+        return index + position.column;
+    }
+    indexToPosition(positionIndex, startRow) {
+        const newlineLength = NEW_LINE_MARKUP.length;
+        for (let lineIndex = startRow || 0; lineIndex < this.paragraphs.length; lineIndex++) {
+            positionIndex -= this.paragraphs[lineIndex].content.length + newlineLength;
+            if (positionIndex < 0) {
+                const column = positionIndex + this.paragraphs[lineIndex].content.length + newlineLength;
+                return new CursorParagraph(lineIndex, column);
+            }
+        }
+        const column = positionIndex + this.paragraphs[this.paragraphs.length - 1].content.length + newlineLength;
+        return new CursorParagraph(this.paragraphs.length - 1, column);
+    }
+    indexesToRange(startIndex, endIndex) {
+        const startPoint = this.indexToPosition(startIndex, 0);
+        const endPoint = this.indexToPosition(endIndex, 0);
+        return new Range(startPoint, endPoint);
+    }
+    isNewLineSymbol(index) {
+        const text = this.paragraphs.map(x => x.content).join(NEW_LINE_MARKUP);
+        return !text || !text[index] || text[index] === NEW_LINE_MARKUP;
+    }
+    getSelectedParagraphsByRange(range) {
+        const newlineLength = NEW_LINE_MARKUP.length;
+        let start = 0;
+        let end = 0;
+        let i;
+        const row = Math.min(range.end.row, this.paragraphs.length - 1);
+        for (i = 0; i < row; i++) {
+            if (i < range.start.row) {
+                start += this.paragraphs[i].content.length + newlineLength;
+            }
+            end += this.paragraphs[i].content.length + newlineLength;
+        }
+        if (i < this.paragraphs.length) {
+            end += this.paragraphs[i].content.length;
+        }
+        return { start, end };
+    }
+    getPositionAfterBreak(position, breakType) {
+        if (breakType === BreakTypes.TextWrapping) {
+            return position;
+        }
+        const isLastColumn = position.column === this.paragraphs[position.row].content.length;
+        const isLastParagraph = position.row === this.paragraphs.length - 1;
+        return isLastColumn && !isLastParagraph ? new CursorParagraph(position.row + 1, 0) : position;
+    }
+    getDistanceFromTop(index) {
+        return this.paragraphs[index]?.paragraphSettings ? this.paragraphs[index].paragraphSettings.distanceFromTop : 0;
+    }
+    getDistanceFromTopForPrint(index) {
+        if (!this.paragraphs[index]?.paragraphSettings) {
+            return 0;
+        }
+        const paragraph = this.paragraphs[index].paragraphSettings;
+        const pageNumber = paragraph.pageNumbers[0];
+        let pageBreakHeight = 0;
+        paragraph.textLinesInfo.forEach(linesInfo => {
+            if (linesInfo.isAfterPageBreak) {
+                pageBreakHeight = linesInfo.height;
+            }
+        });
+        return paragraph.distanceFromTop - pageNumber * this.pagesSpace - pageBreakHeight;
+    }
+    setParagraphSettings(row, lineInfos, numberingData) {
+        if (!this.paragraphs[row].paragraphSettings) {
+            this.paragraphs[row].paragraphSettings = new Paragraph(numberingData, lineInfos[0].offsetBefore, this.processTextLinesProperties);
+        }
+        this.paragraphs[row].paragraphSettings.numberingData = numberingData;
+        this.paragraphs[row].paragraphSettings.width = this.contentWidth;
+        this.paragraphs[row].paragraphSettings.setTextLinesInfo(lineInfos);
+    }
+    getParagraphHeight(index) {
+        return this.paragraphs[index]?.paragraphSettings ? this.paragraphs[index].paragraphSettings.height : 0;
+    }
+    getVisibleRange(offsetTop, scrollerHeight) {
+        let start = this.paragraphs.findIndex(x => offsetTop <= x.paragraphSettings?.distanceFromTop + x.paragraphSettings?.height);
+        if (start < 0) {
+            start = 0;
+        }
+        let startLineInfo = null;
+        const startParagraph = this.paragraphs[start];
+        if (startParagraph) {
+            const startParagraphOffsetTop = offsetTop - startParagraph.paragraphSettings.distanceFromTop;
+            startLineInfo = ParagraphHelper.getVisibleLineInfo(startParagraph?.paragraphSettings.textLinesInfo, startParagraphOffsetTop, 1);
+        }
+        if (!startLineInfo) {
+            return {
+                startParagraph: 0,
+                startLine: 0,
+                startScreenLine: 0,
+                startScreenFullLine: 0,
+                endParagraph: 0,
+                endLine: 0,
+                endScreenLine: 0,
+                endScreenFullLine: 0,
+                pages: [1]
+            };
+        }
+        let end = this.paragraphs.findIndex(x => offsetTop + scrollerHeight <= x.paragraphSettings.distanceFromTop + x.paragraphSettings.height);
+        if (end < 0) {
+            end = this.paragraphs.length - 1;
+        }
+        let endLineInfo = null;
+        const endParagraph = this.paragraphs[end];
+        if (endParagraph) {
+            const endParagraphOffsetTop = offsetTop + scrollerHeight - endParagraph.paragraphSettings.distanceFromTop;
+            endLineInfo = ParagraphHelper.getVisibleLineInfo(endParagraph.paragraphSettings?.textLinesInfo, endParagraphOffsetTop, -1);
+        }
+        const visiblePages = this.getVisiblePages(offsetTop, scrollerHeight);
+        return {
+            startParagraph: start,
+            startLine: startLineInfo.index,
+            startScreenLine: startLineInfo.screenIndex,
+            startScreenFullLine: startLineInfo.visibleScreenIndex,
+            endParagraph: end,
+            endLine: endLineInfo.index,
+            endScreenLine: endLineInfo.screenIndex,
+            endScreenFullLine: endLineInfo.visibleScreenIndex,
+            pages: visiblePages
+        };
+    }
+    processParagraphsProperties(startParagraphIndex) {
+        this.setParagraphIndexes();
+        const pagesInfo = { pagesVerticalData: this.pagesVerticalData, pagesSpace: this.pagesSpace };
+        let currentPage = startParagraphIndex === 0 ? 1 : this.paragraphs[startParagraphIndex - 1].paragraphSettings.lastPageNumber;
+        let pageVerticalData = PageHelper.getVerticalData(currentPage, this.pagesVerticalData);
+        for (let i = startParagraphIndex; i < this.paragraphs.length; i++) {
+            const prevParagraphInfo = this.getPreviousParagraphInfo(i);
+            const paragraphSettings = this.paragraphs[i].paragraphSettings;
+            paragraphSettings.processParagraphProperties(prevParagraphInfo, pagesInfo, this.customComponents.tables);
+            if (paragraphSettings.firstPageNumber !== currentPage) {
+                currentPage = paragraphSettings.firstPageNumber;
+                pageVerticalData = PageHelper.getVerticalData(paragraphSettings.firstPageNumber, this.pagesVerticalData);
+            }
+            paragraphSettings.calculateDistanceFromTop(this.pageHeight, this.pagesSpace, pageVerticalData.marginTop);
+        }
+        let pageHeight = this.pageHeight;
+        if (!pageHeight) {
+            pageHeight = this.getAllParagraphsHeight() + this.pageMargin.top + this.pageMargin.bottom;
+            this.minHeight = pageHeight + 2 * this.pagesSpace;
+            this.defaultVerticalData.contentHeight = pageHeight;
+        }
+        const lastPageNumber = this.paragraphs[this.paragraphs.length - 1].paragraphSettings.lastPageNumber;
+        this.allPagesHeight = lastPageNumber * (pageHeight + this.pagesSpace) + this.pagesSpace;
+        this.emit('pagesCountChanged', { pagesCount: lastPageNumber, pageHeight: pageHeight + 2 * this.pagesSpace });
+    }
+    getAllParagraphsHeight() {
+        return this.paragraphs.reduce((sum, x) => sum + x.paragraphSettings.height, 0);
+    }
+    destroy() {
+        this.removeAllListeners('pagesCountChanged');
+    }
+    updatePageVerticalData(edgeType, page) {
+        const pageVerticalData = PageHelper.getVerticalData(page, this.pagesVerticalData);
+        const componentHeight = this.customComponents.edges.getComponentHeight(page, edgeType);
+        if (edgeType === EdgeType.Header) {
+            pageVerticalData.marginTop = componentHeight > this.pageMargin.top ? componentHeight : this.pageMargin.top;
+        }
+        else {
+            pageVerticalData.marginBottom = componentHeight > this.pageMargin.bottom ? componentHeight : this.pageMargin.bottom;
+        }
+        const newContentHeight = this.pageHeight - pageVerticalData.marginTop - pageVerticalData.marginBottom;
+        if (newContentHeight === pageVerticalData.contentHeight) {
+            return;
+        }
+        pageVerticalData.contentHeight = newContentHeight;
+        this.processParagraphsProperties(0);
+    }
+    updateParagraphLineNumber(first) {
+        const count = this.paragraphs.length;
+        if (first === 0) {
+            this.paragraphs[first].lineNumber = 0;
+            first++;
+        }
+        for (let i = first; i < count; i++) {
+            this.paragraphs[i].lineNumber = this.paragraphs[i - 1].lineNumber + this.paragraphs[i - 1].nextLineIndexes.length + 1;
+        }
+    }
+    updateParagraphStartIndex(first) {
+        if (first === 0) {
+            this.paragraphs[first].startIndex = 0;
+            first++;
+        }
+        for (let i = first; i < this.paragraphs.length; i++) {
+            this.paragraphs[i].startIndex = this.paragraphs[i - 1].startIndex + this.getParagraphContent(i - 1).length + 1;
+        }
+    }
+    updateParagraphSettingsNumberingData(index) {
+        const paragraphSettings = this.getParagraphSettings(index);
+        if (paragraphSettings.numberingData.numberingId !== this.model.paragraphs[index].paragraphStyle.numberingId) {
+            paragraphSettings.numberingData = NumberingHelper.createDataModel(this.generalProperties.numberings, this.model.paragraphs, index, this.generalProperties.numberingInfo);
+        }
+        if (paragraphSettings.numberingData.numberingId !== null) {
+            const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[index].insertIndex);
+            NumberingHelper.updateMarkerData(this.generalProperties, paragraphSettings, paragraphFormat.textStyle, this.model.paragraphs[index].paragraphStyle);
+        }
+    }
+    updateNextLineIndexes(firstParagraph, lastParagraph) {
+        this.updateParagraphStartIndex(firstParagraph);
+        let indexOfParagraphAfterPageBreak = this.getParagraphSettings(firstParagraph - 1)?.isEndedByPageBreak ? firstParagraph : -1;
+        let firstUsedTabIndex = this.model.tabs.findIndex(x => x.insertIndex >= this.paragraphs[firstParagraph].startIndex);
+        for (let i = firstParagraph; i <= lastParagraph; i++) {
+            if (!this.paragraphs[i]) {
+                continue;
+            }
+            this.tabTokens = [];
+            NumberingHelper.calculateNumberingInfo(this.model.paragraphs[i].paragraphStyle.numberingId, this.model.paragraphs[i].paragraphStyle.numberingLevel, this.getParagraphSettings(i)?.numberingData.marker, this.generalProperties.numberingInfo, this.generalProperties.numberings);
+            const numberingData = NumberingHelper.createDataModel(this.generalProperties.numberings, this.model.paragraphs, i, this.generalProperties.numberingInfo);
+            const { splits, rowInfos } = this.getSplits(this.model, i);
+            this.paragraphs[i].nextLineIndexes = splits;
+            if (indexOfParagraphAfterPageBreak === i) {
+                rowInfos[0].isAfterPageBreak = true;
+            }
+            indexOfParagraphAfterPageBreak = rowInfos[rowInfos.length - 1].isEndedByPageBreak ? i + 1 : -1;
+            this.setParagraphSettings(i, rowInfos, numberingData);
+            this.updateParagraphSettingsNumberingData(i);
+            firstUsedTabIndex = this.updateParagraphTabs(firstUsedTabIndex, i);
+        }
+        this.getParagraphSettings(lastParagraph + 1)?.setIsAfterPageBreak(indexOfParagraphAfterPageBreak > -1);
+        this.updateParagraphLineNumber(firstParagraph);
+        this.processParagraphsProperties(firstParagraph);
+    }
+    updateNumberingsDataOnChange(index) {
+        for (let i = index; i < this.paragraphs.length; i++) {
+            const paragraphStyle = this.model.paragraphs[i].paragraphStyle;
+            const paragraphSettings = this.getParagraphSettings(i);
+            if (this.model.paragraphs[i].paragraphStyle.numberingId !== null) {
+                NumberingHelper.calculateNumberingInfo(paragraphStyle.numberingId, paragraphStyle.numberingLevel, paragraphSettings.numberingData.marker, this.generalProperties.numberingInfo, this.generalProperties.numberings);
+                paragraphSettings.numberingData = NumberingHelper.createDataModel(this.generalProperties.numberings, this.model.paragraphs, i, this.generalProperties.numberingInfo);
+                const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[i].insertIndex);
+                NumberingHelper.updateMarkerData(this.generalProperties, paragraphSettings, paragraphFormat.textStyle, paragraphStyle);
+            }
+            const table = this.customContentService.findComponent(this.customComponents.tables, paragraphSettings.startInsertIndex);
+            if (table) {
+                table.instance.updateCells();
+            }
+        }
+        if ('pageType' in this.model) {
+            this.editorService.updateEdges(this.sessionId);
+        }
+    }
+    resetAllNumberingInfo(paragraphIndex) {
+        for (let i = paragraphIndex; i < this.model.paragraphs.length; i++) {
+            const { numberingId, numberingLevel } = this.model.paragraphs[i].paragraphStyle;
+            if (numberingId !== null &&
+                this.generalProperties.numberingInfo[numberingId] &&
+                this.generalProperties.numberingInfo[numberingId][numberingLevel]) {
+                this.generalProperties.numberingInfo[numberingId][numberingLevel].visited = false;
+            }
+        }
+    }
+    resetNumberingInfoByTableCell(table) {
+        for (let i = 0; i < table.instance.rowMatrix.length; i++) {
+            for (let cell of table.instance.rowMatrix[i].cells) {
+                const { marker, numberingId } = cell.componentRef.instance.session.displayData.paragraphs[0].paragraphSettings.numberingData;
+                if (marker && numberingId) {
+                    NumberingHelper.updateNumberingInfo(this.generalProperties.numberingInfo, marker, numberingId);
+                    this.resetAllNumberingInfo(0);
+                    return;
+                }
+            }
+        }
+    }
+    updateParagraphTabs(tabIndex, paragraphIndex) {
+        const paragraphContentLength = this.getParagraphContent(paragraphIndex).length;
+        const paragraphLastIndex = this.paragraphs[paragraphIndex].startIndex + paragraphContentLength;
+        if (tabIndex === -1 ||
+            tabIndex >= this.customComponents.tabs.length ||
+            this.customComponents.tabs[tabIndex].instance.insertIndex > paragraphLastIndex) {
+            return tabIndex;
+        }
+        const startIndex = tabIndex;
+        while (this.customComponents.tabs[tabIndex] && this.customComponents.tabs[tabIndex].instance.insertIndex <= paragraphLastIndex) {
+            this.customComponents.tabs[tabIndex].instance.width = this.tabTokens[tabIndex - startIndex].width;
+            this.customComponents.tabs[tabIndex].instance.height = this.tabTokens[tabIndex - startIndex].font;
+            tabIndex++;
+        }
+        return tabIndex;
+    }
+    getSplits(model, paragraphIndex) {
+        const paragraphContent = this.getParagraphContent(paragraphIndex);
+        const strTokens = this.getDisplayTokens(model, paragraphContent, this.paragraphs[paragraphIndex].startIndex);
+        if (!strTokens.length) {
+            const defaultRowInfo = new LineInfoModel({
+                height: (DEFAULT_FONT_SIZE * 4) / 3,
+                width: 0,
+                align: DEFAULT_PARAGRAPH_STYLE.alignment,
+                indent: new IndentModel(DEFAULT_PARAGRAPH_STYLE.indentFirstLine, DEFAULT_PARAGRAPH_STYLE.indentHanging, DEFAULT_PARAGRAPH_STYLE.indentLeft, DEFAULT_PARAGRAPH_STYLE.indentRight),
+                offsetAfter: DEFAULT_PARAGRAPH_STYLE.spaceAfter,
+                offsetBefore: DEFAULT_PARAGRAPH_STYLE.spaceBefore,
+                lineSpacing: DEFAULT_PARAGRAPH_STYLE.lineSpacing,
+                isAfterPageBreak: false,
+                isEndedByPageBreak: false,
+                backgroundColor: DEFAULT_PARAGRAPH_STYLE.backgroundColor
+            });
+            return { splits: [], rowInfos: [defaultRowInfo] };
+        }
+        const splits = [];
+        const rowInfos = [];
+        let prevToken;
+        let index = -1;
+        let initial = paragraphContent;
+        while (index) {
+            initial = initial.slice(index > 0 ? index : 0);
+            const tokens = strTokens.slice(paragraphContent.length - initial.length);
+            if (!tokens.length) {
+                tokens.push(...this.getEmptyDisplayTokens(model, this.paragraphs[paragraphIndex].startIndex + index));
+            }
+            let wrapLimit = this.computeWrapIndex(tokens, this.contentWidth, this.generalProperties.defaultTabWidth);
+            if (tokens[tokens.length - 1].isPageBreak && wrapLimit === tokens.length && this.paragraphs.length > paragraphIndex + 1) {
+                wrapLimit = 0;
+            }
+            const wrapSplit = tokens[wrapLimit - 1]?.breaksLine || tokens[wrapLimit - 1]?.isTable ? wrapLimit : this.computeWrapSplit(tokens, wrapLimit);
+            const wrapTokens = tokens.slice(0, wrapSplit || undefined);
+            if (wrapTokens.length) {
+                prevToken = wrapTokens[wrapTokens.length - 1];
+            }
+            const isAfterPageBreak = !rowInfos.length ? false : rowInfos[rowInfos.length - 1].isEndedByPageBreak;
+            const lineInfo = DisplayTokenHelper.getLineInfoFromToken(prevToken, wrapTokens[0], wrapTokens, isAfterPageBreak);
+            lineInfo.backgroundColor = model.paragraphs[paragraphIndex].paragraphStyle.backgroundColor;
+            rowInfos.push(lineInfo);
+            if (!wrapLimit) {
+                break;
+            }
+            index = wrapSplit;
+            const splitsLength = splits.length;
+            const splitIndex = splitsLength ? index + splits[splitsLength - 1] : index;
+            splits.push(splitIndex);
+        }
+        this.tabTokens.push(...strTokens.filter(x => x.isTab));
+        ParagraphHelper.applyParagraphIndentsToLines(rowInfos, paragraphIndex, model.paragraphs);
+        return { splits, rowInfos };
+    }
+    /**
+     * Given a string, returns an array of the display characters, including tabs and spaces and custom components.
+     */
+    getDisplayTokens(model, str, startIndex) {
+        if (!str.length) {
+            return this.getEmptyDisplayTokens(model, startIndex);
+        }
+        return this.fillLineTokens(startIndex, str, model);
+    }
+    fillLineTokens(startIndex, line, model) {
+        const lineInfo = this.getLineInfoByBreakModifier(model, startIndex + line.length);
+        const tokens = [];
+        let characters = [];
+        let format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);
+        let prevFormat = null;
+        let prevCharCode = null;
+        let prevFontString = null;
+        let prevChar = null;
+        let fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);
+        let symbolChange = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            const size = FontMetrics.measureCharSize(char, fontString);
+            const customComponent = this.getOrGenerateComponent(startIndex, char);
+            const breakType = BreakHelper.getBreakType(model, char, startIndex);
+            if (customComponent && !breakType) {
+                const token = this.customContentService.getTokenFromComponent(customComponent, lineInfo, DisplayValue.customContent, i === 0, size);
+                tokens.push(token);
+                prevCharCode = -1;
+                prevChar = '';
+                characters = [];
+            }
+            else {
+                const charCode = char.charCodeAt(0);
+                const displayValue = DisplayTokenHelper.getDisplayValue(charCode);
+                const isFirstCharacter = i === 0;
+                const token = new DisplayToken({
+                    ...size,
+                    displayValue,
+                    align: lineInfo.align,
+                    indentFirstLine: isFirstCharacter ? lineInfo.indent.firstLine : DEFAULT_PARAGRAPH_STYLE.indentFirstLine,
+                    indentHanging: isFirstCharacter ? lineInfo.indent.hanging : DEFAULT_PARAGRAPH_STYLE.indentHanging,
+                    indentLeft: lineInfo.indent.left,
+                    indentRight: lineInfo.indent.right,
+                    indentBefore: lineInfo.offsetBefore,
+                    indentAfter: lineInfo.offsetAfter,
+                    lineSpacing: lineInfo.lineSpacing,
+                    isPageBreak: breakType === BreakTypes.Page,
+                    isLineBreak: breakType === BreakTypes.TextWrapping,
+                    isTab: false
+                });
+                tokens.push(token);
+                if (charCode !== prevCharCode ||
+                    !prevFormat ||
+                    !ContentStyleHelper.areSameTextStyles(format?.textStyle, prevFormat?.textStyle)) {
+                    symbolChange = true;
+                }
+                else if (i === line.length - 1) {
+                    characters.push(token);
+                    symbolChange = true;
+                }
+                else {
+                    characters.push(token);
+                }
+                if (characters.length > 1 && symbolChange) {
+                    this.processCharSizes(prevChar, prevFontString, characters);
+                    characters = [token];
+                    symbolChange = false;
+                }
+                else if (symbolChange) {
+                    characters = [token];
+                }
+                prevCharCode = charCode;
+                prevChar = char;
+            }
+            prevFormat = format;
+            prevFontString = fontString;
+            startIndex++;
+            if (startIndex > format?.endIndex) {
+                format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);
+                fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);
+            }
+        }
+        return tokens;
+    }
+    getOrGenerateComponent(charIndex, char) {
+        if (!this.customContentService.isSpecialMarker(char)) {
+            return null;
+        }
+        const existingComponent = this.customContentService.getComponent(this.customComponents, char, charIndex);
+        if (existingComponent) {
+            if (existingComponent.instance instanceof NoderTableComponent) {
+                existingComponent.instance.updateCells();
+            }
+            return existingComponent;
+        }
+        return this.customContentService.generateComponent(this.model, this.customComponents, this.sessionId, this.generalProperties, this.contentWidth, charIndex);
+    }
+    processCharSizes(prevChar, prevFontString, characters) {
+        const newSize = FontMetrics.measureCharSize(prevChar, prevFontString);
+        for (let item of characters) {
+            Object.assign(item, newSize);
+        }
+    }
+    getLineTokens(model, line, startIndex) {
+        const lineInfo = this.getLineInfoFromTextLine(startIndex + line.length);
+        if (!line.length) {
+            return this.getEmptyLineTokens(model, startIndex, lineInfo);
+        }
+        const tokens = [];
+        let characters = [];
+        let format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);
+        let prevFormat = null;
+        let prevCharCode = null;
+        let prevFontString = null;
+        let prevChar = null;
+        let fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);
+        let symbolChange = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            const size = FontMetrics.measureCharSize(char, fontString);
+            const customComponent = this.customContentService.getComponent(this.customComponents, char, startIndex);
+            const breakType = BreakHelper.getBreakType(model, char, startIndex);
+            if (customComponent && !breakType) {
+                const token = this.customContentService.getTokenFromComponent(customComponent, lineInfo, DisplayValue.customContent, i === 0, size);
+                tokens.push(token);
+                prevCharCode = -1;
+                prevChar = '';
+                characters = [];
+            }
+            else {
+                const charCode = char.charCodeAt(0);
+                const displayValue = DisplayTokenHelper.getDisplayValue(charCode);
+                const isFirstCharacter = i === 0;
+                const token = new DisplayToken({
+                    ...size,
+                    displayValue,
+                    align: lineInfo.align,
+                    indentFirstLine: isFirstCharacter ? lineInfo.indent.firstLine : DEFAULT_PARAGRAPH_STYLE.indentFirstLine,
+                    indentHanging: isFirstCharacter ? lineInfo.indent.hanging : DEFAULT_PARAGRAPH_STYLE.indentHanging,
+                    indentLeft: lineInfo.indent.left,
+                    indentRight: lineInfo.indent.right,
+                    indentBefore: lineInfo.offsetBefore,
+                    indentAfter: lineInfo.offsetAfter,
+                    lineSpacing: lineInfo.lineSpacing,
+                    isPageBreak: breakType === BreakTypes.Page,
+                    isLineBreak: breakType === BreakTypes.TextWrapping,
+                    isTab: false
+                });
+                tokens.push(token);
+                if (charCode !== prevCharCode ||
+                    !prevFormat ||
+                    !ContentStyleHelper.areSameTextStyles(format?.textStyle, prevFormat?.textStyle)) {
+                    symbolChange = true;
+                }
+                else if (i === line.length - 1) {
+                    characters.push(token);
+                    symbolChange = true;
+                }
+                else {
+                    characters.push(token);
+                }
+                if (characters.length > 1 && symbolChange) {
+                    this.processCharSizes(prevChar, prevFontString, characters);
+                    characters = [token];
+                    symbolChange = false;
+                }
+                else if (symbolChange) {
+                    characters = [token];
+                }
+                prevCharCode = charCode;
+                prevChar = char;
+            }
+            prevFormat = format;
+            prevFontString = fontString;
+            startIndex++;
+            if (startIndex > format?.endIndex) {
+                format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);
+                fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);
+            }
+        }
+        return tokens;
+    }
+    getEmptyDisplayTokens(model, startIndex) {
+        const lineInfo = this.getLineInfoByBreakModifier(model, startIndex);
+        return this.getEmptyLineTokens(model, startIndex, lineInfo);
+    }
+    getEmptyLineTokens(model, startIndex, lineInfo) {
+        const storedFormat = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);
+        if (!storedFormat) {
+            return [];
+        }
+        const size = FontMetrics.measureCharSize('EMPTY_LINE', ContentStyleHelper.getFontStylesString(storedFormat.textStyle));
+        size.width = 3;
+        return [
+            new DisplayToken({
+                ...size,
+                displayValue: DisplayValue.emptyLine,
+                align: lineInfo.align,
+                indentFirstLine: lineInfo.indent.firstLine,
+                indentHanging: lineInfo.indent.hanging,
+                indentLeft: lineInfo.indent.left,
+                indentRight: lineInfo.indent.right,
+                indentBefore: lineInfo.offsetBefore,
+                indentAfter: lineInfo.offsetAfter,
+                isPageBreak: false,
+                isLineBreak: false,
+                isTab: false,
+                lineSpacing: lineInfo.lineSpacing
+            })
+        ];
+    }
+    getLineInfoByBreakModifier(model, index) {
+        const paragraph = ParagraphStyleHelper.getParagraphAtIndex(model.paragraphs, index);
+        if (!paragraph) {
+            return new LineInfoModel({
+                align: DEFAULT_PARAGRAPH_STYLE.alignment,
+                indent: new IndentModel(DEFAULT_PARAGRAPH_STYLE.indentFirstLine, DEFAULT_PARAGRAPH_STYLE.indentHanging, DEFAULT_PARAGRAPH_STYLE.indentLeft, DEFAULT_PARAGRAPH_STYLE.indentRight),
+                offsetBefore: DEFAULT_PARAGRAPH_STYLE.spaceBefore,
+                offsetAfter: DEFAULT_PARAGRAPH_STYLE.spaceAfter,
+                lineSpacing: DEFAULT_PARAGRAPH_STYLE.lineSpacing
+            });
+        }
+        const indentLeft = this.getParagraphIndentLeft(model, paragraph);
+        return this.getLineInfoModel(paragraph, indentLeft);
+    }
+    getParagraphIndentLeft(model, paragraph) {
+        const numberingId = paragraph.paragraphStyle.numberingId;
+        if (numberingId === null) {
+            return paragraph.paragraphStyle.indentLeft;
+        }
+        const level = paragraph.paragraphStyle.numberingLevel;
+        const paragraphIndex = model.paragraphs.indexOf(paragraph);
+        const levelModel = NumberingHelper.find(this.generalProperties.numberings, numberingId, level);
+        const paragraphFormat = FormatStyleHelper.getFormatAtIndex(model.formats, paragraph.insertIndex);
+        const markerTextStyle = ContentStyleHelper.combineTextStyles(levelModel.markerStyle, paragraphFormat.textStyle);
+        const paragraphSettings = this.getParagraphSettings(paragraphIndex);
+        let markerWidth = paragraphSettings?.numberingData?.width;
+        const marker = NumberingHelper.getMarker(levelModel, numberingId, model.paragraphs, paragraphIndex, this.generalProperties.numberingInfo);
+        const markerSizes = NumberingHelper.getMarkerSizes(marker, markerTextStyle);
+        markerWidth = markerSizes.width;
+        const hangingIndent = paragraph.paragraphStyle.indentHanging ? paragraph.paragraphStyle.indentHanging : levelModel.indentHanging;
+        let paragraphIndent = levelModel.indentLeft;
+        if (markerWidth >= hangingIndent) {
+            const markerOverflow = markerWidth - hangingIndent;
+            const additionalMarkerIndent = TabHelper.calculateTabWidth(levelModel.indentLeft + markerOverflow, this.generalProperties.defaultTabWidth);
+            paragraphIndent += markerOverflow + additionalMarkerIndent;
+        }
+        return paragraphIndent;
+    }
+    getLineInfoFromTextLine(index) {
+        const paragraph = ParagraphStyleHelper.getParagraphAtIndex(this.model.paragraphs, index);
+        const indentLeft = this.getIndentLeftFromTextLine(index);
+        return this.getLineInfoModel(paragraph, indentLeft);
+    }
+    getLineInfoModel(paragraph, indentLeft) {
+        const indentHanging = paragraph.paragraphStyle.numberingId === null ? paragraph.paragraphStyle.indentHanging : 0;
+        return new LineInfoModel({
+            align: paragraph.paragraphStyle.alignment ?? DEFAULT_PARAGRAPH_STYLE.alignment,
+            indent: new IndentModel(paragraph.paragraphStyle.indentFirstLine ?? DEFAULT_PARAGRAPH_STYLE.indentFirstLine, indentHanging ?? DEFAULT_PARAGRAPH_STYLE.indentHanging, indentLeft ?? DEFAULT_PARAGRAPH_STYLE.indentLeft, paragraph.paragraphStyle.indentRight ?? DEFAULT_PARAGRAPH_STYLE.indentRight),
+            offsetBefore: DEFAULT_PARAGRAPH_STYLE.spaceBefore,
+            offsetAfter: DEFAULT_PARAGRAPH_STYLE.spaceAfter,
+            lineSpacing: paragraph.paragraphStyle.lineSpacing ?? DEFAULT_PARAGRAPH_STYLE.lineSpacing
+        });
+    }
+    getIndentLeftFromTextLine(insertIndex) {
+        let startIndex = 0;
+        let endIndex = this.paragraphs.length - 1;
+        while (startIndex <= endIndex) {
+            const middleIndex = Math.round((startIndex + endIndex) / 2);
+            const paragraphInfo = this.paragraphs[middleIndex];
+            if (paragraphInfo.startIndex > insertIndex) {
+                startIndex = middleIndex + 1;
+            }
+            else {
+                endIndex = middleIndex - 1;
+            }
+        }
+        const textLinesInfo = this.paragraphs[startIndex]?.paragraphSettings.textLinesInfo;
+        return textLinesInfo ? Math.max(...textLinesInfo.map(x => x.indentLeft)) : null;
+    }
+    computeWrapSplit(tokens, wrapLimit) {
+        if (!tokens.length || tokens.length <= wrapLimit) {
+            return null;
+        }
+        // If there is a space or tab at this split position, then making
+        // a split is simple.
+        if (wrapLimit === 0 ||
+            tokens[wrapLimit].displayValue === DisplayValue.customContent ||
+            (this.isWhiteSpace(tokens[wrapLimit - 1]) && this.isWhiteSpace(tokens[wrapLimit]))) {
+            return wrapLimit;
+        }
+        return this.calculateSplit(wrapLimit, tokens);
+    }
+    calculateSplit(index, tokens) {
+        for (let i = index; i >= 0; i--) {
+            if (this.isWhiteSpace(tokens[i]) || tokens[i].displayValue === DisplayValue.customContent) {
+                return i + 1;
+            }
+        }
+        return index;
+    }
+    isWhiteSpace(token) {
+        return [DisplayValue.space, DisplayValue.emptyLine].includes(token.displayValue);
+    }
+    /**
+     * Computes wrap index based on max row width
+     */
+    computeWrapIndex(displayTokens, contentWidth, defaultTabWidth) {
+        if (!displayTokens[0]) {
+            return 0;
+        }
+        if (displayTokens[0].isTable || (displayTokens[0].breaksLine && displayTokens.length === 1)) {
+            return 1;
+        }
+        const indent = displayTokens[0].indentLeft +
+            displayTokens[0].indentRight +
+            displayTokens[0].indentFirstLine -
+            displayTokens[0].indentHanging || 0;
+        const maxRowWidth = contentWidth - indent;
+        let sum = 0;
+        for (let i = 0; i < displayTokens.length; i++) {
+            if (displayTokens[i].isTab) {
+                displayTokens[i].width = TabHelper.calculateTabWidth(sum, defaultTabWidth);
+            }
+            sum += displayTokens[i].width;
+            if ((i > 0 && (sum >= maxRowWidth || displayTokens[i - 1].breaksLine)) || displayTokens[i].isTable) {
+                return i;
+            }
+            if (displayTokens[i].isLineBreak || (i === displayTokens.length - 1 && displayTokens[i].isPageBreak)) {
+                return i + 1;
+            }
+        }
+        return 0;
+    }
+    getPreviousParagraphInfo(row) {
+        if (!row || !this.paragraphs.length) {
+            return { lastPage: 1, paragraphHeight: 0, paragraphLastLine: -1 };
+        }
+        const prevParagraph = this.paragraphs[row - 1].paragraphSettings;
+        return prevParagraph.getParagraphData();
+    }
+    getVisiblePages(offsetTop, containerHeight) {
+        const visiblePages = [];
+        let firstVisiblePage = offsetTop / (this.pageHeight + this.pagesSpace);
+        if (firstVisiblePage % 1 === 0) {
+            firstVisiblePage++;
+        }
+        let visiblePagesCount = containerHeight / (this.pageHeight + this.pagesSpace);
+        const partialPageOnScreenPercent = Math.trunc(((visiblePagesCount % 1) + (firstVisiblePage % 1)) * 100);
+        const pageSpaceHeightPercent = Math.trunc((this.pagesSpace / containerHeight) * 100);
+        if (partialPageOnScreenPercent - pageSpaceHeightPercent > 100) {
+            visiblePagesCount++;
+        }
+        visiblePagesCount = Math.ceil(visiblePagesCount);
+        firstVisiblePage = Math.ceil(firstVisiblePage);
+        const documentPagesCount = this.paragraphs[this.paragraphs.length - 1].paragraphSettings.lastPageNumber;
+        if (firstVisiblePage + visiblePagesCount - 1 > documentPagesCount) {
+            visiblePagesCount = documentPagesCount - firstVisiblePage + 1;
+        }
+        for (let i = 0; i < visiblePagesCount; i++) {
+            visiblePages.push(firstVisiblePage + i);
+        }
+        return visiblePages;
+    }
+    insertTextAndReturnEndCursorPosition(text, position) {
+        const left = this.paragraphs[position.row].content.slice(0, position.column);
+        const right = this.paragraphs[position.row].content.slice(position.column);
+        const insertParagraphs = this.splitByParagraphs(`${left}${text}${right}`).map(x => new ParagraphInfoModel({ content: x, nextLineIndexes: [] }));
+        insertParagraphs[0].paragraphSettings = this.getParagraphSettings(position.row);
+        this.paragraphs.splice(position.row, 1, ...insertParagraphs);
+        return new CursorParagraph(position.row + insertParagraphs.length - 1, insertParagraphs[insertParagraphs.length - 1].content.length - right.length);
+    }
+    splitByParagraphs(text) {
+        return text.split(/\r\n|\r|\n/);
+    }
+    setParagraphIndexes() {
+        for (let paragraph of this.paragraphs) {
+            paragraph.paragraphSettings.startInsertIndex = paragraph.startIndex;
+        }
+    }
+    initPagesVerticalData() {
+        if (!this.customComponents.edges ||
+            (!this.customComponents.edges.headersComponents.length && !this.customComponents.edges.footersComponents.length)) {
+            this.pagesVerticalData = [
+                new PageVerticalDataModel({
+                    marginTop: this.pageMargin.top,
+                    marginBottom: this.pageMargin.bottom,
+                    contentHeight: this.pageHeight - this.pageMargin.top - this.pageMargin.bottom,
+                    pageType: PageType.Default
+                })
+            ];
+            return;
+        }
+        const pageTypes = this.customComponents.edges.getUniquePageTypes();
+        this.pagesVerticalData = pageTypes.map(pageType => {
+            const headerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Header);
+            const footerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Footer);
+            const marginTop = Math.max(headerHeight, this.pageMargin.top);
+            const marginBottom = Math.max(footerHeight, this.pageMargin.bottom);
+            return new PageVerticalDataModel({
+                marginTop,
+                marginBottom,
+                contentHeight: this.pageHeight - marginTop - marginBottom,
+                pageType
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-data.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/editor/content/display-data/display-data.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from '@angular/core';\n\nimport { BaseNoderComponent } from '../../components/shared/abstract/base.component';\nimport { BreakHelper } from '../../gadgets/page-break/break.helper';\nimport { BreakTypes } from '../../gadgets/page-break/break-types.enum';\nimport { ContentsInterface } from '../contents.interface';\nimport { ContentStyleHelper } from '../helpers/content-style.helper';\nimport { CursorParagraph } from '../../positioning/cursor-paragraph';\nimport { CustomContentService } from '../../components/shared/services/custom-content.service';\nimport { DEFAULT_FONT_SIZE, DEFAULT_PARAGRAPH_STYLE, NEW_LINE_MARKUP } from '../constants/editor.const';\nimport { DisplayToken } from './display-token.model';\nimport { DisplayTokenHelper } from '../helpers/display-token.helper';\nimport { DisplayValue } from '../constants/display-values.const';\nimport { EdgeType } from '../../components/edges/edge-type.enum';\nimport { EditorService } from '../../interaction/editor.service';\nimport { EventEmitting } from '../../core/event-emitting';\nimport { FontMetrics } from '../../gadgets/font-metrics/font-metrics.helper';\nimport { FormatModel } from '../../../models/generated/format.model';\nimport { FormatStyleHelper } from '../../execution/helpers/format-style.helper';\nimport { GeneralPropertiesModel } from './general-properties.model';\nimport { ICustomComponents } from '../../components/shared/custom-components.interface';\nimport { IndentModel } from './indent.model';\nimport { LineInfoModel } from './line-info.model';\nimport { MarginModel } from '../margin.model';\nimport { NoderTableComponent } from '../../components/table/components/table.component';\nimport { NumberingDataModel } from './../../gadgets/numbering/numbering-data.model';\nimport { NumberingHelper } from '../../gadgets/numbering/numbering.helper';\nimport { PageHelper } from '../../execution/helpers/page.helper';\nimport { PageType } from '../../components/edges/page-type.enum';\nimport { PageVerticalDataModel } from '../page-vertical-data.model';\nimport { Paragraph } from './paragraph';\nimport { ParagraphHelper } from '../../execution/helpers/paragraph.helper';\nimport { ParagraphInfoModel } from './models/paragraph-info.model';\nimport { ParagraphModel } from '../../../models/generated/paragraph.model';\nimport { ParagraphStyleHelper } from '../../execution/helpers/paragraph-style.helper';\nimport { Range } from '../../positioning/range';\nimport { TabHelper } from '../../components/tab/tab.helper';\nimport { VisibleRange } from '../../display/visible-range.interface';\n\nexport class DisplayData extends EventEmitting {\n    paragraphs: ParagraphInfoModel[] = [];\n\n    contentWidth: number;\n\n    allPagesHeight = 0;\n\n    minHeight = 0;\n\n    tabTokens: DisplayToken[] = [];\n\n    pagesVerticalData: PageVerticalDataModel[];\n\n    get defaultVerticalData(): PageVerticalDataModel {\n        return this.pagesVerticalData.find(x => x.pageType === PageType.Default);\n    }\n\n    private processTextLinesProperties: (\n        currentParagraph: Paragraph,\n        prevParagraphInfo: { lastPage: number; paragraphHeight: number; paragraphLastLine: number },\n        pagesInfo: { pagesVerticalData: PageVerticalDataModel[]; pagesSpace: number },\n        tables: ComponentRef<NoderTableComponent>[]\n    ) => void;\n\n    constructor(\n        private model: ContentsInterface,\n        private generalProperties: GeneralPropertiesModel,\n        private sessionId: number,\n        public pageMargin: MarginModel,\n        public pagesSpace: number,\n        public pageWidth: number,\n        public pageHeight: number,\n        public customComponents: ICustomComponents,\n        public customContentService: CustomContentService,\n        public editorService: EditorService\n    ) {\n        super();\n        this.paragraphs = this.splitByParagraphs(this.model.content).map(x => new ParagraphInfoModel({ content: x }));\n        this.minHeight = this.pageHeight + 2 * this.pagesSpace;\n        this.contentWidth = this.pageWidth - this.pageMargin.left - this.pageMargin.right;\n        this.initPagesVerticalData();\n        this.processTextLinesProperties = !this.pageHeight\n            ? ParagraphHelper.processTextLinesPropertiesForSinglePage\n            : ParagraphHelper.processTextLinesProperties;\n    }\n\n    insertText(position: CursorParagraph, text: string): CursorParagraph {\n        const endPoint = this.insertTextAndReturnEndCursorPosition(text, position);\n        return endPoint;\n    }\n\n    removeRange(range: Range): void {\n        const paragraphText =\n            this.paragraphs[range.start.row].content.slice(0, range.start.column) +\n            this.paragraphs[range.end.row].content.slice(range.end.column);\n        const paragraphSettings = this.getParagraphSettings(range.start.row);\n        this.paragraphs.splice(range.start.row, range.end.row - range.start.row + 1, new ParagraphInfoModel({ content: paragraphText }));\n        this.paragraphs[range.start.row].paragraphSettings = paragraphSettings;\n    }\n\n    getParagraphContent(index: number): string {\n        return this.paragraphs[index]?.content || '';\n    }\n\n    getAllParagraphsContent(): string[] {\n        return this.paragraphs.map(x => x.content);\n    }\n\n    getParagraphSettings(index: number): Paragraph | null {\n        return this.paragraphs[index]?.paragraphSettings || null;\n    }\n\n    getParagraphsContentForRange(range: Range): string[] {\n        if (range.isSingleLine) {\n            const line = this.getParagraphContent(range.start.row);\n            const linePartInRange = line.slice(range.start.column, range.end.column);\n\n            return [linePartInRange];\n        }\n        const paragraphsContent = this.paragraphs.slice(range.start.row, range.end.row + 1).map(x => x.content);\n        paragraphsContent[0] = (paragraphsContent[0] || '').slice(range.start.column);\n        const lastIndex = paragraphsContent.length - 1;\n        paragraphsContent[lastIndex] = paragraphsContent[lastIndex].slice(0, range.end.column);\n\n        return paragraphsContent;\n    }\n\n    getTextRange(range: Range): string {\n        return this.getParagraphsContentForRange(range).join(NEW_LINE_MARKUP);\n    }\n\n    positionToIndex(position: CursorParagraph, startRow = 0): number {\n        let index = 0;\n        const endRow = Math.min(position.row, this.paragraphs.length);\n        for (let i = startRow || 0; i < endRow; i++) {\n            index += this.paragraphs[i].content.length + 1;\n        }\n\n        return index + position.column;\n    }\n\n    indexToPosition(positionIndex: number, startRow: number): CursorParagraph {\n        const newlineLength = NEW_LINE_MARKUP.length;\n        for (let lineIndex = startRow || 0; lineIndex < this.paragraphs.length; lineIndex++) {\n            positionIndex -= this.paragraphs[lineIndex].content.length + newlineLength;\n            if (positionIndex < 0) {\n                const column = positionIndex + this.paragraphs[lineIndex].content.length + newlineLength;\n\n                return new CursorParagraph(lineIndex, column);\n            }\n        }\n\n        const column = positionIndex + this.paragraphs[this.paragraphs.length - 1].content.length + newlineLength;\n\n        return new CursorParagraph(this.paragraphs.length - 1, column);\n    }\n\n    indexesToRange(startIndex: number, endIndex: number): Range {\n        const startPoint = this.indexToPosition(startIndex, 0);\n        const endPoint = this.indexToPosition(endIndex, 0);\n\n        return new Range(startPoint, endPoint);\n    }\n\n    isNewLineSymbol(index: number): boolean {\n        const text = this.paragraphs.map(x => x.content).join(NEW_LINE_MARKUP);\n\n        return !text || !text[index] || text[index] === NEW_LINE_MARKUP;\n    }\n\n    getSelectedParagraphsByRange(range: Range): { start: number; end: number } {\n        const newlineLength = NEW_LINE_MARKUP.length;\n        let start = 0;\n        let end = 0;\n        let i;\n        const row = Math.min(range.end.row, this.paragraphs.length - 1);\n        for (i = 0; i < row; i++) {\n            if (i < range.start.row) {\n                start += this.paragraphs[i].content.length + newlineLength;\n            }\n\n            end += this.paragraphs[i].content.length + newlineLength;\n        }\n\n        if (i < this.paragraphs.length) {\n            end += this.paragraphs[i].content.length;\n        }\n\n        return { start, end };\n    }\n\n    getPositionAfterBreak(position: CursorParagraph, breakType: BreakTypes): CursorParagraph {\n        if (breakType === BreakTypes.TextWrapping) {\n            return position;\n        }\n\n        const isLastColumn = position.column === this.paragraphs[position.row].content.length;\n        const isLastParagraph = position.row === this.paragraphs.length - 1;\n        return isLastColumn && !isLastParagraph ? new CursorParagraph(position.row + 1, 0) : position;\n    }\n\n    getDistanceFromTop(index: number): number {\n        return this.paragraphs[index]?.paragraphSettings ? this.paragraphs[index].paragraphSettings.distanceFromTop : 0;\n    }\n\n    getDistanceFromTopForPrint(index: number): number {\n        if (!this.paragraphs[index]?.paragraphSettings) {\n            return 0;\n        }\n        const paragraph = this.paragraphs[index].paragraphSettings;\n        const pageNumber = paragraph.pageNumbers[0];\n        let pageBreakHeight = 0;\n        paragraph.textLinesInfo.forEach(linesInfo => {\n            if (linesInfo.isAfterPageBreak) {\n                pageBreakHeight = linesInfo.height;\n            }\n        });\n        return paragraph.distanceFromTop - pageNumber * this.pagesSpace - pageBreakHeight;\n    }\n\n    setParagraphSettings(row: number, lineInfos: LineInfoModel[], numberingData: NumberingDataModel): void {\n        if (!this.paragraphs[row].paragraphSettings) {\n            this.paragraphs[row].paragraphSettings = new Paragraph(\n                numberingData,\n                lineInfos[0].offsetBefore,\n                this.processTextLinesProperties\n            );\n        }\n\n        this.paragraphs[row].paragraphSettings.numberingData = numberingData;\n        this.paragraphs[row].paragraphSettings.width = this.contentWidth;\n        this.paragraphs[row].paragraphSettings.setTextLinesInfo(lineInfos);\n    }\n\n    getParagraphHeight(index: number): number {\n        return this.paragraphs[index]?.paragraphSettings ? this.paragraphs[index].paragraphSettings.height : 0;\n    }\n\n    getVisibleRange(offsetTop: number, scrollerHeight: number): VisibleRange {\n        let start = this.paragraphs.findIndex(x => offsetTop <= x.paragraphSettings?.distanceFromTop + x.paragraphSettings?.height);\n        if (start < 0) {\n            start = 0;\n        }\n\n        let startLineInfo = null;\n        const startParagraph = this.paragraphs[start];\n        if (startParagraph) {\n            const startParagraphOffsetTop = offsetTop - startParagraph.paragraphSettings.distanceFromTop;\n            startLineInfo = ParagraphHelper.getVisibleLineInfo(startParagraph?.paragraphSettings.textLinesInfo, startParagraphOffsetTop, 1);\n        }\n\n        if (!startLineInfo) {\n            return {\n                startParagraph: 0,\n                startLine: 0,\n                startScreenLine: 0,\n                startScreenFullLine: 0,\n                endParagraph: 0,\n                endLine: 0,\n                endScreenLine: 0,\n                endScreenFullLine: 0,\n                pages: [1]\n            };\n        }\n\n        let end = this.paragraphs.findIndex(\n            x => offsetTop + scrollerHeight <= x.paragraphSettings.distanceFromTop + x.paragraphSettings.height\n        );\n        if (end < 0) {\n            end = this.paragraphs.length - 1;\n        }\n\n        let endLineInfo = null;\n        const endParagraph = this.paragraphs[end];\n        if (endParagraph) {\n            const endParagraphOffsetTop = offsetTop + scrollerHeight - endParagraph.paragraphSettings.distanceFromTop;\n            endLineInfo = ParagraphHelper.getVisibleLineInfo(endParagraph.paragraphSettings?.textLinesInfo, endParagraphOffsetTop, -1);\n        }\n\n        const visiblePages = this.getVisiblePages(offsetTop, scrollerHeight);\n\n        return {\n            startParagraph: start,\n            startLine: startLineInfo.index,\n            startScreenLine: startLineInfo.screenIndex,\n            startScreenFullLine: startLineInfo.visibleScreenIndex,\n            endParagraph: end,\n            endLine: endLineInfo.index,\n            endScreenLine: endLineInfo.screenIndex,\n            endScreenFullLine: endLineInfo.visibleScreenIndex,\n            pages: visiblePages\n        };\n    }\n\n    processParagraphsProperties(startParagraphIndex: number): void {\n        this.setParagraphIndexes();\n        const pagesInfo = { pagesVerticalData: this.pagesVerticalData, pagesSpace: this.pagesSpace };\n        let currentPage = startParagraphIndex === 0 ? 1 : this.paragraphs[startParagraphIndex - 1].paragraphSettings.lastPageNumber;\n        let pageVerticalData = PageHelper.getVerticalData(currentPage, this.pagesVerticalData);\n        for (let i = startParagraphIndex; i < this.paragraphs.length; i++) {\n            const prevParagraphInfo = this.getPreviousParagraphInfo(i);\n            const paragraphSettings = this.paragraphs[i].paragraphSettings;\n            paragraphSettings.processParagraphProperties(prevParagraphInfo, pagesInfo, this.customComponents.tables);\n            if (paragraphSettings.firstPageNumber !== currentPage) {\n                currentPage = paragraphSettings.firstPageNumber;\n                pageVerticalData = PageHelper.getVerticalData(paragraphSettings.firstPageNumber, this.pagesVerticalData);\n            }\n\n            paragraphSettings.calculateDistanceFromTop(this.pageHeight, this.pagesSpace, pageVerticalData.marginTop);\n        }\n\n        let pageHeight = this.pageHeight;\n        if (!pageHeight) {\n            pageHeight = this.getAllParagraphsHeight() + this.pageMargin.top + this.pageMargin.bottom;\n            this.minHeight = pageHeight + 2 * this.pagesSpace;\n            this.defaultVerticalData.contentHeight = pageHeight;\n        }\n\n        const lastPageNumber = this.paragraphs[this.paragraphs.length - 1].paragraphSettings.lastPageNumber;\n        this.allPagesHeight = lastPageNumber * (pageHeight + this.pagesSpace) + this.pagesSpace;\n        this.emit('pagesCountChanged', { pagesCount: lastPageNumber, pageHeight: pageHeight + 2 * this.pagesSpace });\n    }\n\n    getAllParagraphsHeight(): number {\n        return this.paragraphs.reduce((sum, x) => sum + x.paragraphSettings.height, 0);\n    }\n\n    destroy(): void {\n        this.removeAllListeners('pagesCountChanged');\n    }\n\n    updatePageVerticalData(edgeType: EdgeType, page: number): void {\n        const pageVerticalData = PageHelper.getVerticalData(page, this.pagesVerticalData);\n        const componentHeight = this.customComponents.edges.getComponentHeight(page, edgeType);\n        if (edgeType === EdgeType.Header) {\n            pageVerticalData.marginTop = componentHeight > this.pageMargin.top ? componentHeight : this.pageMargin.top;\n        } else {\n            pageVerticalData.marginBottom = componentHeight > this.pageMargin.bottom ? componentHeight : this.pageMargin.bottom;\n        }\n\n        const newContentHeight = this.pageHeight - pageVerticalData.marginTop - pageVerticalData.marginBottom;\n        if (newContentHeight === pageVerticalData.contentHeight) {\n            return;\n        }\n\n        pageVerticalData.contentHeight = newContentHeight;\n        this.processParagraphsProperties(0);\n    }\n\n    updateParagraphLineNumber(first: number): void {\n        const count = this.paragraphs.length;\n        if (first === 0) {\n            this.paragraphs[first].lineNumber = 0;\n            first++;\n        }\n\n        for (let i = first; i < count; i++) {\n            this.paragraphs[i].lineNumber = this.paragraphs[i - 1].lineNumber + this.paragraphs[i - 1].nextLineIndexes.length + 1;\n        }\n    }\n\n    updateParagraphStartIndex(first: number): void {\n        if (first === 0) {\n            this.paragraphs[first].startIndex = 0;\n            first++;\n        }\n        for (let i = first; i < this.paragraphs.length; i++) {\n            this.paragraphs[i].startIndex = this.paragraphs[i - 1].startIndex + this.getParagraphContent(i - 1).length + 1;\n        }\n    }\n\n    updateParagraphSettingsNumberingData(index: number): void {\n        const paragraphSettings = this.getParagraphSettings(index);\n        if (paragraphSettings.numberingData.numberingId !== this.model.paragraphs[index].paragraphStyle.numberingId) {\n            paragraphSettings.numberingData = NumberingHelper.createDataModel(\n                this.generalProperties.numberings,\n                this.model.paragraphs,\n                index,\n                this.generalProperties.numberingInfo\n            );\n        }\n\n        if (paragraphSettings.numberingData.numberingId !== null) {\n            const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[index].insertIndex);\n            NumberingHelper.updateMarkerData(\n                this.generalProperties,\n                paragraphSettings,\n                paragraphFormat.textStyle,\n                this.model.paragraphs[index].paragraphStyle\n            );\n        }\n    }\n\n    updateNextLineIndexes(firstParagraph: number, lastParagraph: number): void {\n        this.updateParagraphStartIndex(firstParagraph);\n        let indexOfParagraphAfterPageBreak = this.getParagraphSettings(firstParagraph - 1)?.isEndedByPageBreak ? firstParagraph : -1;\n        let firstUsedTabIndex = this.model.tabs.findIndex(x => x.insertIndex >= this.paragraphs[firstParagraph].startIndex);\n        for (let i = firstParagraph; i <= lastParagraph; i++) {\n            if (!this.paragraphs[i]) {\n                continue;\n            }\n\n            this.tabTokens = [];\n            NumberingHelper.calculateNumberingInfo(\n                this.model.paragraphs[i].paragraphStyle.numberingId,\n                this.model.paragraphs[i].paragraphStyle.numberingLevel,\n                this.getParagraphSettings(i)?.numberingData.marker,\n                this.generalProperties.numberingInfo,\n                this.generalProperties.numberings\n            );\n            const numberingData = NumberingHelper.createDataModel(\n                this.generalProperties.numberings,\n                this.model.paragraphs,\n                i,\n                this.generalProperties.numberingInfo\n            );\n            const { splits, rowInfos } = this.getSplits(this.model, i);\n            this.paragraphs[i].nextLineIndexes = splits;\n            if (indexOfParagraphAfterPageBreak === i) {\n                rowInfos[0].isAfterPageBreak = true;\n            }\n            indexOfParagraphAfterPageBreak = rowInfos[rowInfos.length - 1].isEndedByPageBreak ? i + 1 : -1;\n            this.setParagraphSettings(i, rowInfos, numberingData);\n            this.updateParagraphSettingsNumberingData(i);\n            firstUsedTabIndex = this.updateParagraphTabs(firstUsedTabIndex, i);\n        }\n\n        this.getParagraphSettings(lastParagraph + 1)?.setIsAfterPageBreak(indexOfParagraphAfterPageBreak > -1);\n        this.updateParagraphLineNumber(firstParagraph);\n        this.processParagraphsProperties(firstParagraph);\n    }\n\n    updateNumberingsDataOnChange(index: number): void {\n        for (let i = index; i < this.paragraphs.length; i++) {\n            const paragraphStyle = this.model.paragraphs[i].paragraphStyle;\n            const paragraphSettings = this.getParagraphSettings(i);\n            if (this.model.paragraphs[i].paragraphStyle.numberingId !== null) {\n                NumberingHelper.calculateNumberingInfo(\n                    paragraphStyle.numberingId,\n                    paragraphStyle.numberingLevel,\n                    paragraphSettings.numberingData.marker,\n                    this.generalProperties.numberingInfo,\n                    this.generalProperties.numberings\n                );\n                paragraphSettings.numberingData = NumberingHelper.createDataModel(\n                    this.generalProperties.numberings,\n                    this.model.paragraphs,\n                    i,\n                    this.generalProperties.numberingInfo\n                );\n                const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[i].insertIndex);\n                NumberingHelper.updateMarkerData(this.generalProperties, paragraphSettings, paragraphFormat.textStyle, paragraphStyle);\n            }\n\n            const table = this.customContentService.findComponent(this.customComponents.tables, paragraphSettings.startInsertIndex);\n            if (table) {\n                table.instance.updateCells();\n            }\n        }\n\n        if ('pageType' in this.model) {\n            this.editorService.updateEdges(this.sessionId);\n        }\n    }\n\n    resetAllNumberingInfo(paragraphIndex: number): void {\n        for (let i = paragraphIndex; i < this.model.paragraphs.length; i++) {\n            const { numberingId, numberingLevel } = this.model.paragraphs[i].paragraphStyle;\n            if (\n                numberingId !== null &&\n                this.generalProperties.numberingInfo[numberingId] &&\n                this.generalProperties.numberingInfo[numberingId][numberingLevel]\n            ) {\n                this.generalProperties.numberingInfo[numberingId][numberingLevel].visited = false;\n            }\n        }\n    }\n\n    resetNumberingInfoByTableCell(table: ComponentRef<NoderTableComponent>): void {\n        for (let i = 0; i < table.instance.rowMatrix.length; i++) {\n            for (let cell of table.instance.rowMatrix[i].cells) {\n                const { marker, numberingId } =\n                    cell.componentRef.instance.session.displayData.paragraphs[0].paragraphSettings.numberingData;\n                if (marker && numberingId) {\n                    NumberingHelper.updateNumberingInfo(this.generalProperties.numberingInfo, marker, numberingId);\n                    this.resetAllNumberingInfo(0);\n                    return;\n                }\n            }\n        }\n    }\n\n    private updateParagraphTabs(tabIndex: number, paragraphIndex: number): number {\n        const paragraphContentLength = this.getParagraphContent(paragraphIndex).length;\n        const paragraphLastIndex = this.paragraphs[paragraphIndex].startIndex + paragraphContentLength;\n        if (\n            tabIndex === -1 ||\n            tabIndex >= this.customComponents.tabs.length ||\n            this.customComponents.tabs[tabIndex].instance.insertIndex > paragraphLastIndex\n        ) {\n            return tabIndex;\n        }\n\n        const startIndex = tabIndex;\n        while (this.customComponents.tabs[tabIndex] && this.customComponents.tabs[tabIndex].instance.insertIndex <= paragraphLastIndex) {\n            this.customComponents.tabs[tabIndex].instance.width = this.tabTokens[tabIndex - startIndex].width;\n            this.customComponents.tabs[tabIndex].instance.height = this.tabTokens[tabIndex - startIndex].font;\n            tabIndex++;\n        }\n\n        return tabIndex;\n    }\n\n    private getSplits(model: ContentsInterface, paragraphIndex: number): { splits: number[]; rowInfos: LineInfoModel[] } {\n        const paragraphContent = this.getParagraphContent(paragraphIndex);\n        const strTokens = this.getDisplayTokens(model, paragraphContent, this.paragraphs[paragraphIndex].startIndex);\n        if (!strTokens.length) {\n            const defaultRowInfo = new LineInfoModel({\n                height: (DEFAULT_FONT_SIZE * 4) / 3,\n                width: 0,\n                align: DEFAULT_PARAGRAPH_STYLE.alignment,\n                indent: new IndentModel(\n                    DEFAULT_PARAGRAPH_STYLE.indentFirstLine,\n                    DEFAULT_PARAGRAPH_STYLE.indentHanging,\n                    DEFAULT_PARAGRAPH_STYLE.indentLeft,\n                    DEFAULT_PARAGRAPH_STYLE.indentRight\n                ),\n                offsetAfter: DEFAULT_PARAGRAPH_STYLE.spaceAfter,\n                offsetBefore: DEFAULT_PARAGRAPH_STYLE.spaceBefore,\n                lineSpacing: DEFAULT_PARAGRAPH_STYLE.lineSpacing,\n                isAfterPageBreak: false,\n                isEndedByPageBreak: false,\n                backgroundColor: DEFAULT_PARAGRAPH_STYLE.backgroundColor\n            });\n\n            return { splits: [], rowInfos: [defaultRowInfo] };\n        }\n\n        const splits: number[] = [];\n        const rowInfos: LineInfoModel[] = [];\n\n        let prevToken: DisplayToken;\n        let index = -1;\n        let initial = paragraphContent;\n        while (index) {\n            initial = initial.slice(index > 0 ? index : 0);\n            const tokens = strTokens.slice(paragraphContent.length - initial.length);\n            if (!tokens.length) {\n                tokens.push(...this.getEmptyDisplayTokens(model, this.paragraphs[paragraphIndex].startIndex + index));\n            }\n\n            let wrapLimit = this.computeWrapIndex(tokens, this.contentWidth, this.generalProperties.defaultTabWidth);\n            if (tokens[tokens.length - 1].isPageBreak && wrapLimit === tokens.length && this.paragraphs.length > paragraphIndex + 1) {\n                wrapLimit = 0;\n            }\n            const wrapSplit =\n                tokens[wrapLimit - 1]?.breaksLine || tokens[wrapLimit - 1]?.isTable ? wrapLimit : this.computeWrapSplit(tokens, wrapLimit);\n            const wrapTokens = tokens.slice(0, wrapSplit || undefined);\n\n            if (wrapTokens.length) {\n                prevToken = wrapTokens[wrapTokens.length - 1];\n            }\n\n            const isAfterPageBreak = !rowInfos.length ? false : rowInfos[rowInfos.length - 1].isEndedByPageBreak;\n            const lineInfo = DisplayTokenHelper.getLineInfoFromToken(prevToken, wrapTokens[0], wrapTokens, isAfterPageBreak);\n            lineInfo.backgroundColor = model.paragraphs[paragraphIndex].paragraphStyle.backgroundColor;\n            rowInfos.push(lineInfo);\n\n            if (!wrapLimit) {\n                break;\n            }\n\n            index = wrapSplit;\n            const splitsLength = splits.length;\n            const splitIndex = splitsLength ? index + splits[splitsLength - 1] : index;\n            splits.push(splitIndex);\n        }\n\n        this.tabTokens.push(...strTokens.filter(x => x.isTab));\n\n        ParagraphHelper.applyParagraphIndentsToLines(rowInfos, paragraphIndex, model.paragraphs);\n        return { splits, rowInfos };\n    }\n\n    /**\n     * Given a string, returns an array of the display characters, including tabs and spaces and custom components.\n     */\n    getDisplayTokens(model: ContentsInterface, str: string, startIndex: number): DisplayToken[] {\n        if (!str.length) {\n            return this.getEmptyDisplayTokens(model, startIndex);\n        }\n\n        return this.fillLineTokens(startIndex, str, model);\n    }\n\n    private fillLineTokens(startIndex: number, line: string, model: ContentsInterface): DisplayToken[] {\n        const lineInfo = this.getLineInfoByBreakModifier(model, startIndex + line.length);\n        const tokens: DisplayToken[] = [];\n        let characters: DisplayToken[] = [];\n        let format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);\n        let prevFormat: FormatModel = null;\n        let prevCharCode: number = null;\n        let prevFontString: string = null;\n        let prevChar: string = null;\n        let fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);\n        let symbolChange = false;\n        for (let i = 0; i < line.length; i++) {\n            const char = line[i];\n            const size = FontMetrics.measureCharSize(char, fontString);\n            const customComponent = this.getOrGenerateComponent(startIndex, char);\n            const breakType = BreakHelper.getBreakType(model, char, startIndex);\n\n            if (customComponent && !breakType) {\n                const token = this.customContentService.getTokenFromComponent(\n                    customComponent,\n                    lineInfo,\n                    DisplayValue.customContent,\n                    i === 0,\n                    size\n                );\n                tokens.push(token);\n\n                prevCharCode = -1;\n                prevChar = '';\n                characters = [];\n            } else {\n                const charCode = char.charCodeAt(0);\n                const displayValue = DisplayTokenHelper.getDisplayValue(charCode);\n                const isFirstCharacter = i === 0;\n                const token = new DisplayToken({\n                    ...size,\n                    displayValue,\n                    align: lineInfo.align,\n                    indentFirstLine: isFirstCharacter ? lineInfo.indent.firstLine : DEFAULT_PARAGRAPH_STYLE.indentFirstLine,\n                    indentHanging: isFirstCharacter ? lineInfo.indent.hanging : DEFAULT_PARAGRAPH_STYLE.indentHanging,\n                    indentLeft: lineInfo.indent.left,\n                    indentRight: lineInfo.indent.right,\n                    indentBefore: lineInfo.offsetBefore,\n                    indentAfter: lineInfo.offsetAfter,\n                    lineSpacing: lineInfo.lineSpacing,\n                    isPageBreak: breakType === BreakTypes.Page,\n                    isLineBreak: breakType === BreakTypes.TextWrapping,\n                    isTab: false\n                });\n\n                tokens.push(token);\n\n                if (\n                    charCode !== prevCharCode ||\n                    !prevFormat ||\n                    !ContentStyleHelper.areSameTextStyles(format?.textStyle, prevFormat?.textStyle)\n                ) {\n                    symbolChange = true;\n                } else if (i === line.length - 1) {\n                    characters.push(token);\n                    symbolChange = true;\n                } else {\n                    characters.push(token);\n                }\n\n                if (characters.length > 1 && symbolChange) {\n                    this.processCharSizes(prevChar, prevFontString, characters);\n                    characters = [token];\n                    symbolChange = false;\n                } else if (symbolChange) {\n                    characters = [token];\n                }\n\n                prevCharCode = charCode;\n                prevChar = char;\n            }\n\n            prevFormat = format;\n            prevFontString = fontString;\n            startIndex++;\n\n            if (startIndex > format?.endIndex) {\n                format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);\n                fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);\n            }\n        }\n\n        return tokens;\n    }\n\n    private getOrGenerateComponent(charIndex: number, char: string): ComponentRef<BaseNoderComponent> | null {\n        if (!this.customContentService.isSpecialMarker(char)) {\n            return null;\n        }\n\n        const existingComponent = this.customContentService.getComponent(this.customComponents, char, charIndex);\n        if (existingComponent) {\n            if (existingComponent.instance instanceof NoderTableComponent) {\n                existingComponent.instance.updateCells();\n            }\n            return existingComponent;\n        }\n\n        return this.customContentService.generateComponent(\n            this.model,\n            this.customComponents,\n            this.sessionId,\n            this.generalProperties,\n            this.contentWidth,\n            charIndex\n        );\n    }\n\n    private processCharSizes(prevChar: string, prevFontString: string, characters: DisplayToken[]): void {\n        const newSize = FontMetrics.measureCharSize(prevChar, prevFontString);\n        for (let item of characters) {\n            Object.assign(item, newSize);\n        }\n    }\n\n    getLineTokens(model: ContentsInterface, line: string, startIndex: number): DisplayToken[] {\n        const lineInfo = this.getLineInfoFromTextLine(startIndex + line.length);\n        if (!line.length) {\n            return this.getEmptyLineTokens(model, startIndex, lineInfo);\n        }\n\n        const tokens: DisplayToken[] = [];\n        let characters: DisplayToken[] = [];\n        let format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);\n        let prevFormat: FormatModel = null;\n        let prevCharCode: number = null;\n        let prevFontString: string = null;\n        let prevChar: string = null;\n        let fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);\n        let symbolChange = false;\n        for (let i = 0; i < line.length; i++) {\n            const char = line[i];\n            const size = FontMetrics.measureCharSize(char, fontString);\n            const customComponent = this.customContentService.getComponent(this.customComponents, char, startIndex);\n            const breakType = BreakHelper.getBreakType(model, char, startIndex);\n\n            if (customComponent && !breakType) {\n                const token = this.customContentService.getTokenFromComponent(\n                    customComponent,\n                    lineInfo,\n                    DisplayValue.customContent,\n                    i === 0,\n                    size\n                );\n                tokens.push(token);\n\n                prevCharCode = -1;\n                prevChar = '';\n                characters = [];\n            } else {\n                const charCode = char.charCodeAt(0);\n                const displayValue = DisplayTokenHelper.getDisplayValue(charCode);\n                const isFirstCharacter = i === 0;\n                const token = new DisplayToken({\n                    ...size,\n                    displayValue,\n                    align: lineInfo.align,\n                    indentFirstLine: isFirstCharacter ? lineInfo.indent.firstLine : DEFAULT_PARAGRAPH_STYLE.indentFirstLine,\n                    indentHanging: isFirstCharacter ? lineInfo.indent.hanging : DEFAULT_PARAGRAPH_STYLE.indentHanging,\n                    indentLeft: lineInfo.indent.left,\n                    indentRight: lineInfo.indent.right,\n                    indentBefore: lineInfo.offsetBefore,\n                    indentAfter: lineInfo.offsetAfter,\n                    lineSpacing: lineInfo.lineSpacing,\n                    isPageBreak: breakType === BreakTypes.Page,\n                    isLineBreak: breakType === BreakTypes.TextWrapping,\n                    isTab: false\n                });\n\n                tokens.push(token);\n\n                if (\n                    charCode !== prevCharCode ||\n                    !prevFormat ||\n                    !ContentStyleHelper.areSameTextStyles(format?.textStyle, prevFormat?.textStyle)\n                ) {\n                    symbolChange = true;\n                } else if (i === line.length - 1) {\n                    characters.push(token);\n                    symbolChange = true;\n                } else {\n                    characters.push(token);\n                }\n\n                if (characters.length > 1 && symbolChange) {\n                    this.processCharSizes(prevChar, prevFontString, characters);\n                    characters = [token];\n                    symbolChange = false;\n                } else if (symbolChange) {\n                    characters = [token];\n                }\n\n                prevCharCode = charCode;\n                prevChar = char;\n            }\n\n            prevFormat = format;\n            prevFontString = fontString;\n            startIndex++;\n\n            if (startIndex > format?.endIndex) {\n                format = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);\n                fontString = ContentStyleHelper.getFontStylesString(format?.textStyle);\n            }\n        }\n\n        return tokens;\n    }\n\n    private getEmptyDisplayTokens(model: ContentsInterface, startIndex: number): DisplayToken[] {\n        const lineInfo = this.getLineInfoByBreakModifier(model, startIndex);\n        return this.getEmptyLineTokens(model, startIndex, lineInfo);\n    }\n\n    private getEmptyLineTokens(model: ContentsInterface, startIndex: number, lineInfo: LineInfoModel): DisplayToken[] {\n        const storedFormat = FormatStyleHelper.getFormatAtIndex(model.formats, startIndex);\n        if (!storedFormat) {\n            return [];\n        }\n\n        const size = FontMetrics.measureCharSize('EMPTY_LINE', ContentStyleHelper.getFontStylesString(storedFormat.textStyle));\n        size.width = 3;\n        return [\n            new DisplayToken({\n                ...size,\n                displayValue: DisplayValue.emptyLine,\n                align: lineInfo.align,\n                indentFirstLine: lineInfo.indent.firstLine,\n                indentHanging: lineInfo.indent.hanging,\n                indentLeft: lineInfo.indent.left,\n                indentRight: lineInfo.indent.right,\n                indentBefore: lineInfo.offsetBefore,\n                indentAfter: lineInfo.offsetAfter,\n                isPageBreak: false,\n                isLineBreak: false,\n                isTab: false,\n                lineSpacing: lineInfo.lineSpacing\n            })\n        ];\n    }\n\n    private getLineInfoByBreakModifier(model: ContentsInterface, index: number): LineInfoModel {\n        const paragraph = ParagraphStyleHelper.getParagraphAtIndex(model.paragraphs, index);\n        if (!paragraph) {\n            return new LineInfoModel({\n                align: DEFAULT_PARAGRAPH_STYLE.alignment,\n                indent: new IndentModel(\n                    DEFAULT_PARAGRAPH_STYLE.indentFirstLine,\n                    DEFAULT_PARAGRAPH_STYLE.indentHanging,\n                    DEFAULT_PARAGRAPH_STYLE.indentLeft,\n                    DEFAULT_PARAGRAPH_STYLE.indentRight\n                ),\n                offsetBefore: DEFAULT_PARAGRAPH_STYLE.spaceBefore,\n                offsetAfter: DEFAULT_PARAGRAPH_STYLE.spaceAfter,\n                lineSpacing: DEFAULT_PARAGRAPH_STYLE.lineSpacing\n            });\n        }\n\n        const indentLeft = this.getParagraphIndentLeft(model, paragraph);\n        return this.getLineInfoModel(paragraph, indentLeft);\n    }\n\n    private getParagraphIndentLeft(model: ContentsInterface, paragraph: ParagraphModel): number {\n        const numberingId = paragraph.paragraphStyle.numberingId;\n        if (numberingId === null) {\n            return paragraph.paragraphStyle.indentLeft;\n        }\n\n        const level = paragraph.paragraphStyle.numberingLevel;\n        const paragraphIndex = model.paragraphs.indexOf(paragraph);\n        const levelModel = NumberingHelper.find(this.generalProperties.numberings, numberingId, level);\n        const paragraphFormat = FormatStyleHelper.getFormatAtIndex(model.formats, paragraph.insertIndex);\n        const markerTextStyle = ContentStyleHelper.combineTextStyles(levelModel.markerStyle, paragraphFormat.textStyle);\n        const paragraphSettings = this.getParagraphSettings(paragraphIndex);\n        let markerWidth = paragraphSettings?.numberingData?.width;\n        const marker = NumberingHelper.getMarker(\n            levelModel,\n            numberingId,\n            model.paragraphs,\n            paragraphIndex,\n            this.generalProperties.numberingInfo\n        );\n        const markerSizes = NumberingHelper.getMarkerSizes(marker, markerTextStyle);\n        markerWidth = markerSizes.width;\n\n        const hangingIndent = paragraph.paragraphStyle.indentHanging ? paragraph.paragraphStyle.indentHanging : levelModel.indentHanging;\n        let paragraphIndent = levelModel.indentLeft;\n        if (markerWidth >= hangingIndent) {\n            const markerOverflow = markerWidth - hangingIndent;\n            const additionalMarkerIndent = TabHelper.calculateTabWidth(\n                levelModel.indentLeft + markerOverflow,\n                this.generalProperties.defaultTabWidth\n            );\n            paragraphIndent += markerOverflow + additionalMarkerIndent;\n        }\n\n        return paragraphIndent;\n    }\n\n    private getLineInfoFromTextLine(index: number): LineInfoModel {\n        const paragraph = ParagraphStyleHelper.getParagraphAtIndex(this.model.paragraphs, index);\n        const indentLeft = this.getIndentLeftFromTextLine(index);\n        return this.getLineInfoModel(paragraph, indentLeft);\n    }\n\n    private getLineInfoModel(paragraph: ParagraphModel, indentLeft: number): LineInfoModel {\n        const indentHanging = paragraph.paragraphStyle.numberingId === null ? paragraph.paragraphStyle.indentHanging : 0;\n        return new LineInfoModel({\n            align: paragraph.paragraphStyle.alignment ?? DEFAULT_PARAGRAPH_STYLE.alignment,\n            indent: new IndentModel(\n                paragraph.paragraphStyle.indentFirstLine ?? DEFAULT_PARAGRAPH_STYLE.indentFirstLine,\n                indentHanging ?? DEFAULT_PARAGRAPH_STYLE.indentHanging,\n                indentLeft ?? DEFAULT_PARAGRAPH_STYLE.indentLeft,\n                paragraph.paragraphStyle.indentRight ?? DEFAULT_PARAGRAPH_STYLE.indentRight\n            ),\n            offsetBefore: DEFAULT_PARAGRAPH_STYLE.spaceBefore,\n            offsetAfter: DEFAULT_PARAGRAPH_STYLE.spaceAfter,\n            lineSpacing: paragraph.paragraphStyle.lineSpacing ?? DEFAULT_PARAGRAPH_STYLE.lineSpacing\n        });\n    }\n\n    private getIndentLeftFromTextLine(insertIndex: number): number | null {\n        let startIndex = 0;\n        let endIndex = this.paragraphs.length - 1;\n        while (startIndex <= endIndex) {\n            const middleIndex = Math.round((startIndex + endIndex) / 2);\n            const paragraphInfo = this.paragraphs[middleIndex];\n            if (paragraphInfo.startIndex > insertIndex) {\n                startIndex = middleIndex + 1;\n            } else {\n                endIndex = middleIndex - 1;\n            }\n        }\n\n        const textLinesInfo = this.paragraphs[startIndex]?.paragraphSettings.textLinesInfo;\n        return textLinesInfo ? Math.max(...textLinesInfo.map(x => x.indentLeft)) : null;\n    }\n\n    private computeWrapSplit(tokens: DisplayToken[], wrapLimit: number): number | null {\n        if (!tokens.length || tokens.length <= wrapLimit) {\n            return null;\n        }\n\n        // If there is a space or tab at this split position, then making\n        // a split is simple.\n        if (\n            wrapLimit === 0 ||\n            tokens[wrapLimit].displayValue === DisplayValue.customContent ||\n            (this.isWhiteSpace(tokens[wrapLimit - 1]) && this.isWhiteSpace(tokens[wrapLimit]))\n        ) {\n            return wrapLimit;\n        }\n\n        return this.calculateSplit(wrapLimit, tokens);\n    }\n\n    private calculateSplit(index: number, tokens: DisplayToken[]): number {\n        for (let i = index; i >= 0; i--) {\n            if (this.isWhiteSpace(tokens[i]) || tokens[i].displayValue === DisplayValue.customContent) {\n                return i + 1;\n            }\n        }\n        return index;\n    }\n\n    private isWhiteSpace(token: DisplayToken): boolean {\n        return [DisplayValue.space, DisplayValue.emptyLine].includes(token.displayValue);\n    }\n\n    /**\n     * Computes wrap index based on max row width\n     */\n    private computeWrapIndex(displayTokens: DisplayToken[], contentWidth: number, defaultTabWidth: number): number {\n        if (!displayTokens[0]) {\n            return 0;\n        }\n\n        if (displayTokens[0].isTable || (displayTokens[0].breaksLine && displayTokens.length === 1)) {\n            return 1;\n        }\n\n        const indent =\n            displayTokens[0].indentLeft +\n                displayTokens[0].indentRight +\n                displayTokens[0].indentFirstLine -\n                displayTokens[0].indentHanging || 0;\n        const maxRowWidth = contentWidth - indent;\n        let sum = 0;\n        for (let i = 0; i < displayTokens.length; i++) {\n            if (displayTokens[i].isTab) {\n                displayTokens[i].width = TabHelper.calculateTabWidth(sum, defaultTabWidth);\n            }\n\n            sum += displayTokens[i].width;\n            if ((i > 0 && (sum >= maxRowWidth || displayTokens[i - 1].breaksLine)) || displayTokens[i].isTable) {\n                return i;\n            }\n\n            if (displayTokens[i].isLineBreak || (i === displayTokens.length - 1 && displayTokens[i].isPageBreak)) {\n                return i + 1;\n            }\n        }\n\n        return 0;\n    }\n\n    private getPreviousParagraphInfo(row: number): { lastPage: number; paragraphHeight: number; paragraphLastLine: number } {\n        if (!row || !this.paragraphs.length) {\n            return { lastPage: 1, paragraphHeight: 0, paragraphLastLine: -1 };\n        }\n\n        const prevParagraph = this.paragraphs[row - 1].paragraphSettings;\n        return prevParagraph.getParagraphData();\n    }\n\n    private getVisiblePages(offsetTop: number, containerHeight: number): number[] {\n        const visiblePages: number[] = [];\n\n        let firstVisiblePage = offsetTop / (this.pageHeight + this.pagesSpace);\n        if (firstVisiblePage % 1 === 0) {\n            firstVisiblePage++;\n        }\n\n        let visiblePagesCount = containerHeight / (this.pageHeight + this.pagesSpace);\n        const partialPageOnScreenPercent = Math.trunc(((visiblePagesCount % 1) + (firstVisiblePage % 1)) * 100);\n        const pageSpaceHeightPercent = Math.trunc((this.pagesSpace / containerHeight) * 100);\n        if (partialPageOnScreenPercent - pageSpaceHeightPercent > 100) {\n            visiblePagesCount++;\n        }\n\n        visiblePagesCount = Math.ceil(visiblePagesCount);\n        firstVisiblePage = Math.ceil(firstVisiblePage);\n        const documentPagesCount = this.paragraphs[this.paragraphs.length - 1].paragraphSettings.lastPageNumber;\n        if (firstVisiblePage + visiblePagesCount - 1 > documentPagesCount) {\n            visiblePagesCount = documentPagesCount - firstVisiblePage + 1;\n        }\n\n        for (let i = 0; i < visiblePagesCount; i++) {\n            visiblePages.push(firstVisiblePage + i);\n        }\n\n        return visiblePages;\n    }\n\n    private insertTextAndReturnEndCursorPosition(text: string, position: CursorParagraph): CursorParagraph {\n        const left = this.paragraphs[position.row].content.slice(0, position.column);\n        const right = this.paragraphs[position.row].content.slice(position.column);\n        const insertParagraphs = this.splitByParagraphs(`${left}${text}${right}`).map(\n            x => new ParagraphInfoModel({ content: x, nextLineIndexes: [] })\n        );\n        insertParagraphs[0].paragraphSettings = this.getParagraphSettings(position.row);\n        this.paragraphs.splice(position.row, 1, ...insertParagraphs);\n        return new CursorParagraph(\n            position.row + insertParagraphs.length - 1,\n            insertParagraphs[insertParagraphs.length - 1].content.length - right.length\n        );\n    }\n\n    private splitByParagraphs(text: string): string[] {\n        return text.split(/\\r\\n|\\r|\\n/);\n    }\n\n    private setParagraphIndexes(): void {\n        for (let paragraph of this.paragraphs) {\n            paragraph.paragraphSettings.startInsertIndex = paragraph.startIndex;\n        }\n    }\n\n    private initPagesVerticalData(): void {\n        if (\n            !this.customComponents.edges ||\n            (!this.customComponents.edges.headersComponents.length && !this.customComponents.edges.footersComponents.length)\n        ) {\n            this.pagesVerticalData = [\n                new PageVerticalDataModel({\n                    marginTop: this.pageMargin.top,\n                    marginBottom: this.pageMargin.bottom,\n                    contentHeight: this.pageHeight - this.pageMargin.top - this.pageMargin.bottom,\n                    pageType: PageType.Default\n                })\n            ];\n            return;\n        }\n\n        const pageTypes = this.customComponents.edges.getUniquePageTypes();\n        this.pagesVerticalData = pageTypes.map(pageType => {\n            const headerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Header);\n            const footerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Footer);\n            const marginTop = Math.max(headerHeight, this.pageMargin.top);\n            const marginBottom = Math.max(footerHeight, this.pageMargin.bottom);\n\n            return new PageVerticalDataModel({\n                marginTop,\n                marginBottom,\n                contentHeight: this.pageHeight - marginTop - marginBottom,\n                pageType\n            });\n        });\n    }\n}\n"]}