@talrace/ngx-noder 0.0.7 → 0.0.8

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

@@ -0,0 +1,1346 @@
+import { AddNumberingModel } from '../../models/generated/add-numbering.model';
+import { ApplyElementStyleModel } from '../../models/generated/apply-element-style.model';
+import { ApplyImageStyleModel } from '../../models/generated/apply-image-style.model';
+import { ApplyParagraphStyleModel } from '../../models/generated/apply-paragraph-style.model';
+import { ApplyTextStyleModel } from '../../models/generated/apply-text-style.model';
+import { BreakHelper } from '../gadgets/page-break/break.helper';
+import { BreakModel } from '../../models/generated/break.model';
+import { BreakTypes } from '../gadgets/page-break/break-types.enum';
+import { ContentHelper } from '../positioning/content.helper';
+import { CursorParagraph } from '../positioning/cursor-paragraph';
+import { CUSTOM_ELEMENT_MARKER, TABLE_MARKER } from '../components/shared/custom-content-markers.const';
+import { DeleteModel } from '../../models/generated/delete.model';
+import { DocumentHandler } from '../interaction/document.handler';
+import { ElementModel } from '../../models/generated/element.model';
+import { EventEmitting } from '../core/event-emitting';
+import { FormatHelper } from '../content/helpers/format.helper';
+import { ImageModel } from '../../models/generated/image.model';
+import { IndexedElementHelper } from '../content/helpers/indexed-element.helper';
+import { InputHandler } from '../interaction/input.handler';
+import { InsertBreakModel } from '../../models/generated/insert-break.model';
+import { InsertElementModel } from '../../models/generated/insert-element.model';
+import { InsertImageModel } from '../../models/generated/insert-image.model';
+import { InsertLinkModel } from '../../models/generated/insert-link.model';
+import { InsertParagraphModel } from '../../models/generated/insert-paragraph.model';
+import { InsertStyledTextModel } from '../../models/generated/insert-styled-text.model';
+import { InsertTableColumnsModel } from '../../models/generated/insert-table-columns.model';
+import { InsertTableModel } from '../../models/generated/insert-table.model';
+import { InsertTableRowsModel } from '../../models/generated/insert-table-rows.model';
+import { InsertTabModel } from '../../models/generated/insert-tab.model';
+import { InsertTextModel } from '../../models/generated/insert-text.model';
+import { LinkModel } from '../../models/generated/link.model';
+import { MouseHandler } from '../interaction/mouse.handler';
+import { NEW_LINE_MARKUP } from '../content/constants/editor.const';
+import { OperationHistory } from '../gadgets/history/operation-history';
+import { ParagraphModel } from '../../models/generated/paragraph.model';
+import { ParagraphStyleModel } from '../../models/generated/paragraph-style.model';
+import { PositionHelper } from '../positioning/position.helper';
+import { PrintHelper } from '../display/print/print.helper';
+import { Range } from '../positioning/range';
+import { RemoveNumberingsModel } from '../../models/generated/remove-numberings.model';
+import { RemoveTableColumnsModel } from '../../models/generated/remove-table-columns.model';
+import { RemoveTableRowsModel } from '../../models/generated/remove-table-rows.model';
+import { ReplaceModel } from '../../models/generated/replace.model';
+import { ResizeTableColumnsModel } from '../../models/generated/resize-table-columns.model';
+import { RestoreModel } from '../../models/generated/restore.model';
+import { RestoreNumberingsModel } from '../../models/generated/restore-numberings.model';
+import { RestoreParagraphStylesModel } from '../../models/generated/restore-paragraph-styles.model';
+import { RestoreTableModel } from '../../models/generated/restore-table.model';
+import { RestoreTextStylesModel } from '../../models/generated/restore-text-styles.model';
+import { SaveCommandsHelper } from '../operations/save-commands.helper';
+import { ScalingHelper } from '../content/helpers/scaling.helper';
+import { Search } from '../gadgets/search/search';
+import { Selection } from '../positioning/selection';
+import { TableModel } from '../../models/generated/table.model';
+import { TabModel } from '../../models/generated/tab.model';
+import { TextInput } from '../interaction/text-input';
+import { TextStyleModel } from '../../models/generated/text-style.model';
+export class Editor extends EventEmitting {
+    get mainSession() {
+        return this.regulatorService.mainSession.session;
+    }
+    get mainRenderer() {
+        return this.regulatorService.mainSession.renderer;
+    }
+    get session() {
+        return this.regulatorService.currentSession.session;
+    }
+    get renderer() {
+        return this.regulatorService.currentSession.renderer;
+    }
+    get isViewOnly() {
+        return this.editorService.isViewOnly;
+    }
+    get targets() {
+        return this.regulatorService.getCurrentSessionTargets();
+    }
+    constructor(model, container, editorService, regulatorService, commandsService, clipboard, externalElementTagNames, customPageWidth) {
+        super();
+        this.model = model;
+        this.container = container;
+        this.editorService = editorService;
+        this.regulatorService = regulatorService;
+        this.commandsService = commandsService;
+        this.clipboard = clipboard;
+        this.externalElementTagNames = externalElementTagNames;
+        this.customPageWidth = customPageWidth;
+        this.MAX_COUNT = 999;
+        this.parentTagName = 'APP-NOD-EDITOR';
+        this.tableCellTagName = 'APP-NOD-TABLE-CELL';
+        this.edgeElementTagName = 'APP-NOD-EDGE';
+        this.imageTagName = 'APP-NOD-IMAGE';
+        this.subscriptions = [];
+        this.rerenderResize = () => {
+            this.mainRenderer.onResize(true);
+        };
+        this.setStyles = (styles) => {
+            this.editorService.styles = styles;
+        };
+        this.onDocumentChange = (range) => {
+            let lastRow = range.start.row === range.end.row ? range.end.row : Infinity;
+            this.renderer.updateLines(range.start.row, lastRow);
+            // Update cursor because tab characters can influence the cursor position.
+            this.renderer.updateCursor();
+        };
+        this.customElementTagNames = [...this.externalElementTagNames, this.imageTagName, this.tableCellTagName, this.edgeElementTagName];
+        this.history = new OperationHistory(editorService, regulatorService);
+        this.selection = new Selection();
+        this.regulatorService.setSelection(this.selection);
+        this.initMainSession();
+        this.textInput = new TextInput(this.mainRenderer.container);
+        this.mainRenderer.textarea = this.textInput.input;
+        this.mouseHandler = new MouseHandler(this.mainRenderer.container, this);
+        this.inputHandler = new InputHandler(this.textInput.input, this);
+        this.documentHandler = new DocumentHandler(this);
+        this.initResizeListener();
+        this.focus();
+        this.session.processSelectionStyles();
+        this.search = new Search();
+        this.search.set({ wrap: true });
+        this.subscriptions.push(this.searchOptionSubscription(), this.replaceSubscription(), this.setTextStylesSubscription(), this.setParagraphStylesSubscription(), this.changeElementStyleSubscription(), this.setNumberingTemplateTypeSubscription(), this.removeNumberingsSubscription(), this.setImageStyleSubscription(), this.createCustomComponentSubscription(), this.insertBreakSubscription(), this.insertImageSubscription(), this.insertLinkSubscription(), this.endMousePressSubscription(), this.clearSelectionSubscription(), this.changedTableSizeSubscription(), this.insertTableRowsSubscription(), this.insertTableColumnsSubscription(), this.removeTableRowsSubscription(), this.removeTableColumnsSubscription(), this.removedImageSubscription(), this.resizeTableColumnsSubscription(), this.insertTableSubscription(), this.rendererUpdatedSubscription(), this.edgeElementCopyUpdatedSubscription(), this.changedEdgeHeightSubscription(), this.undoSubscription(), this.redoSubscription(), this.clipboardDataSubscription(), this.cutSelectedSubscription(), this.copySelectedSubscription(), this.pasteFromClipboardSubscription(), this.selectAllSubscription(), this.removeSelectedSubscription(), this.printSubscription());
+    }
+    destroy() {
+        this.subscriptions.forEach(s => s?.unsubscribe());
+        this.destroyResizeListener();
+        this.mouseHandler.destroy();
+        this.inputHandler.destroy();
+        this.documentHandler.destroy();
+        this.session.removeEventListener('setStyles', this.setStyles);
+        this.blurCustomComponent();
+    }
+    selectPageDown() {
+        const config = this.mainRenderer.layerConfig;
+        const line = config.visibleRange.endScreenLine;
+        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);
+        this.selection.moveSelection(position);
+        this.mainRenderer.scrollBy(config.height);
+        this.scrollCursorIntoMainView(0.5);
+        this.onSelectionChange();
+    }
+    selectPageUp() {
+        const config = this.mainRenderer.layerConfig;
+        const line = config.visibleRange.startScreenLine;
+        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);
+        this.selection.moveSelection(position);
+        this.mainRenderer.scrollBy(-config.height);
+        this.scrollCursorIntoMainView(0.5);
+        this.onSelectionChange();
+    }
+    gotoPageDown() {
+        const config = this.mainRenderer.layerConfig;
+        const line = config.visibleRange.endScreenLine;
+        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);
+        this.selection.placeCursor(position);
+        this.mainRenderer.scrollBy(config.height);
+        this.scrollCursorIntoMainView(0.5);
+        this.onSelectionChange();
+    }
+    gotoPageUp() {
+        const config = this.mainRenderer.layerConfig;
+        const line = config.visibleRange.startScreenLine;
+        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);
+        this.selection.placeCursor(position);
+        this.mainRenderer.scrollBy(-config.height);
+        this.scrollCursorIntoMainView(0.5);
+        this.onSelectionChange();
+    }
+    cut() {
+        this.removeSelected();
+    }
+    insert(text) {
+        if (this.selection.isEmpty) {
+            this.insertText(text, this.session.cursorStyle);
+        }
+        else {
+            const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+            const insertText = new InsertTextModel({ insertIndex, text });
+            this.replaceBy(new ReplaceModel({ insertText }));
+        }
+    }
+    insertText(text, textStyle) {
+        const position = this.selection.cursor;
+        if (textStyle) {
+            this.saveInsertStyledTextToHistory(position.row, position.column, text, textStyle);
+        }
+        else {
+            this.saveInsertTextToHistory(position.row, position.column, text);
+        }
+        this.session.insertText(position, text, textStyle);
+        this.onSelectionChange();
+    }
+    replaceText(text) {
+        const toolbarStyle = new TextStyleModel(this.session.stylesMap);
+        this.removeSelected();
+        this.insertText(text, toolbarStyle);
+    }
+    removeLeft() {
+        if (this.selection.isEmpty) {
+            this.selection.selectLeft(this.session);
+        }
+        this.removeSelected();
+    }
+    removeRight() {
+        if (this.selection.isEmpty) {
+            this.selection.selectRight(this.session);
+        }
+        this.removeSelected();
+    }
+    insertBreak(breakType) {
+        const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+        const insertBreak = new InsertBreakModel({ insertIndex, breakType });
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertBreak }));
+            return;
+        }
+        if (breakType === BreakTypes.Column) {
+            return;
+        }
+        this.saveInsertBreakToHistory(insertBreak);
+        const endPoint = this.session.insertBreak(this.selection.cursor, breakType);
+        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;
+        this.renderer.updateLines(this.selection.cursor.row, lastRow);
+        this.renderer.updateCursor();
+        this.rerenderMarker();
+        this.scrollCursorIntoMainView(0.1);
+    }
+    insertTab() {
+        const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+        const insertTab = new InsertTabModel({ insertIndex });
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertTab }));
+            return;
+        }
+        this.saveInsertTabToHistory(insertTab);
+        const endPoint = this.session.insertTab(this.selection.cursor);
+        this.onDocumentChange(new Range(this.selection.cursor, endPoint));
+        this.onSelectionChange();
+    }
+    insertImage(imageData) {
+        const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+        const insertImage = new InsertImageModel({ insertIndex, imageData });
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertImage }));
+            return;
+        }
+        this.saveInsertImageToHistory(insertImage);
+        const endPoint = this.session.insertImage(this.selection.cursor, imageData);
+        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;
+        this.renderer.updateLines(this.selection.cursor.row, lastRow);
+        this.renderer.updateCursor();
+        this.rerenderMarker();
+    }
+    insertLink(linkDataModel) {
+        const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+        const insertLink = new InsertLinkModel({ insertIndex, endIndex: insertIndex + linkDataModel.text.length, linkDataModel });
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertLink }));
+            return;
+        }
+        this.saveInsertLinkToHistory(insertLink);
+        this.session.insertLink(this.selection.cursor, linkDataModel);
+        this.renderer.updateCursor();
+        this.rerenderMarker();
+    }
+    insertTable(tableData) {
+        const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+        const insertTable = new InsertTableModel({
+            insertIndex,
+            insertTableIndex: insertIndex,
+            rowsCount: tableData.rows,
+            columnsCount: tableData.columns,
+            content: TABLE_MARKER
+        });
+        if (this.session.pagesWrap.paragraphs[this.selection.range.start.row].numberingData.numberingId ||
+            !this.session.wrapParagraphIndex.some(x => x === insertIndex) ||
+            !this.session.document.isNewLineSymbol(insertIndex)) {
+            this.insertTableInNewParagraph(insertTable, insertIndex);
+        }
+        else {
+            this.insertTableInCurrentParagraph(insertTable);
+        }
+    }
+    insertTableInNewParagraph(insertTable, insertIndex) {
+        const insertParagraph = new InsertParagraphModel({ insertIndex, insertTable });
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertParagraph }));
+            return;
+        }
+        this.saveInsertParagraphToHistory(insertParagraph);
+        const endPoint = this.session.insertParagraph(this.selection.cursor, insertParagraph);
+        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;
+        this.renderer.updateLines(this.selection.cursor.row, lastRow);
+        this.renderer.updateCursor();
+        this.rerenderMarker();
+    }
+    insertTableInCurrentParagraph(insertTable) {
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertTable }));
+            return;
+        }
+        this.saveInsertTableToHistory(insertTable);
+        const endPoint = this.session.insertTable(this.selection.cursor, insertTable);
+        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;
+        this.renderer.updateLines(this.selection.cursor.row, lastRow);
+        this.renderer.updateCursor();
+        this.rerenderMarker();
+    }
+    replaceBy(model) {
+        const partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.session.wrapParagraphIndex, this.selection.range);
+        model.delete = new DeleteModel({ startIndex: partIndexes.startIndex, endIndex: partIndexes.endIndex });
+        this.saveReplaceToHistory(this.selection.range, model);
+        const endPosition = this.session.replace(model);
+        this.onDocumentChange(new Range(this.selection.cursor, endPosition));
+        this.onSelectionChange();
+    }
+    removeToLineStart() {
+        if (this.selection.isEmpty) {
+            this.selection.selectLineStart(this.session);
+        }
+        this.removeSelected();
+    }
+    removeToLineEnd() {
+        if (this.selection.isEmpty) {
+            this.selection.selectLineEnd(this.session);
+        }
+        this.removeSelected();
+    }
+    removeWordLeft() {
+        if (this.selection.isEmpty) {
+            this.selection.selectWordLeft(this.session);
+        }
+        this.removeSelected();
+    }
+    removeWordRight() {
+        if (this.selection.isEmpty) {
+            this.selection.selectWordRight(this.session);
+        }
+        this.removeSelected();
+    }
+    applyTextStyles(textStyle) {
+        if (!textStyle) {
+            return;
+        }
+        this.blurCustomComponent();
+        if (!this.selection.isEmpty) {
+            const partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.session.wrapParagraphIndex, this.selection.range);
+            this.saveApplyTextStyleToHistory(partIndexes.startIndex, partIndexes.endIndex, textStyle);
+            this.session.applyTextStyle(partIndexes.startIndex, partIndexes.endIndex, textStyle);
+        }
+        else {
+            this.setTextStyle(textStyle);
+        }
+    }
+    setTextStyle(textStyle) {
+        const index = ContentHelper.paragraphPositionToDocumentIndex(this.session.wrapParagraphIndex, this.selection.cursor);
+        const isParagraph = this.session.model.contentLength === index || this.session.model.content[index] === NEW_LINE_MARKUP;
+        if (isParagraph) {
+            this.saveApplyTextStyleToHistory(index, index, textStyle);
+            this.session.applyTextStyle(index, index, textStyle);
+        }
+        else {
+            this.session.setTextStyle(textStyle);
+        }
+        this.renderer.updateCursor();
+    }
+    applyParagraphStyles(paragraphStyle) {
+        const range = this.selection.range;
+        const startIndex = this.session.model.paragraphs[range.start.row].insertIndex;
+        const endIndex = this.session.model.paragraphs[range.end.row].insertIndex;
+        this.saveApplyParagraphStyleToHistory(startIndex, endIndex, paragraphStyle);
+        this.session.applyParagraphStyle(startIndex, endIndex, paragraphStyle);
+    }
+    applyElementStyle(current) {
+        this.saveApplyElementStyleToHistory(current);
+        this.session.applyElementStyle(new ApplyElementStyleModel(current));
+    }
+    setNumberingTemplate(templateLevels) {
+        const range = this.selection.range;
+        const startIndex = this.session.model.paragraphs[range.start.row].insertIndex;
+        const endIndex = this.session.model.paragraphs[range.end.row].insertIndex;
+        this.saveAddNumberingToHistory(templateLevels, startIndex, endIndex);
+        this.session.addNumbering(templateLevels, startIndex, endIndex);
+    }
+    removeNumberingsFromParagraphs() {
+        const range = this.selection.range;
+        const startIndex = this.session.model.paragraphs[range.start.row].insertIndex;
+        const endIndex = this.session.model.paragraphs[range.end.row].insertIndex;
+        this.saveRemoveNumberingToHistory(startIndex, endIndex);
+        this.session.removeNumberings(startIndex, endIndex);
+    }
+    applyImageStyles(image) {
+        this.saveApplyImageStyleToHistory(image);
+        const imageStyle = new ApplyImageStyleModel({ insertIndex: image.insertIndex, height: image.height, width: image.width });
+        this.session.applyImageStyle(imageStyle);
+        this.renderer.updateCursor();
+    }
+    focus() {
+        this.textInput.input.focus();
+    }
+    openSearch() {
+        this.editorService.openSearchDialog = true;
+    }
+    find(options) {
+        let range = this.selection.range;
+        if (options.term == null) {
+            let term = this.session.document.getTextRange(range) || this.search.options.term;
+            if (!term) {
+                range = this.session.getWordRange(range.start.row, range.start.column);
+                term = this.session.document.getTextRange(range);
+            }
+            options.term = term;
+        }
+        if (!options.start) {
+            options.start = range;
+        }
+        this.search.set(options);
+        const newRange = this.search.find(this.session);
+        if (newRange) {
+            this.selection.placeSelection(range.start, range.end);
+            this.onSelectionChange();
+            if (this.session === this.mainSession) {
+                this.mainRenderer.scrollSelectionIntoView(range.start, range.end, 0.5);
+            }
+            return newRange;
+        }
+        range.end = range.start;
+        this.selection.placeCursor(range.start);
+        this.onSelectionChange();
+        return null;
+    }
+    updateCounter() {
+        const regex = this.search.options.regex;
+        let all = 0;
+        let current = 0;
+        if (!regex) {
+            return { current: 0, total: 0 };
+        }
+        const value = this.session.document.getAllLines().join('\n');
+        let offset = this.session.document.positionToIndex(this.selection.range.start);
+        regex.lastIndex = 0;
+        let regexResult;
+        while ((regexResult = regex.exec(value))) {
+            all++;
+            let last = regexResult.index;
+            if (last <= offset) {
+                current++;
+            }
+            if (all > this.MAX_COUNT) {
+                break;
+            }
+        }
+        return { current: current, total: all > this.MAX_COUNT ? this.MAX_COUNT : all };
+    }
+    replace(search, replace) {
+        if (this.selection.isEmpty) {
+            return;
+        }
+        if (search !== replace) {
+            if (replace) {
+                this.replaceText(replace);
+            }
+            else {
+                this.removeSelected();
+            }
+        }
+        this.find({ term: search, skipCurrent: true, backwards: false });
+    }
+    undo() {
+        const undo = this.history.popUndoOperation();
+        if (!undo) {
+            return;
+        }
+        this.regulatorService.setTargetedSessionAsCurrent(undo.targets);
+        this.applyOperation(undo.operation);
+        this.selection.placeSelection(undo.cursor, undo.anchor);
+        this.onSelectionChange();
+    }
+    redo() {
+        const redo = this.history.popRedoOperation();
+        if (!redo) {
+            return;
+        }
+        this.regulatorService.setTargetedSessionAsCurrent(redo.targets);
+        this.selection.placeSelection(redo.cursor, redo.anchor);
+        this.applyOperation(redo.operation);
+        this.onSelectionChange();
+    }
+    applyOperation(operation) {
+        let command = null;
+        if (operation instanceof InsertTextModel) {
+            this.session.insertTextByDocumentIndex(operation.insertIndex, operation.text, null);
+            const { text, insertIndex } = operation;
+            command = SaveCommandsHelper.getInsertTextCommand(text, insertIndex, this.targets);
+        }
+        else if (operation instanceof InsertParagraphModel) {
+            this.session.insertParagraphByDocumentIndex(operation);
+            command = SaveCommandsHelper.getInsertParagraphCommand(operation, this.targets);
+        }
+        else if (operation instanceof DeleteModel) {
+            this.session.removeByDocumentIndexes(operation.startIndex, operation.endIndex);
+            command = SaveCommandsHelper.getDeleteCommand(operation.startIndex, operation.endIndex, this.targets);
+        }
+        else if (operation instanceof InsertStyledTextModel) {
+            this.session.insertTextByDocumentIndex(operation.insertIndex, operation.text, new TextStyleModel(operation.textStyle));
+            const { text, insertIndex, textStyle } = operation;
+            command = SaveCommandsHelper.getInsertStyledTextCommand(text, insertIndex, textStyle, this.targets);
+        }
+        else if (operation instanceof RestoreModel) {
+            const deepCopy = structuredClone(operation);
+            this.session.restore(deepCopy);
+            command = SaveCommandsHelper.getRestoreCommand(deepCopy, this.targets);
+        }
+        else if (operation instanceof ApplyTextStyleModel) {
+            this.session.applyTextStyle(operation.startIndex, operation.endIndex, new TextStyleModel(operation.textStyle));
+            const { startIndex, endIndex, textStyle } = operation;
+            command = SaveCommandsHelper.getApplyTextStyleCommand(startIndex, endIndex, textStyle, this.targets);
+        }
+        else if (operation instanceof ApplyParagraphStyleModel) {
+            const copy = new ParagraphStyleModel(operation.paragraphStyle);
+            this.session.applyParagraphStyle(operation.startIndex, operation.endIndex, copy);
+            const { startIndex, endIndex, paragraphStyle } = operation;
+            command = SaveCommandsHelper.getApplyParagraphStyleCommand(startIndex, endIndex, paragraphStyle, this.targets);
+        }
+        else if (operation instanceof RestoreTextStylesModel) {
+            const deepCopy = structuredClone(operation);
+            this.session.restoreTextStyles(deepCopy.formats);
+            command = SaveCommandsHelper.getRestoreTextStylesCommand(deepCopy.formats, this.targets);
+        }
+        else if (operation instanceof RestoreParagraphStylesModel) {
+            const deepCopy = structuredClone(operation);
+            this.session.restoreParagraphStyles(deepCopy.paragraphs);
+            command = SaveCommandsHelper.getRestoreParagraphStylesCommand(deepCopy.paragraphs, this.targets);
+        }
+        else if (operation instanceof InsertElementModel) {
+            this.session.insertElementByDocumentIndex(operation);
+            command = SaveCommandsHelper.getInsertElementCommand(operation, this.targets);
+        }
+        else if (operation instanceof InsertBreakModel) {
+            this.session.insertBreakByDocumentIndex(operation);
+            command = SaveCommandsHelper.getInsertBreakCommand(operation, this.targets);
+        }
+        else if (operation instanceof ApplyElementStyleModel) {
+            this.session.applyElementStyle(operation);
+            command = SaveCommandsHelper.getApplyElementStyleCommand(operation, this.targets);
+        }
+        else if (operation instanceof InsertTabModel) {
+            this.session.insertTabByDocumentIndex(operation);
+            command = SaveCommandsHelper.getInsertTabCommand(operation, this.targets);
+        }
+        else if (operation instanceof InsertImageModel) {
+            this.session.insertImageByDocumentIndex(operation);
+            command = SaveCommandsHelper.getInsertImageCommand(operation, this.targets);
+        }
+        else if (operation instanceof ApplyImageStyleModel) {
+            this.session.applyImageStyle(operation);
+            const { height, width, insertIndex } = operation;
+            command = SaveCommandsHelper.getApplyImageStyleCommand(height, width, insertIndex, this.targets);
+        }
+        else if (operation instanceof AddNumberingModel) {
+            this.session.addNumbering(operation.levels, operation.startIndex, operation.endIndex);
+            const { startIndex, endIndex, levels } = operation;
+            command = SaveCommandsHelper.getAddNumberingCommand(startIndex, endIndex, levels, this.targets);
+        }
+        else if (operation instanceof RestoreNumberingsModel) {
+            this.session.restoreNumberings(operation.paragraphs, operation.numberings);
+            command = SaveCommandsHelper.getRestoreNumberingsCommand(operation, this.targets);
+        }
+        else if (operation instanceof InsertTableColumnsModel) {
+            this.session.insertTableColumns(operation.insertIndex, operation.columnsCount, operation.targetIndex, operation.inheritIndex);
+            this.changedTableSize(operation.insertIndex, this.session.sessionId);
+            const { columnsCount, inheritIndex, insertIndex, targetIndex } = operation;
+            command = SaveCommandsHelper.getInsertTableColumnsCommand(columnsCount, inheritIndex, insertIndex, targetIndex, this.targets);
+        }
+        else if (operation instanceof InsertTableRowsModel) {
+            this.session.insertTableRows(operation.insertIndex, operation.rowsCount, operation.targetIndex, operation.inheritIndex);
+            this.changedTableSize(operation.insertIndex, this.session.sessionId);
+            const { insertIndex, rowsCount, targetIndex, inheritIndex } = operation;
+            command = SaveCommandsHelper.getInsertTableRowsCommand(insertIndex, rowsCount, targetIndex, inheritIndex, this.targets);
+        }
+        else if (operation instanceof RemoveTableColumnsModel) {
+            this.session.removeTableColumns(operation.insertIndex, operation.startIndex, operation.endIndex);
+            this.changedTableSize(operation.insertIndex, this.session.sessionId);
+            const { insertIndex, startIndex, endIndex } = operation;
+            command = SaveCommandsHelper.getRemoveTableColumnsCommand(insertIndex, startIndex, endIndex, this.targets);
+        }
+        else if (operation instanceof RemoveTableRowsModel) {
+            this.session.removeTableRows(operation.insertIndex, operation.startIndex, operation.endIndex);
+            this.changedTableSize(operation.insertIndex, this.session.sessionId);
+            const { insertIndex, startIndex, endIndex } = operation;
+            command = SaveCommandsHelper.getRemoveTableRowsCommand(insertIndex, startIndex, endIndex, this.targets);
+        }
+        else if (operation instanceof ResizeTableColumnsModel) {
+            this.session.resizeTableColumns(operation);
+            this.changedTableSize(operation.insertIndex, this.session.sessionId);
+            command = SaveCommandsHelper.getResizeTableColumnsCommand(operation, this.targets);
+        }
+        else if (operation instanceof RestoreTableModel) {
+            this.session.restoreTable(operation.insertIndex, operation.oldTable);
+            this.changedTableSize(operation.insertIndex, this.session.sessionId);
+            command = SaveCommandsHelper.getRestoreTableCommand(operation, this.targets);
+        }
+        else if (operation instanceof InsertTableModel) {
+            this.session.insertTableByDocumentIndex(operation);
+            command = SaveCommandsHelper.getInsertTableCommand(operation, this.targets);
+        }
+        else if (operation instanceof RemoveNumberingsModel) {
+            this.session.removeNumberings(operation.startIndex, operation.endIndex);
+            const { startIndex, endIndex } = operation;
+            command = SaveCommandsHelper.getRemoveNumberingsCommand(startIndex, endIndex, this.targets);
+        }
+        else if (operation instanceof ReplaceModel) {
+            this.session.replace(operation);
+            command = SaveCommandsHelper.getReplaceCommand(operation, this.targets);
+        }
+        else {
+            throw new Error('Undo/redo is not implemented for the Operation');
+        }
+        this.commandsService.createCommand(command);
+        this.renderer.updateCursor();
+    }
+    saveRemoveToHistory(range) {
+        const restoreModel = this.createRestoreFromSlice(range.start.row, range.start.column, range.end.row, range.end.column);
+        const endIndex = restoreModel.endIndex;
+        restoreModel.endIndex = restoreModel.startIndex; // this is to restore in position without deleting/replacing anything in range
+        this.history.pushDelete(restoreModel);
+        this.commandsService.createCommand(SaveCommandsHelper.getDeleteCommand(restoreModel.startIndex, endIndex, this.targets));
+    }
+    saveInsertTextToHistory(paragraph, indexInParagraph, text) {
+        const index = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraph, indexInParagraph);
+        this.history.pushInsertText(index, text);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertTextCommand(text, index, this.targets));
+    }
+    saveInsertParagraphToHistory(model) {
+        this.history.pushInsertParagraph(model, this.session.model.paragraphs);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertParagraphCommand(model, this.targets));
+    }
+    saveInsertStyledTextToHistory(paragraph, indexInParagraph, text, style) {
+        const index = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraph, indexInParagraph);
+        this.history.pushInsertStyledText(index, text, style);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertStyledTextCommand(text, index, style, this.targets));
+    }
+    saveInsertElementToHistory(model) {
+        this.history.pushInsertElement(model);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertElementCommand(model, this.targets));
+    }
+    saveInsertBreakToHistory(model) {
+        model.isOnNewParagraph =
+            model.breakType === BreakTypes.Page &&
+                BreakHelper.getBreakType(this.session.model, CUSTOM_ELEMENT_MARKER, model.insertIndex - 1) !== BreakTypes.Page;
+        const endIndex = model.isOnNewParagraph ? model.insertIndex + NEW_LINE_MARKUP.length + 1 : model.insertIndex + 1;
+        this.history.pushInsertBreak(model, endIndex);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertBreakCommand(model, this.targets));
+    }
+    saveInsertTabToHistory(model) {
+        this.history.pushInsertTab(model);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertTabCommand(model, this.targets));
+    }
+    saveInsertImageToHistory(model) {
+        this.history.pushInsertImage(model);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertImageCommand(model, this.targets));
+    }
+    saveInsertLinkToHistory(model) {
+        this.history.pushInsertLink(model);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertLinkOperation(model, this.targets));
+    }
+    saveInsertTableToHistory(model) {
+        this.history.pushInsertTable(model);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertTableCommand(model, this.targets));
+    }
+    saveApplyTextStyleToHistory(startIndex, endIndex, textStyle) {
+        const formats = FormatHelper.sliceSection(this.session.model.formats, startIndex, endIndex);
+        this.history.pushApplyTextStyle(startIndex, endIndex, textStyle, formats);
+        this.commandsService.createCommand(SaveCommandsHelper.getApplyTextStyleCommand(startIndex, endIndex, textStyle, this.targets));
+    }
+    saveApplyParagraphStyleToHistory(startIndex, endIndex, paragraphStyle) {
+        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex);
+        const paragraphsDeepCopy = paragraphs.map(x => new ParagraphModel({ insertIndex: x.insertIndex, paragraphStyle: new ParagraphStyleModel({ ...x.paragraphStyle }) }));
+        this.history.pushApplyParagraphStyle(startIndex, endIndex, paragraphStyle, paragraphsDeepCopy);
+        this.commandsService.createCommand(SaveCommandsHelper.getApplyParagraphStyleCommand(startIndex, endIndex, paragraphStyle, this.targets));
+    }
+    saveApplyElementStyleToHistory(current) {
+        const previous = this.session.model.elements.find(x => x.insertIndex === current.insertIndex);
+        this.history.pushApplyElementStyle(previous, current);
+        this.commandsService.createCommand(SaveCommandsHelper.getApplyElementStyleCommand(current, this.targets));
+    }
+    saveAddNumberingToHistory(templateLevels, startIndex, endIndex) {
+        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex);
+        const paragraphsDeepCopy = paragraphs.map(x => new ParagraphModel({ insertIndex: x.insertIndex, paragraphStyle: new ParagraphStyleModel({ ...x.paragraphStyle }) }));
+        const removedNumberingIds = [...new Set(paragraphs.map(x => x.paragraphStyle.numberingId))];
+        const numberings = this.session.generalProperties.numberings.filter(x => removedNumberingIds.includes(x.numberingId));
+        this.history.pushAddNumbering(startIndex, endIndex, templateLevels, paragraphsDeepCopy, numberings);
+        this.commandsService.createCommand(SaveCommandsHelper.getAddNumberingCommand(startIndex, endIndex, templateLevels, this.targets));
+    }
+    saveRemoveNumberingToHistory(startIndex, endIndex) {
+        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex);
+        const paragraphsDeepCopy = paragraphs.map(x => new ParagraphModel({ insertIndex: x.insertIndex, paragraphStyle: new ParagraphStyleModel({ ...x.paragraphStyle }) }));
+        const removedNumberingIds = [...new Set(paragraphs.map(x => x.paragraphStyle.numberingId))];
+        const numberings = this.session.generalProperties.numberings.filter(x => removedNumberingIds.includes(x.numberingId));
+        this.history.pushRemoveNumberings(startIndex, endIndex, numberings, paragraphsDeepCopy);
+        this.commandsService.createCommand(SaveCommandsHelper.getRemoveNumberingsCommand(startIndex, endIndex, this.targets));
+    }
+    saveApplyImageStyleToHistory(image) {
+        const previous = this.session.model.images.find(x => x.insertIndex === image.insertIndex);
+        this.history.pushApplyImageStyle(previous, image);
+        this.commandsService.createCommand(SaveCommandsHelper.getApplyImageStyleCommand(image.height, image.width, image.insertIndex, this.targets));
+    }
+    saveReplaceToHistory(range, model) {
+        const restoreModel = this.createRestoreFromSlice(range.start.row, range.start.column, range.end.row, range.end.column);
+        restoreModel.endIndex = restoreModel.startIndex + (model.insertText?.text.length ?? 1); // this is to restore in range with deleting/replacing content within
+        this.history.pushReplace(restoreModel, model);
+        this.commandsService.createCommand(SaveCommandsHelper.getReplaceCommand(model, this.targets));
+    }
+    createRestoreFromSlice(paragraphStart, indexInStart, paragraphEnd, indexInEnd) {
+        const startIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraphStart, indexInStart);
+        const endIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraphEnd, indexInEnd) - 1;
+        const text = this.session.model.content.slice(startIndex, endIndex + 1);
+        const formats = FormatHelper.sliceSection(this.session.model.formats, startIndex, endIndex);
+        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex).map(x => new ParagraphModel(x));
+        const images = IndexedElementHelper.sliceSection(this.session.model.images, startIndex, endIndex).map(x => new ImageModel(x));
+        const tables = IndexedElementHelper.sliceSection(this.session.model.tables, startIndex, endIndex).map(x => new TableModel(x));
+        const elements = IndexedElementHelper.sliceSection(this.session.model.elements, startIndex, endIndex).map(x => new ElementModel(x));
+        const breaks = IndexedElementHelper.sliceSection(this.session.model.breaks, startIndex, endIndex).map(x => new BreakModel(x));
+        const tabs = IndexedElementHelper.sliceSection(this.session.model.tabs, startIndex, endIndex).map(x => new TabModel(x));
+        const links = IndexedElementHelper.sliceSection(this.session.model.links, startIndex, endIndex).map(x => new LinkModel(x));
+        return new RestoreModel({ startIndex, endIndex, text, formats, paragraphs, images, tables, elements, breaks, tabs, links });
+    }
+    createCustomElement(data) {
+        const insertIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start.row, this.selection.range.start.column);
+        const insertElement = new InsertElementModel({ element: new ElementModel({ ...data, insertIndex }) });
+        if (!this.selection.isEmpty) {
+            this.replaceBy(new ReplaceModel({ insertElement }));
+            return;
+        }
+        this.saveInsertElementToHistory(insertElement);
+        const endPoint = this.session.insertElement(this.selection.cursor, data);
+        this.onDocumentChange(new Range(this.selection.cursor, endPoint));
+        this.onSelectionChange();
+    }
+    removeSelected() {
+        if (this.selection.isEmpty) {
+            return;
+        }
+        this.saveRemoveToHistory(this.selection.range);
+        this.session.remove(this.selection.range);
+        this.onSelectionChange();
+    }
+    onInput() {
+        const text = this.textInput.getInsertText();
+        if (!text) {
+            return;
+        }
+        const isEmptyNumberingParagraph = this.isEmptyNumberingParagraph(this.selection.cursor.row);
+        if (text === NEW_LINE_MARKUP && this.selection.isEmpty && isEmptyNumberingParagraph) {
+            this.removeNumberingsFromParagraphs();
+        }
+        else {
+            this.insert(text);
+            this.scrollCursorIntoMainView();
+        }
+    }
+    onCut(event) {
+        event.preventDefault();
+        const data = this.getSelectedText();
+        if (!data) {
+            return;
+        }
+        this.editorService.setClipboardData(data);
+        this.clipboard.copy(data);
+        this.cut();
+        this.scrollCursorIntoMainView();
+    }
+    onCopy(event) {
+        event.preventDefault();
+        const data = this.getSelectedText();
+        if (!data) {
+            return;
+        }
+        this.editorService.setClipboardData(data);
+        this.clipboard.copy(data);
+    }
+    onPaste(event) {
+        event.preventDefault();
+        const data = this.textInput.getClipboardData(event);
+        this.pasteData(data);
+    }
+    initResizeListener() {
+        window.addEventListener('resize', this.rerenderResize);
+    }
+    destroyResizeListener() {
+        window.removeEventListener('resize', this.rerenderResize);
+    }
+    rerenderMarker() {
+        this.renderer.loop.schedule({ marker: true });
+    }
+    onBlur() {
+        if (!this.textInput.isFocused) {
+            return;
+        }
+        this.textInput.isFocused = false;
+        this.renderer.hideCursor();
+    }
+    onFocus() {
+        if (this.textInput.isFocused) {
+            return;
+        }
+        this.blurCustomComponent();
+        this.textInput.isFocused = true;
+        this.renderer.showCursor();
+    }
+    onMouseClick(event) {
+        const customElement = this.setCurrentSession(event.clientY, event.target);
+        if (customElement && customElement.tagName !== this.tableCellTagName) {
+            this.focusCustomComponent(customElement);
+        }
+        else {
+            this.blurCustomComponent();
+        }
+    }
+    onLeftClick(event) {
+        const customElement = this.setCurrentSession(event.clientY, event.target);
+        if (customElement && customElement.tagName !== this.tableCellTagName) {
+            this.focusCustomComponent(customElement);
+            return;
+        }
+        this.blurCustomComponent();
+        if (!this.textInput.isFocused) {
+            this.textInput.input.focus();
+        }
+        const position = this.renderer.screenToTextCoordinates(event.clientX, event.clientY);
+        if (event.shiftKey) {
+            this.selection.moveSelection(position);
+        }
+        else if (event.ctrlKey) {
+            const linkModel = this.session.getLinkModel(position);
+            if (linkModel) {
+                window.open(linkModel.link);
+                event.preventDefault();
+                return;
+            }
+        }
+        else {
+            this.selection.placeCursor(position);
+        }
+        this.onSelectionChange();
+        event.preventDefault();
+        this.mouseHandler.startMousePress(this);
+    }
+    onDoubleClick(event) {
+        this.session.removeEventListener('setStyles', this.setStyles);
+        let isStartEditEdge = false;
+        const customElement = this.getCustomElement(event.target);
+        if (customElement) {
+            const elementSessionId = +customElement.attributes.getNamedItem('data-session-id').value;
+            let clickedPage = null;
+            const isParentEdge = this.isParentEdge(customElement);
+            if (customElement.tagName === this.edgeElementTagName || (isParentEdge && !this.regulatorService.edgeEditingPage)) {
+                clickedPage = this.getClickedPage(event.clientY);
+                isStartEditEdge = !this.regulatorService.edgeEditingPage;
+            }
+            this.regulatorService.setCustomSessionAsCurrent(elementSessionId, clickedPage);
+        }
+        else {
+            this.regulatorService.setMainSessionAsCurrent();
+        }
+        this.session.addEventListener('setStyles', this.setStyles);
+        if (customElement && customElement.tagName !== this.tableCellTagName && customElement.tagName !== this.edgeElementTagName) {
+            this.focusCustomComponent(customElement);
+            return;
+        }
+        this.blurCustomComponent();
+        event.preventDefault();
+        const position = this.renderer.screenToTextCoordinates(event.clientX, event.clientY);
+        if (isStartEditEdge) {
+            this.selection.placeCursor(position);
+        }
+        else {
+            const range = this.session.getWordRange(position.row, position.column);
+            this.selection.placeSelection(range.start, range.end);
+        }
+        this.onSelectionChange();
+    }
+    onTripleClick(event) {
+        const customElement = this.setCurrentSession(event.clientY, event.target);
+        if (customElement && customElement.tagName !== this.tableCellTagName) {
+            this.focusCustomComponent(customElement);
+            return;
+        }
+        this.blurCustomComponent();
+        event.preventDefault();
+        const position = this.renderer.screenToTextCoordinates(event.clientX, event.clientY);
+        const start = new CursorParagraph(position.row, 0);
+        const end = new CursorParagraph(position.row, this.session.document.lines[position.row].length);
+        this.selection.placeSelection(start, end);
+        this.onSelectionChange();
+    }
+    onQuadClick(event) {
+        const customElement = this.setCurrentSession(event.clientY, event.target);
+        if (customElement && customElement.tagName !== this.tableCellTagName) {
+            this.focusCustomComponent(customElement);
+            return;
+        }
+        this.blurCustomComponent();
+        event.preventDefault();
+        this.selection.selectAll(this.session.model);
+        this.onSelectionChange();
+    }
+    onMouseWheel(event) {
+        if (event.ctrlKey) {
+            return;
+        }
+        const factor = 0.35;
+        const scrollSpeed = 4;
+        const deltaY = event.deltaY * factor * scrollSpeed;
+        this.mainRenderer.scrollBy(deltaY);
+        event.stopPropagation();
+        event.preventDefault();
+    }
+    setCurrentSession(clickPositionY, element) {
+        this.session.removeEventListener('setStyles', this.setStyles);
+        const customElement = this.getCustomElement(element);
+        if (!customElement) {
+            this.regulatorService.setMainSessionAsCurrent();
+        }
+        else {
+            const elementSessionId = +customElement.attributes.getNamedItem('data-session-id').value;
+            const isEdgeEditing = this.regulatorService.edgeEditingPage;
+            if (customElement.tagName === this.edgeElementTagName) {
+                if (isEdgeEditing) {
+                    const clickedPage = this.getClickedPage(clickPositionY);
+                    this.regulatorService.setCustomSessionAsCurrent(elementSessionId, clickedPage);
+                }
+                else {
+                    this.regulatorService.setMainSessionAsCurrent();
+                }
+            }
+            else {
+                const isParentEdge = this.isParentEdge(customElement);
+                if (!isParentEdge) {
+                    this.regulatorService.setCustomSessionAsCurrent(elementSessionId);
+                    this.session.addEventListener('setStyles', this.setStyles);
+                    return customElement;
+                }
+                if (isEdgeEditing) {
+                    const clickedPage = this.getClickedPage(clickPositionY);
+                    this.regulatorService.setCustomSessionAsCurrent(elementSessionId, clickedPage);
+                    this.session.addEventListener('setStyles', this.setStyles);
+                    return customElement;
+                }
+                else {
+                    this.regulatorService.setMainSessionAsCurrent();
+                }
+            }
+        }
+        this.session.addEventListener('setStyles', this.setStyles);
+        return null;
+    }
+    getCustomElement(element) {
+        if (element.tagName === this.parentTagName) {
+            return null;
+        }
+        else if (this.customElementTagNames.includes(element.tagName)) {
+            return element;
+        }
+        else {
+            return this.getCustomElement(element.parentElement);
+        }
+    }
+    isParentEdge(element) {
+        if (element.tagName === this.parentTagName) {
+            return false;
+        }
+        else if (element.tagName === this.edgeElementTagName) {
+            return true;
+        }
+        else {
+            return this.isParentEdge(element.parentElement);
+        }
+    }
+    getClickedPage(mousePosition) {
+        const positionY = mousePosition + this.mainSession.scrollTop - this.mainRenderer.container.getBoundingClientRect().top;
+        return PositionHelper.pixelToPage(positionY, this.mainSession);
+    }
+    /**
+     * Returns the string of text currently highlighted.
+     */
+    getSelectedText() {
+        if (this.selection.isEmpty) {
+            return '';
+        }
+        const startIndex = ContentHelper.paragraphPositionToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start);
+        const endIndex = ContentHelper.paragraphPositionToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.end);
+        let elementIndexes = [];
+        ContentHelper.setIndexesElementsInInterval(this.session.model.breaks, elementIndexes, startIndex, endIndex);
+        ContentHelper.setIndexesElementsInInterval(this.session.model.tables, elementIndexes, startIndex, endIndex);
+        ContentHelper.setIndexesElementsInInterval(this.session.model.images, elementIndexes, startIndex, endIndex);
+        ContentHelper.setIndexesElementsInInterval(this.session.model.elements, elementIndexes, startIndex, endIndex);
+        ContentHelper.setIndexesElementsInInterval(this.session.model.tabs, elementIndexes, startIndex, endIndex);
+        elementIndexes.sort((a, b) => b - a);
+        let textInterval = this.session.document.getTextRange(this.selection.range);
+        elementIndexes.forEach(x => {
+            textInterval = textInterval.slice(0, x) + textInterval.slice(x + 1);
+        });
+        return textInterval;
+    }
+    initMainSession() {
+        const pageWidth = this.customPageWidth ?? this.model.pageWidth;
+        this.container.nativeElement.style.maxWidth = `${pageWidth}px`;
+        const scalingRatio = this.customPageWidth ? ScalingHelper.getRatio(this.customPageWidth, this.model.pageWidth) : 1;
+        this.regulatorService.addMainSession(this.model, pageWidth, scalingRatio, this.container);
+        this.session.addEventListener('setStyles', this.setStyles);
+    }
+    onSelectionChange() {
+        this.session.processSelectionStyles();
+        this.renderer.updateSelection(this.selection.range);
+        if (this.selection.isEmpty) {
+            this.renderer.updateCursor();
+        }
+        this.editorService.setHasSelection(!this.selection.isEmpty);
+        this.rerenderMarker();
+    }
+    onHotKeyDown(event) {
+        this.editorService.keyDown(event);
+    }
+    onPrint() {
+        PrintHelper.printDocument(this.mainSession, this.editorService);
+    }
+    focusCustomComponent(element) {
+        const index = +element.attributes.getNamedItem('data-insert-index').value;
+        const component = this.session.customComponents.images.find(x => x.instance.insertIndex === index) ??
+            this.session.customComponents.tables.find(x => x.instance.insertIndex === index) ??
+            this.session.customComponents.customElements.find(x => x.instance.insertIndex === index);
+        if (!component || component === this.focusedComponent) {
+            return;
+        }
+        this.focusedComponent?.instance.blur();
+        component.instance.focus();
+        this.focusedComponent = component;
+        const position = this.session.document.indexToPosition(index, 0);
+        this.selection.placeCursor(position);
+        this.onSelectionChange();
+    }
+    blurCustomComponent() {
+        if (this.focusedComponent) {
+            this.focusedComponent.instance.blur();
+            this.focusedComponent = null;
+        }
+    }
+    isEmptyNumberingParagraph(paragraphIndex) {
+        const currentLine = this.session.document.getLine(this.session.document.lines, paragraphIndex);
+        return currentLine.length === 0 && this.session.model.paragraphs[paragraphIndex].paragraphStyle.numberingId !== null;
+    }
+    scrollCursorIntoMainView(offset) {
+        if (this.session !== this.mainSession) {
+            return;
+        }
+        this.mainRenderer.scrollCursorIntoView(null, offset);
+    }
+    changedTableSize(insertIndex, sessionId) {
+        const session = this.regulatorService.getSession(sessionId);
+        const paragraph = ContentHelper.documentIndexToParagraphIndex(session.wrapParagraphIndex, insertIndex).row;
+        session.updateWrapData(paragraph, paragraph);
+        this.textInput.input.focus();
+    }
+    insertTableRows(insertIndex, rowsCount, targetIndex, inheritIndex, sessionId) {
+        this.regulatorService.setCustomSessionAsCurrent(sessionId);
+        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);
+        this.selection.placeCursor(beforeTable);
+        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);
+        this.history.pushInsertTableRows(insertIndex, rowsCount, targetIndex, inheritIndex, table);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertTableRowsCommand(rowsCount, inheritIndex, insertIndex, targetIndex, this.targets));
+        this.session.insertTableRows(insertIndex, rowsCount, targetIndex, inheritIndex);
+        this.changedTableSize(insertIndex, sessionId);
+    }
+    insertTableColumns(insertIndex, columnsCount, targetIndex, inheritIndex, sessionId) {
+        this.regulatorService.setCustomSessionAsCurrent(sessionId);
+        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);
+        this.selection.placeCursor(beforeTable);
+        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);
+        this.history.pushInsertTableColumns(insertIndex, columnsCount, targetIndex, inheritIndex, table);
+        this.commandsService.createCommand(SaveCommandsHelper.getInsertTableColumnsCommand(columnsCount, inheritIndex, insertIndex, targetIndex, this.targets));
+        this.session.insertTableColumns(insertIndex, columnsCount, targetIndex, inheritIndex);
+        this.changedTableSize(insertIndex, sessionId);
+    }
+    removeTableRows(insertIndex, startIndex, endIndex, sessionId) {
+        this.regulatorService.setCustomSessionAsCurrent(sessionId);
+        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);
+        this.selection.placeCursor(beforeTable);
+        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);
+        this.history.pushRemoveTableRows(insertIndex, startIndex, endIndex, table);
+        this.commandsService.createCommand(SaveCommandsHelper.getRemoveTableRowsCommand(startIndex, endIndex, insertIndex, this.targets));
+        this.session.removeTableRows(insertIndex, startIndex, endIndex);
+        this.changedTableSize(insertIndex, sessionId);
+    }
+    removeTableColumns(insertIndex, startIndex, endIndex, sessionId) {
+        this.regulatorService.setCustomSessionAsCurrent(sessionId);
+        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);
+        this.selection.placeCursor(beforeTable);
+        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);
+        this.history.pushRemoveTableColumns(insertIndex, startIndex, endIndex, table);
+        this.commandsService.createCommand(SaveCommandsHelper.getRemoveTableColumnsCommand(startIndex, endIndex, insertIndex, this.targets));
+        this.session.removeTableColumns(insertIndex, startIndex, endIndex);
+        this.changedTableSize(insertIndex, sessionId);
+    }
+    removeImage(insertIndex) {
+        const range = this.session.document.indexesToRange(insertIndex, insertIndex + 1);
+        this.saveRemoveToHistory(range);
+        this.session.remove(range);
+        this.renderer.updateCursor();
+        this.textInput.input.focus();
+    }
+    resizeTableColumns(resizeTableColumns, sessionId) {
+        this.regulatorService.setCustomSessionAsCurrent(sessionId);
+        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, resizeTableColumns.insertIndex);
+        this.selection.placeCursor(beforeTable);
+        this.history.pushResizeTableColumns(resizeTableColumns);
+        this.session.resizeTableColumns(resizeTableColumns);
+        this.changedTableSize(resizeTableColumns.insertIndex, sessionId);
+    }
+    onMousePressedMove(x, y) {
+        const position = this.renderer.screenToTextCoordinates(x, y);
+        this.selection.moveSelection(position);
+        this.onSelectionChange();
+        this.scrollCursorIntoMainView();
+    }
+    searchOptionSubscription() {
+        return this.editorService.searchOptions$.subscribe(searchOptions => {
+            this.find(searchOptions);
+            this.editorService.searchIteration = this.updateCounter();
+        });
+    }
+    replaceSubscription() {
+        return this.editorService.replace$.subscribe(replace => {
+            this.replace(replace.searchValue, replace.replaceValue);
+            this.editorService.searchIteration = this.updateCounter();
+        });
+    }
+    setTextStylesSubscription() {
+        return this.editorService.setTextStyles$.subscribe(textStyles => {
+            this.applyTextStyles(textStyles);
+            this.focus();
+        });
+    }
+    setParagraphStylesSubscription() {
+        return this.editorService.setParagraphStyles$.subscribe(paragraphStyles => {
+            this.applyParagraphStyles(paragraphStyles);
+            this.focus();
+        });
+    }
+    setNumberingTemplateTypeSubscription() {
+        return this.editorService.setNumberingTemplateType$.subscribe(numberingTemplateType => {
+            this.setNumberingTemplate(numberingTemplateType);
+            this.focus();
+        });
+    }
+    removeNumberingsSubscription() {
+        return this.editorService.removeNumberings$.subscribe(() => {
+            this.removeNumberingsFromParagraphs();
+            this.focus();
+        });
+    }
+    setImageStyleSubscription() {
+        return this.editorService.setImageStyle$.subscribe(image => {
+            this.applyImageStyles(image);
+            this.focus();
+        });
+    }
+    changeElementStyleSubscription() {
+        return this.editorService.changeElementStyle$.subscribe(x => this.applyElementStyle(x));
+    }
+    createCustomComponentSubscription() {
+        return this.editorService.createCustomComponent$.subscribe(model => {
+            this.createCustomElement(model);
+            this.focus();
+        });
+    }
+    insertBreakSubscription() {
+        return this.editorService.insertBreak$.subscribe(breakType => {
+            this.insertBreak(breakType);
+            this.focus();
+        });
+    }
+    insertImageSubscription() {
+        return this.editorService.insertImage$.subscribe(imageData => {
+            this.insertImage(imageData);
+            this.focus();
+        });
+    }
+    insertLinkSubscription() {
+        return this.editorService.insertLink$.subscribe(linkData => {
+            this.insertLink(linkData);
+            this.focus();
+        });
+    }
+    endMousePressSubscription() {
+        return this.editorService.endMousePress$.subscribe(() => {
+            this.mouseHandler.endMousePress();
+        });
+    }
+    clearSelectionSubscription() {
+        return this.editorService.clearSelection$.subscribe(() => {
+            this.selection.clearSelection();
+            this.onSelectionChange();
+        });
+    }
+    changedTableSizeSubscription() {
+        return this.editorService.changedTableSize$.subscribe(data => {
+            this.changedTableSize(data.insertIndex, data.sessionId);
+        });
+    }
+    insertTableRowsSubscription() {
+        return this.editorService.insertTableRows$.subscribe(data => {
+            this.insertTableRows(data.insertIndex, data.rowsCount, data.targetIndex, data.inheritIndex, data.sessionId);
+        });
+    }
+    insertTableColumnsSubscription() {
+        return this.editorService.insertTableColumns$.subscribe(data => {
+            this.insertTableColumns(data.insertIndex, data.columnsCount, data.targetIndex, data.inheritIndex, data.sessionId);
+        });
+    }
+    removeTableRowsSubscription() {
+        return this.editorService.removeTableRows$.subscribe(data => {
+            this.removeTableRows(data.insertIndex, data.startIndex, data.endIndex, data.sessionId);
+        });
+    }
+    removeTableColumnsSubscription() {
+        return this.editorService.removeTableColumns$.subscribe(data => {
+            this.removeTableColumns(data.insertIndex, data.startIndex, data.endIndex, data.sessionId);
+        });
+    }
+    removedImageSubscription() {
+        return this.editorService.removeImage$.subscribe(data => {
+            this.removeImage(data.insertIndex);
+        });
+    }
+    resizeTableColumnsSubscription() {
+        return this.editorService.resizeTableColumns$.subscribe(data => {
+            this.resizeTableColumns(data.resizeTableColumns, data.sessionId);
+        });
+    }
+    insertTableSubscription() {
+        return this.editorService.insertTable$.subscribe(data => {
+            this.insertTable(data);
+        });
+    }
+    rendererUpdatedSubscription() {
+        return this.editorService.rendererUpdated$.subscribe(sessionId => {
+            const edgeTarget = this.regulatorService.getEdgeTarget(sessionId);
+            if (edgeTarget !== null) {
+                this.mainRenderer.renderer.textLayer.updateEdgeByLocation(edgeTarget.edgeData.pageType);
+            }
+        });
+    }
+    edgeElementCopyUpdatedSubscription() {
+        return this.editorService.edgeElementCopyUpdated$.subscribe(data => {
+            if (this.regulatorService.edgeEditingPage !== data.page) {
+                return;
+            }
+            const edgeSessionId = +data.newElementCopy.attributes.getNamedItem('data-session-id').value;
+            const edgeSession = this.regulatorService.sessions.find(x => x.sessionId === edgeSessionId);
+            edgeSession.renderer.container = data.newElementCopy.firstChild;
+        });
+    }
+    changedEdgeHeightSubscription() {
+        return this.editorService.changedEdgeHeight$.subscribe(edgeType => {
+            this.mainSession.pagesWrap.updatePageVerticalData(edgeType, this.regulatorService.edgeEditingPage, this.mainSession.wrapParagraphIndex);
+        });
+    }
+    undoSubscription() {
+        return this.editorService.undo$.subscribe(() => {
+            this.undo();
+            this.focus();
+            this.scrollCursorIntoMainView();
+        });
+    }
+    redoSubscription() {
+        return this.editorService.redo$.subscribe(() => {
+            this.redo();
+            this.focus();
+            this.scrollCursorIntoMainView();
+        });
+    }
+    printSubscription() {
+        return this.editorService.print$.subscribe(() => this.onPrint());
+    }
+    cutSelectedSubscription() {
+        return this.editorService.cutSelected$.subscribe(() => {
+            this.onCut(new ClipboardEvent('cut'));
+        });
+    }
+    copySelectedSubscription() {
+        return this.editorService.copySelected$.subscribe(() => {
+            this.onCopy(new ClipboardEvent('copy'));
+        });
+    }
+    pasteFromClipboardSubscription() {
+        return this.editorService.pasteFromClipboard$.subscribe(() => {
+            this.readClipboard()
+                .then(data => this.pasteData(data))
+                .catch(() => {
+                // continue regardless error
+            });
+        });
+    }
+    async readClipboard() {
+        const read = await navigator.permissions.query({ name: 'clipboard-read' });
+        return new Promise(resolve => {
+            if (navigator.clipboard && read.state != 'denied') {
+                navigator.clipboard
+                    .readText()
+                    .then(data => {
+                    resolve(data);
+                })
+                    .catch(() => {
+                    // continue regardless error
+                });
+            }
+            else {
+                resolve(this.clipboardData);
+            }
+        });
+    }
+    pasteData(data) {
+        if (!data) {
+            return;
+        }
+        const text = data.replace(/\r\n/g, '\n').replace(/\t/g, ' ');
+        this.insert(text);
+        this.scrollCursorIntoMainView();
+    }
+    selectAllSubscription() {
+        return this.editorService.selectAll$.subscribe(() => {
+            this.selection.selectAll(this.session.model);
+            this.onSelectionChange();
+        });
+    }
+    removeSelectedSubscription() {
+        return this.editorService.removeSelected$.subscribe(() => {
+            this.removeSelected();
+        });
+    }
+    clipboardDataSubscription() {
+        return this.editorService.clipboardData$.subscribe(data => {
+            this.clipboardData = data;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/execution/editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Clipboard } from '@angular/cdk/clipboard';\nimport { ComponentRef, ElementRef } from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { AddNumberingModel } from '../../models/generated/add-numbering.model';\nimport { ApplyElementStyleModel } from '../../models/generated/apply-element-style.model';\nimport { ApplyImageStyleModel } from '../../models/generated/apply-image-style.model';\nimport { ApplyParagraphStyleModel } from '../../models/generated/apply-paragraph-style.model';\nimport { ApplyTextStyleModel } from '../../models/generated/apply-text-style.model';\nimport { BaseNoderComponent } from '../components/shared/abstract/base.component';\nimport { BreakHelper } from '../gadgets/page-break/break.helper';\nimport { BreakModel } from '../../models/generated/break.model';\nimport { BreakTypes } from '../gadgets/page-break/break-types.enum';\nimport { CommandModel } from '../../models/generated/command.model';\nimport { CommandsService } from '../operations/commands.service';\nimport { ContentHelper } from '../positioning/content.helper';\nimport { CursorParagraph } from '../positioning/cursor-paragraph';\nimport { CUSTOM_ELEMENT_MARKER, TABLE_MARKER } from '../components/shared/custom-content-markers.const';\nimport { DeleteModel } from '../../models/generated/delete.model';\nimport { DocumentHandler } from '../interaction/document.handler';\nimport { DocxModel } from '../../models/generated/docx.model';\nimport { EditorService } from '../interaction/editor.service';\nimport { EditSession } from './edit.session';\nimport { ElementDataModel } from '../components/external-element/models/element-data.model';\nimport { ElementModel } from '../../models/generated/element.model';\nimport { EventEmitting } from '../core/event-emitting';\nimport { FormatHelper } from '../content/helpers/format.helper';\nimport { ImageDataModel } from '../../models/generated/image-data.model';\nimport { ImageModel } from '../../models/generated/image.model';\nimport { IndexedElementHelper } from '../content/helpers/indexed-element.helper';\nimport { InputHandler } from '../interaction/input.handler';\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 { InsertLinkModel } from '../../models/generated/insert-link.model';\nimport { InsertParagraphModel } from '../../models/generated/insert-paragraph.model';\nimport { InsertStyledTextModel } from '../../models/generated/insert-styled-text.model';\nimport { InsertTableColumnsModel } from '../../models/generated/insert-table-columns.model';\nimport { InsertTableModel } from '../../models/generated/insert-table.model';\nimport { InsertTableRowsModel } from '../../models/generated/insert-table-rows.model';\nimport { InsertTabModel } from '../../models/generated/insert-tab.model';\nimport { InsertTextModel } from '../../models/generated/insert-text.model';\nimport { IToolbarStyles } from '../content/display-data/toolbar-styles.interface';\nimport { LinkDataModel } from '../../models/generated/link-data.model';\nimport { LinkModel } from '../../models/generated/link.model';\nimport { MouseHandler } from '../interaction/mouse.handler';\nimport { NEW_LINE_MARKUP } from '../content/constants/editor.const';\nimport { NumberingLevelModel } from '../../models/generated/numbering-level.model';\nimport { Operation } from '../gadgets/history/operation.type';\nimport { OperationHistory } from '../gadgets/history/operation-history';\nimport { PageType } from '../components/edges/page-type.enum';\nimport { ParagraphModel } from '../../models/generated/paragraph.model';\nimport { ParagraphStyleModel } from '../../models/generated/paragraph-style.model';\nimport { PositionHelper } from '../positioning/position.helper';\nimport { PrintHelper } from '../display/print/print.helper';\nimport { Range } from '../positioning/range';\nimport { RegulatorService } from './regulator.service';\nimport { RemoveNumberingsModel } from '../../models/generated/remove-numberings.model';\nimport { RemoveTableColumnsModel } from '../../models/generated/remove-table-columns.model';\nimport { RemoveTableRowsModel } from '../../models/generated/remove-table-rows.model';\nimport { Renderer } from '../display/renderer';\nimport { ReplaceModel } from '../../models/generated/replace.model';\nimport { ResizeTableColumnsModel } from '../../models/generated/resize-table-columns.model';\nimport { RestoreModel } from '../../models/generated/restore.model';\nimport { RestoreNumberingsModel } from '../../models/generated/restore-numberings.model';\nimport { RestoreParagraphStylesModel } from '../../models/generated/restore-paragraph-styles.model';\nimport { RestoreTableModel } from '../../models/generated/restore-table.model';\nimport { RestoreTextStylesModel } from '../../models/generated/restore-text-styles.model';\nimport { SaveCommandsHelper } from '../operations/save-commands.helper';\nimport { ScalingHelper } from '../content/helpers/scaling.helper';\nimport { Search, SearchOptions } from '../gadgets/search/search';\nimport { SearchIteration } from '../gadgets/search/search-iteration.interface';\nimport { Selection } from '../positioning/selection';\nimport { TableModel } from '../../models/generated/table.model';\nimport { TabModel } from '../../models/generated/tab.model';\nimport { TargetModel } from '../../models/generated/target.model';\nimport { TextInput } from '../interaction/text-input';\nimport { TextStyleModel } from '../../models/generated/text-style.model';\nimport { VirtualRenderer } from '../display/virtual.renderer';\n\nexport class Editor extends EventEmitting {\n    readonly MAX_COUNT = 999;\n\n    readonly parentTagName = 'APP-NOD-EDITOR';\n\n    readonly tableCellTagName = 'APP-NOD-TABLE-CELL';\n\n    readonly edgeElementTagName = 'APP-NOD-EDGE';\n\n    readonly imageTagName = 'APP-NOD-IMAGE';\n\n    readonly customElementTagNames: string[];\n\n    readonly history: OperationHistory;\n\n    get mainSession(): EditSession {\n        return this.regulatorService.mainSession.session;\n    }\n\n    get mainRenderer(): VirtualRenderer {\n        return this.regulatorService.mainSession.renderer as VirtualRenderer;\n    }\n\n    get session(): EditSession {\n        return this.regulatorService.currentSession.session;\n    }\n\n    get renderer(): Renderer | VirtualRenderer {\n        return this.regulatorService.currentSession.renderer;\n    }\n\n    get isViewOnly(): boolean {\n        return this.editorService.isViewOnly;\n    }\n\n    get targets(): TargetModel[] {\n        return this.regulatorService.getCurrentSessionTargets();\n    }\n\n    selection: Selection;\n\n    mouseHandler: MouseHandler;\n\n    inputHandler: InputHandler;\n\n    documentHandler: DocumentHandler;\n\n    subscriptions: Subscription[] = [];\n\n    private search: Search;\n\n    private textInput: TextInput;\n\n    private focusedComponent: ComponentRef<BaseNoderComponent>;\n\n    private clipboardData: string;\n\n    constructor(\n        private model: DocxModel,\n        private container: ElementRef<HTMLElement>,\n        private editorService: EditorService,\n        private regulatorService: RegulatorService,\n        private commandsService: CommandsService,\n        private clipboard: Clipboard,\n        private externalElementTagNames: string[],\n        private customPageWidth?: number\n    ) {\n        super();\n\n        this.customElementTagNames = [...this.externalElementTagNames, this.imageTagName, this.tableCellTagName, this.edgeElementTagName];\n        this.history = new OperationHistory(editorService, regulatorService);\n        this.selection = new Selection();\n        this.regulatorService.setSelection(this.selection);\n        this.initMainSession();\n        this.textInput = new TextInput(this.mainRenderer.container);\n        this.mainRenderer.textarea = this.textInput.input;\n        this.mouseHandler = new MouseHandler(this.mainRenderer.container, this);\n        this.inputHandler = new InputHandler(this.textInput.input, this);\n        this.documentHandler = new DocumentHandler(this);\n        this.initResizeListener();\n        this.focus();\n        this.session.processSelectionStyles();\n\n        this.search = new Search();\n        this.search.set({ wrap: true });\n        this.subscriptions.push(\n            this.searchOptionSubscription(),\n            this.replaceSubscription(),\n            this.setTextStylesSubscription(),\n            this.setParagraphStylesSubscription(),\n            this.changeElementStyleSubscription(),\n            this.setNumberingTemplateTypeSubscription(),\n            this.removeNumberingsSubscription(),\n            this.setImageStyleSubscription(),\n            this.createCustomComponentSubscription(),\n            this.insertBreakSubscription(),\n            this.insertImageSubscription(),\n            this.insertLinkSubscription(),\n            this.endMousePressSubscription(),\n            this.clearSelectionSubscription(),\n            this.changedTableSizeSubscription(),\n            this.insertTableRowsSubscription(),\n            this.insertTableColumnsSubscription(),\n            this.removeTableRowsSubscription(),\n            this.removeTableColumnsSubscription(),\n            this.removedImageSubscription(),\n            this.resizeTableColumnsSubscription(),\n            this.insertTableSubscription(),\n            this.rendererUpdatedSubscription(),\n            this.edgeElementCopyUpdatedSubscription(),\n            this.changedEdgeHeightSubscription(),\n            this.undoSubscription(),\n            this.redoSubscription(),\n            this.clipboardDataSubscription(),\n            this.cutSelectedSubscription(),\n            this.copySelectedSubscription(),\n            this.pasteFromClipboardSubscription(),\n            this.selectAllSubscription(),\n            this.removeSelectedSubscription(),\n            this.printSubscription()\n        );\n    }\n\n    destroy(): void {\n        this.subscriptions.forEach(s => s?.unsubscribe());\n        this.destroyResizeListener();\n        this.mouseHandler.destroy();\n        this.inputHandler.destroy();\n        this.documentHandler.destroy();\n        this.session.removeEventListener('setStyles', this.setStyles);\n        this.blurCustomComponent();\n    }\n\n    selectPageDown(): void {\n        const config = this.mainRenderer.layerConfig;\n        const line = config.visibleRange.endScreenLine;\n        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);\n        this.selection.moveSelection(position);\n        this.mainRenderer.scrollBy(config.height);\n        this.scrollCursorIntoMainView(0.5);\n        this.onSelectionChange();\n    }\n\n    selectPageUp(): void {\n        const config = this.mainRenderer.layerConfig;\n        const line = config.visibleRange.startScreenLine;\n        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);\n        this.selection.moveSelection(position);\n        this.mainRenderer.scrollBy(-config.height);\n        this.scrollCursorIntoMainView(0.5);\n        this.onSelectionChange();\n    }\n\n    gotoPageDown(): void {\n        const config = this.mainRenderer.layerConfig;\n        const line = config.visibleRange.endScreenLine;\n        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);\n        this.selection.placeCursor(position);\n        this.mainRenderer.scrollBy(config.height);\n        this.scrollCursorIntoMainView(0.5);\n        this.onSelectionChange();\n    }\n\n    gotoPageUp(): void {\n        const config = this.mainRenderer.layerConfig;\n        const line = config.visibleRange.startScreenLine;\n        const position = PositionHelper.screenToDocument(this.mainSession, line, 0);\n        this.selection.placeCursor(position);\n        this.mainRenderer.scrollBy(-config.height);\n        this.scrollCursorIntoMainView(0.5);\n        this.onSelectionChange();\n    }\n\n    cut(): void {\n        this.removeSelected();\n    }\n\n    insert(text: string): void {\n        if (this.selection.isEmpty) {\n            this.insertText(text, this.session.cursorStyle);\n        } else {\n            const insertIndex = ContentHelper.paragraphToDocumentIndex(\n                this.session.wrapParagraphIndex,\n                this.selection.range.start.row,\n                this.selection.range.start.column\n            );\n            const insertText = new InsertTextModel({ insertIndex, text });\n            this.replaceBy(new ReplaceModel({ insertText }));\n        }\n    }\n\n    insertText(text: string, textStyle: TextStyleModel): void {\n        const position = this.selection.cursor;\n        if (textStyle) {\n            this.saveInsertStyledTextToHistory(position.row, position.column, text, textStyle);\n        } else {\n            this.saveInsertTextToHistory(position.row, position.column, text);\n        }\n        this.session.insertText(position, text, textStyle);\n        this.onSelectionChange();\n    }\n\n    replaceText(text: string): void {\n        const toolbarStyle = new TextStyleModel(this.session.stylesMap);\n        this.removeSelected();\n        this.insertText(text, toolbarStyle);\n    }\n\n    removeLeft(): void {\n        if (this.selection.isEmpty) {\n            this.selection.selectLeft(this.session);\n        }\n        this.removeSelected();\n    }\n\n    removeRight(): void {\n        if (this.selection.isEmpty) {\n            this.selection.selectRight(this.session);\n        }\n        this.removeSelected();\n    }\n\n    insertBreak(breakType: BreakTypes): void {\n        const insertIndex = ContentHelper.paragraphToDocumentIndex(\n            this.session.wrapParagraphIndex,\n            this.selection.range.start.row,\n            this.selection.range.start.column\n        );\n        const insertBreak = new InsertBreakModel({ insertIndex, breakType });\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertBreak }));\n            return;\n        }\n\n        if (breakType === BreakTypes.Column) {\n            return;\n        }\n\n        this.saveInsertBreakToHistory(insertBreak);\n        const endPoint = this.session.insertBreak(this.selection.cursor, breakType);\n        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;\n        this.renderer.updateLines(this.selection.cursor.row, lastRow);\n        this.renderer.updateCursor();\n        this.rerenderMarker();\n        this.scrollCursorIntoMainView(0.1);\n    }\n\n    insertTab() {\n        const insertIndex = ContentHelper.paragraphToDocumentIndex(\n            this.session.wrapParagraphIndex,\n            this.selection.range.start.row,\n            this.selection.range.start.column\n        );\n        const insertTab = new InsertTabModel({ insertIndex });\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertTab }));\n            return;\n        }\n\n        this.saveInsertTabToHistory(insertTab);\n        const endPoint = this.session.insertTab(this.selection.cursor);\n        this.onDocumentChange(new Range(this.selection.cursor, endPoint));\n        this.onSelectionChange();\n    }\n\n    insertImage(imageData: ImageDataModel): void {\n        const insertIndex = ContentHelper.paragraphToDocumentIndex(\n            this.session.wrapParagraphIndex,\n            this.selection.range.start.row,\n            this.selection.range.start.column\n        );\n        const insertImage = new InsertImageModel({ insertIndex, imageData });\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertImage }));\n            return;\n        }\n\n        this.saveInsertImageToHistory(insertImage);\n        const endPoint = this.session.insertImage(this.selection.cursor, imageData);\n        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;\n        this.renderer.updateLines(this.selection.cursor.row, lastRow);\n        this.renderer.updateCursor();\n        this.rerenderMarker();\n    }\n\n    insertLink(linkDataModel: LinkDataModel): void {\n        const insertIndex = ContentHelper.paragraphToDocumentIndex(\n            this.session.wrapParagraphIndex,\n            this.selection.range.start.row,\n            this.selection.range.start.column\n        );\n        const insertLink = new InsertLinkModel({ insertIndex, endIndex: insertIndex + linkDataModel.text.length, linkDataModel });\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertLink }));\n            return;\n        }\n\n        this.saveInsertLinkToHistory(insertLink);\n        this.session.insertLink(this.selection.cursor, linkDataModel);\n        this.renderer.updateCursor();\n        this.rerenderMarker();\n    }\n\n    insertTable(tableData: { rows: number; columns: number }): void {\n        const insertIndex = ContentHelper.paragraphToDocumentIndex(\n            this.session.wrapParagraphIndex,\n            this.selection.range.start.row,\n            this.selection.range.start.column\n        );\n        const insertTable = new InsertTableModel({\n            insertIndex,\n            insertTableIndex: insertIndex,\n            rowsCount: tableData.rows,\n            columnsCount: tableData.columns,\n            content: TABLE_MARKER\n        });\n\n        if (\n            this.session.pagesWrap.paragraphs[this.selection.range.start.row].numberingData.numberingId ||\n            !this.session.wrapParagraphIndex.some(x => x === insertIndex) ||\n            !this.session.document.isNewLineSymbol(insertIndex)\n        ) {\n            this.insertTableInNewParagraph(insertTable, insertIndex);\n        } else {\n            this.insertTableInCurrentParagraph(insertTable);\n        }\n    }\n\n    insertTableInNewParagraph(insertTable: InsertTableModel, insertIndex: number): void {\n        const insertParagraph = new InsertParagraphModel({ insertIndex, insertTable });\n\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertParagraph }));\n            return;\n        }\n\n        this.saveInsertParagraphToHistory(insertParagraph);\n        const endPoint = this.session.insertParagraph(this.selection.cursor, insertParagraph);\n        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;\n        this.renderer.updateLines(this.selection.cursor.row, lastRow);\n        this.renderer.updateCursor();\n        this.rerenderMarker();\n    }\n\n    insertTableInCurrentParagraph(insertTable: InsertTableModel): void {\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertTable }));\n            return;\n        }\n\n        this.saveInsertTableToHistory(insertTable);\n        const endPoint = this.session.insertTable(this.selection.cursor, insertTable);\n        let lastRow = this.selection.cursor.row === endPoint.row ? endPoint.row : Infinity;\n        this.renderer.updateLines(this.selection.cursor.row, lastRow);\n        this.renderer.updateCursor();\n        this.rerenderMarker();\n    }\n\n    replaceBy(model: ReplaceModel): void {\n        const partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.session.wrapParagraphIndex, this.selection.range);\n        model.delete = new DeleteModel({ startIndex: partIndexes.startIndex, endIndex: partIndexes.endIndex });\n        this.saveReplaceToHistory(this.selection.range, model);\n        const endPosition = this.session.replace(model);\n        this.onDocumentChange(new Range(this.selection.cursor, endPosition));\n        this.onSelectionChange();\n    }\n\n    removeToLineStart(): void {\n        if (this.selection.isEmpty) {\n            this.selection.selectLineStart(this.session);\n        }\n        this.removeSelected();\n    }\n\n    removeToLineEnd(): void {\n        if (this.selection.isEmpty) {\n            this.selection.selectLineEnd(this.session);\n        }\n        this.removeSelected();\n    }\n\n    removeWordLeft(): void {\n        if (this.selection.isEmpty) {\n            this.selection.selectWordLeft(this.session);\n        }\n        this.removeSelected();\n    }\n\n    removeWordRight(): void {\n        if (this.selection.isEmpty) {\n            this.selection.selectWordRight(this.session);\n        }\n        this.removeSelected();\n    }\n\n    applyTextStyles(textStyle: TextStyleModel): void {\n        if (!textStyle) {\n            return;\n        }\n\n        this.blurCustomComponent();\n        if (!this.selection.isEmpty) {\n            const partIndexes = ContentHelper.getSelectedPartDocumentIndexes(this.session.wrapParagraphIndex, this.selection.range);\n            this.saveApplyTextStyleToHistory(partIndexes.startIndex, partIndexes.endIndex, textStyle);\n            this.session.applyTextStyle(partIndexes.startIndex, partIndexes.endIndex, textStyle);\n        } else {\n            this.setTextStyle(textStyle);\n        }\n    }\n\n    setTextStyle(textStyle: TextStyleModel): void {\n        const index = ContentHelper.paragraphPositionToDocumentIndex(this.session.wrapParagraphIndex, this.selection.cursor);\n        const isParagraph = this.session.model.contentLength === index || this.session.model.content[index] === NEW_LINE_MARKUP;\n        if (isParagraph) {\n            this.saveApplyTextStyleToHistory(index, index, textStyle);\n            this.session.applyTextStyle(index, index, textStyle);\n        } else {\n            this.session.setTextStyle(textStyle);\n        }\n        this.renderer.updateCursor();\n    }\n\n    applyParagraphStyles(paragraphStyle: ParagraphStyleModel): void {\n        const range = this.selection.range;\n        const startIndex = this.session.model.paragraphs[range.start.row].insertIndex;\n        const endIndex = this.session.model.paragraphs[range.end.row].insertIndex;\n        this.saveApplyParagraphStyleToHistory(startIndex, endIndex, paragraphStyle);\n        this.session.applyParagraphStyle(startIndex, endIndex, paragraphStyle);\n    }\n\n    applyElementStyle(current: ElementModel): void {\n        this.saveApplyElementStyleToHistory(current);\n        this.session.applyElementStyle(new ApplyElementStyleModel(current));\n    }\n\n    setNumberingTemplate(templateLevels: NumberingLevelModel[]): void {\n        const range = this.selection.range;\n        const startIndex = this.session.model.paragraphs[range.start.row].insertIndex;\n        const endIndex = this.session.model.paragraphs[range.end.row].insertIndex;\n        this.saveAddNumberingToHistory(templateLevels, startIndex, endIndex);\n        this.session.addNumbering(templateLevels, startIndex, endIndex);\n    }\n\n    removeNumberingsFromParagraphs(): void {\n        const range = this.selection.range;\n        const startIndex = this.session.model.paragraphs[range.start.row].insertIndex;\n        const endIndex = this.session.model.paragraphs[range.end.row].insertIndex;\n        this.saveRemoveNumberingToHistory(startIndex, endIndex);\n        this.session.removeNumberings(startIndex, endIndex);\n    }\n\n    applyImageStyles(image: ImageModel): void {\n        this.saveApplyImageStyleToHistory(image);\n        const imageStyle = new ApplyImageStyleModel({ insertIndex: image.insertIndex, height: image.height, width: image.width });\n        this.session.applyImageStyle(imageStyle);\n        this.renderer.updateCursor();\n    }\n\n    focus(): void {\n        this.textInput.input.focus();\n    }\n\n    openSearch(): void {\n        this.editorService.openSearchDialog = true;\n    }\n\n    find(options: SearchOptions): Range {\n        let range = this.selection.range;\n        if (options.term == null) {\n            let term = this.session.document.getTextRange(range) || this.search.options.term;\n            if (!term) {\n                range = this.session.getWordRange(range.start.row, range.start.column);\n                term = this.session.document.getTextRange(range);\n            }\n            options.term = term;\n        }\n\n        if (!options.start) {\n            options.start = range;\n        }\n\n        this.search.set(options);\n\n        const newRange = this.search.find(this.session);\n        if (newRange) {\n            this.selection.placeSelection(range.start, range.end);\n            this.onSelectionChange();\n            if (this.session === this.mainSession) {\n                this.mainRenderer.scrollSelectionIntoView(range.start, range.end, 0.5);\n            }\n            return newRange;\n        }\n\n        range.end = range.start;\n        this.selection.placeCursor(range.start);\n        this.onSelectionChange();\n        return null;\n    }\n\n    updateCounter(): SearchIteration {\n        const regex = this.search.options.regex as RegExp;\n        let all = 0;\n        let current = 0;\n        if (!regex) {\n            return { current: 0, total: 0 };\n        }\n\n        const value = this.session.document.getAllLines().join('\\n');\n\n        let offset = this.session.document.positionToIndex(this.selection.range.start);\n\n        regex.lastIndex = 0;\n        let regexResult;\n        while ((regexResult = regex.exec(value))) {\n            all++;\n            let last = regexResult.index;\n            if (last <= offset) {\n                current++;\n            }\n            if (all > this.MAX_COUNT) {\n                break;\n            }\n        }\n\n        return { current: current, total: all > this.MAX_COUNT ? this.MAX_COUNT : all };\n    }\n\n    replace(search: string, replace: string): void {\n        if (this.selection.isEmpty) {\n            return;\n        }\n\n        if (search !== replace) {\n            if (replace) {\n                this.replaceText(replace);\n            } else {\n                this.removeSelected();\n            }\n        }\n\n        this.find({ term: search, skipCurrent: true, backwards: false });\n    }\n\n    undo(): void {\n        const undo = this.history.popUndoOperation();\n        if (!undo) {\n            return;\n        }\n        this.regulatorService.setTargetedSessionAsCurrent(undo.targets);\n        this.applyOperation(undo.operation);\n        this.selection.placeSelection(undo.cursor, undo.anchor);\n        this.onSelectionChange();\n    }\n\n    redo(): void {\n        const redo = this.history.popRedoOperation();\n        if (!redo) {\n            return;\n        }\n        this.regulatorService.setTargetedSessionAsCurrent(redo.targets);\n        this.selection.placeSelection(redo.cursor, redo.anchor);\n        this.applyOperation(redo.operation);\n        this.onSelectionChange();\n    }\n\n    applyOperation(operation: Operation): void {\n        let command: CommandModel | null = null;\n        if (operation instanceof InsertTextModel) {\n            this.session.insertTextByDocumentIndex(operation.insertIndex, operation.text, null);\n            const { text, insertIndex } = operation;\n            command = SaveCommandsHelper.getInsertTextCommand(text, insertIndex, this.targets);\n        } else if (operation instanceof InsertParagraphModel) {\n            this.session.insertParagraphByDocumentIndex(operation);\n            command = SaveCommandsHelper.getInsertParagraphCommand(operation, this.targets);\n        } else if (operation instanceof DeleteModel) {\n            this.session.removeByDocumentIndexes(operation.startIndex, operation.endIndex);\n            command = SaveCommandsHelper.getDeleteCommand(operation.startIndex, operation.endIndex, this.targets);\n        } else if (operation instanceof InsertStyledTextModel) {\n            this.session.insertTextByDocumentIndex(operation.insertIndex, operation.text, new TextStyleModel(operation.textStyle));\n            const { text, insertIndex, textStyle } = operation;\n            command = SaveCommandsHelper.getInsertStyledTextCommand(text, insertIndex, textStyle, this.targets);\n        } else if (operation instanceof RestoreModel) {\n            const deepCopy = structuredClone(operation);\n            this.session.restore(deepCopy);\n            command = SaveCommandsHelper.getRestoreCommand(deepCopy, this.targets);\n        } else if (operation instanceof ApplyTextStyleModel) {\n            this.session.applyTextStyle(operation.startIndex, operation.endIndex, new TextStyleModel(operation.textStyle));\n            const { startIndex, endIndex, textStyle } = operation;\n            command = SaveCommandsHelper.getApplyTextStyleCommand(startIndex, endIndex, textStyle, this.targets);\n        } else if (operation instanceof ApplyParagraphStyleModel) {\n            const copy = new ParagraphStyleModel(operation.paragraphStyle);\n            this.session.applyParagraphStyle(operation.startIndex, operation.endIndex, copy);\n            const { startIndex, endIndex, paragraphStyle } = operation;\n            command = SaveCommandsHelper.getApplyParagraphStyleCommand(startIndex, endIndex, paragraphStyle, this.targets);\n        } else if (operation instanceof RestoreTextStylesModel) {\n            const deepCopy = structuredClone(operation);\n            this.session.restoreTextStyles(deepCopy.formats);\n            command = SaveCommandsHelper.getRestoreTextStylesCommand(deepCopy.formats, this.targets);\n        } else if (operation instanceof RestoreParagraphStylesModel) {\n            const deepCopy = structuredClone(operation);\n            this.session.restoreParagraphStyles(deepCopy.paragraphs);\n            command = SaveCommandsHelper.getRestoreParagraphStylesCommand(deepCopy.paragraphs, this.targets);\n        } else if (operation instanceof InsertElementModel) {\n            this.session.insertElementByDocumentIndex(operation);\n            command = SaveCommandsHelper.getInsertElementCommand(operation, this.targets);\n        } else if (operation instanceof InsertBreakModel) {\n            this.session.insertBreakByDocumentIndex(operation);\n            command = SaveCommandsHelper.getInsertBreakCommand(operation, this.targets);\n        } else if (operation instanceof ApplyElementStyleModel) {\n            this.session.applyElementStyle(operation);\n            command = SaveCommandsHelper.getApplyElementStyleCommand(operation, this.targets);\n        } else if (operation instanceof InsertTabModel) {\n            this.session.insertTabByDocumentIndex(operation);\n            command = SaveCommandsHelper.getInsertTabCommand(operation, this.targets);\n        } else if (operation instanceof InsertImageModel) {\n            this.session.insertImageByDocumentIndex(operation);\n            command = SaveCommandsHelper.getInsertImageCommand(operation, this.targets);\n        } else if (operation instanceof ApplyImageStyleModel) {\n            this.session.applyImageStyle(operation);\n            const { height, width, insertIndex } = operation;\n            command = SaveCommandsHelper.getApplyImageStyleCommand(height, width, insertIndex, this.targets);\n        } else if (operation instanceof AddNumberingModel) {\n            this.session.addNumbering(operation.levels, operation.startIndex, operation.endIndex);\n            const { startIndex, endIndex, levels } = operation;\n            command = SaveCommandsHelper.getAddNumberingCommand(startIndex, endIndex, levels, this.targets);\n        } else if (operation instanceof RestoreNumberingsModel) {\n            this.session.restoreNumberings(operation.paragraphs, operation.numberings);\n            command = SaveCommandsHelper.getRestoreNumberingsCommand(operation, this.targets);\n        } else if (operation instanceof InsertTableColumnsModel) {\n            this.session.insertTableColumns(operation.insertIndex, operation.columnsCount, operation.targetIndex, operation.inheritIndex);\n            this.changedTableSize(operation.insertIndex, this.session.sessionId);\n            const { columnsCount, inheritIndex, insertIndex, targetIndex } = operation;\n            command = SaveCommandsHelper.getInsertTableColumnsCommand(columnsCount, inheritIndex, insertIndex, targetIndex, this.targets);\n        } else if (operation instanceof InsertTableRowsModel) {\n            this.session.insertTableRows(operation.insertIndex, operation.rowsCount, operation.targetIndex, operation.inheritIndex);\n            this.changedTableSize(operation.insertIndex, this.session.sessionId);\n            const { insertIndex, rowsCount, targetIndex, inheritIndex } = operation;\n            command = SaveCommandsHelper.getInsertTableRowsCommand(insertIndex, rowsCount, targetIndex, inheritIndex, this.targets);\n        } else if (operation instanceof RemoveTableColumnsModel) {\n            this.session.removeTableColumns(operation.insertIndex, operation.startIndex, operation.endIndex);\n            this.changedTableSize(operation.insertIndex, this.session.sessionId);\n            const { insertIndex, startIndex, endIndex } = operation;\n            command = SaveCommandsHelper.getRemoveTableColumnsCommand(insertIndex, startIndex, endIndex, this.targets);\n        } else if (operation instanceof RemoveTableRowsModel) {\n            this.session.removeTableRows(operation.insertIndex, operation.startIndex, operation.endIndex);\n            this.changedTableSize(operation.insertIndex, this.session.sessionId);\n            const { insertIndex, startIndex, endIndex } = operation;\n            command = SaveCommandsHelper.getRemoveTableRowsCommand(insertIndex, startIndex, endIndex, this.targets);\n        } else if (operation instanceof ResizeTableColumnsModel) {\n            this.session.resizeTableColumns(operation);\n            this.changedTableSize(operation.insertIndex, this.session.sessionId);\n            command = SaveCommandsHelper.getResizeTableColumnsCommand(operation, this.targets);\n        } else if (operation instanceof RestoreTableModel) {\n            this.session.restoreTable(operation.insertIndex, operation.oldTable);\n            this.changedTableSize(operation.insertIndex, this.session.sessionId);\n            command = SaveCommandsHelper.getRestoreTableCommand(operation, this.targets);\n        } else if (operation instanceof InsertTableModel) {\n            this.session.insertTableByDocumentIndex(operation);\n            command = SaveCommandsHelper.getInsertTableCommand(operation, this.targets);\n        } else if (operation instanceof RemoveNumberingsModel) {\n            this.session.removeNumberings(operation.startIndex, operation.endIndex);\n            const { startIndex, endIndex } = operation;\n            command = SaveCommandsHelper.getRemoveNumberingsCommand(startIndex, endIndex, this.targets);\n        } else if (operation instanceof ReplaceModel) {\n            this.session.replace(operation);\n            command = SaveCommandsHelper.getReplaceCommand(operation, this.targets);\n        } else {\n            throw new Error('Undo/redo is not implemented for the Operation');\n        }\n        this.commandsService.createCommand(command);\n        this.renderer.updateCursor();\n    }\n\n    saveRemoveToHistory(range: Range): void {\n        const restoreModel = this.createRestoreFromSlice(range.start.row, range.start.column, range.end.row, range.end.column);\n        const endIndex = restoreModel.endIndex;\n        restoreModel.endIndex = restoreModel.startIndex; // this is to restore in position without deleting/replacing anything in range\n        this.history.pushDelete(restoreModel);\n        this.commandsService.createCommand(SaveCommandsHelper.getDeleteCommand(restoreModel.startIndex, endIndex, this.targets));\n    }\n\n    saveInsertTextToHistory(paragraph: number, indexInParagraph: number, text: string): void {\n        const index = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraph, indexInParagraph);\n        this.history.pushInsertText(index, text);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertTextCommand(text, index, this.targets));\n    }\n\n    saveInsertParagraphToHistory(model: InsertParagraphModel): void {\n        this.history.pushInsertParagraph(model, this.session.model.paragraphs);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertParagraphCommand(model, this.targets));\n    }\n\n    saveInsertStyledTextToHistory(paragraph: number, indexInParagraph: number, text: string, style: TextStyleModel): void {\n        const index = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraph, indexInParagraph);\n        this.history.pushInsertStyledText(index, text, style);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertStyledTextCommand(text, index, style, this.targets));\n    }\n\n    saveInsertElementToHistory(model: InsertElementModel): void {\n        this.history.pushInsertElement(model);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertElementCommand(model, this.targets));\n    }\n\n    saveInsertBreakToHistory(model: InsertBreakModel): void {\n        model.isOnNewParagraph =\n            model.breakType === BreakTypes.Page &&\n            BreakHelper.getBreakType(this.session.model, CUSTOM_ELEMENT_MARKER, model.insertIndex - 1) !== BreakTypes.Page;\n        const endIndex = model.isOnNewParagraph ? model.insertIndex + NEW_LINE_MARKUP.length + 1 : model.insertIndex + 1;\n        this.history.pushInsertBreak(model, endIndex);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertBreakCommand(model, this.targets));\n    }\n\n    saveInsertTabToHistory(model: InsertTabModel): void {\n        this.history.pushInsertTab(model);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertTabCommand(model, this.targets));\n    }\n\n    saveInsertImageToHistory(model: InsertImageModel): void {\n        this.history.pushInsertImage(model);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertImageCommand(model, this.targets));\n    }\n\n    saveInsertLinkToHistory(model: InsertLinkModel): void {\n        this.history.pushInsertLink(model);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertLinkOperation(model, this.targets));\n    }\n\n    saveInsertTableToHistory(model: InsertTableModel): void {\n        this.history.pushInsertTable(model);\n        this.commandsService.createCommand(SaveCommandsHelper.getInsertTableCommand(model, this.targets));\n    }\n\n    saveApplyTextStyleToHistory(startIndex: number, endIndex: number, textStyle: TextStyleModel): void {\n        const formats = FormatHelper.sliceSection(this.session.model.formats, startIndex, endIndex);\n        this.history.pushApplyTextStyle(startIndex, endIndex, textStyle, formats);\n        this.commandsService.createCommand(SaveCommandsHelper.getApplyTextStyleCommand(startIndex, endIndex, textStyle, this.targets));\n    }\n\n    saveApplyParagraphStyleToHistory(startIndex: number, endIndex: number, paragraphStyle: ParagraphStyleModel): void {\n        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex);\n        const paragraphsDeepCopy = paragraphs.map(\n            x => new ParagraphModel({ insertIndex: x.insertIndex, paragraphStyle: new ParagraphStyleModel({ ...x.paragraphStyle }) })\n        );\n        this.history.pushApplyParagraphStyle(startIndex, endIndex, paragraphStyle, paragraphsDeepCopy);\n        this.commandsService.createCommand(\n            SaveCommandsHelper.getApplyParagraphStyleCommand(startIndex, endIndex, paragraphStyle, this.targets)\n        );\n    }\n\n    saveApplyElementStyleToHistory(current: ElementModel): void {\n        const previous = this.session.model.elements.find(x => x.insertIndex === current.insertIndex);\n        this.history.pushApplyElementStyle(previous, current);\n        this.commandsService.createCommand(SaveCommandsHelper.getApplyElementStyleCommand(current, this.targets));\n    }\n\n    saveAddNumberingToHistory(templateLevels: NumberingLevelModel[], startIndex: number, endIndex: number): void {\n        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex);\n        const paragraphsDeepCopy = paragraphs.map(\n            x => new ParagraphModel({ insertIndex: x.insertIndex, paragraphStyle: new ParagraphStyleModel({ ...x.paragraphStyle }) })\n        );\n        const removedNumberingIds = [...new Set(paragraphs.map(x => x.paragraphStyle.numberingId))];\n        const numberings = this.session.generalProperties.numberings.filter(x => removedNumberingIds.includes(x.numberingId));\n        this.history.pushAddNumbering(startIndex, endIndex, templateLevels, paragraphsDeepCopy, numberings);\n        this.commandsService.createCommand(SaveCommandsHelper.getAddNumberingCommand(startIndex, endIndex, templateLevels, this.targets));\n    }\n\n    saveRemoveNumberingToHistory(startIndex: number, endIndex: number): void {\n        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex);\n        const paragraphsDeepCopy = paragraphs.map(\n            x => new ParagraphModel({ insertIndex: x.insertIndex, paragraphStyle: new ParagraphStyleModel({ ...x.paragraphStyle }) })\n        );\n        const removedNumberingIds = [...new Set(paragraphs.map(x => x.paragraphStyle.numberingId))];\n        const numberings = this.session.generalProperties.numberings.filter(x => removedNumberingIds.includes(x.numberingId));\n        this.history.pushRemoveNumberings(startIndex, endIndex, numberings, paragraphsDeepCopy);\n        this.commandsService.createCommand(SaveCommandsHelper.getRemoveNumberingsCommand(startIndex, endIndex, this.targets));\n    }\n\n    private saveApplyImageStyleToHistory(image: ImageModel): void {\n        const previous = this.session.model.images.find(x => x.insertIndex === image.insertIndex);\n        this.history.pushApplyImageStyle(previous, image);\n        this.commandsService.createCommand(\n            SaveCommandsHelper.getApplyImageStyleCommand(image.height, image.width, image.insertIndex, this.targets)\n        );\n    }\n\n    private saveReplaceToHistory(range: Range, model: ReplaceModel): void {\n        const restoreModel = this.createRestoreFromSlice(range.start.row, range.start.column, range.end.row, range.end.column);\n        restoreModel.endIndex = restoreModel.startIndex + (model.insertText?.text.length ?? 1); // this is to restore in range with deleting/replacing content within\n        this.history.pushReplace(restoreModel, model);\n        this.commandsService.createCommand(SaveCommandsHelper.getReplaceCommand(model, this.targets));\n    }\n\n    private createRestoreFromSlice(paragraphStart: number, indexInStart: number, paragraphEnd: number, indexInEnd: number): RestoreModel {\n        const startIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraphStart, indexInStart);\n        const endIndex = ContentHelper.paragraphToDocumentIndex(this.session.wrapParagraphIndex, paragraphEnd, indexInEnd) - 1;\n        const text = this.session.model.content.slice(startIndex, endIndex + 1);\n        const formats = FormatHelper.sliceSection(this.session.model.formats, startIndex, endIndex);\n        const paragraphs = IndexedElementHelper.sliceSection(this.session.model.paragraphs, startIndex, endIndex).map(\n            x => new ParagraphModel(x)\n        );\n        const images = IndexedElementHelper.sliceSection(this.session.model.images, startIndex, endIndex).map(x => new ImageModel(x));\n        const tables = IndexedElementHelper.sliceSection(this.session.model.tables, startIndex, endIndex).map(x => new TableModel(x));\n        const elements = IndexedElementHelper.sliceSection(this.session.model.elements, startIndex, endIndex).map(x => new ElementModel(x));\n        const breaks = IndexedElementHelper.sliceSection(this.session.model.breaks, startIndex, endIndex).map(x => new BreakModel(x));\n        const tabs = IndexedElementHelper.sliceSection(this.session.model.tabs, startIndex, endIndex).map(x => new TabModel(x));\n        const links = IndexedElementHelper.sliceSection(this.session.model.links, startIndex, endIndex).map(x => new LinkModel(x));\n        return new RestoreModel({ startIndex, endIndex, text, formats, paragraphs, images, tables, elements, breaks, tabs, links });\n    }\n\n    createCustomElement(data: ElementDataModel): void {\n        const insertIndex = ContentHelper.paragraphToDocumentIndex(\n            this.session.wrapParagraphIndex,\n            this.selection.range.start.row,\n            this.selection.range.start.column\n        );\n        const insertElement = new InsertElementModel({ element: new ElementModel({ ...data, insertIndex }) });\n        if (!this.selection.isEmpty) {\n            this.replaceBy(new ReplaceModel({ insertElement }));\n            return;\n        }\n\n        this.saveInsertElementToHistory(insertElement);\n        const endPoint = this.session.insertElement(this.selection.cursor, data);\n        this.onDocumentChange(new Range(this.selection.cursor, endPoint));\n        this.onSelectionChange();\n    }\n\n    removeSelected(): void {\n        if (this.selection.isEmpty) {\n            return;\n        }\n\n        this.saveRemoveToHistory(this.selection.range);\n        this.session.remove(this.selection.range);\n        this.onSelectionChange();\n    }\n\n    onInput(): void {\n        const text = this.textInput.getInsertText();\n        if (!text) {\n            return;\n        }\n\n        const isEmptyNumberingParagraph = this.isEmptyNumberingParagraph(this.selection.cursor.row);\n        if (text === NEW_LINE_MARKUP && this.selection.isEmpty && isEmptyNumberingParagraph) {\n            this.removeNumberingsFromParagraphs();\n        } else {\n            this.insert(text);\n            this.scrollCursorIntoMainView();\n        }\n    }\n\n    onCut(event: ClipboardEvent): void {\n        event.preventDefault();\n        const data = this.getSelectedText();\n        if (!data) {\n            return;\n        }\n        this.editorService.setClipboardData(data);\n        this.clipboard.copy(data);\n        this.cut();\n        this.scrollCursorIntoMainView();\n    }\n\n    onCopy(event: ClipboardEvent): void {\n        event.preventDefault();\n        const data = this.getSelectedText();\n        if (!data) {\n            return;\n        }\n        this.editorService.setClipboardData(data);\n        this.clipboard.copy(data);\n    }\n\n    onPaste(event: ClipboardEvent): void {\n        event.preventDefault();\n        const data = this.textInput.getClipboardData(event);\n        this.pasteData(data);\n    }\n\n    private initResizeListener(): void {\n        window.addEventListener('resize', this.rerenderResize);\n    }\n\n    private destroyResizeListener(): void {\n        window.removeEventListener('resize', this.rerenderResize);\n    }\n\n    private rerenderMarker(): void {\n        this.renderer.loop.schedule({ marker: true });\n    }\n\n    private rerenderResize = (): void => {\n        this.mainRenderer.onResize(true);\n    };\n\n    onBlur(): void {\n        if (!this.textInput.isFocused) {\n            return;\n        }\n\n        this.textInput.isFocused = false;\n        this.renderer.hideCursor();\n    }\n\n    onFocus(): void {\n        if (this.textInput.isFocused) {\n            return;\n        }\n\n        this.blurCustomComponent();\n        this.textInput.isFocused = true;\n        this.renderer.showCursor();\n    }\n\n    onMouseClick(event: MouseEvent): void {\n        const customElement = this.setCurrentSession(event.clientY, event.target as HTMLElement);\n        if (customElement && customElement.tagName !== this.tableCellTagName) {\n            this.focusCustomComponent(customElement);\n        } else {\n            this.blurCustomComponent();\n        }\n    }\n\n    onLeftClick(event: MouseEvent): void {\n        const customElement = this.setCurrentSession(event.clientY, event.target as HTMLElement);\n        if (customElement && customElement.tagName !== this.tableCellTagName) {\n            this.focusCustomComponent(customElement);\n            return;\n        }\n\n        this.blurCustomComponent();\n\n        if (!this.textInput.isFocused) {\n            this.textInput.input.focus();\n        }\n\n        const position = this.renderer.screenToTextCoordinates(event.clientX, event.clientY);\n        if (event.shiftKey) {\n            this.selection.moveSelection(position);\n        } else if (event.ctrlKey) {\n            const linkModel = this.session.getLinkModel(position);\n            if (linkModel) {\n                window.open(linkModel.link);\n                event.preventDefault();\n                return;\n            }\n        } else {\n            this.selection.placeCursor(position);\n        }\n\n        this.onSelectionChange();\n        event.preventDefault();\n        this.mouseHandler.startMousePress(this);\n    }\n\n    onDoubleClick(event: MouseEvent): void {\n        this.session.removeEventListener('setStyles', this.setStyles);\n        let isStartEditEdge = false;\n        const customElement = this.getCustomElement(event.target as HTMLElement);\n        if (customElement) {\n            const elementSessionId = +customElement.attributes.getNamedItem('data-session-id').value;\n            let clickedPage: number = null;\n            const isParentEdge = this.isParentEdge(customElement);\n            if (customElement.tagName === this.edgeElementTagName || (isParentEdge && !this.regulatorService.edgeEditingPage)) {\n                clickedPage = this.getClickedPage(event.clientY);\n                isStartEditEdge = !this.regulatorService.edgeEditingPage;\n            }\n            this.regulatorService.setCustomSessionAsCurrent(elementSessionId, clickedPage);\n        } else {\n            this.regulatorService.setMainSessionAsCurrent();\n        }\n\n        this.session.addEventListener('setStyles', this.setStyles);\n        if (customElement && customElement.tagName !== this.tableCellTagName && customElement.tagName !== this.edgeElementTagName) {\n            this.focusCustomComponent(customElement);\n            return;\n        }\n\n        this.blurCustomComponent();\n        event.preventDefault();\n        const position = this.renderer.screenToTextCoordinates(event.clientX, event.clientY);\n        if (isStartEditEdge) {\n            this.selection.placeCursor(position);\n        } else {\n            const range = this.session.getWordRange(position.row, position.column);\n            this.selection.placeSelection(range.start, range.end);\n        }\n        this.onSelectionChange();\n    }\n\n    onTripleClick(event: MouseEvent): void {\n        const customElement = this.setCurrentSession(event.clientY, event.target as HTMLElement);\n        if (customElement && customElement.tagName !== this.tableCellTagName) {\n            this.focusCustomComponent(customElement);\n            return;\n        }\n\n        this.blurCustomComponent();\n        event.preventDefault();\n        const position = this.renderer.screenToTextCoordinates(event.clientX, event.clientY);\n        const start = new CursorParagraph(position.row, 0);\n        const end = new CursorParagraph(position.row, this.session.document.lines[position.row].length);\n        this.selection.placeSelection(start, end);\n        this.onSelectionChange();\n    }\n\n    onQuadClick(event: MouseEvent): void {\n        const customElement = this.setCurrentSession(event.clientY, event.target as HTMLElement);\n        if (customElement && customElement.tagName !== this.tableCellTagName) {\n            this.focusCustomComponent(customElement);\n            return;\n        }\n\n        this.blurCustomComponent();\n        event.preventDefault();\n        this.selection.selectAll(this.session.model);\n        this.onSelectionChange();\n    }\n\n    onMouseWheel(event: WheelEvent): void {\n        if (event.ctrlKey) {\n            return;\n        }\n\n        const factor = 0.35;\n        const scrollSpeed = 4;\n        const deltaY = event.deltaY * factor * scrollSpeed;\n        this.mainRenderer.scrollBy(deltaY);\n        event.stopPropagation();\n        event.preventDefault();\n    }\n\n    setCurrentSession(clickPositionY: number, element: HTMLElement): HTMLElement | null {\n        this.session.removeEventListener('setStyles', this.setStyles);\n        const customElement = this.getCustomElement(element);\n        if (!customElement) {\n            this.regulatorService.setMainSessionAsCurrent();\n        } else {\n            const elementSessionId = +customElement.attributes.getNamedItem('data-session-id').value;\n            const isEdgeEditing = this.regulatorService.edgeEditingPage;\n            if (customElement.tagName === this.edgeElementTagName) {\n                if (isEdgeEditing) {\n                    const clickedPage = this.getClickedPage(clickPositionY);\n                    this.regulatorService.setCustomSessionAsCurrent(elementSessionId, clickedPage);\n                } else {\n                    this.regulatorService.setMainSessionAsCurrent();\n                }\n            } else {\n                const isParentEdge = this.isParentEdge(customElement);\n                if (!isParentEdge) {\n                    this.regulatorService.setCustomSessionAsCurrent(elementSessionId);\n                    this.session.addEventListener('setStyles', this.setStyles);\n                    return customElement;\n                }\n\n                if (isEdgeEditing) {\n                    const clickedPage = this.getClickedPage(clickPositionY);\n                    this.regulatorService.setCustomSessionAsCurrent(elementSessionId, clickedPage);\n                    this.session.addEventListener('setStyles', this.setStyles);\n                    return customElement;\n                } else {\n                    this.regulatorService.setMainSessionAsCurrent();\n                }\n            }\n        }\n\n        this.session.addEventListener('setStyles', this.setStyles);\n        return null;\n    }\n\n    getCustomElement(element: HTMLElement): HTMLElement | null {\n        if (element.tagName === this.parentTagName) {\n            return null;\n        } else if (this.customElementTagNames.includes(element.tagName)) {\n            return element;\n        } else {\n            return this.getCustomElement(element.parentElement);\n        }\n    }\n\n    isParentEdge(element: HTMLElement): boolean {\n        if (element.tagName === this.parentTagName) {\n            return false;\n        } else if (element.tagName === this.edgeElementTagName) {\n            return true;\n        } else {\n            return this.isParentEdge(element.parentElement);\n        }\n    }\n\n    getClickedPage(mousePosition: number): number {\n        const positionY = mousePosition + this.mainSession.scrollTop - this.mainRenderer.container.getBoundingClientRect().top;\n        return PositionHelper.pixelToPage(positionY, this.mainSession);\n    }\n\n    setStyles = (styles: IToolbarStyles) => {\n        this.editorService.styles = styles;\n    };\n\n    /**\n     * Returns the string of text currently highlighted.\n     */\n    getSelectedText(): string {\n        if (this.selection.isEmpty) {\n            return '';\n        }\n\n        const startIndex = ContentHelper.paragraphPositionToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.start);\n        const endIndex = ContentHelper.paragraphPositionToDocumentIndex(this.session.wrapParagraphIndex, this.selection.range.end);\n        let elementIndexes: number[] = [];\n        ContentHelper.setIndexesElementsInInterval(this.session.model.breaks, elementIndexes, startIndex, endIndex);\n        ContentHelper.setIndexesElementsInInterval(this.session.model.tables, elementIndexes, startIndex, endIndex);\n        ContentHelper.setIndexesElementsInInterval(this.session.model.images, elementIndexes, startIndex, endIndex);\n        ContentHelper.setIndexesElementsInInterval(this.session.model.elements, elementIndexes, startIndex, endIndex);\n        ContentHelper.setIndexesElementsInInterval(this.session.model.tabs, elementIndexes, startIndex, endIndex);\n        elementIndexes.sort((a, b) => b - a);\n        let textInterval = this.session.document.getTextRange(this.selection.range);\n        elementIndexes.forEach(x => {\n            textInterval = textInterval.slice(0, x) + textInterval.slice(x + 1);\n        });\n\n        return textInterval;\n    }\n\n    initMainSession(): void {\n        const pageWidth = this.customPageWidth ?? this.model.pageWidth;\n        this.container.nativeElement.style.maxWidth = `${pageWidth}px`;\n        const scalingRatio = this.customPageWidth ? ScalingHelper.getRatio(this.customPageWidth, this.model.pageWidth) : 1;\n        this.regulatorService.addMainSession(this.model, pageWidth, scalingRatio, this.container);\n        this.session.addEventListener('setStyles', this.setStyles);\n    }\n\n    onSelectionChange(): void {\n        this.session.processSelectionStyles();\n        this.renderer.updateSelection(this.selection.range);\n        if (this.selection.isEmpty) {\n            this.renderer.updateCursor();\n        }\n        this.editorService.setHasSelection(!this.selection.isEmpty);\n        this.rerenderMarker();\n    }\n\n    onHotKeyDown(event: KeyboardEvent): void {\n        this.editorService.keyDown(event);\n    }\n\n    onPrint(): void {\n        PrintHelper.printDocument(this.mainSession, this.editorService);\n    }\n\n    private onDocumentChange = (range: Range): void => {\n        let lastRow = range.start.row === range.end.row ? range.end.row : Infinity;\n        this.renderer.updateLines(range.start.row, lastRow);\n\n        // Update cursor because tab characters can influence the cursor position.\n        this.renderer.updateCursor();\n    };\n\n    private focusCustomComponent(element: HTMLElement): void {\n        const index = +element.attributes.getNamedItem('data-insert-index').value;\n        const component =\n            this.session.customComponents.images.find(x => x.instance.insertIndex === index) ??\n            this.session.customComponents.tables.find(x => x.instance.insertIndex === index) ??\n            this.session.customComponents.customElements.find(x => x.instance.insertIndex === index);\n        if (!component || component === this.focusedComponent) {\n            return;\n        }\n\n        this.focusedComponent?.instance.blur();\n        component.instance.focus();\n        this.focusedComponent = component;\n        const position = this.session.document.indexToPosition(index, 0);\n        this.selection.placeCursor(position);\n        this.onSelectionChange();\n    }\n\n    private blurCustomComponent(): void {\n        if (this.focusedComponent) {\n            this.focusedComponent.instance.blur();\n            this.focusedComponent = null;\n        }\n    }\n\n    private isEmptyNumberingParagraph(paragraphIndex: number): boolean {\n        const currentLine = this.session.document.getLine(this.session.document.lines, paragraphIndex);\n        return currentLine.length === 0 && this.session.model.paragraphs[paragraphIndex].paragraphStyle.numberingId !== null;\n    }\n\n    scrollCursorIntoMainView(offset?: number): void {\n        if (this.session !== this.mainSession) {\n            return;\n        }\n        this.mainRenderer.scrollCursorIntoView(null, offset);\n    }\n\n    changedTableSize(insertIndex: number, sessionId: number): void {\n        const session = this.regulatorService.getSession(sessionId);\n        const paragraph = ContentHelper.documentIndexToParagraphIndex(session.wrapParagraphIndex, insertIndex).row;\n        session.updateWrapData(paragraph, paragraph);\n        this.textInput.input.focus();\n    }\n\n    insertTableRows(insertIndex: number, rowsCount: number, targetIndex: number, inheritIndex: number, sessionId: number): void {\n        this.regulatorService.setCustomSessionAsCurrent(sessionId);\n        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);\n        this.selection.placeCursor(beforeTable);\n        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);\n        this.history.pushInsertTableRows(insertIndex, rowsCount, targetIndex, inheritIndex, table);\n        this.commandsService.createCommand(\n            SaveCommandsHelper.getInsertTableRowsCommand(rowsCount, inheritIndex, insertIndex, targetIndex, this.targets)\n        );\n        this.session.insertTableRows(insertIndex, rowsCount, targetIndex, inheritIndex);\n        this.changedTableSize(insertIndex, sessionId);\n    }\n\n    insertTableColumns(insertIndex: number, columnsCount: number, targetIndex: number, inheritIndex: number, sessionId: number): void {\n        this.regulatorService.setCustomSessionAsCurrent(sessionId);\n        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);\n        this.selection.placeCursor(beforeTable);\n        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);\n        this.history.pushInsertTableColumns(insertIndex, columnsCount, targetIndex, inheritIndex, table);\n        this.commandsService.createCommand(\n            SaveCommandsHelper.getInsertTableColumnsCommand(columnsCount, inheritIndex, insertIndex, targetIndex, this.targets)\n        );\n        this.session.insertTableColumns(insertIndex, columnsCount, targetIndex, inheritIndex);\n        this.changedTableSize(insertIndex, sessionId);\n    }\n\n    removeTableRows(insertIndex: number, startIndex: number, endIndex: number, sessionId: number): void {\n        this.regulatorService.setCustomSessionAsCurrent(sessionId);\n        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);\n        this.selection.placeCursor(beforeTable);\n        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);\n        this.history.pushRemoveTableRows(insertIndex, startIndex, endIndex, table);\n        this.commandsService.createCommand(SaveCommandsHelper.getRemoveTableRowsCommand(startIndex, endIndex, insertIndex, this.targets));\n        this.session.removeTableRows(insertIndex, startIndex, endIndex);\n        this.changedTableSize(insertIndex, sessionId);\n    }\n\n    removeTableColumns(insertIndex: number, startIndex: number, endIndex: number, sessionId: number): void {\n        this.regulatorService.setCustomSessionAsCurrent(sessionId);\n        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, insertIndex);\n        this.selection.placeCursor(beforeTable);\n        const table = this.session.model.tables.find(x => x.insertIndex === insertIndex);\n        this.history.pushRemoveTableColumns(insertIndex, startIndex, endIndex, table);\n        this.commandsService.createCommand(\n            SaveCommandsHelper.getRemoveTableColumnsCommand(startIndex, endIndex, insertIndex, this.targets)\n        );\n        this.session.removeTableColumns(insertIndex, startIndex, endIndex);\n        this.changedTableSize(insertIndex, sessionId);\n    }\n\n    removeImage(insertIndex: number): void {\n        const range = this.session.document.indexesToRange(insertIndex, insertIndex + 1);\n        this.saveRemoveToHistory(range);\n        this.session.remove(range);\n        this.renderer.updateCursor();\n        this.textInput.input.focus();\n    }\n\n    resizeTableColumns(resizeTableColumns: ResizeTableColumnsModel, sessionId: number): void {\n        this.regulatorService.setCustomSessionAsCurrent(sessionId);\n        const beforeTable = ContentHelper.documentIndexToParagraphIndex(this.session.wrapParagraphIndex, resizeTableColumns.insertIndex);\n        this.selection.placeCursor(beforeTable);\n        this.history.pushResizeTableColumns(resizeTableColumns);\n        this.session.resizeTableColumns(resizeTableColumns);\n        this.changedTableSize(resizeTableColumns.insertIndex, sessionId);\n    }\n\n    onMousePressedMove(x: number, y: number): void {\n        const position = this.renderer.screenToTextCoordinates(x, y);\n        this.selection.moveSelection(position);\n        this.onSelectionChange();\n        this.scrollCursorIntoMainView();\n    }\n\n    searchOptionSubscription(): Subscription {\n        return this.editorService.searchOptions$.subscribe(searchOptions => {\n            this.find(searchOptions);\n            this.editorService.searchIteration = this.updateCounter();\n        });\n    }\n\n    replaceSubscription(): Subscription {\n        return this.editorService.replace$.subscribe(replace => {\n            this.replace(replace.searchValue, replace.replaceValue);\n            this.editorService.searchIteration = this.updateCounter();\n        });\n    }\n\n    setTextStylesSubscription(): Subscription {\n        return this.editorService.setTextStyles$.subscribe(textStyles => {\n            this.applyTextStyles(textStyles);\n            this.focus();\n        });\n    }\n\n    setParagraphStylesSubscription(): Subscription {\n        return this.editorService.setParagraphStyles$.subscribe(paragraphStyles => {\n            this.applyParagraphStyles(paragraphStyles);\n            this.focus();\n        });\n    }\n\n    setNumberingTemplateTypeSubscription(): Subscription {\n        return this.editorService.setNumberingTemplateType$.subscribe(numberingTemplateType => {\n            this.setNumberingTemplate(numberingTemplateType);\n            this.focus();\n        });\n    }\n\n    removeNumberingsSubscription(): Subscription {\n        return this.editorService.removeNumberings$.subscribe(() => {\n            this.removeNumberingsFromParagraphs();\n            this.focus();\n        });\n    }\n\n    setImageStyleSubscription(): Subscription {\n        return this.editorService.setImageStyle$.subscribe(image => {\n            this.applyImageStyles(image);\n            this.focus();\n        });\n    }\n\n    changeElementStyleSubscription(): Subscription {\n        return this.editorService.changeElementStyle$.subscribe(x => this.applyElementStyle(x));\n    }\n\n    createCustomComponentSubscription(): Subscription {\n        return this.editorService.createCustomComponent$.subscribe(model => {\n            this.createCustomElement(model);\n            this.focus();\n        });\n    }\n\n    insertBreakSubscription(): Subscription {\n        return this.editorService.insertBreak$.subscribe(breakType => {\n            this.insertBreak(breakType);\n            this.focus();\n        });\n    }\n\n    insertImageSubscription(): Subscription {\n        return this.editorService.insertImage$.subscribe(imageData => {\n            this.insertImage(imageData);\n            this.focus();\n        });\n    }\n\n    insertLinkSubscription(): Subscription {\n        return this.editorService.insertLink$.subscribe(linkData => {\n            this.insertLink(linkData);\n            this.focus();\n        });\n    }\n\n    endMousePressSubscription(): Subscription {\n        return this.editorService.endMousePress$.subscribe(() => {\n            this.mouseHandler.endMousePress();\n        });\n    }\n\n    clearSelectionSubscription(): Subscription {\n        return this.editorService.clearSelection$.subscribe(() => {\n            this.selection.clearSelection();\n            this.onSelectionChange();\n        });\n    }\n\n    changedTableSizeSubscription(): Subscription {\n        return this.editorService.changedTableSize$.subscribe(data => {\n            this.changedTableSize(data.insertIndex, data.sessionId);\n        });\n    }\n\n    insertTableRowsSubscription(): Subscription {\n        return this.editorService.insertTableRows$.subscribe(data => {\n            this.insertTableRows(data.insertIndex, data.rowsCount, data.targetIndex, data.inheritIndex, data.sessionId);\n        });\n    }\n\n    insertTableColumnsSubscription(): Subscription {\n        return this.editorService.insertTableColumns$.subscribe(data => {\n            this.insertTableColumns(data.insertIndex, data.columnsCount, data.targetIndex, data.inheritIndex, data.sessionId);\n        });\n    }\n\n    removeTableRowsSubscription(): Subscription {\n        return this.editorService.removeTableRows$.subscribe(data => {\n            this.removeTableRows(data.insertIndex, data.startIndex, data.endIndex, data.sessionId);\n        });\n    }\n\n    removeTableColumnsSubscription(): Subscription {\n        return this.editorService.removeTableColumns$.subscribe(data => {\n            this.removeTableColumns(data.insertIndex, data.startIndex, data.endIndex, data.sessionId);\n        });\n    }\n\n    removedImageSubscription(): Subscription {\n        return this.editorService.removeImage$.subscribe(data => {\n            this.removeImage(data.insertIndex);\n        });\n    }\n\n    resizeTableColumnsSubscription(): Subscription {\n        return this.editorService.resizeTableColumns$.subscribe(data => {\n            this.resizeTableColumns(data.resizeTableColumns, data.sessionId);\n        });\n    }\n\n    insertTableSubscription(): Subscription {\n        return this.editorService.insertTable$.subscribe(data => {\n            this.insertTable(data);\n        });\n    }\n\n    rendererUpdatedSubscription(): Subscription {\n        return this.editorService.rendererUpdated$.subscribe(sessionId => {\n            const edgeTarget = this.regulatorService.getEdgeTarget(sessionId);\n            if (edgeTarget !== null) {\n                this.mainRenderer.renderer.textLayer.updateEdgeByLocation(edgeTarget.edgeData.pageType as PageType);\n            }\n        });\n    }\n\n    edgeElementCopyUpdatedSubscription(): Subscription {\n        return this.editorService.edgeElementCopyUpdated$.subscribe(data => {\n            if (this.regulatorService.edgeEditingPage !== data.page) {\n                return;\n            }\n\n            const edgeSessionId = +data.newElementCopy.attributes.getNamedItem('data-session-id').value;\n            const edgeSession = this.regulatorService.sessions.find(x => x.sessionId === edgeSessionId);\n            edgeSession.renderer.container = data.newElementCopy.firstChild as HTMLElement;\n        });\n    }\n\n    changedEdgeHeightSubscription(): Subscription {\n        return this.editorService.changedEdgeHeight$.subscribe(edgeType => {\n            this.mainSession.pagesWrap.updatePageVerticalData(\n                edgeType,\n                this.regulatorService.edgeEditingPage,\n                this.mainSession.wrapParagraphIndex\n            );\n        });\n    }\n\n    undoSubscription(): Subscription {\n        return this.editorService.undo$.subscribe(() => {\n            this.undo();\n            this.focus();\n            this.scrollCursorIntoMainView();\n        });\n    }\n\n    redoSubscription(): Subscription {\n        return this.editorService.redo$.subscribe(() => {\n            this.redo();\n            this.focus();\n            this.scrollCursorIntoMainView();\n        });\n    }\n\n    private printSubscription(): Subscription {\n        return this.editorService.print$.subscribe(() => this.onPrint());\n    }\n\n    private cutSelectedSubscription(): Subscription {\n        return this.editorService.cutSelected$.subscribe(() => {\n            this.onCut(new ClipboardEvent('cut'));\n        });\n    }\n\n    private copySelectedSubscription(): Subscription {\n        return this.editorService.copySelected$.subscribe(() => {\n            this.onCopy(new ClipboardEvent('copy'));\n        });\n    }\n\n    private pasteFromClipboardSubscription(): Subscription {\n        return this.editorService.pasteFromClipboard$.subscribe(() => {\n            this.readClipboard()\n                .then(data => this.pasteData(data))\n                .catch(() => {\n                    // continue regardless error\n                });\n        });\n    }\n\n    private async readClipboard(): Promise<string> {\n        const read = await navigator.permissions.query({ name: 'clipboard-read' as PermissionName });\n        return new Promise(resolve => {\n            if (navigator.clipboard && read.state != 'denied') {\n                navigator.clipboard\n                    .readText()\n                    .then(data => {\n                        resolve(data);\n                    })\n                    .catch(() => {\n                        // continue regardless error\n                    });\n            } else {\n                resolve(this.clipboardData);\n            }\n        });\n    }\n\n    private pasteData(data: string): void {\n        if (!data) {\n            return;\n        }\n        const text = data.replace(/\\r\\n/g, '\\n').replace(/\\t/g, ' ');\n        this.insert(text);\n        this.scrollCursorIntoMainView();\n    }\n\n    private selectAllSubscription(): Subscription {\n        return this.editorService.selectAll$.subscribe(() => {\n            this.selection.selectAll(this.session.model);\n            this.onSelectionChange();\n        });\n    }\n\n    private removeSelectedSubscription(): Subscription {\n        return this.editorService.removeSelected$.subscribe(() => {\n            this.removeSelected();\n        });\n    }\n\n    private clipboardDataSubscription(): Subscription {\n        return this.editorService.clipboardData$.subscribe(data => {\n            this.clipboardData = data;\n        });\n    }\n}\n"]}