@talrace/ngx-noder 0.0.7 → 0.0.9

package/esm2022/lib/editor/operations/save-commands.helper.mjs

@@ -0,0 +1,127 @@
+import { AddNumberingModel } from '../../models/generated/add-numbering.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 { CommandModel } from '../../models/generated/command.model';
+import { CommandType } from './enums/command-type.enum';
+import { DeleteModel } from '../../models/generated/delete.model';
+import { InsertStyledTextModel } from '../../models/generated/insert-styled-text.model';
+import { InsertTableColumnsModel } from '../../models/generated/insert-table-columns.model';
+import { InsertTableRowsModel } from '../../models/generated/insert-table-rows.model';
+import { InsertTextModel } from '../../models/generated/insert-text.model';
+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 { RestoreModel } from '../../models/generated/restore.model';
+import { RestoreParagraphStylesModel } from '../../models/generated/restore-paragraph-styles.model';
+import { RestoreTextStylesModel } from '../../models/generated/restore-text-styles.model';
+export class SaveCommandsHelper {
+    static getAddNumberingCommand(startIndex, endIndex, levels, targets) {
+        const addNumbering = new AddNumberingModel({ startIndex, endIndex, levels });
+        return new CommandModel({ commandType: CommandType.AddNumbering, addNumbering, targets });
+    }
+    static getRemoveNumberingsCommand(startIndex, endIndex, targets) {
+        const removeNumberings = new RemoveNumberingsModel({ startIndex, endIndex });
+        return new CommandModel({ commandType: CommandType.RemoveNumberings, removeNumberings, targets });
+    }
+    static getRestoreNumberingsCommand(restoreNumberings, targets) {
+        return new CommandModel({ commandType: CommandType.AddNumbering, restoreNumberings, targets });
+    }
+    static getApplyImageStyleCommand(height, width, insertIndex, targets) {
+        const applyImageStyle = new ApplyImageStyleModel({ height, width, insertIndex });
+        return new CommandModel({ commandType: CommandType.ApplyImageStyle, applyImageStyle, targets });
+    }
+    static getApplyParagraphStyleCommand(startIndex, endIndex, paragraphStyle, targets) {
+        const applyParagraphStyle = new ApplyParagraphStyleModel({ startIndex, endIndex, paragraphStyle });
+        return new CommandModel({ commandType: CommandType.ApplyParagraphStyle, applyParagraphStyle, targets });
+    }
+    static getApplyTextStyleCommand(startIndex, endIndex, textStyle, targets) {
+        const applyTextStyle = new ApplyTextStyleModel({ startIndex, endIndex, textStyle });
+        return new CommandModel({ commandType: CommandType.ApplyTextStyle, applyTextStyle, targets });
+    }
+    static getDeleteCommand(startIndex, endIndex, targets) {
+        const deleteModel = new DeleteModel({ startIndex, endIndex });
+        return new CommandModel({ commandType: CommandType.Delete, delete: deleteModel, targets });
+    }
+    static getInsertTextCommand(text, insertIndex, targets) {
+        const insertText = new InsertTextModel({ text, insertIndex });
+        return new CommandModel({ commandType: CommandType.InsertText, insertText, targets });
+    }
+    static getInsertParagraphCommand(insertParagraph, targets) {
+        return new CommandModel({ commandType: CommandType.InsertParagraph, insertParagraph, targets });
+    }
+    static getInsertStyledTextCommand(text, insertIndex, textStyle, targets) {
+        const insertStyledText = new InsertStyledTextModel({ text, insertIndex, textStyle });
+        return new CommandModel({ commandType: CommandType.InsertStyledText, insertStyledText, targets });
+    }
+    static getInsertBreakCommand(insertBreak, targets) {
+        return new CommandModel({ commandType: CommandType.InsertBreak, insertBreak, targets });
+    }
+    static getInsertElementCommand(insertElement, targets) {
+        return new CommandModel({ commandType: CommandType.InsertElement, insertElement, targets });
+    }
+    static getInsertImageCommand(insertImage, targets) {
+        return new CommandModel({ commandType: CommandType.InsertImage, insertImage, targets });
+    }
+    static getInsertLinkOperation(insertLink, targets) {
+        return new CommandModel({ commandType: CommandType.InsertLink, insertLink, targets });
+    }
+    static getInsertTabCommand(insertTab, targets) {
+        return new CommandModel({ commandType: CommandType.InsertTab, insertTab, targets });
+    }
+    static getInsertTableCommand(insertTable, targets) {
+        return new CommandModel({ commandType: CommandType.InsertTable, insertTable, targets });
+    }
+    static getInsertTableColumnsCommand(columnsCount, inheritIndex, insertIndex, targetIndex, targets) {
+        const insertTableColumns = new InsertTableColumnsModel({ columnsCount, inheritIndex, insertIndex, targetIndex });
+        return new CommandModel({ commandType: CommandType.InsertTableColumns, insertTableColumns, targets });
+    }
+    static getInsertTableRowsCommand(rowsCount, inheritIndex, insertIndex, targetIndex, targets) {
+        const insertTableRows = new InsertTableRowsModel({ rowsCount, inheritIndex, insertIndex, targetIndex });
+        return new CommandModel({ commandType: CommandType.InsertTableRows, insertTableRows, targets });
+    }
+    static getRemoveTableColumnsCommand(startIndex, endIndex, insertIndex, targets) {
+        const removeTableColumns = new RemoveTableColumnsModel({ startIndex, endIndex, insertIndex });
+        return new CommandModel({ commandType: CommandType.RemoveTableColumns, removeTableColumns, targets });
+    }
+    static getRemoveTableRowsCommand(startIndex, endIndex, insertIndex, targets) {
+        const removeTableRows = new RemoveTableRowsModel({ startIndex, endIndex, insertIndex });
+        return new CommandModel({ commandType: CommandType.RemoveTableRows, removeTableRows, targets });
+    }
+    static getRestoreTextStylesCommand(formats, targets) {
+        const restoreTextStyles = new RestoreTextStylesModel({ formats });
+        return new CommandModel({ commandType: CommandType.RestoreTextStyles, restoreTextStyles, targets });
+    }
+    static getRestoreParagraphStylesCommand(paragraphs, targets) {
+        const restoreParagraphStyles = new RestoreParagraphStylesModel({ paragraphs });
+        return new CommandModel({ commandType: CommandType.RestoreParagraphStyles, restoreParagraphStyles, targets });
+    }
+    static getRestoreCommand(restoreModel, targets) {
+        const restore = new RestoreModel({
+            breaks: restoreModel.breaks,
+            elements: restoreModel.elements,
+            formats: restoreModel.formats,
+            images: restoreModel.images,
+            startIndex: restoreModel.startIndex,
+            endIndex: restoreModel.endIndex,
+            paragraphs: restoreModel.paragraphs,
+            tables: restoreModel.tables,
+            tabs: restoreModel.tabs,
+            text: restoreModel.text
+        });
+        return new CommandModel({ commandType: CommandType.Restore, restore, targets });
+    }
+    static getRestoreTableCommand(restoreTable, targets) {
+        return new CommandModel({ commandType: CommandType.RestoreTable, restoreTable, targets });
+    }
+    static getReplaceCommand(model, targets) {
+        return new CommandModel({ commandType: CommandType.Replace, replace: model, targets });
+    }
+    static getResizeTableColumnsCommand(resizeTableColumns, targets) {
+        return new CommandModel({ commandType: CommandType.ResizeTableColumns, resizeTableColumns, targets });
+    }
+    static getApplyElementStyleCommand(applyElementStyle, targets) {
+        return new CommandModel({ commandType: CommandType.ApplyElementStyle, applyElementStyle, targets });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save-commands.helper.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/operations/save-commands.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { 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 { CommandModel } from '../../models/generated/command.model';\nimport { CommandType } from './enums/command-type.enum';\nimport { DeleteModel } from '../../models/generated/delete.model';\nimport { FormatModel } from '../../models/generated/format.model';\nimport { InsertBreakModel } from '../../models/generated/insert-break.model';\nimport { InsertElementModel } from '../../models/generated/insert-element.model';\nimport { InsertImageModel } from '../../models/generated/insert-image.model';\nimport { 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 { NumberingLevelModel } from '../../models/generated/numbering-level.model';\nimport { ParagraphModel } from '../../models/generated/paragraph.model';\nimport { ParagraphStyleModel } from '../../models/generated/paragraph-style.model';\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 { 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 { TargetModel } from '../../models/generated/target.model';\nimport { TextStyleModel } from '../../models/generated/text-style.model';\n\nexport class SaveCommandsHelper {\n    public static getAddNumberingCommand(\n        startIndex: number,\n        endIndex: number,\n        levels: NumberingLevelModel[],\n        targets: TargetModel[]\n    ): CommandModel {\n        const addNumbering = new AddNumberingModel({ startIndex, endIndex, levels });\n        return new CommandModel({ commandType: CommandType.AddNumbering, addNumbering, targets });\n    }\n\n    public static getRemoveNumberingsCommand(startIndex: number, endIndex: number, targets: TargetModel[]): CommandModel {\n        const removeNumberings = new RemoveNumberingsModel({ startIndex, endIndex });\n        return new CommandModel({ commandType: CommandType.RemoveNumberings, removeNumberings, targets });\n    }\n    public static getRestoreNumberingsCommand(restoreNumberings: RestoreNumberingsModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.AddNumbering, restoreNumberings, targets });\n    }\n\n    public static getApplyImageStyleCommand(height: number, width: number, insertIndex: number, targets: TargetModel[]): CommandModel {\n        const applyImageStyle = new ApplyImageStyleModel({ height, width, insertIndex });\n        return new CommandModel({ commandType: CommandType.ApplyImageStyle, applyImageStyle, targets });\n    }\n\n    public static getApplyParagraphStyleCommand(\n        startIndex: number,\n        endIndex: number,\n        paragraphStyle: ParagraphStyleModel,\n        targets: TargetModel[]\n    ): CommandModel {\n        const applyParagraphStyle = new ApplyParagraphStyleModel({ startIndex, endIndex, paragraphStyle });\n        return new CommandModel({ commandType: CommandType.ApplyParagraphStyle, applyParagraphStyle, targets });\n    }\n\n    public static getApplyTextStyleCommand(\n        startIndex: number,\n        endIndex: number,\n        textStyle: TextStyleModel,\n        targets: TargetModel[]\n    ): CommandModel {\n        const applyTextStyle = new ApplyTextStyleModel({ startIndex, endIndex, textStyle });\n        return new CommandModel({ commandType: CommandType.ApplyTextStyle, applyTextStyle, targets });\n    }\n\n    public static getDeleteCommand(startIndex: number, endIndex: number, targets: TargetModel[]): CommandModel {\n        const deleteModel = new DeleteModel({ startIndex, endIndex });\n        return new CommandModel({ commandType: CommandType.Delete, delete: deleteModel, targets });\n    }\n\n    public static getInsertTextCommand(text: string, insertIndex: number, targets: TargetModel[]): CommandModel {\n        const insertText = new InsertTextModel({ text, insertIndex });\n        return new CommandModel({ commandType: CommandType.InsertText, insertText, targets });\n    }\n\n    public static getInsertParagraphCommand(insertParagraph: InsertParagraphModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertParagraph, insertParagraph, targets });\n    }\n\n    public static getInsertStyledTextCommand(\n        text: string,\n        insertIndex: number,\n        textStyle: TextStyleModel,\n        targets: TargetModel[]\n    ): CommandModel {\n        const insertStyledText = new InsertStyledTextModel({ text, insertIndex, textStyle });\n        return new CommandModel({ commandType: CommandType.InsertStyledText, insertStyledText, targets });\n    }\n\n    public static getInsertBreakCommand(insertBreak: InsertBreakModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertBreak, insertBreak, targets });\n    }\n\n    public static getInsertElementCommand(insertElement: InsertElementModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertElement, insertElement, targets });\n    }\n\n    public static getInsertImageCommand(insertImage: InsertImageModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertImage, insertImage, targets });\n    }\n\n    public static getInsertLinkOperation(insertLink: InsertLinkModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertLink, insertLink, targets });\n    }\n\n    public static getInsertTabCommand(insertTab: InsertTabModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertTab, insertTab, targets });\n    }\n\n    public static getInsertTableCommand(insertTable: InsertTableModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.InsertTable, insertTable, targets });\n    }\n\n    public static getInsertTableColumnsCommand(\n        columnsCount: number,\n        inheritIndex: number,\n        insertIndex: number,\n        targetIndex: number,\n        targets: TargetModel[]\n    ): CommandModel {\n        const insertTableColumns = new InsertTableColumnsModel({ columnsCount, inheritIndex, insertIndex, targetIndex });\n        return new CommandModel({ commandType: CommandType.InsertTableColumns, insertTableColumns, targets });\n    }\n\n    public static getInsertTableRowsCommand(\n        rowsCount: number,\n        inheritIndex: number,\n        insertIndex: number,\n        targetIndex: number,\n        targets: TargetModel[]\n    ): CommandModel {\n        const insertTableRows = new InsertTableRowsModel({ rowsCount, inheritIndex, insertIndex, targetIndex });\n        return new CommandModel({ commandType: CommandType.InsertTableRows, insertTableRows, targets });\n    }\n\n    public static getRemoveTableColumnsCommand(\n        startIndex: number,\n        endIndex: number,\n        insertIndex: number,\n        targets: TargetModel[]\n    ): CommandModel {\n        const removeTableColumns = new RemoveTableColumnsModel({ startIndex, endIndex, insertIndex });\n        return new CommandModel({ commandType: CommandType.RemoveTableColumns, removeTableColumns, targets });\n    }\n\n    public static getRemoveTableRowsCommand(\n        startIndex: number,\n        endIndex: number,\n        insertIndex: number,\n        targets: TargetModel[]\n    ): CommandModel {\n        const removeTableRows = new RemoveTableRowsModel({ startIndex, endIndex, insertIndex });\n        return new CommandModel({ commandType: CommandType.RemoveTableRows, removeTableRows, targets });\n    }\n\n    public static getRestoreTextStylesCommand(formats: FormatModel[], targets: TargetModel[]): CommandModel {\n        const restoreTextStyles = new RestoreTextStylesModel({ formats });\n        return new CommandModel({ commandType: CommandType.RestoreTextStyles, restoreTextStyles, targets });\n    }\n\n    public static getRestoreParagraphStylesCommand(paragraphs: ParagraphModel[], targets: TargetModel[]): CommandModel {\n        const restoreParagraphStyles = new RestoreParagraphStylesModel({ paragraphs });\n        return new CommandModel({ commandType: CommandType.RestoreParagraphStyles, restoreParagraphStyles, targets });\n    }\n\n    public static getRestoreCommand(restoreModel: RestoreModel, targets: TargetModel[]): CommandModel {\n        const restore = new RestoreModel({\n            breaks: restoreModel.breaks,\n            elements: restoreModel.elements,\n            formats: restoreModel.formats,\n            images: restoreModel.images,\n            startIndex: restoreModel.startIndex,\n            endIndex: restoreModel.endIndex,\n            paragraphs: restoreModel.paragraphs,\n            tables: restoreModel.tables,\n            tabs: restoreModel.tabs,\n            text: restoreModel.text\n        });\n        return new CommandModel({ commandType: CommandType.Restore, restore, targets });\n    }\n\n    public static getRestoreTableCommand(restoreTable: RestoreTableModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.RestoreTable, restoreTable, targets });\n    }\n\n    public static getReplaceCommand(model: ReplaceModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.Replace, replace: model, targets });\n    }\n\n    public static getResizeTableColumnsCommand(resizeTableColumns: ResizeTableColumnsModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.ResizeTableColumns, resizeTableColumns, targets });\n    }\n\n    public static getApplyElementStyleCommand(applyElementStyle: ApplyElementStyleModel, targets: TargetModel[]): CommandModel {\n        return new CommandModel({ commandType: CommandType.ApplyElementStyle, applyElementStyle, targets });\n    }\n}\n"]}

