@talrace/ngx-noder 0.0.7 → 0.0.8

package/esm2022/lib/editor/execution/edit.session.mjs

@@ -0,0 +1,1117 @@
+import { Alignment } from '../positioning/alignments.const';
+import { BreakHelper } from '../gadgets/page-break/break.helper';
+import { BreakTypes } from '../gadgets/page-break/break-types.enum';
+import { ContentHelper } from '../positioning/content.helper';
+import { ContentStyleHelper } from '../content/helpers/content-style.helper';
+import { CursorParagraph } from '../positioning/cursor-paragraph';
+import { CUSTOM_ELEMENT_MARKER } from '../components/shared/custom-content-markers.const';
+import { CustomComponentHelper } from '../components/shared/custom-component.hepler';
+import { DEFAULT_BACKGROUND_COLOR, DEFAULT_FONT_COLOR, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_PARAGRAPH_STYLE, HYPERLINK_HEADING_STYLE_ID, NEW_LINE_MARKUP } from '../content/constants/editor.const';
+import { DisplayToken } from '../content/display-data/display-token.model';
+import { DisplayValue } from '../content/constants/display-values.const';
+import { DocxModel } from '../../models/generated/docx.model';
+import { Edges } from '../components/edges/edges';
+import { ElementModel } from '../../models/generated/element.model';
+import { EventEmitting } from '../core/event-emitting';
+import { FontMetrics } from '../gadgets/font-metrics/font-metrics.helper';
+import { FormatStyleHelper } from './helpers/format-style.helper';
+import { ImageDataModel } from '../../models/generated/image-data.model';
+import { IndentModel } from '../content/display-data/indent.model';
+import { InsertElementModel } from '../../models/generated/insert-element.model';
+import { LineInfoModel } from '../content/display-data/line-info.model';
+import { NoderImageComponent } from '../components/image/components/image.component';
+import { NoderTabComponent } from '../components/tab/tab.component';
+import { NoderTableComponent } from '../components/table/components/table.component';
+import { NumberingHelper } from '../gadgets/numbering/numbering.helper';
+import { NumberingMarkerType } from '../gadgets/numbering/numbering-marker-type.enum';
+import { OperationsHelper } from '../operations/operations-helper.helper';
+import { PagesWrap } from '../content/display-data/pages.wrap';
+import { ParagraphHelper } from './helpers/paragraph.helper';
+import { ParagraphStyleHelper } from './helpers/paragraph-style.helper';
+import { Range } from '../positioning/range';
+import { TabHelper } from '../components/tab/tab.helper';
+import { TextStyleModel } from '../../models/generated/text-style.model';
+import { UnicodeHelper } from '../gadgets/unicode/unicode.helper';
+export class EditSession extends EventEmitting {
+    get scrollTop() {
+        return this.scrollBar?.scrollTop ?? 0; // only main session is scrollable
+    }
+    get stylesMap() {
+        return this._stylesMap;
+    }
+    set contentWidth(value) {
+        if (!value) {
+            return;
+        }
+        this._contentWidth = value;
+        this.updateWrapData(0, this.document.lines.length - 1);
+    }
+    get contentWidth() {
+        return this._contentWidth;
+    }
+    constructor(document, sessionId, customContentService, model, selection, generalProperties, componentService, scrollBar) {
+        super();
+        this.document = document;
+        this.sessionId = sessionId;
+        this.customContentService = customContentService;
+        this.model = model;
+        this.selection = selection;
+        this.generalProperties = generalProperties;
+        this.scrollBar = scrollBar;
+        this.tokenRe = new RegExp('^[' + UnicodeHelper.wordChars + '\\$_]+', 'g');
+        this.nonTokenRe = new RegExp('^(?:[^' + UnicodeHelper.wordChars + '\\$_]|\\s])+', 'g');
+        this.wrapData = [[]]; // Wrap indexes for document rows
+        this.wrapParagraphLine = []; // line numbers that begin the paragraphs
+        this.wrapParagraphIndex = []; // symbol indexes that begin the paragraphs
+        this._stylesMap = {
+            fontFamily: DEFAULT_FONT_FAMILY,
+            fontSize: DEFAULT_FONT_SIZE,
+            fontColor: DEFAULT_FONT_COLOR,
+            alignment: Alignment.left,
+            backgroundColor: DEFAULT_BACKGROUND_COLOR,
+            highlightColor: DEFAULT_BACKGROUND_COLOR
+        };
+        const edges = model instanceof DocxModel
+            ? new Edges(componentService, model.headers, model.footers, document.pageMargin, document.pageWidth, sessionId, generalProperties)
+            : null;
+        this.customComponents = { images: [], tables: [], tabs: [], customElements: [], edges: edges };
+        this.setDocument();
+    }
+    destroy() {
+        this.pagesWrap.destroy();
+    }
+    getRowLength(row) {
+        if (!this.wrapData[row]) {
+            return 1;
+        }
+        return this.wrapData[row].length + 1;
+    }
+    updateWrapParagraphIndex(first) {
+        const count = this.document.lines.length;
+        if (first === 0) {
+            this.wrapParagraphIndex[first] = 0;
+            first++;
+        }
+        for (let i = first; i < count; i++) {
+            this.wrapParagraphIndex[i] = this.wrapParagraphIndex[i - 1] + this.document.lines[i - 1].length + 1;
+        }
+        this.wrapParagraphIndex.splice(count);
+    }
+    updateWrapParagraphLine(first) {
+        const count = this.document.lines.length;
+        if (first === 0) {
+            this.wrapParagraphLine[first] = 0;
+        }
+        else {
+            this.wrapParagraphLine[first] = this.wrapParagraphLine[first - 1] + this.wrapData[first - 1].length + 1;
+        }
+        for (let i = first + 1; i < count; i++) {
+            this.wrapParagraphLine[i] = this.wrapParagraphLine[i - 1] + this.wrapData[i - 1].length + 1;
+        }
+        this.wrapParagraphLine.splice(count);
+    }
+    updateParagraphNumberingData(index) {
+        if (this.pagesWrap.paragraphs[index].numberingData.numberingId !== this.model.paragraphs[index].paragraphStyle.numberingId) {
+            this.pagesWrap.paragraphs[index].numberingData = NumberingHelper.createDataModel(this.generalProperties.numberings, this.model.paragraphs, index);
+        }
+        if (this.pagesWrap.paragraphs[index].numberingData.numberingId !== null) {
+            const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[index].insertIndex);
+            NumberingHelper.updateMarkerData(this.generalProperties, this.pagesWrap.paragraphs[index], paragraphFormat.textStyle, this.model.paragraphs[index].paragraphStyle);
+        }
+    }
+    updateWrapData(firstParagraph, lastParagraph) {
+        this.updateWrapParagraphIndex(firstParagraph);
+        let indexOfParagraphAfterPageBreak = this.pagesWrap.paragraphs[firstParagraph - 1]?.isEndedByPageBreak ? firstParagraph : -1;
+        let firstUsedTabIndex = this.model.tabs.findIndex(x => x.insertIndex >= this.wrapParagraphIndex[firstParagraph]);
+        for (let i = firstParagraph; i <= lastParagraph; i++) {
+            this.pagesWrap.tabTokens = [];
+            const currentLine = this.document.getLine(this.document.lines, i);
+            const isNextLineExists = this.document.lines.length > i + 1;
+            const { splits, rowInfos } = this.getSplits(this.model, currentLine, this.wrapParagraphIndex[i], i, isNextLineExists);
+            this.wrapData[i] = splits;
+            if (indexOfParagraphAfterPageBreak === i) {
+                rowInfos[0].isAfterPageBreak = true;
+            }
+            indexOfParagraphAfterPageBreak = rowInfos[rowInfos.length - 1].isEndedByPageBreak ? i + 1 : -1;
+            this.pagesWrap.set(i, rowInfos, this.generalProperties.numberings, this.model.paragraphs);
+            this.updateParagraphNumberingData(i);
+            this.updateWrapParagraphIndex(firstParagraph);
+            firstUsedTabIndex = this.updateParagraphTabs(firstUsedTabIndex, i, currentLine.length);
+        }
+        this.pagesWrap.paragraphs[lastParagraph + 1]?.setIsAfterPageBreak(indexOfParagraphAfterPageBreak > -1);
+        const count = this.document.lines.length;
+        this.pagesWrap.paragraphs.splice(count);
+        this.wrapData.splice(count);
+        this.updateWrapParagraphLine(firstParagraph);
+        this.pagesWrap.processParagraphsProperties(firstParagraph, this.wrapParagraphIndex);
+    }
+    /**
+     * Given a string, returns an array of the display characters, including tabs and spaces.
+     */
+    getDisplayTokens(model, str, startIndex) {
+        if (!str.length) {
+            return this.getEmptyLineTokens(startIndex);
+        }
+        return this.getFilledLineTokens(startIndex, str, model);
+    }
+    getRowCacheIndex(cacheArray, value) {
+        let start = 0;
+        let end = cacheArray.length - 1;
+        while (start <= end) {
+            const mid = (start + end) >> 1;
+            const center = cacheArray[mid];
+            if (value > center) {
+                start = mid + 1;
+            }
+            else if (value < center) {
+                end = mid - 1;
+            }
+            else {
+                return mid;
+            }
+        }
+        return start - 1;
+    }
+    /**
+     * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen.
+     * The first position indicates the number of columns for `str` on screen.
+     * The second value contains the position of the document column that this function read until.
+     */
+    getStringScreenWidth(str, maxScreenColumn) {
+        let screenColumn = 0;
+        let column;
+        for (column = 0; column < str.length; column++) {
+            screenColumn += 1;
+            if (screenColumn > maxScreenColumn) {
+                break;
+            }
+        }
+        return [screenColumn, column];
+    }
+    /**
+     * Given a starting row and column, this method returns the `Range` of the first word boundary it finds.
+     */
+    getWordRange(row, column) {
+        const line = this.document.getLine(this.document.lines, row);
+        let inToken = false;
+        if (column > 0) {
+            inToken = !!line.charAt(column - 1).match(this.tokenRe);
+        }
+        if (!inToken) {
+            inToken = !!line.charAt(column).match(this.tokenRe);
+        }
+        let regexp;
+        if (inToken) {
+            regexp = this.tokenRe;
+        }
+        else if (/^\s+$/.test(line.slice(column - 1, column + 1))) {
+            regexp = /\s/;
+        }
+        else {
+            regexp = this.nonTokenRe;
+        }
+        let start = column;
+        if (start > 0) {
+            do {
+                start--;
+            } while (start >= 0 && line.charAt(start).match(regexp));
+            start++;
+        }
+        let end = column;
+        while (end < line.length && line.charAt(end).match(regexp)) {
+            end++;
+        }
+        return new Range(new CursorParagraph(row, start), new CursorParagraph(row, end));
+    }
+    getDisplayLine(row, endColumn, startColumn) {
+        const line = this.document.getLine(this.document.lines, row);
+        return line.substring(startColumn || 0, endColumn || line.length);
+    }
+    removeByDocumentIndexes(startIndex, endIndex) {
+        const startParagraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex);
+        const endParagraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex);
+        this.remove(new Range(startParagraphPosition, endParagraphPosition));
+    }
+    insertTextByDocumentIndex(index, text, style) {
+        const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, index);
+        return this.insertText(paragraphPosition, text, style);
+    }
+    insertElementByDocumentIndex(insertElement) {
+        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.element.insertIndex);
+        return this.insertElement(elementPosition, insertElement.element);
+    }
+    insertBreakByDocumentIndex(insertElement) {
+        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);
+        return this.insertBreak(elementPosition, insertElement.breakType);
+    }
+    insertTabByDocumentIndex(insertElement) {
+        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);
+        return this.insertTab(elementPosition);
+    }
+    insertImageByDocumentIndex(insertElement) {
+        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);
+        return this.insertImage(elementPosition, insertElement.imageData);
+    }
+    insertTableByDocumentIndex(insertElement) {
+        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);
+        return this.insertTable(elementPosition, insertElement);
+    }
+    insertParagraphByDocumentIndex(insertElement) {
+        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);
+        return this.insertParagraph(elementPosition, insertElement);
+    }
+    applyTextStyle(startIndex, endIndex, textStyle) {
+        this.cursorStyle = new TextStyleModel(textStyle);
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;
+        OperationsHelper.applyTextStyle(this.model, startIndex, endIndex, textStyle);
+        this.updateWrapData(startParagraph, endParagraph);
+        this.setStyle(textStyle);
+    }
+    applyParagraphStyle(startIndex, endIndex, paragraphStyle) {
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;
+        OperationsHelper.applyParagraphStyle(this.model, startIndex, endIndex, paragraphStyle);
+        this.updateWrapData(startParagraph, endParagraph);
+        this.setStyle(paragraphStyle);
+    }
+    applyElementStyle(model) {
+        OperationsHelper.applyElementStyle(this.model, model);
+        const imageComponentRef = this.customComponents.customElements.find(x => x.instance.insertIndex === model.insertIndex);
+        imageComponentRef.instance.initialize();
+        const paragraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, model.insertIndex).row;
+        this.updateWrapData(paragraph, paragraph);
+    }
+    addNumbering(levels, startIndex, endIndex) {
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;
+        OperationsHelper.addNumbering(this.model, this.generalProperties.numberings, startIndex, endIndex, levels);
+        for (let i = startParagraph; i <= endParagraph; i++) {
+            if (this.pagesWrap.paragraphs[i].numberingData.numberingId !== null) {
+                this.updateNumberingsDataOnChange(endParagraph);
+                break;
+            }
+        }
+        this.updateWrapData(startParagraph, endParagraph);
+        this.setNumberingStyle(startIndex, endIndex);
+    }
+    removeNumberings(startIndex, endIndex) {
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;
+        OperationsHelper.removeNumberings(this.model, this.generalProperties.numberings, startIndex, endIndex);
+        for (let i = startParagraph; i <= endParagraph; i++) {
+            if (this.pagesWrap.paragraphs[i].numberingData.numberingId !== null) {
+                this.updateNumberingsDataOnChange(endParagraph);
+                break;
+            }
+        }
+        this.updateWrapData(startParagraph, endParagraph);
+        this.setNumberingStyle(startIndex, endIndex);
+    }
+    restoreNumberings(paragraphs, numberings) {
+        const startIndex = paragraphs[0].insertIndex;
+        const endIndex = paragraphs[paragraphs.length - 1].insertIndex;
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endPosition = ContentHelper.documentIndexToParagraphWithOffset(this.wrapParagraphIndex, this.document.lines, endIndex);
+        OperationsHelper.restoreNumberings(this.model, this.generalProperties.numberings, paragraphs, numberings);
+        for (const paragraph of paragraphs) {
+            if (paragraph.paragraphStyle.numberingId !== null) {
+                this.updateNumberingsDataOnChange(endPosition.row);
+                break;
+            }
+        }
+        this.updateWrapData(startParagraph, endPosition.row);
+        this.selection.placeCursor(endPosition);
+        this.setNumberingStyle(startIndex, endIndex);
+    }
+    applyImageStyle(applyImage) {
+        const imageComponentRef = this.customComponents.images.find(x => x.instance.insertIndex === applyImage.insertIndex);
+        imageComponentRef.instance.resize({ width: applyImage.width, height: applyImage.height });
+        OperationsHelper.applyImageStyle(this.model, applyImage);
+        const start = this.document.indexToPosition(applyImage.insertIndex, 0);
+        this.updateWrapData(start.row, this.document.lines.length - 1);
+    }
+    restoreTextStyles(formats) {
+        const startIndex = formats[0].startIndex;
+        const endIndex = formats[formats.length - 1].endIndex;
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endPosition = ContentHelper.documentIndexToParagraphWithOffset(this.wrapParagraphIndex, this.document.lines, endIndex);
+        OperationsHelper.restoreTextStyles(this.model, formats);
+        this.updateWrapData(startParagraph, endPosition.row);
+        this.selection.placeCursor(endPosition);
+        this.processSelectionStyles();
+    }
+    restoreParagraphStyles(paragraphs) {
+        const startIndex = paragraphs[0].insertIndex;
+        const endIndex = paragraphs[paragraphs.length - 1].insertIndex;
+        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;
+        const endPosition = ContentHelper.documentIndexToParagraphWithOffset(this.wrapParagraphIndex, this.document.lines, endIndex);
+        OperationsHelper.restoreParagraphStyles(this.model, paragraphs);
+        this.updateWrapData(startParagraph, endPosition.row);
+        this.selection.placeCursor(endPosition);
+        this.processSelectionStyles();
+    }
+    setTextStyle(textStyle) {
+        this.cursorStyle = new TextStyleModel(textStyle);
+        this.setStyle(textStyle);
+    }
+    /**
+     * Removes the `range` from the document.
+     * If `range` is empty, this function returns the unmodified value of `range.start`.
+     */
+    remove(range) {
+        const partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.wrapParagraphIndex, range);
+        this.document.removeRange(range);
+        CustomComponentHelper.applyRemovingComponents(this.customComponents.tables, partIndexes.startIndex, partIndexes.endIndex);
+        CustomComponentHelper.applyRemovingComponents(this.customComponents.images, partIndexes.startIndex, partIndexes.endIndex);
+        CustomComponentHelper.applyRemovingComponents(this.customComponents.customElements, partIndexes.startIndex, partIndexes.endIndex);
+        CustomComponentHelper.applyRemovingComponents(this.customComponents.tabs, partIndexes.startIndex, partIndexes.endIndex);
+        OperationsHelper.delete(this.model, partIndexes.startIndex, partIndexes.endIndex);
+        this.selection.placeCursor(range.start);
+        this.updateInternalDataOnDeleteText(range.start.row, range.end.row);
+        this.processSelectionStyles();
+    }
+    replace(model) {
+        this.removeByDocumentIndexes(model.delete.startIndex, model.delete.endIndex + 1);
+        let endPoint;
+        if (model.insertText) {
+            endPoint = this.insertTextByDocumentIndex(model.insertText.insertIndex, model.insertText.text);
+        }
+        else if (model.insertParagraph) {
+            endPoint = this.insertParagraphByDocumentIndex(model.insertParagraph);
+        }
+        else if (model.insertElement) {
+            endPoint = this.insertElementByDocumentIndex(model.insertElement);
+        }
+        else if (model.insertBreak) {
+            endPoint = this.insertBreakByDocumentIndex(model.insertBreak);
+        }
+        else if (model.insertTab) {
+            endPoint = this.insertTabByDocumentIndex(model.insertTab);
+        }
+        else if (model.insertImage) {
+            endPoint = this.insertImageByDocumentIndex(model.insertImage);
+        }
+        else if (model.insertTable) {
+            endPoint = this.insertTableByDocumentIndex(model.insertTable);
+        }
+        return endPoint;
+    }
+    insertText(position, text, cursorStyle) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        if (cursorStyle) {
+            OperationsHelper.insertStyledText(this.model, text, insertIndex, cursorStyle);
+        }
+        else {
+            OperationsHelper.insertText(this.model, text, insertIndex);
+        }
+        const endPosition = this.document.insertText(position, text);
+        this.updateInternalDataOnInsertText(position.row, endPosition.row);
+        this.selection.placeCursor(endPosition);
+        return endPosition;
+    }
+    insertElement(position, element) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        const insertElement = new InsertElementModel({ element: new ElementModel({ insertIndex, ...element }) });
+        OperationsHelper.insertElement(this.model, insertElement);
+        const model = this.model.elements.find(x => x.insertIndex === insertIndex);
+        const type = this.customContentService.findComponentType(model.type);
+        this.addComponent(this.customComponents.customElements, model, type);
+        const endPosition = this.document.insertText(position, CUSTOM_ELEMENT_MARKER);
+        this.updateWrapData(position.row, endPosition.row);
+        this.selection.placeCursor(endPosition);
+        return endPosition;
+    }
+    insertBreak(position, breakType) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        const isOnNewParagraph = breakType === BreakTypes.Page &&
+            BreakHelper.getBreakType(this.model, CUSTOM_ELEMENT_MARKER, insertIndex - 1) !== BreakTypes.Page;
+        const text = isOnNewParagraph ? `${NEW_LINE_MARKUP}${CUSTOM_ELEMENT_MARKER}` : CUSTOM_ELEMENT_MARKER;
+        OperationsHelper.insertBreak(this.model, text, insertIndex, breakType);
+        const endPosition = this.document.insertText(position, text);
+        if (isOnNewParagraph) {
+            this.updateInternalDataOnInsertText(position.row, endPosition.row);
+        }
+        else {
+            this.updateWrapData(position.row, endPosition.row);
+        }
+        const cursorPosition = this.document.getPositionAfterBreak(endPosition, breakType);
+        this.selection.placeCursor(cursorPosition);
+        return endPosition;
+    }
+    insertTab(position) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        OperationsHelper.insertTab(this.model, insertIndex);
+        const model = this.model.tabs.find(x => x.insertIndex === insertIndex);
+        this.addComponent(this.customComponents.tabs, model, NoderTabComponent);
+        const endPosition = this.document.insertText(position, CUSTOM_ELEMENT_MARKER);
+        this.updateWrapData(position.row, position.row);
+        this.selection.placeCursor(endPosition);
+        return endPosition;
+    }
+    insertImage(position, imageData) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        const adjustedImage = this.getImageWithAllowedSize(imageData, this.contentWidth);
+        OperationsHelper.insertImage(this.model, insertIndex, adjustedImage);
+        const model = this.model.images.find(x => x.insertIndex === insertIndex);
+        this.addComponent(this.customComponents.images, model, NoderImageComponent);
+        const endPosition = this.document.insertText(position, CUSTOM_ELEMENT_MARKER);
+        this.updateWrapData(position.row, position.row);
+        this.selection.placeCursor(endPosition);
+        return endPosition;
+    }
+    insertLink(position, linkData) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        const linkStyle = new TextStyleModel({ headingStyleId: HYPERLINK_HEADING_STYLE_ID, underline: true });
+        OperationsHelper.insertLink(this.model, linkData.text, linkData.link, insertIndex, linkStyle);
+        const endPosition = this.document.insertText(position, linkData.text);
+        this.updateWrapData(position.row, position.row);
+        this.selection.placeCursor(endPosition);
+        return endPosition;
+    }
+    insertTable(position, tableModel) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        OperationsHelper.insertTable(this.model, insertIndex, tableModel, this.pagesWrap.contentWidth);
+        const model = this.model.tables.find(x => x.insertIndex === tableModel.insertTableIndex);
+        this.addComponent(this.customComponents.tables, model, NoderTableComponent);
+        const endPosition = this.document.insertText(position, tableModel.content);
+        this.updateInternalDataOnInsertText(position.row, endPosition.row);
+        this.selection.placeCursor(endPosition);
+        return endPosition;
+    }
+    insertParagraph(position, paragraphModel) {
+        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+        const text = OperationsHelper.insertParagraph(this.model, insertIndex, paragraphModel, this.pagesWrap.contentWidth);
+        const endPosition = this.document.insertText(position, text);
+        this.updateInternalDataOnInsertText(position.row, endPosition.row);
+        let endPoint;
+        if (paragraphModel.insertText) {
+            const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, paragraphModel.insertText.insertIndex);
+            endPoint = this.document.insertText(paragraphPosition, text);
+            this.updateInternalDataOnInsertText(paragraphPosition.row, endPoint.row);
+            this.selection.placeCursor(endPoint);
+        }
+        else if (paragraphModel.insertImage) {
+            const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, paragraphModel.insertImage.insertIndex);
+            const imageInsertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);
+            const model = this.model.images.find(x => x.insertIndex === imageInsertIndex);
+            this.addComponent(this.customComponents.images, model, NoderImageComponent);
+            endPoint = this.document.insertText(paragraphPosition, CUSTOM_ELEMENT_MARKER);
+            this.updateWrapData(paragraphPosition.row, paragraphPosition.row);
+            this.selection.placeCursor(endPoint);
+        }
+        else if (paragraphModel.insertTable) {
+            const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, paragraphModel.insertTable.insertIndex);
+            const model = this.model.tables.find(x => x.insertIndex === paragraphModel.insertTable.insertTableIndex);
+            this.addComponent(this.customComponents.tables, model, NoderTableComponent);
+            endPoint = this.document.insertText(paragraphPosition, paragraphModel.insertTable.content);
+            this.updateInternalDataOnInsertText(paragraphPosition.row, endPoint.row);
+            this.selection.placeCursor(endPoint);
+        }
+        return endPoint;
+    }
+    addComponent(customElements, model, componentType) {
+        const customElement = this.customContentService.componentService.generateComponent(componentType, {
+            content: model,
+            sessionId: this.sessionId,
+            generalProperties: this.generalProperties,
+            contentWidth: this.contentWidth
+        });
+        const newElementPosition = customElements.findIndex(x => x.instance.insertIndex > model.insertIndex);
+        if (newElementPosition >= 0) {
+            customElements.splice(newElementPosition, 0, customElement);
+        }
+        else {
+            customElements.push(customElement);
+        }
+    }
+    setStyle(style) {
+        for (const key of Object.keys(style)) {
+            this._stylesMap[key] = style[key];
+        }
+        this.signal('setStyles', this._stylesMap);
+    }
+    setStyles(styles) {
+        for (let key of Object.keys(styles)) {
+            if (styles[key].length === 0) {
+                this._stylesMap[key] = ContentStyleHelper.getDefaultStyleValueByKey(key);
+                continue;
+            }
+            else if (styles[key].length > 1 && !styles[key].every(x => x === styles[key][0])) {
+                this._stylesMap[key] = typeof styles[key][0] === 'boolean' && key !== 'isBulletMarker' ? false : null;
+                continue;
+            }
+            this._stylesMap[key] = styles[key][0];
+        }
+        this.signal('setStyles', this._stylesMap);
+    }
+    setNumberingStyle(startIndex, endIndex) {
+        const styles = {
+            alignment: [this._stylesMap.alignment],
+            backgroundColor: [this._stylesMap.backgroundColor],
+            highlightColor: [this._stylesMap.highlightColor],
+            fontColor: [this._stylesMap.fontColor],
+            fontFamily: [this._stylesMap.fontFamily],
+            fontSize: [this._stylesMap.fontSize],
+            italic: [this._stylesMap.italic],
+            bold: [this._stylesMap.bold],
+            strikethrough: [this._stylesMap.strikethrough],
+            underline: [this._stylesMap.underline],
+            spaceBefore: [this._stylesMap.spaceBefore],
+            spaceAfter: [this._stylesMap.spaceAfter],
+            indentLeft: [this._stylesMap.indentLeft],
+            indentRight: [this._stylesMap.indentRight],
+            isBulletMarker: [],
+            numberingLevelsStyles: []
+        };
+        this.updateNumberingStyles(styles, startIndex, endIndex);
+        this.setStyles(styles);
+    }
+    restore(model) {
+        const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, model.startIndex);
+        if (model.startIndex !== model.endIndex) {
+            this.removeByDocumentIndexes(model.startIndex, model.endIndex);
+        }
+        OperationsHelper.restore(this.model, model);
+        const restoreEndIndex = model.startIndex + model.text.length;
+        this.restoreComponents(this.model.tables, this.customComponents.tables, NoderTableComponent, model.startIndex, restoreEndIndex);
+        this.restoreComponents(this.model.images, this.customComponents.images, NoderImageComponent, model.startIndex, restoreEndIndex);
+        this.restoreComponents(this.model.tabs, this.customComponents.tabs, NoderTabComponent, model.startIndex, restoreEndIndex);
+        this.restoreElementComponents(this.model.elements, model.startIndex, restoreEndIndex);
+        const endPoint = this.document.insertText(paragraphPosition, model.text);
+        this.updateInternalDataOnInsertText(paragraphPosition.row, endPoint.row);
+        this.selection.placeCursor(endPoint);
+        this.processSelectionStyles();
+    }
+    restoreComponents(models, components, componentType, restoreIndex, restoreEndIndex) {
+        for (const model of models) {
+            if (model.insertIndex < restoreIndex) {
+                continue;
+            }
+            else if (model.insertIndex >= restoreEndIndex) {
+                break;
+            }
+            this.addComponent(components, model, componentType);
+        }
+    }
+    restoreElementComponents(elements, restoreIndex, restoreEndIndex) {
+        for (const model of elements) {
+            if (model.insertIndex < restoreIndex) {
+                continue;
+            }
+            else if (model.insertIndex >= restoreEndIndex) {
+                break;
+            }
+            const type = this.customContentService.findComponentType(model.type);
+            this.addComponent(this.customComponents.customElements, model, type);
+        }
+    }
+    processSelectionStyles() {
+        const { startIndex, endIndex } = this.getRangeIndexes(this.selection.range);
+        const styles = {
+            alignment: [],
+            backgroundColor: [],
+            highlightColor: [],
+            fontColor: [],
+            fontFamily: [],
+            fontSize: [],
+            italic: [],
+            bold: [],
+            strikethrough: [],
+            underline: [],
+            spaceBefore: [],
+            spaceAfter: [],
+            indentLeft: [],
+            indentRight: [],
+            isBulletMarker: [],
+            numberingLevelsStyles: []
+        };
+        this.updateParagraphStyles(styles, startIndex, endIndex);
+        this.updateNumberingStyles(styles, startIndex, endIndex);
+        const format = this.updateTextStyles(styles, startIndex, endIndex);
+        this.setStyles(styles);
+        if (format) {
+            this.cursorStyle = Object.assign({}, format.textStyle, this.cursorStyle);
+            this.setStyle(this.cursorStyle);
+        }
+        else {
+            this.cursorStyle = null;
+        }
+    }
+    getLinkModel(cursor) {
+        const { startIndex, endIndex } = this.getRangeIndexes(new Range(cursor, cursor));
+        return this.model.links.find(x => x.insertIndex <= startIndex + 1 && x.endIndex > endIndex);
+    }
+    insertTableRows(insertIndex, rowsCount, targetIndex, inheritIndex) {
+        OperationsHelper.insertTableRows(this.model, insertIndex, rowsCount, targetIndex, inheritIndex);
+        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);
+        tableComponent.instance.updateTable();
+    }
+    insertTableColumns(insertIndex, columnsCount, targetIndex, inheritIndex) {
+        OperationsHelper.insertTableColumns(this.model, insertIndex, columnsCount, targetIndex, inheritIndex, this.pagesWrap.contentWidth);
+        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);
+        tableComponent.instance.updateTable();
+    }
+    removeTableRows(insertIndex, startIndex, endIndex) {
+        OperationsHelper.removeTableRows(this.model, insertIndex, startIndex, endIndex);
+        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);
+        tableComponent.instance.updateTable();
+    }
+    removeTableColumns(insertIndex, startIndex, endIndex) {
+        OperationsHelper.removeTableColumns(this.model, insertIndex, startIndex, endIndex, this.pagesWrap.contentWidth);
+        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);
+        tableComponent.instance.updateTable();
+    }
+    resizeTableColumns(resizeTableColumns) {
+        OperationsHelper.resizeTableColumns(this.model, resizeTableColumns);
+        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === resizeTableColumns.insertIndex);
+        tableComponent.instance.updateTable();
+    }
+    restoreTable(insertIndex, table) {
+        const oldTable = JSON.parse(JSON.stringify(table));
+        OperationsHelper.restoreTable(this.model, insertIndex, oldTable);
+        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);
+        tableComponent.instance.updateTable();
+    }
+    updateParagraphTabs(tabIndex, paragraphIndex, length) {
+        const paragraphLastIndex = this.wrapParagraphIndex[paragraphIndex] + length;
+        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.pagesWrap.tabTokens[tabIndex - startIndex].width;
+            this.customComponents.tabs[tabIndex].instance.height = this.pagesWrap.tabTokens[tabIndex - startIndex].font;
+            tabIndex++;
+        }
+        return tabIndex;
+    }
+    getRangeIndexes(range) {
+        let partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.wrapParagraphIndex, range);
+        const prevNewLineSymbol = this.document.isNewLineSymbol(partIndexes.endIndex - 1);
+        if (!prevNewLineSymbol) {
+            if (partIndexes.endIndex > partIndexes.startIndex) {
+                partIndexes.endIndex--;
+            }
+            else if (partIndexes.startIndex === partIndexes.endIndex && partIndexes.startIndex > 0) {
+                partIndexes.startIndex--;
+                partIndexes.endIndex--;
+            }
+        }
+        return partIndexes;
+    }
+    updateInternalDataOnInsertText(startRow, endRow) {
+        const length = endRow - startRow;
+        const newParagraphs = Array(length);
+        const newWrapData = Array(length);
+        for (let i = 0; i < length; i++) {
+            newWrapData[i] = [];
+        }
+        this.wrapData.splice(startRow, 0, ...newWrapData);
+        this.pagesWrap.paragraphs.splice(startRow, 0, ...newParagraphs);
+        if (length) {
+            this.updateNumberingsDataOnChange(endRow);
+        }
+        this.updateWrapData(startRow, endRow);
+    }
+    updateInternalDataOnDeleteText(startRow, endRow) {
+        const length = endRow - startRow;
+        this.wrapData.splice(startRow, length);
+        this.pagesWrap.remove(startRow, length);
+        if (length) {
+            this.updateNumberingsDataOnChange(startRow);
+        }
+        this.updateWrapData(startRow, startRow);
+    }
+    updateNumberingsDataOnChange(index) {
+        for (let i = index; i < this.pagesWrap.paragraphs.length; i++) {
+            if (this.model.paragraphs[i].paragraphStyle.numberingId !== null) {
+                this.pagesWrap.paragraphs[i].numberingData = NumberingHelper.createDataModel(this.generalProperties.numberings, this.model.paragraphs, i);
+                const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[i].insertIndex);
+                NumberingHelper.updateMarkerData(this.generalProperties, this.pagesWrap.paragraphs[i], paragraphFormat.textStyle, this.model.paragraphs[i].paragraphStyle);
+            }
+        }
+    }
+    /**
+     * Computes wrap index based on max row width
+     */
+    computeWrapIndex(displayTokens) {
+        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 = (this.pagesWrap.contentWidth || this.contentWidth) - indent;
+        let sum = 0;
+        for (let i = 0; i < displayTokens.length; i++) {
+            if (displayTokens[i].isTab) {
+                displayTokens[i].width = TabHelper.calculateTabWidth(sum, this.generalProperties.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;
+    }
+    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);
+    }
+    getSplits(model, line, startIndex, paragraphIndex, isNextLineExists) {
+        const strTokens = this.getDisplayTokens(model, line, startIndex);
+        if (!strTokens.length) {
+            const defaultRowInfo = new LineInfoModel({
+                height: (this.stylesMap.fontSize * 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 = line;
+        while (index) {
+            initial = initial.slice(index > 0 ? index : 0);
+            const tokens = strTokens.slice(line.length - initial.length);
+            if (!tokens.length) {
+                tokens.push(...this.getEmptyLineTokens(startIndex + index));
+            }
+            let wrapLimit = this.computeWrapIndex(tokens);
+            if (tokens[tokens.length - 1].isPageBreak && wrapLimit === tokens.length && isNextLineExists) {
+                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 = this.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.pagesWrap.tabTokens.push(...strTokens.filter(x => x.isTab));
+        ParagraphHelper.applyParagraphIndentsToLines(rowInfos, paragraphIndex, model.paragraphs);
+        return { splits, rowInfos };
+    }
+    setDocument() {
+        const pageMargin = this.document.pageMargin;
+        this.pagesWrap = new PagesWrap(this.document.pagesSpace, pageMargin, this.document.pageWidth, this.document.pageHeight, this.customComponents);
+    }
+    getEmptyLineTokens(startIndex) {
+        const storedFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, startIndex);
+        if (!storedFormat) {
+            return [];
+        }
+        const lineInfo = this.getLineInfoByBreakModifier(startIndex);
+        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
+            })
+        ];
+    }
+    getFilledLineTokens(startIndex, line, model) {
+        const lineInfo = this.getLineInfoByBreakModifier(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.customContentService.getOrGenerateComponent(this.model, this.customComponents, this.sessionId, this.generalProperties, this.contentWidth, startIndex, char);
+            const breakType = BreakHelper.getBreakType(model, char, startIndex);
+            if (customComponent && !breakType) {
+                this.customContentService.addToCustomComponents(this.customComponents, customComponent, char, startIndex);
+                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 = this.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;
+    }
+    processCharSizes(prevChar, prevFontString, characters) {
+        const newSize = FontMetrics.measureCharSize(prevChar, prevFontString);
+        for (let item of characters) {
+            Object.assign(item, newSize);
+        }
+    }
+    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);
+    }
+    getLineInfoFromToken(prevToken, firstWrapToken, wrapTokens, isAfterPageBreak) {
+        const info = new LineInfoModel({
+            width: 0,
+            height: 0,
+            align: prevToken.align,
+            indent: new IndentModel(prevToken.indentFirstLine, prevToken.indentHanging, prevToken.indentLeft, prevToken.indentRight),
+            offsetBefore: prevToken.indentBefore,
+            offsetAfter: prevToken.indentAfter,
+            lineSpacing: prevToken.lineSpacing,
+            isAfterPageBreak,
+            isEndedByPageBreak: prevToken.isPageBreak
+        });
+        if (firstWrapToken) {
+            info.align = firstWrapToken.align;
+            info.indent.firstLine = firstWrapToken.indentFirstLine;
+            info.indent.hanging = firstWrapToken.indentHanging;
+            info.indent.left = firstWrapToken.indentLeft;
+            info.indent.right = firstWrapToken.indentRight;
+            info.offsetBefore = firstWrapToken.indentBefore;
+            info.offsetAfter = firstWrapToken.indentAfter;
+            info.lineSpacing = firstWrapToken.lineSpacing;
+            info.hasTable = firstWrapToken.isTable;
+        }
+        let fontSize = 0;
+        let ascent = 0;
+        let descent = 0;
+        const tokens = isAfterPageBreak && !wrapTokens.length ? [prevToken] : wrapTokens;
+        for (const wrapToken of tokens) {
+            if (info.height < wrapToken.height) {
+                info.height = wrapToken.height;
+            }
+            if (fontSize < wrapToken.font && wrapToken.displayValue !== DisplayValue.customContent) {
+                fontSize = wrapToken.font;
+                ascent = wrapToken.ascent;
+                descent = wrapToken.descent;
+            }
+            info.width += wrapToken.width;
+        }
+        info.height = info.height || 18;
+        if (info.lineSpacing > 1) {
+            info.offsetAfter = (ascent + descent) * (info.lineSpacing - 1);
+        }
+        else if (ascent + descent === info.height) {
+            info.height = info.height * info.lineSpacing;
+        }
+        return info;
+    }
+    getDisplayValue(charCode) {
+        if (charCode === 32) {
+            return DisplayValue.space;
+        }
+        if ((charCode > 39 && charCode < 48) || (charCode > 57 && charCode < 64)) {
+            return DisplayValue.punctuation;
+        }
+        return DisplayValue.char;
+    }
+    getLineInfoByBreakModifier(index) {
+        const paragraph = ParagraphStyleHelper.getParagraphAtIndex(this.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(paragraph);
+        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
+        });
+    }
+    getParagraphIndentLeft(paragraph) {
+        let paragraphIndent = paragraph.paragraphStyle.indentLeft;
+        const numberingId = paragraph.paragraphStyle.numberingId;
+        if (numberingId !== null) {
+            const level = paragraph.paragraphStyle.numberingLevel;
+            const paragraphIndex = this.model.paragraphs.indexOf(paragraph);
+            const levelModel = NumberingHelper.find(this.generalProperties.numberings, numberingId, level);
+            const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, paragraph.insertIndex);
+            const markerTextStyle = ContentStyleHelper.combineTextStyles(levelModel.markerStyle, paragraphFormat.textStyle);
+            let markerWidth = this.pagesWrap.paragraphs[paragraphIndex]?.numberingData?.width;
+            if (!this.pagesWrap.paragraphs[paragraphIndex]?.numberingData.markerTextStyle ||
+                !ContentStyleHelper.areSameTextStyles(markerTextStyle, this.pagesWrap.paragraphs[paragraphIndex].numberingData.markerTextStyle) ||
+                this.pagesWrap.paragraphs[paragraphIndex].numberingData.numberingId !== numberingId) {
+                const marker = NumberingHelper.getMarker(levelModel, numberingId, this.model.paragraphs, paragraphIndex);
+                const markerSizes = NumberingHelper.getMarkerSizes(marker, markerTextStyle);
+                markerWidth = markerSizes.width;
+            }
+            const hangingIndent = paragraph.paragraphStyle.indentHanging
+                ? paragraph.paragraphStyle.indentHanging
+                : levelModel.indentHanging;
+            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;
+    }
+    updateTextStyles(styles, startIndex, endIndex) {
+        let textStyles = FormatStyleHelper.getFormatsAtRange(this.model.formats, startIndex, endIndex).map(format => format.textStyle);
+        let prevFormat;
+        if (!textStyles.length) {
+            prevFormat = FormatStyleHelper.getPrevFormatAtIndex(this.model.formats, startIndex);
+            if (prevFormat) {
+                textStyles = [prevFormat.textStyle];
+            }
+        }
+        for (const textStyle of textStyles) {
+            for (const key of Object.keys(textStyle)) {
+                if (styles[key]) {
+                    styles[key].push(textStyle[key]);
+                }
+            }
+        }
+        return prevFormat;
+    }
+    updateParagraphStyles(styles, startIndex, endIndex) {
+        const paragraphStyles = ParagraphStyleHelper.getParagraphsAtRange(this.model.paragraphs, startIndex, endIndex).map(paragraph => paragraph.paragraphStyle);
+        for (const paragraphStyle of paragraphStyles) {
+            for (const key of Object.keys(paragraphStyle)) {
+                if (styles[key]) {
+                    styles[key].push(paragraphStyle[key]);
+                }
+            }
+        }
+    }
+    updateNumberingStyles(styles, startIndex, endIndex) {
+        const paragraphStyles = ParagraphStyleHelper.getParagraphsAtRange(this.model.paragraphs, startIndex, endIndex).map(paragraph => paragraph.paragraphStyle);
+        for (const paragraphStyle of paragraphStyles) {
+            if (paragraphStyle.numberingId !== null) {
+                const numberingLevels = this.generalProperties.numberings.find(x => x.numberingId === paragraphStyle.numberingId).levels;
+                const levelsMarkerStyles = numberingLevels.reduce((prev, next) => `${prev}${next.marker}${next.markerType}`, '');
+                const level = numberingLevels.find(x => x.level === paragraphStyle.numberingLevel);
+                const isBulletMarker = level.markerType === NumberingMarkerType.Bullet;
+                styles['isBulletMarker'].push(isBulletMarker);
+                styles['numberingLevelsStyles'].push(levelsMarkerStyles);
+            }
+            else {
+                styles['isBulletMarker'].push(null);
+                styles['numberingLevelsStyles'].push('');
+            }
+        }
+    }
+    getImageWithAllowedSize(imageData, maxWidth) {
+        if (imageData.width <= maxWidth) {
+            return imageData;
+        }
+        const aspectRatio = imageData.width / imageData.height;
+        const height = maxWidth / aspectRatio;
+        return new ImageDataModel({ width: Math.round(maxWidth), height: Math.round(height), content: imageData.content });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edit.session.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/execution/edit.session.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAI5D,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAEpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAGrF,OAAO,EACH,wBAAwB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,0BAA0B,EAC1B,eAAe,EAClB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAEzE,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,6CAA6C,CAAC;AAE1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGlE,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAMjF,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAGxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAExE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AAEtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAM7C,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,MAAM,OAAO,WAAY,SAAQ,aAAa;IAe1C,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,SAAS,EAAE,SAAS,IAAI,CAAC,CAAC,CAAC,kCAAkC;IAC7E,CAAC;IAED,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAUD,IAAI,YAAY,CAAC,KAAa;QAC1B,IAAI,CAAC,KAAK,EAAE;YACR,OAAO;SACV;QAED,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAKD,YACW,QAAkB,EAClB,SAAiB,EACjB,oBAA0C,EAC1C,KAAwB,EACxB,SAAoB,EACpB,iBAAyC,EAChD,gBAAkC,EAC1B,SAAqB;QAE7B,KAAK,EAAE,CAAC;QATD,aAAQ,GAAR,QAAQ,CAAU;QAClB,cAAS,GAAT,SAAS,CAAQ;QACjB,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,UAAK,GAAL,KAAK,CAAmB;QACxB,cAAS,GAAT,SAAS,CAAW;QACpB,sBAAiB,GAAjB,iBAAiB,CAAwB;QAExC,cAAS,GAAT,SAAS,CAAY;QAnDjC,YAAO,GAAG,IAAI,MAAM,CAAC,IAAI,GAAG,aAAa,CAAC,SAAS,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC;QAErE,eAAU,GAAG,IAAI,MAAM,CAAC,QAAQ,GAAG,aAAa,CAAC,SAAS,GAAG,cAAc,EAAE,GAAG,CAAC,CAAC;QAIlF,aAAQ,GAAe,CAAC,EAAE,CAAC,CAAC,CAAC,iCAAiC;QAE9D,sBAAiB,GAAa,EAAE,CAAC,CAAC,yCAAyC;QAE3E,uBAAkB,GAAa,EAAE,CAAC,CAAC,2CAA2C;QAS7D,eAAU,GAAmB;YAC1C,UAAU,EAAE,mBAAmB;YAC/B,QAAQ,EAAE,iBAAiB;YAC3B,SAAS,EAAE,kBAAkB;YAC7B,SAAS,EAAE,SAAS,CAAC,IAAI;YACzB,eAAe,EAAE,wBAAwB;YACzC,cAAc,EAAE,wBAAwB;SAC3C,CAAC;QA4BE,MAAM,KAAK,GACP,KAAK,YAAY,SAAS;YACtB,CAAC,CAAC,IAAI,KAAK,CACL,gBAAgB,EAChB,KAAK,CAAC,OAAO,EACb,KAAK,CAAC,OAAO,EACb,QAAQ,CAAC,UAAU,EACnB,QAAQ,CAAC,SAAS,EAClB,SAAS,EACT,iBAAiB,CACpB;YACH,CAAC,CAAC,IAAI,CAAC;QACf,IAAI,CAAC,gBAAgB,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QAC/F,IAAI,CAAC,WAAW,EAAE,CAAC;IACvB,CAAC;IAED,OAAO;QACH,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED,YAAY,CAAC,GAAW;QACpB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACrB,OAAO,CAAC,CAAC;SACZ;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IACzC,CAAC;IAED,wBAAwB,CAAC,KAAa;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC;QACzC,IAAI,KAAK,KAAK,CAAC,EAAE;YACb,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACnC,KAAK,EAAE,CAAC;SACX;QACD,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;YAChC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SACvG;QACD,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,uBAAuB,CAAC,KAAa;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC;QACzC,IAAI,KAAK,KAAK,CAAC,EAAE;YACb,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SACrC;aAAM;YACH,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SAC3G;QACD,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;YACpC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SAC/F;QACD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,4BAA4B,CAAC,KAAa;QACtC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,WAAW,KAAK,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,WAAW,EAAE;YACxH,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,aAAa,GAAG,eAAe,CAAC,eAAe,CAC5E,IAAI,CAAC,iBAAiB,CAAC,UAAU,EACjC,IAAI,CAAC,KAAK,CAAC,UAAU,EACrB,KAAK,CACR,CAAC;SACL;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,WAAW,KAAK,IAAI,EAAE;YACrE,MAAM,eAAe,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,WAAW,CAAC,CAAC;YACzH,eAAe,CAAC,gBAAgB,CAC5B,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAChC,eAAe,CAAC,SAAS,EACzB,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,cAAc,CAC9C,CAAC;SACL;IACL,CAAC;IAED,cAAc,CAAC,cAAsB,EAAE,aAAqB;QACxD,IAAI,CAAC,wBAAwB,CAAC,cAAc,CAAC,CAAC;QAC9C,IAAI,8BAA8B,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,cAAc,GAAG,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7H,IAAI,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,IAAI,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC,CAAC;QACjH,KAAK,IAAI,CAAC,GAAG,cAAc,EAAE,CAAC,IAAI,aAAa,EAAE,CAAC,EAAE,EAAE;YAClD,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC;YAC9B,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAClE,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;YAC5D,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,gBAAgB,CAAC,CAAC;YACtH,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;YAC1B,IAAI,8BAA8B,KAAK,CAAC,EAAE;gBACtC,QAAQ,CAAC,CAAC,CAAC,CAAC,gBAAgB,GAAG,IAAI,CAAC;aACvC;YACD,8BAA8B,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/F,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAC1F,IAAI,CAAC,4BAA4B,CAAC,CAAC,CAAC,CAAC;YACrC,IAAI,CAAC,wBAAwB,CAAC,cAAc,CAAC,CAAC;YAC9C,iBAAiB,GAAG,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,EAAE,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;SAC1F;QAED,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,aAAa,GAAG,CAAC,CAAC,EAAE,mBAAmB,CAAC,8BAA8B,GAAG,CAAC,CAAC,CAAC,CAAC;QACvG,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC;QACzC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,uBAAuB,CAAC,cAAc,CAAC,CAAC;QAC7C,IAAI,CAAC,SAAS,CAAC,2BAA2B,CAAC,cAAc,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;IACxF,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,KAAwB,EAAE,GAAW,EAAE,UAAkB;QACtE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;YACb,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;SAC9C;QAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IAC5D,CAAC;IAED,gBAAgB,CAAC,UAAoB,EAAE,KAAa;QAChD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,GAAG,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QAChC,OAAO,KAAK,IAAI,GAAG,EAAE;YACjB,MAAM,GAAG,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YAC/B,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;YAE/B,IAAI,KAAK,GAAG,MAAM,EAAE;gBAChB,KAAK,GAAG,GAAG,GAAG,CAAC,CAAC;aACnB;iBAAM,IAAI,KAAK,GAAG,MAAM,EAAE;gBACvB,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;aACjB;iBAAM;gBACH,OAAO,GAAG,CAAC;aACd;SACJ;QAED,OAAO,KAAK,GAAG,CAAC,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,GAAW,EAAE,eAAwB;QACtD,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,MAAc,CAAC;QACnB,KAAK,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE;YAC5C,YAAY,IAAI,CAAC,CAAC;YAElB,IAAI,YAAY,GAAG,eAAe,EAAE;gBAChC,MAAM;aACT;SACJ;QAED,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,GAAW,EAAE,MAAc;QACpC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC7D,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,MAAM,GAAG,CAAC,EAAE;YACZ,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAC3D;QAED,IAAI,CAAC,OAAO,EAAE;YACV,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACvD;QAED,IAAI,MAAc,CAAC;QACnB,IAAI,OAAO,EAAE;YACT,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;SACzB;aAAM,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE;YACzD,MAAM,GAAG,IAAI,CAAC;SACjB;aAAM;YACH,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;SAC5B;QAED,IAAI,KAAK,GAAG,MAAM,CAAC;QACnB,IAAI,KAAK,GAAG,CAAC,EAAE;YACX,GAAG;gBACC,KAAK,EAAE,CAAC;aACX,QAAQ,KAAK,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YAEzD,KAAK,EAAE,CAAC;SACX;QAED,IAAI,GAAG,GAAG,MAAM,CAAC;QACjB,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YACxD,GAAG,EAAE,CAAC;SACT;QAED,OAAO,IAAI,KAAK,CAAC,IAAI,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,IAAI,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACrF,CAAC;IAED,cAAc,CAAC,GAAW,EAAE,SAAiB,EAAE,WAAoB;QAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAE7D,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,IAAI,CAAC,EAAE,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;IACtE,CAAC;IAED,uBAAuB,CAAC,UAAkB,EAAE,QAAgB;QACxD,MAAM,sBAAsB,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;QAChH,MAAM,oBAAoB,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAC5G,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,CAAC,CAAC;IACzE,CAAC;IAED,yBAAyB,CAAC,KAAa,EAAE,IAAY,EAAE,KAAsB;QACzE,MAAM,iBAAiB,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QACtG,OAAO,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC3D,CAAC;IAED,4BAA4B,CAAC,aAAiC;QAC1D,MAAM,eAAe,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAChI,OAAO,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACtE,CAAC;IAED,0BAA0B,CAAC,aAA+B;QACtD,MAAM,eAAe,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,aAAa,CAAC,SAAuB,CAAC,CAAC;IACpF,CAAC;IAED,wBAAwB,CAAC,aAA6B;QAClD,MAAM,eAAe,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;IAC3C,CAAC;IAED,0BAA0B,CAAC,aAA+B;QACtD,MAAM,eAAe,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACtE,CAAC;IAED,0BAA0B,CAAC,aAA+B;QACtD,MAAM,eAAe,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;IAC5D,CAAC;IAED,8BAA8B,CAAC,aAAmC;QAC9D,MAAM,eAAe,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;IAChE,CAAC;IAED,cAAc,CAAC,UAAkB,EAAE,QAAgB,EAAE,SAAyB;QAC1E,IAAI,CAAC,WAAW,GAAG,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC;QACjD,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,YAAY,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC;QACxG,gBAAgB,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QAC7E,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED,mBAAmB,CAAC,UAAkB,EAAE,QAAgB,EAAE,cAAmC;QACzF,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,YAAY,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC;QACxG,gBAAgB,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QACvF,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;IAClC,CAAC;IAED,iBAAiB,CAAC,KAA6B;QAC3C,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACtD,MAAM,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,KAAK,CAAC,WAAW,CAAC,CAAC;QACvH,iBAAiB,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;QACxC,MAAM,SAAS,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC;QAC9G,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED,YAAY,CAAC,MAA6B,EAAE,UAAkB,EAAE,QAAgB;QAC5E,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,YAAY,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC;QACxG,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC3G,KAAK,IAAI,CAAC,GAAG,cAAc,EAAE,CAAC,IAAI,YAAY,EAAE,CAAC,EAAE,EAAE;YACjD,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,KAAK,IAAI,EAAE;gBACjE,IAAI,CAAC,4BAA4B,CAAC,YAAY,CAAC,CAAC;gBAChD,MAAM;aACT;SACJ;QAED,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAED,gBAAgB,CAAC,UAAkB,EAAE,QAAgB;QACjD,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,YAAY,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC;QACxG,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACvG,KAAK,IAAI,CAAC,GAAG,cAAc,EAAE,CAAC,IAAI,YAAY,EAAE,CAAC,EAAE,EAAE;YACjD,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,KAAK,IAAI,EAAE;gBACjE,IAAI,CAAC,4BAA4B,CAAC,YAAY,CAAC,CAAC;gBAChD,MAAM;aACT;SACJ;QAED,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAED,iBAAiB,CAAC,UAA4B,EAAE,UAA4B;QACxE,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAC7C,MAAM,QAAQ,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC;QAC/D,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,WAAW,GAAG,aAAa,CAAC,kCAAkC,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC7H,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QAC1G,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAChC,IAAI,SAAS,CAAC,cAAc,CAAC,WAAW,KAAK,IAAI,EAAE;gBAC/C,IAAI,CAAC,4BAA4B,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;gBACnD,MAAM;aACT;SACJ;QAED,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAED,eAAe,CAAC,UAAgC;QAC5C,MAAM,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,UAAU,CAAC,WAAW,CAAC,CAAC;QACpH,iBAAiB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;QAC1F,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QACzD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACvE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,iBAAiB,CAAC,OAAsB;QACpC,MAAM,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC;QACtD,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,WAAW,GAAG,aAAa,CAAC,kCAAkC,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC7H,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACxD,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAClC,CAAC;IAED,sBAAsB,CAAC,UAA4B;QAC/C,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAC7C,MAAM,QAAQ,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC;QAC/D,MAAM,cAAc,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC;QAC5G,MAAM,WAAW,GAAG,aAAa,CAAC,kCAAkC,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC7H,gBAAgB,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAClC,CAAC;IAED,YAAY,CAAC,SAAyB;QAClC,IAAI,CAAC,WAAW,GAAG,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAY;QACf,MAAM,WAAW,GAAG,aAAa,CAAC,8BAA8B,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QAEjG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAEjC,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC1H,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC1H,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,CAAC,gBAAgB,CAAC,cAAc,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;QAClI,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;QAExH,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;QAElF,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACxC,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEpE,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAClC,CAAC;IAED,OAAO,CAAC,KAAmB;QACvB,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;QACjF,IAAI,QAAyB,CAAC;QAC9B,IAAI,KAAK,CAAC,UAAU,EAAE;YAClB,QAAQ,GAAG,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SAClG;aAAM,IAAI,KAAK,CAAC,eAAe,EAAE;YAC9B,QAAQ,GAAG,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;SACzE;aAAM,IAAI,KAAK,CAAC,aAAa,EAAE;YAC5B,QAAQ,GAAG,IAAI,CAAC,4BAA4B,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SACrE;aAAM,IAAI,KAAK,CAAC,WAAW,EAAE;YAC1B,QAAQ,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;SACjE;aAAM,IAAI,KAAK,CAAC,SAAS,EAAE;YACxB,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;SAC7D;aAAM,IAAI,KAAK,CAAC,WAAW,EAAE;YAC1B,QAAQ,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;SACjE;aAAM,IAAI,KAAK,CAAC,WAAW,EAAE;YAC1B,QAAQ,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;SACjE;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,UAAU,CAAC,QAAyB,EAAE,IAAY,EAAE,WAA4B;QAC5E,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,IAAI,WAAW,EAAE;YACb,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;SACjF;aAAM;YACH,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;SAC9D;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC7D,IAAI,CAAC,8BAA8B,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACnE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,aAAa,CAAC,QAAyB,EAAE,OAAyB;QAC9D,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,MAAM,aAAa,GAAG,IAAI,kBAAkB,CAAC,EAAE,OAAO,EAAE,IAAI,YAAY,CAAC,EAAE,WAAW,EAAE,GAAG,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;QACzG,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QAE1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QAC3E,MAAM,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACrE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,cAAc,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAErE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QAC9E,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACnD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,QAAyB,EAAE,SAAqB;QACxD,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,MAAM,gBAAgB,GAClB,SAAS,KAAK,UAAU,CAAC,IAAI;YAC7B,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,qBAAqB,EAAE,WAAW,GAAG,CAAC,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC;QACrG,MAAM,IAAI,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,eAAe,GAAG,qBAAqB,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC;QACrG,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QAEvE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC7D,IAAI,gBAAgB,EAAE;YAClB,IAAI,CAAC,8BAA8B,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;SACtE;aAAM;YACH,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;SACtD;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QACnF,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QAE3C,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,SAAS,CAAC,QAAyB;QAC/B,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAEpD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACvE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAExE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QAC9E,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,QAAyB,EAAE,SAAyB;QAC5D,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,MAAM,aAAa,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACjF,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC;QAErE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACzE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC;QAE5E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QAC9E,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAExC,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,UAAU,CAAC,QAAyB,EAAE,QAAuB;QACzD,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,MAAM,SAAS,GAAG,IAAI,cAAc,CAAC,EAAE,cAAc,EAAE,0BAA0B,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACtG,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QAE9F,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,QAAyB,EAAE,UAA4B;QAC/D,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAC/F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,UAAU,CAAC,gBAAgB,CAAC,CAAC;QACzF,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC;QAC5E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;QAC3E,IAAI,CAAC,8BAA8B,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACnE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,eAAe,CAAC,QAAyB,EAAE,cAAoC;QAC3E,MAAM,WAAW,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QACtG,MAAM,IAAI,GAAG,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACpH,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC7D,IAAI,CAAC,8BAA8B,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;QACnE,IAAI,QAAyB,CAAC;QAC9B,IAAI,cAAc,CAAC,UAAU,EAAE;YAC3B,MAAM,iBAAiB,GAAG,aAAa,CAAC,6BAA6B,CACjE,IAAI,CAAC,kBAAkB,EACvB,cAAc,CAAC,UAAU,CAAC,WAAW,CACxC,CAAC;YACF,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;YAC7D,IAAI,CAAC,8BAA8B,CAAC,iBAAiB,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;YACzE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;SACxC;aAAM,IAAI,cAAc,CAAC,WAAW,EAAE;YACnC,MAAM,iBAAiB,GAAG,aAAa,CAAC,6BAA6B,CACjE,IAAI,CAAC,kBAAkB,EACvB,cAAc,CAAC,WAAW,CAAC,WAAW,CACzC,CAAC;YACF,MAAM,gBAAgB,GAAG,aAAa,CAAC,gCAAgC,CAAC,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAC3G,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,gBAAgB,CAAC,CAAC;YAC9E,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC;YAC5E,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,CAAC;YAC9E,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;SACxC;aAAM,IAAI,cAAc,CAAC,WAAW,EAAE;YACnC,MAAM,iBAAiB,GAAG,aAAa,CAAC,6BAA6B,CACjE,IAAI,CAAC,kBAAkB,EACvB,cAAc,CAAC,WAAW,CAAC,WAAW,CACzC,CAAC;YACF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,cAAc,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;YACzG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC;YAC5E,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAC3F,IAAI,CAAC,8BAA8B,CAAC,iBAAiB,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;YACzE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;SACxC;QACD,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,YAAY,CAA+B,cAAiC,EAAE,KAAoB,EAAE,aAAsB;QACtH,MAAM,aAAa,GAAG,IAAI,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,aAAa,EAAE;YAC9F,OAAO,EAAE,KAAK;YACd,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,YAAY,EAAE,IAAI,CAAC,YAAY;SAClC,CAAC,CAAC;QACH,MAAM,kBAAkB,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;QACrG,IAAI,kBAAkB,IAAI,CAAC,EAAE;YACzB,cAAc,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC;SAC/D;aAAM;YACH,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACtC;IACL,CAAC;IAED,QAAQ,CAAC,KAA2C;QAChD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAClC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;SACrC;QAED,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;IAED,SAAS,CAAC,MAAgC;QACtC,KAAK,IAAI,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACjC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC1B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,kBAAkB,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC;gBACzE,SAAS;aACZ;iBAAM,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;gBAChF,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,GAAG,KAAK,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;gBACtG,SAAS;aACZ;YAED,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;SACzC;QAED,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;IAED,iBAAiB,CAAC,UAAkB,EAAE,QAAgB;QAClD,MAAM,MAAM,GAAG;YACX,SAAS,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;YACtC,eAAe,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;YAClD,cAAc,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;YAChD,SAAS,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;YACtC,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACxC,QAAQ,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;YACpC,MAAM,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;YAChC,IAAI,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAC5B,aAAa,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;YAC9C,SAAS,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;YACtC,WAAW,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;YAC1C,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACxC,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACxC,WAAW,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;YAC1C,cAAc,EAAE,EAAE;YAClB,qBAAqB,EAAE,EAAE;SAC5B,CAAC;QACF,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACzD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO,CAAC,KAAmB;QACvB,MAAM,iBAAiB,GAAG,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QACjH,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,QAAQ,EAAE;YACrC,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;SAClE;QAED,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAE5C,MAAM,eAAe,GAAG,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;QAC7D,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;QAChI,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;QAChI,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;QAC1H,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;QAEtF,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,iBAAiB,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACzE,IAAI,CAAC,8BAA8B,CAAC,iBAAiB,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACzE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAClC,CAAC;IAED,iBAAiB,CACb,MAAuB,EACvB,UAA8C,EAC9C,aAAsB,EACtB,YAAoB,EACpB,eAAuB;QAEvB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YACxB,IAAI,KAAK,CAAC,WAAW,GAAG,YAAY,EAAE;gBAClC,SAAS;aACZ;iBAAM,IAAI,KAAK,CAAC,WAAW,IAAI,eAAe,EAAE;gBAC7C,MAAM;aACT;YACD,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;SACvD;IACL,CAAC;IAED,wBAAwB,CAAC,QAAwB,EAAE,YAAoB,EAAE,eAAuB;QAC5F,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE;YAC1B,IAAI,KAAK,CAAC,WAAW,GAAG,YAAY,EAAE;gBAClC,SAAS;aACZ;iBAAM,IAAI,KAAK,CAAC,WAAW,IAAI,eAAe,EAAE;gBAC7C,MAAM;aACT;YACD,MAAM,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACrE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,cAAc,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;SACxE;IACL,CAAC;IAED,sBAAsB;QAClB,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAE5E,MAAM,MAAM,GAAG;YACX,SAAS,EAAE,EAAE;YACb,eAAe,EAAE,EAAE;YACnB,cAAc,EAAE,EAAE;YAClB,SAAS,EAAE,EAAE;YACb,UAAU,EAAE,EAAE;YACd,QAAQ,EAAE,EAAE;YACZ,MAAM,EAAE,EAAE;YACV,IAAI,EAAE,EAAE;YACR,aAAa,EAAE,EAAE;YACjB,SAAS,EAAE,EAAE;YACb,WAAW,EAAE,EAAE;YACf,UAAU,EAAE,EAAE;YACd,UAAU,EAAE,EAAE;YACd,WAAW,EAAE,EAAE;YACf,cAAc,EAAE,EAAE;YAClB,qBAAqB,EAAE,EAAE;SAC5B,CAAC;QACF,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACzD,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACzD,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACnE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAEvB,IAAI,MAAM,EAAE;YACR,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YACzE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;SACnC;aAAM;YACH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;SAC3B;IACL,CAAC;IAED,YAAY,CAAC,MAAuB;QAChC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACjF,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,IAAI,UAAU,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC;IAChG,CAAC;IAED,eAAe,CAAC,WAAmB,EAAE,SAAiB,EAAE,WAAmB,EAAE,YAAoB;QAC7F,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;QAChG,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACtG,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAED,kBAAkB,CAAC,WAAmB,EAAE,YAAoB,EAAE,WAAmB,EAAE,YAAoB;QACnG,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACnI,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACtG,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAED,eAAe,CAAC,WAAmB,EAAE,UAAkB,EAAE,QAAgB;QACrE,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QAChF,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACtG,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAED,kBAAkB,CAAC,WAAmB,EAAE,UAAkB,EAAE,QAAgB;QACxE,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAChH,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACtG,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAED,kBAAkB,CAAC,kBAA2C;QAC1D,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;QACpE,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,kBAAkB,CAAC,WAAW,CAAC,CAAC;QACzH,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAED,YAAY,CAAC,WAAmB,EAAE,KAAiB;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAe,CAAC;QACjE,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;QACjE,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;QACtG,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAEO,mBAAmB,CAAC,QAAgB,EAAE,cAAsB,EAAE,MAAc;QAChF,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,GAAG,MAAM,CAAC;QAC5E,IACI,QAAQ,KAAK,CAAC,CAAC;YACf,QAAQ,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM;YAC7C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,WAAW,GAAG,kBAAkB,EAChF;YACE,OAAO,QAAQ,CAAC;SACnB;QAED,MAAM,UAAU,GAAG,QAAQ,CAAC;QAC5B,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,WAAW,IAAI,kBAAkB,EAAE;YAC5H,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,KAAK,CAAC;YAC5G,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,IAAI,CAAC;YAC5G,QAAQ,EAAE,CAAC;SACd;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEO,eAAe,CAAC,KAAY;QAChC,IAAI,WAAW,GAAG,aAAa,CAAC,8BAA8B,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QAC/F,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;QAClF,IAAI,CAAC,iBAAiB,EAAE;YACpB,IAAI,WAAW,CAAC,QAAQ,GAAG,WAAW,CAAC,UAAU,EAAE;gBAC/C,WAAW,CAAC,QAAQ,EAAE,CAAC;aAC1B;iBAAM,IAAI,WAAW,CAAC,UAAU,KAAK,WAAW,CAAC,QAAQ,IAAI,WAAW,CAAC,UAAU,GAAG,CAAC,EAAE;gBACtF,WAAW,CAAC,UAAU,EAAE,CAAC;gBACzB,WAAW,CAAC,QAAQ,EAAE,CAAC;aAC1B;SACJ;QAED,OAAO,WAAW,CAAC;IACvB,CAAC;IAEO,8BAA8B,CAAC,QAAgB,EAAE,MAAc;QACnE,MAAM,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;QACjC,MAAM,aAAa,GAAgB,KAAK,CAAC,MAAM,CAAC,CAAC;QACjD,MAAM,WAAW,GAAe,KAAK,CAAC,MAAM,CAAC,CAAC;QAC9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;YAC7B,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;SACvB;QAED,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC;QAClD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,GAAG,aAAa,CAAC,CAAC;QAChE,IAAI,MAAM,EAAE;YACR,IAAI,CAAC,4BAA4B,CAAC,MAAM,CAAC,CAAC;SAC7C;QAED,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAEO,8BAA8B,CAAC,QAAgB,EAAE,MAAc;QACnE,MAAM,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;QAEjC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACxC,IAAI,MAAM,EAAE;YACR,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC;SAC/C;QAED,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAEO,4BAA4B,CAAC,KAAa;QAC9C,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC3D,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,WAAW,KAAK,IAAI,EAAE;gBAC9D,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,eAAe,CAAC,eAAe,CACxE,IAAI,CAAC,iBAAiB,CAAC,UAAU,EACjC,IAAI,CAAC,KAAK,CAAC,UAAU,EACrB,CAAC,CACJ,CAAC;gBACF,MAAM,eAAe,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;gBACrH,eAAe,CAAC,gBAAgB,CAC5B,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,EAC5B,eAAe,CAAC,SAAS,EACzB,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,cAAc,CAC1C,CAAC;aACL;SACJ;IACL,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,aAA6B;QAClD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE;YACnB,OAAO,CAAC,CAAC;SACZ;QAED,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,UAAU,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;YACzF,OAAO,CAAC,CAAC;SACZ;QAED,MAAM,MAAM,GACR,aAAa,CAAC,CAAC,CAAC,CAAC,UAAU;YACvB,aAAa,CAAC,CAAC,CAAC,CAAC,WAAW;YAC5B,aAAa,CAAC,CAAC,CAAC,CAAC,eAAe;YAChC,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC;QAC5C,MAAM,WAAW,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC;QAChF,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC3C,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE;gBACxB,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,SAAS,CAAC,iBAAiB,CAAC,GAAG,EAAE,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC;aACrG;YAED,GAAG,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YAC9B,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,WAAW,IAAI,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE;gBAChG,OAAO,CAAC,CAAC;aACZ;YAED,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,KAAK,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE;gBAClG,OAAO,CAAC,GAAG,CAAC,CAAC;aAChB;SACJ;QAED,OAAO,CAAC,CAAC;IACb,CAAC;IAEO,gBAAgB,CAAC,MAAsB,EAAE,SAAiB;QAC9D,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,IAAI,SAAS,EAAE;YAC9C,OAAO,IAAI,CAAC;SACf;QAED,iEAAiE;QACjE,qBAAqB;QACrB,IACI,SAAS,KAAK,CAAC;YACf,MAAM,CAAC,SAAS,CAAC,CAAC,YAAY,KAAK,YAAY,CAAC,aAAa;YAC7D,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EACpF;YACE,OAAO,SAAS,CAAC;SACpB;QAED,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IAEO,SAAS,CACb,KAAwB,EACxB,IAAY,EACZ,UAAkB,EAClB,cAAsB,EACtB,gBAAyB;QAEzB,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;QACjE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YACnB,MAAM,cAAc,GAAG,IAAI,aAAa,CAAC;gBACrC,MAAM,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC;gBACzC,KAAK,EAAE,CAAC;gBACR,KAAK,EAAE,uBAAuB,CAAC,SAAS;gBACxC,MAAM,EAAE,IAAI,WAAW,CACnB,uBAAuB,CAAC,eAAe,EACvC,uBAAuB,CAAC,aAAa,EACrC,uBAAuB,CAAC,UAAU,EAClC,uBAAuB,CAAC,WAAW,CACtC;gBACD,WAAW,EAAE,uBAAuB,CAAC,UAAU;gBAC/C,YAAY,EAAE,uBAAuB,CAAC,WAAW;gBACjD,WAAW,EAAE,uBAAuB,CAAC,WAAW;gBAChD,gBAAgB,EAAE,KAAK;gBACvB,kBAAkB,EAAE,KAAK;gBACzB,eAAe,EAAE,uBAAuB,CAAC,eAAe;aAC3D,CAAC,CAAC;YAEH,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC;SACrD;QAED,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAoB,EAAE,CAAC;QAErC,IAAI,SAAuB,CAAC;QAC5B,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC;QACf,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,OAAO,KAAK,EAAE;YACV,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/C,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;YAC7D,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;gBAChB,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC;aAC/D;YAED,IAAI,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,WAAW,IAAI,SAAS,KAAK,MAAM,CAAC,MAAM,IAAI,gBAAgB,EAAE;gBAC1F,SAAS,GAAG,CAAC,CAAC;aACjB;YACD,MAAM,SAAS,GACX,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,UAAU,IAAI,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAC/H,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,IAAI,SAAS,CAAC,CAAC;YAE3D,IAAI,UAAU,CAAC,MAAM,EAAE;gBACnB,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;aACjD;YAED,MAAM,gBAAgB,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,kBAAkB,CAAC;YACrG,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;YACnG,QAAQ,CAAC,eAAe,GAAG,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,cAAc,CAAC,eAAe,CAAC;YAC3F,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAExB,IAAI,CAAC,SAAS,EAAE;gBACZ,MAAM;aACT;YAED,KAAK,GAAG,SAAS,CAAC;YAClB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;YACnC,MAAM,UAAU,GAAG,YAAY,CAAC,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YAC3E,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC3B;QAED,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QAEjE,eAAe,CAAC,4BAA4B,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QACzF,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IAChC,CAAC;IAEO,WAAW;QACf,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;QAE5C,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,CAC1B,IAAI,CAAC,QAAQ,CAAC,UAAU,EACxB,UAAU,EACV,IAAI,CAAC,QAAQ,CAAC,SAAS,EACvB,IAAI,CAAC,QAAQ,CAAC,UAAU,EACxB,IAAI,CAAC,gBAAgB,CACxB,CAAC;IACN,CAAC;IAEO,kBAAkB,CAAC,UAAkB;QACzC,MAAM,YAAY,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QACxF,IAAI,CAAC,YAAY,EAAE;YACf,OAAO,EAAE,CAAC;SACb;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;QAC7D,MAAM,IAAI,GAAG,WAAW,CAAC,eAAe,CAAC,YAAY,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;QACvH,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QACf,OAAO;YACH,IAAI,YAAY,CAAC;gBACb,GAAG,IAAI;gBACP,YAAY,EAAE,YAAY,CAAC,SAAS;gBACpC,KAAK,EAAE,QAAQ,CAAC,KAAK;gBACrB,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS;gBAC1C,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO;gBACtC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI;gBAChC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK;gBAClC,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,WAAW,EAAE,QAAQ,CAAC,WAAW;gBACjC,WAAW,EAAE,KAAK;gBAClB,WAAW,EAAE,KAAK;gBAClB,KAAK,EAAE,KAAK;gBACZ,WAAW,EAAE,QAAQ,CAAC,WAAW;aACpC,CAAC;SACL,CAAC;IACN,CAAC;IAEO,mBAAmB,CAAC,UAAkB,EAAE,IAAY,EAAE,KAAwB;QAClF,MAAM,QAAQ,GAAG,IAAI,CAAC,0BAA0B,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAmB,EAAE,CAAC;QAClC,IAAI,UAAU,GAAmB,EAAE,CAAC;QACpC,IAAI,MAAM,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAC3E,IAAI,UAAU,GAAgB,IAAI,CAAC;QACnC,IAAI,YAAY,GAAW,IAAI,CAAC;QAChC,IAAI,cAAc,GAAW,IAAI,CAAC;QAClC,IAAI,QAAQ,GAAW,IAAI,CAAC;QAC5B,IAAI,UAAU,GAAG,kBAAkB,CAAC,mBAAmB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC3E,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAClC,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,GAAG,WAAW,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAC3D,MAAM,eAAe,GAAG,IAAI,CAAC,oBAAoB,CAAC,sBAAsB,CACpE,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,gBAAgB,EACrB,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,YAAY,EACjB,UAAU,EACV,IAAI,CACP,CAAC;YACF,MAAM,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;YAEpE,IAAI,eAAe,IAAI,CAAC,SAAS,EAAE;gBAC/B,IAAI,CAAC,oBAAoB,CAAC,qBAAqB,CAAC,IAAI,CAAC,gBAAgB,EAAE,eAAe,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;gBAC1G,MAAM,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,qBAAqB,CACzD,eAAe,EACf,QAAQ,EACR,YAAY,CAAC,aAAa,EAC1B,CAAC,KAAK,CAAC,EACP,IAAI,CACP,CAAC;gBACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAEnB,YAAY,GAAG,CAAC,CAAC,CAAC;gBAClB,QAAQ,GAAG,EAAE,CAAC;gBACd,UAAU,GAAG,EAAE,CAAC;aACnB;iBAAM;gBACH,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;gBACpC,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBACpD,MAAM,gBAAgB,GAAG,CAAC,KAAK,CAAC,CAAC;gBACjC,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC;oBAC3B,GAAG,IAAI;oBACP,YAAY;oBACZ,KAAK,EAAE,QAAQ,CAAC,KAAK;oBACrB,eAAe,EAAE,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,uBAAuB,CAAC,eAAe;oBACvG,aAAa,EAAE,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,uBAAuB,CAAC,aAAa;oBACjG,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI;oBAChC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK;oBAClC,YAAY,EAAE,QAAQ,CAAC,YAAY;oBACnC,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,WAAW,EAAE,SAAS,KAAK,UAAU,CAAC,IAAI;oBAC1C,WAAW,EAAE,SAAS,KAAK,UAAU,CAAC,YAAY;oBAClD,KAAK,EAAE,KAAK;iBACf,CAAC,CAAC;gBAEH,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAEnB,IACI,QAAQ,KAAK,YAAY;oBACzB,CAAC,UAAU;oBACX,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,EACjF;oBACE,YAAY,GAAG,IAAI,CAAC;iBACvB;qBAAM,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC9B,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACvB,YAAY,GAAG,IAAI,CAAC;iBACvB;qBAAM;oBACH,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;iBAC1B;gBAED,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,EAAE;oBACvC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;oBAC5D,UAAU,GAAG,CAAC,KAAK,CAAC,CAAC;oBACrB,YAAY,GAAG,KAAK,CAAC;iBACxB;qBAAM,IAAI,YAAY,EAAE;oBACrB,UAAU,GAAG,CAAC,KAAK,CAAC,CAAC;iBACxB;gBAED,YAAY,GAAG,QAAQ,CAAC;gBACxB,QAAQ,GAAG,IAAI,CAAC;aACnB;YAED,UAAU,GAAG,MAAM,CAAC;YACpB,cAAc,GAAG,UAAU,CAAC;YAC5B,UAAU,EAAE,CAAC;YAEb,IAAI,UAAU,GAAG,MAAM,EAAE,QAAQ,EAAE;gBAC/B,MAAM,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;gBACvE,UAAU,GAAG,kBAAkB,CAAC,mBAAmB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;aAC1E;SACJ;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,gBAAgB,CAAC,QAAgB,EAAE,cAAsB,EAAE,UAA0B;QACzF,MAAM,OAAO,GAAG,WAAW,CAAC,eAAe,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;QACtE,KAAK,IAAI,IAAI,IAAI,UAAU,EAAE;YACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;SAChC;IACL,CAAC;IAEO,cAAc,CAAC,KAAa,EAAE,MAAsB;QACxD,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAC7B,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,KAAK,YAAY,CAAC,aAAa,EAAE;gBACvF,OAAO,CAAC,GAAG,CAAC,CAAC;aAChB;SACJ;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAEO,YAAY,CAAC,KAAmB;QACpC,OAAO,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACrF,CAAC;IAEO,oBAAoB,CACxB,SAAuB,EACvB,cAA4B,EAC5B,UAA0B,EAC1B,gBAAyB;QAEzB,MAAM,IAAI,GAAG,IAAI,aAAa,CAAC;YAC3B,KAAK,EAAE,CAAC;YACR,MAAM,EAAE,CAAC;YACT,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,MAAM,EAAE,IAAI,WAAW,CAAC,SAAS,CAAC,eAAe,EAAE,SAAS,CAAC,aAAa,EAAE,SAAS,CAAC,UAAU,EAAE,SAAS,CAAC,WAAW,CAAC;YACxH,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,WAAW,EAAE,SAAS,CAAC,WAAW;YAClC,WAAW,EAAE,SAAS,CAAC,WAAW;YAClC,gBAAgB;YAChB,kBAAkB,EAAE,SAAS,CAAC,WAAW;SAC5C,CAAC,CAAC;QAEH,IAAI,cAAc,EAAE;YAChB,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,cAAc,CAAC,eAAe,CAAC;YACvD,IAAI,CAAC,MAAM,CAAC,OAAO,GAAG,cAAc,CAAC,aAAa,CAAC;YACnD,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,cAAc,CAAC,UAAU,CAAC;YAC7C,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,cAAc,CAAC,WAAW,CAAC;YAC/C,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC;YAChD,IAAI,CAAC,WAAW,GAAG,cAAc,CAAC,WAAW,CAAC;YAC9C,IAAI,CAAC,WAAW,GAAG,cAAc,CAAC,WAAW,CAAC;YAC9C,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC;SAC1C;QAED,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,MAAM,MAAM,GAAG,gBAAgB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QACjF,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE;YAC5B,IAAI,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE;gBAChC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;aAClC;YAED,IAAI,QAAQ,GAAG,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC,YAAY,KAAK,YAAY,CAAC,aAAa,EAAE;gBACpF,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC;gBAC1B,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;gBAC1B,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;aAC/B;YAED,IAAI,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC;SACjC;QAED,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;QAChC,IAAI,IAAI,CAAC,WAAW,GAAG,CAAC,EAAE;YACtB,IAAI,CAAC,WAAW,GAAG,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;SAClE;aAAM,IAAI,MAAM,GAAG,OAAO,KAAK,IAAI,CAAC,MAAM,EAAE;YACzC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC;SAChD;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,eAAe,CAAC,QAAgB;QACpC,IAAI,QAAQ,KAAK,EAAE,EAAE;YACjB,OAAO,YAAY,CAAC,KAAK,CAAC;SAC7B;QAED,IAAI,CAAC,QAAQ,GAAG,EAAE,IAAI,QAAQ,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,GAAG,EAAE,IAAI,QAAQ,GAAG,EAAE,CAAC,EAAE;YACtE,OAAO,YAAY,CAAC,WAAW,CAAC;SACnC;QAED,OAAO,YAAY,CAAC,IAAI,CAAC;IAC7B,CAAC;IAEO,0BAA0B,CAAC,KAAa;QAC5C,MAAM,SAAS,GAAG,oBAAoB,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QACzF,IAAI,CAAC,SAAS,EAAE;YACZ,OAAO,IAAI,aAAa,CAAC;gBACrB,KAAK,EAAE,uBAAuB,CAAC,SAAS;gBACxC,MAAM,EAAE,IAAI,WAAW,CACnB,uBAAuB,CAAC,eAAe,EACvC,uBAAuB,CAAC,aAAa,EACrC,uBAAuB,CAAC,UAAU,EAClC,uBAAuB,CAAC,WAAW,CACtC;gBACD,YAAY,EAAE,uBAAuB,CAAC,WAAW;gBACjD,WAAW,EAAE,uBAAuB,CAAC,UAAU;gBAC/C,WAAW,EAAE,uBAAuB,CAAC,WAAW;aACnD,CAAC,CAAC;SACN;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;QAC1D,MAAM,aAAa,GAAG,SAAS,CAAC,cAAc,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QAEjH,OAAO,IAAI,aAAa,CAAC;YACrB,KAAK,EAAE,SAAS,CAAC,cAAc,CAAC,SAAS,IAAI,uBAAuB,CAAC,SAAS;YAC9E,MAAM,EAAE,IAAI,WAAW,CACnB,SAAS,CAAC,cAAc,CAAC,eAAe,IAAI,uBAAuB,CAAC,eAAe,EACnF,aAAa,IAAI,uBAAuB,CAAC,aAAa,EACtD,UAAU,IAAI,uBAAuB,CAAC,UAAU,EAChD,SAAS,CAAC,cAAc,CAAC,WAAW,IAAI,uBAAuB,CAAC,WAAW,CAC9E;YACD,YAAY,EAAE,uBAAuB,CAAC,WAAW;YACjD,WAAW,EAAE,uBAAuB,CAAC,UAAU;YAC/C,WAAW,EAAE,SAAS,CAAC,cAAc,CAAC,WAAW,IAAI,uBAAuB,CAAC,WAAW;SAC3F,CAAC,CAAC;IACP,CAAC;IAEO,sBAAsB,CAAC,SAAyB;QACpD,IAAI,eAAe,GAAG,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC;QAC1D,MAAM,WAAW,GAAG,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC;QACzD,IAAI,WAAW,KAAK,IAAI,EAAE;YACtB,MAAM,KAAK,GAAG,SAAS,CAAC,cAAc,CAAC,cAAc,CAAC;YACtD,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAChE,MAAM,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;YAC/F,MAAM,eAAe,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;YACtG,MAAM,eAAe,GAAG,kBAAkB,CAAC,iBAAiB,CAAC,UAAU,CAAC,WAAW,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;YAChH,IAAI,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC;YAClF,IACI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,eAAe;gBACzE,CAAC,kBAAkB,CAAC,iBAAiB,CACjC,eAAe,EACf,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,aAAa,CAAC,eAAe,CAC1E;gBACD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,aAAa,CAAC,WAAW,KAAK,WAAW,EACrF;gBACE,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,CAAC,UAAU,EAAE,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;gBACzG,MAAM,WAAW,GAAG,eAAe,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;gBAC5E,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC;aACnC;YAED,MAAM,aAAa,GAAG,SAAS,CAAC,cAAc,CAAC,aAAa;gBACxD,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,aAAa;gBACxC,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC;YAC/B,eAAe,GAAG,UAAU,CAAC,UAAU,CAAC;YACxC,IAAI,WAAW,IAAI,aAAa,EAAE;gBAC9B,MAAM,cAAc,GAAG,WAAW,GAAG,aAAa,CAAC;gBACnD,MAAM,sBAAsB,GAAG,SAAS,CAAC,iBAAiB,CACtD,UAAU,CAAC,UAAU,GAAG,cAAc,EACtC,IAAI,CAAC,iBAAiB,CAAC,eAAe,CACzC,CAAC;gBACF,eAAe,IAAI,cAAc,GAAG,sBAAsB,CAAC;aAC9D;SACJ;QAED,OAAO,eAAe,CAAC;IAC3B,CAAC;IAEO,gBAAgB,CAAC,MAAgC,EAAE,UAAkB,EAAE,QAAgB;QAC3F,IAAI,UAAU,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC/H,IAAI,UAAuB,CAAC;QAC5B,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;YACpB,UAAU,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YAEpF,IAAI,UAAU,EAAE;gBACZ,UAAU,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;aACvC;SACJ;QAED,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAChC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;gBACtC,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE;oBACb,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;iBACpC;aACJ;SACJ;QAED,OAAO,UAAU,CAAC;IACtB,CAAC;IAEO,qBAAqB,CAAC,MAAgC,EAAE,UAAkB,EAAE,QAAgB;QAChG,MAAM,eAAe,GAAG,oBAAoB,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,GAAG,CAC9G,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,cAAc,CACxC,CAAC;QACF,KAAK,MAAM,cAAc,IAAI,eAAe,EAAE;YAC1C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE;gBAC3C,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE;oBACb,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;iBACzC;aACJ;SACJ;IACL,CAAC;IAEO,qBAAqB,CAAC,MAAgC,EAAE,UAAkB,EAAE,QAAgB;QAChG,MAAM,eAAe,GAAG,oBAAoB,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,GAAG,CAC9G,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,cAAc,CACxC,CAAC;QACF,KAAK,MAAM,cAAc,IAAI,eAAe,EAAE;YAC1C,IAAI,cAAc,CAAC,WAAW,KAAK,IAAI,EAAE;gBACrC,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,cAAc,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC;gBACzH,MAAM,kBAAkB,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;gBACjH,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,cAAc,CAAC,cAAc,CAAC,CAAC;gBACnF,MAAM,cAAc,GAAG,KAAK,CAAC,UAAU,KAAK,mBAAmB,CAAC,MAAM,CAAC;gBACvE,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBAC9C,MAAM,CAAC,uBAAuB,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;aAC5D;iBAAM;gBACH,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACpC,MAAM,CAAC,uBAAuB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aAC5C;SACJ;IACL,CAAC;IAEO,uBAAuB,CAAC,SAAyB,EAAE,QAAgB;QACvE,IAAI,SAAS,CAAC,KAAK,IAAI,QAAQ,EAAE;YAC7B,OAAO,SAAS,CAAC;SACpB;QAED,MAAM,WAAW,GAAG,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC;QACvD,MAAM,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;QACtC,OAAO,IAAI,cAAc,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;IACvH,CAAC;CACJ","sourcesContent":["import { ComponentRef, Type } from '@angular/core';\n\nimport { Alignment } from '../positioning/alignments.const';\nimport { ApplyElementStyleModel } from '../../models/generated/apply-element-style.model';\nimport { ApplyImageStyleModel } from '../../models/generated/apply-image-style.model';\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 { ComponentService } from '../components/shared/services/component.service';\nimport { ContentHelper } from '../positioning/content.helper';\nimport { ContentsInterface } from '../content/contents.interface';\nimport { ContentStyleHelper } from '../content/helpers/content-style.helper';\nimport { CursorParagraph } from '../positioning/cursor-paragraph';\nimport { CUSTOM_ELEMENT_MARKER } from '../components/shared/custom-content-markers.const';\nimport { CustomComponentHelper } from '../components/shared/custom-component.hepler';\nimport { CustomContent } from '../components/shared/custom-content';\nimport { CustomContentService } from '../components/shared/services/custom-content.service';\nimport {\n    DEFAULT_BACKGROUND_COLOR,\n    DEFAULT_FONT_COLOR,\n    DEFAULT_FONT_FAMILY,\n    DEFAULT_FONT_SIZE,\n    DEFAULT_PARAGRAPH_STYLE,\n    HYPERLINK_HEADING_STYLE_ID,\n    NEW_LINE_MARKUP\n} from '../content/constants/editor.const';\nimport { DisplayToken } from '../content/display-data/display-token.model';\nimport { DisplayValue } from '../content/constants/display-values.const';\nimport { Document } from '../content/display-data/document';\nimport { DocxModel } from '../../models/generated/docx.model';\nimport { Edges } from '../components/edges/edges';\nimport { ElementDataModel } from '../components/external-element/models/element-data.model';\nimport { ElementModel } from '../../models/generated/element.model';\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 './helpers/format-style.helper';\nimport { GeneralPropertiesModel } from '../content/display-data/general-properties.model';\nimport { ICustomComponents } from '../components/shared/custom-components.interface';\nimport { ImageDataModel } from '../../models/generated/image-data.model';\nimport { IndentModel } from '../content/display-data/indent.model';\nimport { InsertBreakModel } from '../../models/generated/insert-break.model';\nimport { InsertElementModel } from '../../models/generated/insert-element.model';\nimport { InsertImageModel } from '../../models/generated/insert-image.model';\nimport { InsertParagraphModel } from '../../models/generated/insert-paragraph.model';\nimport { InsertTableModel } from '../../models/generated/insert-table.model';\nimport { InsertTabModel } from '../../models/generated/insert-tab.model';\nimport { IToolbarStyles } from '../content/display-data/toolbar-styles.interface';\nimport { LineInfoModel } from '../content/display-data/line-info.model';\nimport { LinkDataModel } from '../../models/generated/link-data.model';\nimport { LinkModel } from '../../models/generated/link.model';\nimport { NoderImageComponent } from '../components/image/components/image.component';\nimport { NoderTabComponent } from '../components/tab/tab.component';\nimport { NoderTableComponent } from '../components/table/components/table.component';\nimport { NumberingHelper } from '../gadgets/numbering/numbering.helper';\nimport { NumberingLevelModel } from '../../models/generated/numbering-level.model';\nimport { NumberingMarkerType } from '../gadgets/numbering/numbering-marker-type.enum';\nimport { NumberingModel } from '../../models/generated/numbering.model';\nimport { OperationsHelper } from '../operations/operations-helper.helper';\nimport { PagesWrap } from '../content/display-data/pages.wrap';\nimport { Paragraph } from '../content/display-data/paragraph';\nimport { ParagraphHelper } from './helpers/paragraph.helper';\nimport { ParagraphModel } from '../../models/generated/paragraph.model';\nimport { ParagraphStyleHelper } from './helpers/paragraph-style.helper';\nimport { ParagraphStyleModel } from '../../models/generated/paragraph-style.model';\nimport { Range } from '../positioning/range';\nimport { ReplaceModel } from '../../models/generated/replace.model';\nimport { ResizeTableColumnsModel } from '../../models/generated/resize-table-columns.model';\nimport { RestoreModel } from '../../models/generated/restore.model';\nimport { ScrollBar } from '../gadgets/scrollbar';\nimport { Selection } from '../positioning/selection';\nimport { TabHelper } from '../components/tab/tab.helper';\nimport { TableModel } from '../../models/generated/table.model';\nimport { TextStyleModel } from '../../models/generated/text-style.model';\nimport { UnicodeHelper } from '../gadgets/unicode/unicode.helper';\n\nexport class EditSession extends EventEmitting {\n    readonly customComponents: ICustomComponents;\n\n    tokenRe = new RegExp('^[' + UnicodeHelper.wordChars + '\\\\$_]+', 'g');\n\n    nonTokenRe = new RegExp('^(?:[^' + UnicodeHelper.wordChars + '\\\\$_]|\\\\s])+', 'g');\n\n    pagesWrap: PagesWrap;\n\n    wrapData: number[][] = [[]]; // Wrap indexes for document rows\n\n    wrapParagraphLine: number[] = []; // line numbers that begin the paragraphs\n\n    wrapParagraphIndex: number[] = []; // symbol indexes that begin the paragraphs\n\n    get scrollTop() {\n        return this.scrollBar?.scrollTop ?? 0; // only main session is scrollable\n    }\n\n    get stylesMap(): IToolbarStyles {\n        return this._stylesMap;\n    }\n    private readonly _stylesMap: IToolbarStyles = {\n        fontFamily: DEFAULT_FONT_FAMILY,\n        fontSize: DEFAULT_FONT_SIZE,\n        fontColor: DEFAULT_FONT_COLOR,\n        alignment: Alignment.left,\n        backgroundColor: DEFAULT_BACKGROUND_COLOR,\n        highlightColor: DEFAULT_BACKGROUND_COLOR\n    };\n\n    set contentWidth(value: number) {\n        if (!value) {\n            return;\n        }\n\n        this._contentWidth = value;\n        this.updateWrapData(0, this.document.lines.length - 1);\n    }\n    get contentWidth(): number {\n        return this._contentWidth;\n    }\n    private _contentWidth: number;\n\n    cursorStyle: TextStyleModel;\n\n    constructor(\n        public document: Document,\n        public sessionId: number,\n        public customContentService: CustomContentService,\n        public model: ContentsInterface,\n        public selection: Selection,\n        public generalProperties: GeneralPropertiesModel,\n        componentService: ComponentService,\n        private scrollBar?: ScrollBar\n    ) {\n        super();\n        const edges =\n            model instanceof DocxModel\n                ? new Edges(\n                      componentService,\n                      model.headers,\n                      model.footers,\n                      document.pageMargin,\n                      document.pageWidth,\n                      sessionId,\n                      generalProperties\n                  )\n                : null;\n        this.customComponents = { images: [], tables: [], tabs: [], customElements: [], edges: edges };\n        this.setDocument();\n    }\n\n    destroy(): void {\n        this.pagesWrap.destroy();\n    }\n\n    getRowLength(row: number): number {\n        if (!this.wrapData[row]) {\n            return 1;\n        }\n\n        return this.wrapData[row].length + 1;\n    }\n\n    updateWrapParagraphIndex(first: number): void {\n        const count = this.document.lines.length;\n        if (first === 0) {\n            this.wrapParagraphIndex[first] = 0;\n            first++;\n        }\n        for (let i = first; i < count; i++) {\n            this.wrapParagraphIndex[i] = this.wrapParagraphIndex[i - 1] + this.document.lines[i - 1].length + 1;\n        }\n        this.wrapParagraphIndex.splice(count);\n    }\n\n    updateWrapParagraphLine(first: number): void {\n        const count = this.document.lines.length;\n        if (first === 0) {\n            this.wrapParagraphLine[first] = 0;\n        } else {\n            this.wrapParagraphLine[first] = this.wrapParagraphLine[first - 1] + this.wrapData[first - 1].length + 1;\n        }\n        for (let i = first + 1; i < count; i++) {\n            this.wrapParagraphLine[i] = this.wrapParagraphLine[i - 1] + this.wrapData[i - 1].length + 1;\n        }\n        this.wrapParagraphLine.splice(count);\n    }\n\n    updateParagraphNumberingData(index: number): void {\n        if (this.pagesWrap.paragraphs[index].numberingData.numberingId !== this.model.paragraphs[index].paragraphStyle.numberingId) {\n            this.pagesWrap.paragraphs[index].numberingData = NumberingHelper.createDataModel(\n                this.generalProperties.numberings,\n                this.model.paragraphs,\n                index\n            );\n        }\n\n        if (this.pagesWrap.paragraphs[index].numberingData.numberingId !== null) {\n            const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[index].insertIndex);\n            NumberingHelper.updateMarkerData(\n                this.generalProperties,\n                this.pagesWrap.paragraphs[index],\n                paragraphFormat.textStyle,\n                this.model.paragraphs[index].paragraphStyle\n            );\n        }\n    }\n\n    updateWrapData(firstParagraph: number, lastParagraph: number): void {\n        this.updateWrapParagraphIndex(firstParagraph);\n        let indexOfParagraphAfterPageBreak = this.pagesWrap.paragraphs[firstParagraph - 1]?.isEndedByPageBreak ? firstParagraph : -1;\n        let firstUsedTabIndex = this.model.tabs.findIndex(x => x.insertIndex >= this.wrapParagraphIndex[firstParagraph]);\n        for (let i = firstParagraph; i <= lastParagraph; i++) {\n            this.pagesWrap.tabTokens = [];\n            const currentLine = this.document.getLine(this.document.lines, i);\n            const isNextLineExists = this.document.lines.length > i + 1;\n            const { splits, rowInfos } = this.getSplits(this.model, currentLine, this.wrapParagraphIndex[i], i, isNextLineExists);\n            this.wrapData[i] = splits;\n            if (indexOfParagraphAfterPageBreak === i) {\n                rowInfos[0].isAfterPageBreak = true;\n            }\n            indexOfParagraphAfterPageBreak = rowInfos[rowInfos.length - 1].isEndedByPageBreak ? i + 1 : -1;\n            this.pagesWrap.set(i, rowInfos, this.generalProperties.numberings, this.model.paragraphs);\n            this.updateParagraphNumberingData(i);\n            this.updateWrapParagraphIndex(firstParagraph);\n            firstUsedTabIndex = this.updateParagraphTabs(firstUsedTabIndex, i, currentLine.length);\n        }\n\n        this.pagesWrap.paragraphs[lastParagraph + 1]?.setIsAfterPageBreak(indexOfParagraphAfterPageBreak > -1);\n        const count = this.document.lines.length;\n        this.pagesWrap.paragraphs.splice(count);\n        this.wrapData.splice(count);\n        this.updateWrapParagraphLine(firstParagraph);\n        this.pagesWrap.processParagraphsProperties(firstParagraph, this.wrapParagraphIndex);\n    }\n\n    /**\n     * Given a string, returns an array of the display characters, including tabs and spaces.\n     */\n    getDisplayTokens(model: ContentsInterface, str: string, startIndex: number): DisplayToken[] {\n        if (!str.length) {\n            return this.getEmptyLineTokens(startIndex);\n        }\n\n        return this.getFilledLineTokens(startIndex, str, model);\n    }\n\n    getRowCacheIndex(cacheArray: number[], value: number): number {\n        let start = 0;\n        let end = cacheArray.length - 1;\n        while (start <= end) {\n            const mid = (start + end) >> 1;\n            const center = cacheArray[mid];\n\n            if (value > center) {\n                start = mid + 1;\n            } else if (value < center) {\n                end = mid - 1;\n            } else {\n                return mid;\n            }\n        }\n\n        return start - 1;\n    }\n\n    /**\n     * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen.\n     * The first position indicates the number of columns for `str` on screen.\n     * The second value contains the position of the document column that this function read until.\n     */\n    getStringScreenWidth(str: string, maxScreenColumn?: number): number[] {\n        let screenColumn = 0;\n        let column: number;\n        for (column = 0; column < str.length; column++) {\n            screenColumn += 1;\n\n            if (screenColumn > maxScreenColumn) {\n                break;\n            }\n        }\n\n        return [screenColumn, column];\n    }\n\n    /**\n     * Given a starting row and column, this method returns the `Range` of the first word boundary it finds.\n     */\n    getWordRange(row: number, column: number): Range {\n        const line = this.document.getLine(this.document.lines, row);\n        let inToken = false;\n        if (column > 0) {\n            inToken = !!line.charAt(column - 1).match(this.tokenRe);\n        }\n\n        if (!inToken) {\n            inToken = !!line.charAt(column).match(this.tokenRe);\n        }\n\n        let regexp: RegExp;\n        if (inToken) {\n            regexp = this.tokenRe;\n        } else if (/^\\s+$/.test(line.slice(column - 1, column + 1))) {\n            regexp = /\\s/;\n        } else {\n            regexp = this.nonTokenRe;\n        }\n\n        let start = column;\n        if (start > 0) {\n            do {\n                start--;\n            } while (start >= 0 && line.charAt(start).match(regexp));\n\n            start++;\n        }\n\n        let end = column;\n        while (end < line.length && line.charAt(end).match(regexp)) {\n            end++;\n        }\n\n        return new Range(new CursorParagraph(row, start), new CursorParagraph(row, end));\n    }\n\n    getDisplayLine(row: number, endColumn: number, startColumn?: number): string {\n        const line = this.document.getLine(this.document.lines, row);\n\n        return line.substring(startColumn || 0, endColumn || line.length);\n    }\n\n    removeByDocumentIndexes(startIndex: number, endIndex: number): void {\n        const startParagraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex);\n        const endParagraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex);\n        this.remove(new Range(startParagraphPosition, endParagraphPosition));\n    }\n\n    insertTextByDocumentIndex(index: number, text: string, style?: TextStyleModel): CursorParagraph {\n        const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, index);\n        return this.insertText(paragraphPosition, text, style);\n    }\n\n    insertElementByDocumentIndex(insertElement: InsertElementModel): CursorParagraph {\n        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.element.insertIndex);\n        return this.insertElement(elementPosition, insertElement.element);\n    }\n\n    insertBreakByDocumentIndex(insertElement: InsertBreakModel): CursorParagraph {\n        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);\n        return this.insertBreak(elementPosition, insertElement.breakType as BreakTypes);\n    }\n\n    insertTabByDocumentIndex(insertElement: InsertTabModel): CursorParagraph {\n        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);\n        return this.insertTab(elementPosition);\n    }\n\n    insertImageByDocumentIndex(insertElement: InsertImageModel): CursorParagraph {\n        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);\n        return this.insertImage(elementPosition, insertElement.imageData);\n    }\n\n    insertTableByDocumentIndex(insertElement: InsertTableModel): CursorParagraph {\n        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);\n        return this.insertTable(elementPosition, insertElement);\n    }\n\n    insertParagraphByDocumentIndex(insertElement: InsertParagraphModel): CursorParagraph {\n        const elementPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, insertElement.insertIndex);\n        return this.insertParagraph(elementPosition, insertElement);\n    }\n\n    applyTextStyle(startIndex: number, endIndex: number, textStyle: TextStyleModel): void {\n        this.cursorStyle = new TextStyleModel(textStyle);\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;\n        OperationsHelper.applyTextStyle(this.model, startIndex, endIndex, textStyle);\n        this.updateWrapData(startParagraph, endParagraph);\n        this.setStyle(textStyle);\n    }\n\n    applyParagraphStyle(startIndex: number, endIndex: number, paragraphStyle: ParagraphStyleModel): void {\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;\n        OperationsHelper.applyParagraphStyle(this.model, startIndex, endIndex, paragraphStyle);\n        this.updateWrapData(startParagraph, endParagraph);\n        this.setStyle(paragraphStyle);\n    }\n\n    applyElementStyle(model: ApplyElementStyleModel): void {\n        OperationsHelper.applyElementStyle(this.model, model);\n        const imageComponentRef = this.customComponents.customElements.find(x => x.instance.insertIndex === model.insertIndex);\n        imageComponentRef.instance.initialize();\n        const paragraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, model.insertIndex).row;\n        this.updateWrapData(paragraph, paragraph);\n    }\n\n    addNumbering(levels: NumberingLevelModel[], startIndex: number, endIndex: number): void {\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;\n        OperationsHelper.addNumbering(this.model, this.generalProperties.numberings, startIndex, endIndex, levels);\n        for (let i = startParagraph; i <= endParagraph; i++) {\n            if (this.pagesWrap.paragraphs[i].numberingData.numberingId !== null) {\n                this.updateNumberingsDataOnChange(endParagraph);\n                break;\n            }\n        }\n\n        this.updateWrapData(startParagraph, endParagraph);\n        this.setNumberingStyle(startIndex, endIndex);\n    }\n\n    removeNumberings(startIndex: number, endIndex: number): void {\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, endIndex).row;\n        OperationsHelper.removeNumberings(this.model, this.generalProperties.numberings, startIndex, endIndex);\n        for (let i = startParagraph; i <= endParagraph; i++) {\n            if (this.pagesWrap.paragraphs[i].numberingData.numberingId !== null) {\n                this.updateNumberingsDataOnChange(endParagraph);\n                break;\n            }\n        }\n\n        this.updateWrapData(startParagraph, endParagraph);\n        this.setNumberingStyle(startIndex, endIndex);\n    }\n\n    restoreNumberings(paragraphs: ParagraphModel[], numberings: NumberingModel[]): void {\n        const startIndex = paragraphs[0].insertIndex;\n        const endIndex = paragraphs[paragraphs.length - 1].insertIndex;\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endPosition = ContentHelper.documentIndexToParagraphWithOffset(this.wrapParagraphIndex, this.document.lines, endIndex);\n        OperationsHelper.restoreNumberings(this.model, this.generalProperties.numberings, paragraphs, numberings);\n        for (const paragraph of paragraphs) {\n            if (paragraph.paragraphStyle.numberingId !== null) {\n                this.updateNumberingsDataOnChange(endPosition.row);\n                break;\n            }\n        }\n\n        this.updateWrapData(startParagraph, endPosition.row);\n        this.selection.placeCursor(endPosition);\n        this.setNumberingStyle(startIndex, endIndex);\n    }\n\n    applyImageStyle(applyImage: ApplyImageStyleModel): void {\n        const imageComponentRef = this.customComponents.images.find(x => x.instance.insertIndex === applyImage.insertIndex);\n        imageComponentRef.instance.resize({ width: applyImage.width, height: applyImage.height });\n        OperationsHelper.applyImageStyle(this.model, applyImage);\n        const start = this.document.indexToPosition(applyImage.insertIndex, 0);\n        this.updateWrapData(start.row, this.document.lines.length - 1);\n    }\n\n    restoreTextStyles(formats: FormatModel[]): void {\n        const startIndex = formats[0].startIndex;\n        const endIndex = formats[formats.length - 1].endIndex;\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endPosition = ContentHelper.documentIndexToParagraphWithOffset(this.wrapParagraphIndex, this.document.lines, endIndex);\n        OperationsHelper.restoreTextStyles(this.model, formats);\n        this.updateWrapData(startParagraph, endPosition.row);\n        this.selection.placeCursor(endPosition);\n        this.processSelectionStyles();\n    }\n\n    restoreParagraphStyles(paragraphs: ParagraphModel[]): void {\n        const startIndex = paragraphs[0].insertIndex;\n        const endIndex = paragraphs[paragraphs.length - 1].insertIndex;\n        const startParagraph = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, startIndex).row;\n        const endPosition = ContentHelper.documentIndexToParagraphWithOffset(this.wrapParagraphIndex, this.document.lines, endIndex);\n        OperationsHelper.restoreParagraphStyles(this.model, paragraphs);\n        this.updateWrapData(startParagraph, endPosition.row);\n        this.selection.placeCursor(endPosition);\n        this.processSelectionStyles();\n    }\n\n    setTextStyle(textStyle: TextStyleModel): void {\n        this.cursorStyle = new TextStyleModel(textStyle);\n        this.setStyle(textStyle);\n    }\n\n    /**\n     * Removes the `range` from the document.\n     * If `range` is empty, this function returns the unmodified value of `range.start`.\n     */\n    remove(range: Range): void {\n        const partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.wrapParagraphIndex, range);\n\n        this.document.removeRange(range);\n\n        CustomComponentHelper.applyRemovingComponents(this.customComponents.tables, partIndexes.startIndex, partIndexes.endIndex);\n        CustomComponentHelper.applyRemovingComponents(this.customComponents.images, partIndexes.startIndex, partIndexes.endIndex);\n        CustomComponentHelper.applyRemovingComponents(this.customComponents.customElements, partIndexes.startIndex, partIndexes.endIndex);\n        CustomComponentHelper.applyRemovingComponents(this.customComponents.tabs, partIndexes.startIndex, partIndexes.endIndex);\n\n        OperationsHelper.delete(this.model, partIndexes.startIndex, partIndexes.endIndex);\n\n        this.selection.placeCursor(range.start);\n        this.updateInternalDataOnDeleteText(range.start.row, range.end.row);\n\n        this.processSelectionStyles();\n    }\n\n    replace(model: ReplaceModel): CursorParagraph {\n        this.removeByDocumentIndexes(model.delete.startIndex, model.delete.endIndex + 1);\n        let endPoint: CursorParagraph;\n        if (model.insertText) {\n            endPoint = this.insertTextByDocumentIndex(model.insertText.insertIndex, model.insertText.text);\n        } else if (model.insertParagraph) {\n            endPoint = this.insertParagraphByDocumentIndex(model.insertParagraph);\n        } else if (model.insertElement) {\n            endPoint = this.insertElementByDocumentIndex(model.insertElement);\n        } else if (model.insertBreak) {\n            endPoint = this.insertBreakByDocumentIndex(model.insertBreak);\n        } else if (model.insertTab) {\n            endPoint = this.insertTabByDocumentIndex(model.insertTab);\n        } else if (model.insertImage) {\n            endPoint = this.insertImageByDocumentIndex(model.insertImage);\n        } else if (model.insertTable) {\n            endPoint = this.insertTableByDocumentIndex(model.insertTable);\n        }\n\n        return endPoint;\n    }\n\n    insertText(position: CursorParagraph, text: string, cursorStyle?: TextStyleModel): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        if (cursorStyle) {\n            OperationsHelper.insertStyledText(this.model, text, insertIndex, cursorStyle);\n        } else {\n            OperationsHelper.insertText(this.model, text, insertIndex);\n        }\n        const endPosition = this.document.insertText(position, text);\n        this.updateInternalDataOnInsertText(position.row, endPosition.row);\n        this.selection.placeCursor(endPosition);\n        return endPosition;\n    }\n\n    insertElement(position: CursorParagraph, element: ElementDataModel): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        const insertElement = new InsertElementModel({ element: new ElementModel({ insertIndex, ...element }) });\n        OperationsHelper.insertElement(this.model, insertElement);\n\n        const model = this.model.elements.find(x => x.insertIndex === insertIndex);\n        const type = this.customContentService.findComponentType(model.type);\n        this.addComponent(this.customComponents.customElements, model, type);\n\n        const endPosition = this.document.insertText(position, CUSTOM_ELEMENT_MARKER);\n        this.updateWrapData(position.row, endPosition.row);\n        this.selection.placeCursor(endPosition);\n        return endPosition;\n    }\n\n    insertBreak(position: CursorParagraph, breakType: BreakTypes): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        const isOnNewParagraph =\n            breakType === BreakTypes.Page &&\n            BreakHelper.getBreakType(this.model, CUSTOM_ELEMENT_MARKER, insertIndex - 1) !== BreakTypes.Page;\n        const text = isOnNewParagraph ? `${NEW_LINE_MARKUP}${CUSTOM_ELEMENT_MARKER}` : CUSTOM_ELEMENT_MARKER;\n        OperationsHelper.insertBreak(this.model, text, insertIndex, breakType);\n\n        const endPosition = this.document.insertText(position, text);\n        if (isOnNewParagraph) {\n            this.updateInternalDataOnInsertText(position.row, endPosition.row);\n        } else {\n            this.updateWrapData(position.row, endPosition.row);\n        }\n\n        const cursorPosition = this.document.getPositionAfterBreak(endPosition, breakType);\n        this.selection.placeCursor(cursorPosition);\n\n        return endPosition;\n    }\n\n    insertTab(position: CursorParagraph): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        OperationsHelper.insertTab(this.model, insertIndex);\n\n        const model = this.model.tabs.find(x => x.insertIndex === insertIndex);\n        this.addComponent(this.customComponents.tabs, model, NoderTabComponent);\n\n        const endPosition = this.document.insertText(position, CUSTOM_ELEMENT_MARKER);\n        this.updateWrapData(position.row, position.row);\n        this.selection.placeCursor(endPosition);\n        return endPosition;\n    }\n\n    insertImage(position: CursorParagraph, imageData: ImageDataModel): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        const adjustedImage = this.getImageWithAllowedSize(imageData, this.contentWidth);\n        OperationsHelper.insertImage(this.model, insertIndex, adjustedImage);\n\n        const model = this.model.images.find(x => x.insertIndex === insertIndex);\n        this.addComponent(this.customComponents.images, model, NoderImageComponent);\n\n        const endPosition = this.document.insertText(position, CUSTOM_ELEMENT_MARKER);\n        this.updateWrapData(position.row, position.row);\n        this.selection.placeCursor(endPosition);\n\n        return endPosition;\n    }\n\n    insertLink(position: CursorParagraph, linkData: LinkDataModel): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        const linkStyle = new TextStyleModel({ headingStyleId: HYPERLINK_HEADING_STYLE_ID, underline: true });\n        OperationsHelper.insertLink(this.model, linkData.text, linkData.link, insertIndex, linkStyle);\n\n        const endPosition = this.document.insertText(position, linkData.text);\n        this.updateWrapData(position.row, position.row);\n        this.selection.placeCursor(endPosition);\n        return endPosition;\n    }\n\n    insertTable(position: CursorParagraph, tableModel: InsertTableModel): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        OperationsHelper.insertTable(this.model, insertIndex, tableModel, this.pagesWrap.contentWidth);\n        const model = this.model.tables.find(x => x.insertIndex === tableModel.insertTableIndex);\n        this.addComponent(this.customComponents.tables, model, NoderTableComponent);\n        const endPosition = this.document.insertText(position, tableModel.content);\n        this.updateInternalDataOnInsertText(position.row, endPosition.row);\n        this.selection.placeCursor(endPosition);\n        return endPosition;\n    }\n\n    insertParagraph(position: CursorParagraph, paragraphModel: InsertParagraphModel): CursorParagraph {\n        const insertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n        const text = OperationsHelper.insertParagraph(this.model, insertIndex, paragraphModel, this.pagesWrap.contentWidth);\n        const endPosition = this.document.insertText(position, text);\n        this.updateInternalDataOnInsertText(position.row, endPosition.row);\n        let endPoint: CursorParagraph;\n        if (paragraphModel.insertText) {\n            const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(\n                this.wrapParagraphIndex,\n                paragraphModel.insertText.insertIndex\n            );\n            endPoint = this.document.insertText(paragraphPosition, text);\n            this.updateInternalDataOnInsertText(paragraphPosition.row, endPoint.row);\n            this.selection.placeCursor(endPoint);\n        } else if (paragraphModel.insertImage) {\n            const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(\n                this.wrapParagraphIndex,\n                paragraphModel.insertImage.insertIndex\n            );\n            const imageInsertIndex = ContentHelper.paragraphPositionToDocumentIndex(this.wrapParagraphIndex, position);\n            const model = this.model.images.find(x => x.insertIndex === imageInsertIndex);\n            this.addComponent(this.customComponents.images, model, NoderImageComponent);\n            endPoint = this.document.insertText(paragraphPosition, CUSTOM_ELEMENT_MARKER);\n            this.updateWrapData(paragraphPosition.row, paragraphPosition.row);\n            this.selection.placeCursor(endPoint);\n        } else if (paragraphModel.insertTable) {\n            const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(\n                this.wrapParagraphIndex,\n                paragraphModel.insertTable.insertIndex\n            );\n            const model = this.model.tables.find(x => x.insertIndex === paragraphModel.insertTable.insertTableIndex);\n            this.addComponent(this.customComponents.tables, model, NoderTableComponent);\n            endPoint = this.document.insertText(paragraphPosition, paragraphModel.insertTable.content);\n            this.updateInternalDataOnInsertText(paragraphPosition.row, endPoint.row);\n            this.selection.placeCursor(endPoint);\n        }\n        return endPoint;\n    }\n\n    addComponent<T extends BaseNoderComponent>(customElements: ComponentRef<T>[], model: CustomContent, componentType: Type<T>) {\n        const customElement = this.customContentService.componentService.generateComponent(componentType, {\n            content: model,\n            sessionId: this.sessionId,\n            generalProperties: this.generalProperties,\n            contentWidth: this.contentWidth\n        });\n        const newElementPosition = customElements.findIndex(x => x.instance.insertIndex > model.insertIndex);\n        if (newElementPosition >= 0) {\n            customElements.splice(newElementPosition, 0, customElement);\n        } else {\n            customElements.push(customElement);\n        }\n    }\n\n    setStyle(style: TextStyleModel | ParagraphStyleModel): void {\n        for (const key of Object.keys(style)) {\n            this._stylesMap[key] = style[key];\n        }\n\n        this.signal('setStyles', this._stylesMap);\n    }\n\n    setStyles(styles: { [key: string]: any[] }): void {\n        for (let key of Object.keys(styles)) {\n            if (styles[key].length === 0) {\n                this._stylesMap[key] = ContentStyleHelper.getDefaultStyleValueByKey(key);\n                continue;\n            } else if (styles[key].length > 1 && !styles[key].every(x => x === styles[key][0])) {\n                this._stylesMap[key] = typeof styles[key][0] === 'boolean' && key !== 'isBulletMarker' ? false : null;\n                continue;\n            }\n\n            this._stylesMap[key] = styles[key][0];\n        }\n\n        this.signal('setStyles', this._stylesMap);\n    }\n\n    setNumberingStyle(startIndex: number, endIndex: number): void {\n        const styles = {\n            alignment: [this._stylesMap.alignment],\n            backgroundColor: [this._stylesMap.backgroundColor],\n            highlightColor: [this._stylesMap.highlightColor],\n            fontColor: [this._stylesMap.fontColor],\n            fontFamily: [this._stylesMap.fontFamily],\n            fontSize: [this._stylesMap.fontSize],\n            italic: [this._stylesMap.italic],\n            bold: [this._stylesMap.bold],\n            strikethrough: [this._stylesMap.strikethrough],\n            underline: [this._stylesMap.underline],\n            spaceBefore: [this._stylesMap.spaceBefore],\n            spaceAfter: [this._stylesMap.spaceAfter],\n            indentLeft: [this._stylesMap.indentLeft],\n            indentRight: [this._stylesMap.indentRight],\n            isBulletMarker: [],\n            numberingLevelsStyles: []\n        };\n        this.updateNumberingStyles(styles, startIndex, endIndex);\n        this.setStyles(styles);\n    }\n\n    restore(model: RestoreModel): void {\n        const paragraphPosition = ContentHelper.documentIndexToParagraphIndex(this.wrapParagraphIndex, model.startIndex);\n        if (model.startIndex !== model.endIndex) {\n            this.removeByDocumentIndexes(model.startIndex, model.endIndex);\n        }\n\n        OperationsHelper.restore(this.model, model);\n\n        const restoreEndIndex = model.startIndex + model.text.length;\n        this.restoreComponents(this.model.tables, this.customComponents.tables, NoderTableComponent, model.startIndex, restoreEndIndex);\n        this.restoreComponents(this.model.images, this.customComponents.images, NoderImageComponent, model.startIndex, restoreEndIndex);\n        this.restoreComponents(this.model.tabs, this.customComponents.tabs, NoderTabComponent, model.startIndex, restoreEndIndex);\n        this.restoreElementComponents(this.model.elements, model.startIndex, restoreEndIndex);\n\n        const endPoint = this.document.insertText(paragraphPosition, model.text);\n        this.updateInternalDataOnInsertText(paragraphPosition.row, endPoint.row);\n        this.selection.placeCursor(endPoint);\n        this.processSelectionStyles();\n    }\n\n    restoreComponents<T extends BaseNoderComponent>(\n        models: CustomContent[],\n        components: ComponentRef<BaseNoderComponent>[],\n        componentType: Type<T>,\n        restoreIndex: number,\n        restoreEndIndex: number\n    ): void {\n        for (const model of models) {\n            if (model.insertIndex < restoreIndex) {\n                continue;\n            } else if (model.insertIndex >= restoreEndIndex) {\n                break;\n            }\n            this.addComponent(components, model, componentType);\n        }\n    }\n\n    restoreElementComponents(elements: ElementModel[], restoreIndex: number, restoreEndIndex: number): void {\n        for (const model of elements) {\n            if (model.insertIndex < restoreIndex) {\n                continue;\n            } else if (model.insertIndex >= restoreEndIndex) {\n                break;\n            }\n            const type = this.customContentService.findComponentType(model.type);\n            this.addComponent(this.customComponents.customElements, model, type);\n        }\n    }\n\n    processSelectionStyles(): void {\n        const { startIndex, endIndex } = this.getRangeIndexes(this.selection.range);\n\n        const styles = {\n            alignment: [],\n            backgroundColor: [],\n            highlightColor: [],\n            fontColor: [],\n            fontFamily: [],\n            fontSize: [],\n            italic: [],\n            bold: [],\n            strikethrough: [],\n            underline: [],\n            spaceBefore: [],\n            spaceAfter: [],\n            indentLeft: [],\n            indentRight: [],\n            isBulletMarker: [],\n            numberingLevelsStyles: []\n        };\n        this.updateParagraphStyles(styles, startIndex, endIndex);\n        this.updateNumberingStyles(styles, startIndex, endIndex);\n        const format = this.updateTextStyles(styles, startIndex, endIndex);\n        this.setStyles(styles);\n\n        if (format) {\n            this.cursorStyle = Object.assign({}, format.textStyle, this.cursorStyle);\n            this.setStyle(this.cursorStyle);\n        } else {\n            this.cursorStyle = null;\n        }\n    }\n\n    getLinkModel(cursor: CursorParagraph): LinkModel {\n        const { startIndex, endIndex } = this.getRangeIndexes(new Range(cursor, cursor));\n        return this.model.links.find(x => x.insertIndex <= startIndex + 1 && x.endIndex > endIndex);\n    }\n\n    insertTableRows(insertIndex: number, rowsCount: number, targetIndex: number, inheritIndex: number): void {\n        OperationsHelper.insertTableRows(this.model, insertIndex, rowsCount, targetIndex, inheritIndex);\n        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);\n        tableComponent.instance.updateTable();\n    }\n\n    insertTableColumns(insertIndex: number, columnsCount: number, targetIndex: number, inheritIndex: number): void {\n        OperationsHelper.insertTableColumns(this.model, insertIndex, columnsCount, targetIndex, inheritIndex, this.pagesWrap.contentWidth);\n        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);\n        tableComponent.instance.updateTable();\n    }\n\n    removeTableRows(insertIndex: number, startIndex: number, endIndex: number): void {\n        OperationsHelper.removeTableRows(this.model, insertIndex, startIndex, endIndex);\n        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);\n        tableComponent.instance.updateTable();\n    }\n\n    removeTableColumns(insertIndex: number, startIndex: number, endIndex: number): void {\n        OperationsHelper.removeTableColumns(this.model, insertIndex, startIndex, endIndex, this.pagesWrap.contentWidth);\n        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);\n        tableComponent.instance.updateTable();\n    }\n\n    resizeTableColumns(resizeTableColumns: ResizeTableColumnsModel): void {\n        OperationsHelper.resizeTableColumns(this.model, resizeTableColumns);\n        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === resizeTableColumns.insertIndex);\n        tableComponent.instance.updateTable();\n    }\n\n    restoreTable(insertIndex: number, table: TableModel): void {\n        const oldTable = JSON.parse(JSON.stringify(table)) as TableModel;\n        OperationsHelper.restoreTable(this.model, insertIndex, oldTable);\n        const tableComponent = this.customComponents.tables.find(x => x.instance.insertIndex === insertIndex);\n        tableComponent.instance.updateTable();\n    }\n\n    private updateParagraphTabs(tabIndex: number, paragraphIndex: number, length: number): number {\n        const paragraphLastIndex = this.wrapParagraphIndex[paragraphIndex] + length;\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.pagesWrap.tabTokens[tabIndex - startIndex].width;\n            this.customComponents.tabs[tabIndex].instance.height = this.pagesWrap.tabTokens[tabIndex - startIndex].font;\n            tabIndex++;\n        }\n\n        return tabIndex;\n    }\n\n    private getRangeIndexes(range: Range): { startIndex: number; endIndex: number } {\n        let partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.wrapParagraphIndex, range);\n        const prevNewLineSymbol = this.document.isNewLineSymbol(partIndexes.endIndex - 1);\n        if (!prevNewLineSymbol) {\n            if (partIndexes.endIndex > partIndexes.startIndex) {\n                partIndexes.endIndex--;\n            } else if (partIndexes.startIndex === partIndexes.endIndex && partIndexes.startIndex > 0) {\n                partIndexes.startIndex--;\n                partIndexes.endIndex--;\n            }\n        }\n\n        return partIndexes;\n    }\n\n    private updateInternalDataOnInsertText(startRow: number, endRow: number): void {\n        const length = endRow - startRow;\n        const newParagraphs: Paragraph[] = Array(length);\n        const newWrapData: number[][] = Array(length);\n        for (let i = 0; i < length; i++) {\n            newWrapData[i] = [];\n        }\n\n        this.wrapData.splice(startRow, 0, ...newWrapData);\n        this.pagesWrap.paragraphs.splice(startRow, 0, ...newParagraphs);\n        if (length) {\n            this.updateNumberingsDataOnChange(endRow);\n        }\n\n        this.updateWrapData(startRow, endRow);\n    }\n\n    private updateInternalDataOnDeleteText(startRow: number, endRow: number): void {\n        const length = endRow - startRow;\n\n        this.wrapData.splice(startRow, length);\n        this.pagesWrap.remove(startRow, length);\n        if (length) {\n            this.updateNumberingsDataOnChange(startRow);\n        }\n\n        this.updateWrapData(startRow, startRow);\n    }\n\n    private updateNumberingsDataOnChange(index: number): void {\n        for (let i = index; i < this.pagesWrap.paragraphs.length; i++) {\n            if (this.model.paragraphs[i].paragraphStyle.numberingId !== null) {\n                this.pagesWrap.paragraphs[i].numberingData = NumberingHelper.createDataModel(\n                    this.generalProperties.numberings,\n                    this.model.paragraphs,\n                    i\n                );\n                const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, this.model.paragraphs[i].insertIndex);\n                NumberingHelper.updateMarkerData(\n                    this.generalProperties,\n                    this.pagesWrap.paragraphs[i],\n                    paragraphFormat.textStyle,\n                    this.model.paragraphs[i].paragraphStyle\n                );\n            }\n        }\n    }\n\n    /**\n     * Computes wrap index based on max row width\n     */\n    private computeWrapIndex(displayTokens: DisplayToken[]): 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 = (this.pagesWrap.contentWidth || this.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, this.generalProperties.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 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 getSplits(\n        model: ContentsInterface,\n        line: string,\n        startIndex: number,\n        paragraphIndex: number,\n        isNextLineExists: boolean\n    ): { splits: number[]; rowInfos: LineInfoModel[] } {\n        const strTokens = this.getDisplayTokens(model, line, startIndex);\n        if (!strTokens.length) {\n            const defaultRowInfo = new LineInfoModel({\n                height: (this.stylesMap.fontSize * 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 = line;\n        while (index) {\n            initial = initial.slice(index > 0 ? index : 0);\n            const tokens = strTokens.slice(line.length - initial.length);\n            if (!tokens.length) {\n                tokens.push(...this.getEmptyLineTokens(startIndex + index));\n            }\n\n            let wrapLimit = this.computeWrapIndex(tokens);\n            if (tokens[tokens.length - 1].isPageBreak && wrapLimit === tokens.length && isNextLineExists) {\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 = this.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.pagesWrap.tabTokens.push(...strTokens.filter(x => x.isTab));\n\n        ParagraphHelper.applyParagraphIndentsToLines(rowInfos, paragraphIndex, model.paragraphs);\n        return { splits, rowInfos };\n    }\n\n    private setDocument(): void {\n        const pageMargin = this.document.pageMargin;\n\n        this.pagesWrap = new PagesWrap(\n            this.document.pagesSpace,\n            pageMargin,\n            this.document.pageWidth,\n            this.document.pageHeight,\n            this.customComponents\n        );\n    }\n\n    private getEmptyLineTokens(startIndex: number): DisplayToken[] {\n        const storedFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, startIndex);\n        if (!storedFormat) {\n            return [];\n        }\n\n        const lineInfo = this.getLineInfoByBreakModifier(startIndex);\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 getFilledLineTokens(startIndex: number, line: string, model: ContentsInterface): DisplayToken[] {\n        const lineInfo = this.getLineInfoByBreakModifier(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.customContentService.getOrGenerateComponent(\n                this.model,\n                this.customComponents,\n                this.sessionId,\n                this.generalProperties,\n                this.contentWidth,\n                startIndex,\n                char\n            );\n            const breakType = BreakHelper.getBreakType(model, char, startIndex);\n\n            if (customComponent && !breakType) {\n                this.customContentService.addToCustomComponents(this.customComponents, customComponent, char, startIndex);\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 = this.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 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    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    private getLineInfoFromToken(\n        prevToken: DisplayToken,\n        firstWrapToken: DisplayToken,\n        wrapTokens: DisplayToken[],\n        isAfterPageBreak: boolean\n    ): LineInfoModel {\n        const info = new LineInfoModel({\n            width: 0,\n            height: 0,\n            align: prevToken.align,\n            indent: new IndentModel(prevToken.indentFirstLine, prevToken.indentHanging, prevToken.indentLeft, prevToken.indentRight),\n            offsetBefore: prevToken.indentBefore,\n            offsetAfter: prevToken.indentAfter,\n            lineSpacing: prevToken.lineSpacing,\n            isAfterPageBreak,\n            isEndedByPageBreak: prevToken.isPageBreak\n        });\n\n        if (firstWrapToken) {\n            info.align = firstWrapToken.align;\n            info.indent.firstLine = firstWrapToken.indentFirstLine;\n            info.indent.hanging = firstWrapToken.indentHanging;\n            info.indent.left = firstWrapToken.indentLeft;\n            info.indent.right = firstWrapToken.indentRight;\n            info.offsetBefore = firstWrapToken.indentBefore;\n            info.offsetAfter = firstWrapToken.indentAfter;\n            info.lineSpacing = firstWrapToken.lineSpacing;\n            info.hasTable = firstWrapToken.isTable;\n        }\n\n        let fontSize = 0;\n        let ascent = 0;\n        let descent = 0;\n        const tokens = isAfterPageBreak && !wrapTokens.length ? [prevToken] : wrapTokens;\n        for (const wrapToken of tokens) {\n            if (info.height < wrapToken.height) {\n                info.height = wrapToken.height;\n            }\n\n            if (fontSize < wrapToken.font && wrapToken.displayValue !== DisplayValue.customContent) {\n                fontSize = wrapToken.font;\n                ascent = wrapToken.ascent;\n                descent = wrapToken.descent;\n            }\n\n            info.width += wrapToken.width;\n        }\n\n        info.height = info.height || 18;\n        if (info.lineSpacing > 1) {\n            info.offsetAfter = (ascent + descent) * (info.lineSpacing - 1);\n        } else if (ascent + descent === info.height) {\n            info.height = info.height * info.lineSpacing;\n        }\n\n        return info;\n    }\n\n    private getDisplayValue(charCode: number): number {\n        if (charCode === 32) {\n            return DisplayValue.space;\n        }\n\n        if ((charCode > 39 && charCode < 48) || (charCode > 57 && charCode < 64)) {\n            return DisplayValue.punctuation;\n        }\n\n        return DisplayValue.char;\n    }\n\n    private getLineInfoByBreakModifier(index: number): LineInfoModel {\n        const paragraph = ParagraphStyleHelper.getParagraphAtIndex(this.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(paragraph);\n        const indentHanging = paragraph.paragraphStyle.numberingId === null ? paragraph.paragraphStyle.indentHanging : 0;\n\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 getParagraphIndentLeft(paragraph: ParagraphModel): number {\n        let paragraphIndent = paragraph.paragraphStyle.indentLeft;\n        const numberingId = paragraph.paragraphStyle.numberingId;\n        if (numberingId !== null) {\n            const level = paragraph.paragraphStyle.numberingLevel;\n            const paragraphIndex = this.model.paragraphs.indexOf(paragraph);\n            const levelModel = NumberingHelper.find(this.generalProperties.numberings, numberingId, level);\n            const paragraphFormat = FormatStyleHelper.getFormatAtIndex(this.model.formats, paragraph.insertIndex);\n            const markerTextStyle = ContentStyleHelper.combineTextStyles(levelModel.markerStyle, paragraphFormat.textStyle);\n            let markerWidth = this.pagesWrap.paragraphs[paragraphIndex]?.numberingData?.width;\n            if (\n                !this.pagesWrap.paragraphs[paragraphIndex]?.numberingData.markerTextStyle ||\n                !ContentStyleHelper.areSameTextStyles(\n                    markerTextStyle,\n                    this.pagesWrap.paragraphs[paragraphIndex].numberingData.markerTextStyle\n                ) ||\n                this.pagesWrap.paragraphs[paragraphIndex].numberingData.numberingId !== numberingId\n            ) {\n                const marker = NumberingHelper.getMarker(levelModel, numberingId, this.model.paragraphs, paragraphIndex);\n                const markerSizes = NumberingHelper.getMarkerSizes(marker, markerTextStyle);\n                markerWidth = markerSizes.width;\n            }\n\n            const hangingIndent = paragraph.paragraphStyle.indentHanging\n                ? paragraph.paragraphStyle.indentHanging\n                : levelModel.indentHanging;\n            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\n        return paragraphIndent;\n    }\n\n    private updateTextStyles(styles: { [key: string]: any[] }, startIndex: number, endIndex: number): FormatModel {\n        let textStyles = FormatStyleHelper.getFormatsAtRange(this.model.formats, startIndex, endIndex).map(format => format.textStyle);\n        let prevFormat: FormatModel;\n        if (!textStyles.length) {\n            prevFormat = FormatStyleHelper.getPrevFormatAtIndex(this.model.formats, startIndex);\n\n            if (prevFormat) {\n                textStyles = [prevFormat.textStyle];\n            }\n        }\n\n        for (const textStyle of textStyles) {\n            for (const key of Object.keys(textStyle)) {\n                if (styles[key]) {\n                    styles[key].push(textStyle[key]);\n                }\n            }\n        }\n\n        return prevFormat;\n    }\n\n    private updateParagraphStyles(styles: { [key: string]: any[] }, startIndex: number, endIndex: number): void {\n        const paragraphStyles = ParagraphStyleHelper.getParagraphsAtRange(this.model.paragraphs, startIndex, endIndex).map(\n            paragraph => paragraph.paragraphStyle\n        );\n        for (const paragraphStyle of paragraphStyles) {\n            for (const key of Object.keys(paragraphStyle)) {\n                if (styles[key]) {\n                    styles[key].push(paragraphStyle[key]);\n                }\n            }\n        }\n    }\n\n    private updateNumberingStyles(styles: { [key: string]: any[] }, startIndex: number, endIndex: number): void {\n        const paragraphStyles = ParagraphStyleHelper.getParagraphsAtRange(this.model.paragraphs, startIndex, endIndex).map(\n            paragraph => paragraph.paragraphStyle\n        );\n        for (const paragraphStyle of paragraphStyles) {\n            if (paragraphStyle.numberingId !== null) {\n                const numberingLevels = this.generalProperties.numberings.find(x => x.numberingId === paragraphStyle.numberingId).levels;\n                const levelsMarkerStyles = numberingLevels.reduce((prev, next) => `${prev}${next.marker}${next.markerType}`, '');\n                const level = numberingLevels.find(x => x.level === paragraphStyle.numberingLevel);\n                const isBulletMarker = level.markerType === NumberingMarkerType.Bullet;\n                styles['isBulletMarker'].push(isBulletMarker);\n                styles['numberingLevelsStyles'].push(levelsMarkerStyles);\n            } else {\n                styles['isBulletMarker'].push(null);\n                styles['numberingLevelsStyles'].push('');\n            }\n        }\n    }\n\n    private getImageWithAllowedSize(imageData: ImageDataModel, maxWidth: number): ImageDataModel {\n        if (imageData.width <= maxWidth) {\n            return imageData;\n        }\n\n        const aspectRatio = imageData.width / imageData.height;\n        const height = maxWidth / aspectRatio;\n        return new ImageDataModel({ width: Math.round(maxWidth), height: Math.round(height), content: imageData.content });\n    }\n}\n"]}