package/esm2022/lib/editor/operations/target-operations.helper.mjs

@@ -0,0 +1,23 @@
+import { EdgeType } from '../components/edges/edge-type.enum';
+import { TargetType } from './enums/target-type.enum';
+export class TargetOperationsHelper {
+    static getContents(contents, target, document) {
+        switch (target.type) {
+            case TargetType.Document:
+                return contents;
+            case TargetType.TableCell: {
+                const cellTarget = target.tableCell;
+                const table = contents.tables.find(x => x.insertIndex === cellTarget.insertIndex);
+                return table.rows[cellTarget.row].cells[cellTarget.column];
+            }
+            case TargetType.Edge: {
+                const edgeTarget = target.edgeData;
+                const edges = edgeTarget.type === EdgeType.Header ? document.headers : document.footers;
+                return edges.find(x => x.pageType === edgeTarget.pageType);
+            }
+            default:
+                throw new Error('Invalid target type for operation');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/positioning/alignments.const.mjs

@@ -0,0 +1,8 @@
+export const Alignment = {
+    left: 0,
+    center: 1,
+    right: 2,
+    justify: 3,
+    all: [0, 1, 2, 3]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxpZ25tZW50cy5jb25zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9wb3NpdGlvbmluZy9hbGlnbm1lbnRzLmNvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRztJQUNyQixJQUFJLEVBQUUsQ0FBQztJQUNQLE1BQU0sRUFBRSxDQUFDO0lBQ1QsS0FBSyxFQUFFLENBQUM7SUFDUixPQUFPLEVBQUUsQ0FBQztJQUNWLEdBQUcsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztDQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IEFsaWdubWVudCA9IHtcbiAgICBsZWZ0OiAwLFxuICAgIGNlbnRlcjogMSxcbiAgICByaWdodDogMixcbiAgICBqdXN0aWZ5OiAzLFxuICAgIGFsbDogWzAsIDEsIDIsIDNdXG59O1xuIl19

package/esm2022/lib/editor/positioning/content.helper.mjs

@@ -0,0 +1,36 @@
+import { CursorParagraph } from './cursor-paragraph';
+export class ContentHelper {
+    static documentIndexToParagraphIndex(paragraphs, indexInDocument) {
+        let paragraph = paragraphs.findIndex(x => x.startIndex > indexInDocument);
+        paragraph = paragraph === -1 ? paragraphs.length - 1 : paragraph - 1;
+        const indexInParagraph = indexInDocument - paragraphs[paragraph].startIndex;
+        return new CursorParagraph(paragraph, indexInParagraph);
+    }
+    static documentIndexToParagraphWithOffset(paragraphs, indexInDocument) {
+        const position = this.documentIndexToParagraphIndex(paragraphs, indexInDocument);
+        if (position.column < paragraphs[position.row].content.length) {
+            return new CursorParagraph(position.row, position.column + 1);
+        }
+        return position;
+    }
+    static paragraphPositionToDocumentIndex(paragraphs, paragraph) {
+        return this.paragraphToDocumentIndex(paragraphs, paragraph.row, paragraph.column);
+    }
+    static getSelectedPartDocumentIndexes(paragraphs, range) {
+        return {
+            startIndex: this.paragraphPositionToDocumentIndex(paragraphs, range.start),
+            endIndex: this.paragraphPositionToDocumentIndex(paragraphs, range.end) - 1
+        };
+    }
+    static paragraphToDocumentIndex(paragraphs, paragraph, index) {
+        return paragraphs[paragraph].startIndex + index;
+    }
+    static setIndexesElementsInInterval(elements, elementIndexes, startIndex, endIndex) {
+        elements.forEach(x => {
+            if (x.insertIndex >= startIndex && x.insertIndex <= endIndex) {
+                elementIndexes.push(x.insertIndex - startIndex);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/positioning/cursor-paragraph.mjs

@@ -0,0 +1,13 @@
+export class CursorParagraph {
+    constructor(row, column) {
+        this.row = row;
+        this.column = column;
+    }
+    static compareCursorPositions(first, second) {
+        return first.row - second.row || first.column - second.column;
+    }
+    static clone(position) {
+        return new CursorParagraph(position.row, position.column);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Vyc29yLXBhcmFncmFwaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9wb3NpdGlvbmluZy9jdXJzb3ItcGFyYWdyYXBoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxlQUFlO0lBS3hCLFlBQVksR0FBVyxFQUFFLE1BQWM7UUFDbkMsSUFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7UUFDZixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN6QixDQUFDO0lBRUQsTUFBTSxDQUFDLHNCQUFzQixDQUFDLEtBQXNCLEVBQUUsTUFBdUI7UUFDekUsT0FBTyxLQUFLLENBQUMsR0FBRyxHQUFHLE1BQU0sQ0FBQyxHQUFHLElBQUksS0FBSyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ2xFLENBQUM7SUFFRCxNQUFNLENBQUMsS0FBSyxDQUFDLFFBQXlCO1FBQ2xDLE9BQU8sSUFBSSxlQUFlLENBQUMsUUFBUSxDQUFDLEdBQUcsRUFBRSxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDOUQsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEN1cnNvclBhcmFncmFwaCB7XG4gICAgcm93OiBudW1iZXI7XG5cbiAgICBjb2x1bW46IG51bWJlcjtcblxuICAgIGNvbnN0cnVjdG9yKHJvdzogbnVtYmVyLCBjb2x1bW46IG51bWJlcikge1xuICAgICAgICB0aGlzLnJvdyA9IHJvdztcbiAgICAgICAgdGhpcy5jb2x1bW4gPSBjb2x1bW47XG4gICAgfVxuXG4gICAgc3RhdGljIGNvbXBhcmVDdXJzb3JQb3NpdGlvbnMoZmlyc3Q6IEN1cnNvclBhcmFncmFwaCwgc2Vjb25kOiBDdXJzb3JQYXJhZ3JhcGgpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gZmlyc3Qucm93IC0gc2Vjb25kLnJvdyB8fCBmaXJzdC5jb2x1bW4gLSBzZWNvbmQuY29sdW1uO1xuICAgIH1cblxuICAgIHN0YXRpYyBjbG9uZShwb3NpdGlvbjogQ3Vyc29yUGFyYWdyYXBoKTogQ3Vyc29yUGFyYWdyYXBoIHtcbiAgICAgICAgcmV0dXJuIG5ldyBDdXJzb3JQYXJhZ3JhcGgocG9zaXRpb24ucm93LCBwb3NpdGlvbi5jb2x1bW4pO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/lib/editor/positioning/cursor-position.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Vyc29yLXBvc2l0aW9uLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9wb3NpdGlvbmluZy9jdXJzb3ItcG9zaXRpb24uaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJRm9udE1ldHJpY1NpemUgfSBmcm9tICcuLi9nYWRnZXRzL2ZvbnQtbWV0cmljcy9mb250LW1ldHJpYy1zaXplLmludGVyZmFjZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3Vyc29yUG9zaXRpb24ge1xuICAgIHBhZ2VYOiBudW1iZXI7XG4gICAgcGFnZVk6IG51bWJlcjtcbiAgICBsaW5lSGVpZ2h0PzogbnVtYmVyO1xuICAgIHNpemVDdXJyZW50PzogSUZvbnRNZXRyaWNTaXplO1xuICAgIHNpemVNYXg/OiBJRm9udE1ldHJpY1NpemU7XG4gICAgc2l6ZU5leHQ/OiBJRm9udE1ldHJpY1NpemU7XG4gICAgZmlyc3RDaGFyPzogYm9vbGVhbjtcbiAgICBsYXN0Q2hhcj86IGJvb2xlYW47XG59XG4iXX0=

package/esm2022/lib/editor/positioning/insert-index.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zZXJ0LWluZGV4LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9wb3NpdGlvbmluZy9pbnNlcnQtaW5kZXguaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEluc2VydEluZGV4SW50ZXJmYWNlIHtcbiAgICBpbnNlcnRJbmRleDogbnVtYmVyO1xufVxuIl19

package/esm2022/lib/editor/positioning/line-width.helper.mjs

@@ -0,0 +1,13 @@
+import { CursorParagraph } from './cursor-paragraph';
+export class LineWidthHelper {
+    static getParagraphLineDisplayTokens(session, paragraphIndex, lineIndex) {
+        const docPos = session.displayData.positionToIndex(new CursorParagraph(paragraphIndex, 0), 0);
+        const rowWrap = session.displayData.paragraphs[paragraphIndex]?.nextLineIndexes || [];
+        const startWrapIndex = lineIndex > 0 ? rowWrap[lineIndex - 1] : 0;
+        const endIndex = rowWrap[lineIndex];
+        const docLine = session.displayData.getParagraphContent(paragraphIndex);
+        const offset = startWrapIndex ? docPos + startWrapIndex : docPos;
+        return session.displayData.getLineTokens(session.model, docLine.substring(startWrapIndex, endIndex || undefined), offset);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/positioning/position.helper.mjs

@@ -0,0 +1,196 @@
+import { CursorParagraph } from './cursor-paragraph';
+import { DisplayValue } from '../content/constants/display-values.const';
+import { LineWidthHelper } from './line-width.helper';
+export class PositionHelper {
+    /**
+     * Returns an object containing the `pageX` and `pageY` coordinates of the document position.
+     */
+    static documentToPixel(session, documentPosition) {
+        const screenPosition = this.documentToScreen(session, documentPosition.row, documentPosition.column);
+        return this.screenToPixel(session, screenPosition.row, screenPosition.column);
+    }
+    /**
+     * Get paragraph info (paragraph index, paragraph line index, line top offset and others) by row index
+     **/
+    static getParagraphInfoByRow(paragraphs, row) {
+        const { paragraphIndex, lineIndex } = this.findLineInParagraphs(paragraphs, row);
+        let lineTopOffset = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            const info = paragraphs[paragraphIndex].paragraphSettings.textLinesInfo[i];
+            lineTopOffset += info.height + info.endPageOffset + info.offsetBefore + info.offsetAfter;
+        }
+        const paragraphLineInfo = paragraphs[paragraphIndex].paragraphSettings.textLinesInfo[lineIndex];
+        lineTopOffset += paragraphLineInfo.offsetBefore;
+        return {
+            paragraphIndex,
+            lineIndex,
+            lineTopOffset,
+            indentBefore: paragraphLineInfo.offsetBefore,
+            lineHeight: paragraphLineInfo.height
+        };
+    }
+    static documentToScreen(session, paragraph, indexInParagraph) {
+        const paragraphLine = session.displayData.paragraphs[paragraph].lineNumber;
+        if (!session.displayData.paragraphs[paragraph].nextLineIndexes.length ||
+            session.displayData.paragraphs[paragraph].nextLineIndexes[0] > indexInParagraph) {
+            return new CursorParagraph(paragraphLine, indexInParagraph);
+        }
+        let line = 0;
+        while (session.displayData.paragraphs[paragraph].nextLineIndexes[line] <= indexInParagraph &&
+            line < session.displayData.paragraphs[paragraph].nextLineIndexes.length) {
+            line++;
+        }
+        const index = indexInParagraph - session.displayData.paragraphs[paragraph].nextLineIndexes[line - 1];
+        return new CursorParagraph(paragraphLine + line, index);
+    }
+    static screenToDocument(session, line, indexInLine) {
+        let paragraph = session.displayData.paragraphs.findIndex(x => x.lineNumber > line);
+        if (paragraph === -1) {
+            paragraph = session.displayData.paragraphs.length - 1;
+        }
+        else if (paragraph > 0) {
+            paragraph = paragraph - 1;
+        }
+        let lineInParagraph = line - session.displayData.paragraphs[paragraph].lineNumber;
+        if (!session.displayData.paragraphs[paragraph].nextLineIndexes.length || lineInParagraph === 0) {
+            return new CursorParagraph(paragraph, indexInLine);
+        }
+        const index = indexInLine + session.displayData.paragraphs[paragraph].nextLineIndexes[lineInParagraph - 1];
+        return new CursorParagraph(paragraph, index);
+    }
+    /**
+     * Returns an object containing the `pageX` and `pageY` coordinates of the document position.
+     **/
+    static screenToPixel(session, row, column) {
+        const paragraphs = session.displayData.paragraphs;
+        const paragraphInfo = this.getParagraphInfoByRow(paragraphs, row);
+        const tokens = LineWidthHelper.getParagraphLineDisplayTokens(session, paragraphInfo.paragraphIndex, paragraphInfo.lineIndex);
+        let size = {
+            width: 8,
+            height: paragraphInfo.lineHeight,
+            baseline: paragraphInfo.lineHeight,
+            content: paragraphInfo.lineHeight,
+            font: paragraphInfo.lineHeight,
+            line: paragraphInfo.lineHeight,
+            multiplier: paragraphInfo.lineHeight,
+            ascent: 0,
+            descent: 0
+        };
+        let tokenIndex = column > 0 ? column - 1 : column;
+        if (tokens.length > 0) {
+            size = tokens[tokenIndex];
+        }
+        const sizeNext = tokens[tokenIndex + 1];
+        let sizeMax = { ...size };
+        let lineWidthToPosition = session.displayData.pageMargin.left;
+        for (let currentColumn = 0; currentColumn < tokens.length; currentColumn++) {
+            if (currentColumn < column) {
+                lineWidthToPosition += tokens[currentColumn].width;
+            }
+            if (sizeMax.ascent < tokens[currentColumn].ascent) {
+                sizeMax = tokens[currentColumn];
+            }
+        }
+        if (tokens[tokenIndex]?.isTable) {
+            sizeMax.ascent = paragraphInfo.lineHeight;
+        }
+        const paragraph = paragraphs[paragraphInfo.paragraphIndex];
+        const paragraphTop = paragraph.paragraphSettings.distanceFromTop || 0;
+        const linePaddingLeft = paragraph.paragraphSettings.textLinesInfo[paragraphInfo.lineIndex].paddingLeft;
+        return {
+            pageX: lineWidthToPosition + linePaddingLeft,
+            pageY: paragraphTop + paragraphInfo.lineTopOffset - session.scrollTop,
+            lineHeight: paragraphInfo.lineHeight,
+            sizeCurrent: size,
+            sizeMax,
+            sizeNext,
+            firstChar: column === 0,
+            lastChar: column === tokens.length - 1
+        };
+    }
+    /**
+     * Converts pixel position to screen position
+     **/
+    static pixelToScreen(session, x, y, scrollerPosition) {
+        const displayData = session.displayData;
+        const scrollTop = session.scrollTop;
+        let yPos = y + scrollTop - scrollerPosition.top;
+        let paragraphIndex = displayData.paragraphs.findIndex(paragraph => paragraph.paragraphSettings.distanceFromTop > yPos);
+        if (paragraphIndex < 0) {
+            paragraphIndex = displayData.paragraphs.length - 1;
+        }
+        else if (paragraphIndex > 0) {
+            paragraphIndex--;
+        }
+        const paragraphSettings = displayData.getParagraphSettings(paragraphIndex);
+        yPos -= paragraphSettings.distanceFromTop;
+        let lineIndex = 0;
+        while (yPos > 0 && lineIndex < paragraphSettings.textLinesInfo.length - 1) {
+            const line = paragraphSettings.textLinesInfo[lineIndex];
+            const width = line.height + line.endPageOffset + line.offsetBefore + line.offsetAfter;
+            if (yPos <= width) {
+                break;
+            }
+            lineIndex++;
+            yPos -= width;
+        }
+        const line = paragraphSettings.textLinesInfo[lineIndex].screenLine;
+        let index = 0;
+        let xPos = x - scrollerPosition.left - displayData.pageMargin.left - paragraphSettings.textLinesInfo[lineIndex].paddingLeft;
+        const tokens = LineWidthHelper.getParagraphLineDisplayTokens(session, paragraphIndex, lineIndex);
+        if (tokens[0].displayValue === DisplayValue.emptyLine) {
+            return new CursorParagraph(line, index);
+        }
+        while (tokens.length > index) {
+            if (xPos < tokens[index].width / 2) {
+                break;
+            }
+            xPos -= tokens[index].width;
+            index++;
+        }
+        return new CursorParagraph(line, index);
+    }
+    static findLineInParagraphs(paragraphs, documentLine) {
+        let index = 0;
+        let paragraphIndex = 0;
+        while (paragraphIndex < paragraphs.length) {
+            if (index + paragraphs[paragraphIndex].paragraphSettings.textLinesInfo.length > documentLine) {
+                break;
+            }
+            index += paragraphs[paragraphIndex].paragraphSettings.textLinesInfo.length;
+            paragraphIndex++;
+        }
+        const lineIndex = documentLine - index;
+        return { paragraphIndex, lineIndex };
+    }
+    static getApproximatePosition(session, documentLine, positionWidth) {
+        const paragraphs = session.displayData.paragraphs;
+        const documentMargin = session.displayData.pageMargin;
+        const { paragraphIndex, lineIndex } = PositionHelper.findLineInParagraphs(paragraphs, documentLine);
+        let column = 0;
+        const tokens = LineWidthHelper.getParagraphLineDisplayTokens(session, paragraphIndex, lineIndex);
+        if (tokens.length === 1 && tokens[0].displayValue === DisplayValue.emptyLine) {
+            return column;
+        }
+        const textLineInfo = paragraphs[paragraphIndex].paragraphSettings.textLinesInfo[lineIndex];
+        let width = positionWidth - textLineInfo.paddingLeft - documentMargin.left;
+        while (column < tokens.length && width >= tokens[column].width) {
+            width -= tokens[column].width;
+            column++;
+        }
+        return column;
+    }
+    static pixelToPage(posY, session) {
+        const pagesCount = session.displayData.getParagraphSettings(session.displayData.paragraphs.length - 1).lastPageNumber;
+        let page = 1;
+        while (page <= pagesCount) {
+            const endPagePosition = (session.displayData.pagesSpace + session.displayData.pageHeight) * page;
+            if (endPagePosition >= posY) {
+                break;
+            }
+            page++;
+        }
+        return page;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"position.helper.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/editor/positioning/position.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { CursorParagraph } from './cursor-paragraph';\nimport { CursorPosition } from './cursor-position.interface';\nimport { DisplayValue } from '../content/constants/display-values.const';\nimport { EditSession } from '../execution/edit.session';\nimport { IFontMetricSize } from '../gadgets/font-metrics/font-metric-size.interface';\nimport { LineWidthHelper } from './line-width.helper';\nimport { ParagraphInfo } from '../content/display-data/paragraph-info.interface';\nimport { ParagraphInfoModel } from '../content/display-data/models/paragraph-info.model';\n\nexport class PositionHelper {\n    /**\n     * Returns an object containing the `pageX` and `pageY` coordinates of the document position.\n     */\n    static documentToPixel(session: EditSession, documentPosition: CursorParagraph): CursorPosition {\n        const screenPosition = this.documentToScreen(session, documentPosition.row, documentPosition.column);\n\n        return this.screenToPixel(session, screenPosition.row, screenPosition.column);\n    }\n\n    /**\n     * Get paragraph info (paragraph index, paragraph line index, line top offset and others) by row index\n     **/\n    static getParagraphInfoByRow(paragraphs: ParagraphInfoModel[], row: number): ParagraphInfo {\n        const { paragraphIndex, lineIndex } = this.findLineInParagraphs(paragraphs, row);\n        let lineTopOffset = 0;\n        for (let i = 0; i < lineIndex; i++) {\n            const info = paragraphs[paragraphIndex].paragraphSettings.textLinesInfo[i];\n            lineTopOffset += info.height + info.endPageOffset + info.offsetBefore + info.offsetAfter;\n        }\n\n        const paragraphLineInfo = paragraphs[paragraphIndex].paragraphSettings.textLinesInfo[lineIndex];\n        lineTopOffset += paragraphLineInfo.offsetBefore;\n\n        return {\n            paragraphIndex,\n            lineIndex,\n            lineTopOffset,\n            indentBefore: paragraphLineInfo.offsetBefore,\n            lineHeight: paragraphLineInfo.height\n        };\n    }\n\n    static documentToScreen(session: EditSession, paragraph: number, indexInParagraph: number): CursorParagraph {\n        const paragraphLine = session.displayData.paragraphs[paragraph].lineNumber;\n        if (\n            !session.displayData.paragraphs[paragraph].nextLineIndexes.length ||\n            session.displayData.paragraphs[paragraph].nextLineIndexes[0] > indexInParagraph\n        ) {\n            return new CursorParagraph(paragraphLine, indexInParagraph);\n        }\n\n        let line = 0;\n        while (\n            session.displayData.paragraphs[paragraph].nextLineIndexes[line] <= indexInParagraph &&\n            line < session.displayData.paragraphs[paragraph].nextLineIndexes.length\n        ) {\n            line++;\n        }\n        const index = indexInParagraph - session.displayData.paragraphs[paragraph].nextLineIndexes[line - 1];\n        return new CursorParagraph(paragraphLine + line, index);\n    }\n\n    static screenToDocument(session: EditSession, line: number, indexInLine: number): CursorParagraph {\n        let paragraph = session.displayData.paragraphs.findIndex(x => x.lineNumber > line);\n        if (paragraph === -1) {\n            paragraph = session.displayData.paragraphs.length - 1;\n        } else if (paragraph > 0) {\n            paragraph = paragraph - 1;\n        }\n        let lineInParagraph = line - session.displayData.paragraphs[paragraph].lineNumber;\n        if (!session.displayData.paragraphs[paragraph].nextLineIndexes.length || lineInParagraph === 0) {\n            return new CursorParagraph(paragraph, indexInLine);\n        }\n        const index = indexInLine + session.displayData.paragraphs[paragraph].nextLineIndexes[lineInParagraph - 1];\n        return new CursorParagraph(paragraph, index);\n    }\n\n    /**\n     * Returns an object containing the `pageX` and `pageY` coordinates of the document position.\n     **/\n    static screenToPixel(session: EditSession, row: number, column: number): CursorPosition {\n        const paragraphs = session.displayData.paragraphs;\n        const paragraphInfo = this.getParagraphInfoByRow(paragraphs, row);\n        const tokens = LineWidthHelper.getParagraphLineDisplayTokens(session, paragraphInfo.paragraphIndex, paragraphInfo.lineIndex);\n\n        let size: IFontMetricSize = {\n            width: 8,\n            height: paragraphInfo.lineHeight,\n            baseline: paragraphInfo.lineHeight,\n            content: paragraphInfo.lineHeight,\n            font: paragraphInfo.lineHeight,\n            line: paragraphInfo.lineHeight,\n            multiplier: paragraphInfo.lineHeight,\n            ascent: 0,\n            descent: 0\n        };\n        let tokenIndex = column > 0 ? column - 1 : column;\n        if (tokens.length > 0) {\n            size = tokens[tokenIndex];\n        }\n\n        const sizeNext = tokens[tokenIndex + 1];\n        let sizeMax = { ...size };\n        let lineWidthToPosition = session.displayData.pageMargin.left;\n        for (let currentColumn = 0; currentColumn < tokens.length; currentColumn++) {\n            if (currentColumn < column) {\n                lineWidthToPosition += tokens[currentColumn].width;\n            }\n\n            if (sizeMax.ascent < tokens[currentColumn].ascent) {\n                sizeMax = tokens[currentColumn];\n            }\n        }\n\n        if (tokens[tokenIndex]?.isTable) {\n            sizeMax.ascent = paragraphInfo.lineHeight;\n        }\n\n        const paragraph = paragraphs[paragraphInfo.paragraphIndex];\n        const paragraphTop = paragraph.paragraphSettings.distanceFromTop || 0;\n        const linePaddingLeft = paragraph.paragraphSettings.textLinesInfo[paragraphInfo.lineIndex].paddingLeft;\n\n        return {\n            pageX: lineWidthToPosition + linePaddingLeft,\n            pageY: paragraphTop + paragraphInfo.lineTopOffset - session.scrollTop,\n            lineHeight: paragraphInfo.lineHeight,\n            sizeCurrent: size,\n            sizeMax,\n            sizeNext,\n            firstChar: column === 0,\n            lastChar: column === tokens.length - 1\n        };\n    }\n\n    /**\n     * Converts pixel position to screen position\n     **/\n    static pixelToScreen(session: EditSession, x: number, y: number, scrollerPosition: { top: number; left: number }): CursorParagraph {\n        const displayData = session.displayData;\n        const scrollTop = session.scrollTop;\n\n        let yPos = y + scrollTop - scrollerPosition.top;\n        let paragraphIndex = displayData.paragraphs.findIndex(paragraph => paragraph.paragraphSettings.distanceFromTop > yPos);\n        if (paragraphIndex < 0) {\n            paragraphIndex = displayData.paragraphs.length - 1;\n        } else if (paragraphIndex > 0) {\n            paragraphIndex--;\n        }\n\n        const paragraphSettings = displayData.getParagraphSettings(paragraphIndex);\n        yPos -= paragraphSettings.distanceFromTop;\n        let lineIndex = 0;\n        while (yPos > 0 && lineIndex < paragraphSettings.textLinesInfo.length - 1) {\n            const line = paragraphSettings.textLinesInfo[lineIndex];\n            const width = line.height + line.endPageOffset + line.offsetBefore + line.offsetAfter;\n            if (yPos <= width) {\n                break;\n            }\n            lineIndex++;\n            yPos -= width;\n        }\n        const line = paragraphSettings.textLinesInfo[lineIndex].screenLine;\n\n        let index = 0;\n        let xPos = x - scrollerPosition.left - displayData.pageMargin.left - paragraphSettings.textLinesInfo[lineIndex].paddingLeft;\n        const tokens = LineWidthHelper.getParagraphLineDisplayTokens(session, paragraphIndex, lineIndex);\n        if (tokens[0].displayValue === DisplayValue.emptyLine) {\n            return new CursorParagraph(line, index);\n        }\n\n        while (tokens.length > index) {\n            if (xPos < tokens[index].width / 2) {\n                break;\n            }\n\n            xPos -= tokens[index].width;\n            index++;\n        }\n        return new CursorParagraph(line, index);\n    }\n\n    static findLineInParagraphs(paragraphs: ParagraphInfoModel[], documentLine: number): { paragraphIndex: number; lineIndex: number } {\n        let index = 0;\n        let paragraphIndex = 0;\n        while (paragraphIndex < paragraphs.length) {\n            if (index + paragraphs[paragraphIndex].paragraphSettings.textLinesInfo.length > documentLine) {\n                break;\n            }\n\n            index += paragraphs[paragraphIndex].paragraphSettings.textLinesInfo.length;\n            paragraphIndex++;\n        }\n        const lineIndex = documentLine - index;\n        return { paragraphIndex, lineIndex };\n    }\n\n    static getApproximatePosition(session: EditSession, documentLine: number, positionWidth: number): number {\n        const paragraphs = session.displayData.paragraphs;\n        const documentMargin = session.displayData.pageMargin;\n        const { paragraphIndex, lineIndex } = PositionHelper.findLineInParagraphs(paragraphs, documentLine);\n        let column = 0;\n        const tokens = LineWidthHelper.getParagraphLineDisplayTokens(session, paragraphIndex, lineIndex);\n        if (tokens.length === 1 && tokens[0].displayValue === DisplayValue.emptyLine) {\n            return column;\n        }\n\n        const textLineInfo = paragraphs[paragraphIndex].paragraphSettings.textLinesInfo[lineIndex];\n        let width = positionWidth - textLineInfo.paddingLeft - documentMargin.left;\n        while (column < tokens.length && width >= tokens[column].width) {\n            width -= tokens[column].width;\n            column++;\n        }\n        return column;\n    }\n\n    static pixelToPage(posY: number, session: EditSession): number {\n        const pagesCount = session.displayData.getParagraphSettings(session.displayData.paragraphs.length - 1).lastPageNumber;\n        let page = 1;\n        while (page <= pagesCount) {\n            const endPagePosition = (session.displayData.pagesSpace + session.displayData.pageHeight) * page;\n            if (endPagePosition >= posY) {\n                break;\n            }\n            page++;\n        }\n        return page;\n    }\n}\n"]}