@talrace/ngx-noder 0.0.6 → 0.0.8

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

@@ -0,0 +1,226 @@
+import { EdgeType } from '../../components/edges/edge-type.enum';
+import { EventEmitting } from '../../core/event-emitting';
+import { NumberingHelper } from '../../gadgets/numbering/numbering.helper';
+import { PageHelper } from '../../execution/helpers/page.helper';
+import { PageType } from '../../components/edges/page-type.enum';
+import { PageVerticalDataModel } from '../page-vertical-data.model';
+import { Paragraph } from './paragraph';
+import { ParagraphHelper } from '../../execution/helpers/paragraph.helper';
+export class PagesWrap extends EventEmitting {
+    get defaultVerticalData() {
+        return this.pagesVerticalData.find(x => x.pageType === PageType.Default);
+    }
+    constructor(pagesSpace, documentMargin, pageWidth, pageHeight = 0, customComponents) {
+        super();
+        this.pagesSpace = pagesSpace;
+        this.documentMargin = documentMargin;
+        this.pageWidth = pageWidth;
+        this.pageHeight = pageHeight;
+        this.customComponents = customComponents;
+        this.allPagesHeight = 0;
+        this.minHeight = 0;
+        this.paragraphs = [];
+        this.tabTokens = [];
+        this.minHeight = this.pageHeight + 2 * this.pagesSpace;
+        this.contentWidth = this.pageWidth - this.documentMargin.left - this.documentMargin.right;
+        this.initPagesVerticalData();
+        this.processTextLinesProperties = !this.pageHeight
+            ? ParagraphHelper.processTextLinesPropertiesForSinglePage
+            : ParagraphHelper.processTextLinesProperties;
+    }
+    getParagraphTop(index) {
+        return this.paragraphs[index] ? this.paragraphs[index].distanceFromTop : 0;
+    }
+    getParagraphTopForPrint(index) {
+        if (!this.paragraphs[index]) {
+            return 0;
+        }
+        const paragraph = this.paragraphs[index];
+        const pageNumber = paragraph.pageNumbers[0];
+        let pageBreakHeight = 0;
+        paragraph.textLinesInfo.forEach(linesInfo => {
+            if (linesInfo.isAfterPageBreak) {
+                pageBreakHeight = linesInfo.height;
+            }
+        });
+        return paragraph.distanceFromTop - pageNumber * this.pagesSpace - pageBreakHeight;
+    }
+    getParagraphHeight(index) {
+        return this.paragraphs[index] ? this.paragraphs[index].height : 0;
+    }
+    remove(index, length) {
+        this.paragraphs.splice(index, length);
+    }
+    reset(paragraphsLength) {
+        this.paragraphs.length = paragraphsLength;
+    }
+    set(row, lineInfos, numberings, docParagraphs) {
+        if (!this.paragraphs[row]) {
+            const numberingData = NumberingHelper.createDataModel(numberings, docParagraphs, row);
+            this.paragraphs[row] = new Paragraph(numberingData, lineInfos[0].offsetBefore, this.processTextLinesProperties);
+        }
+        this.paragraphs[row].width = this.contentWidth;
+        this.paragraphs[row].setTextLinesInfo(lineInfos);
+    }
+    getVisibleRange(offsetTop, scrollerHeight) {
+        let start = this.paragraphs.findIndex(x => offsetTop <= x.distanceFromTop + x.height);
+        if (start < 0) {
+            start = 0;
+        }
+        let startLineInfo = null;
+        const startParagraph = this.paragraphs[start];
+        if (startParagraph) {
+            const startParagraphOffsetTop = offsetTop - startParagraph.distanceFromTop;
+            startLineInfo = ParagraphHelper.getVisibleLineInfo(startParagraph?.textLinesInfo, startParagraphOffsetTop, 1);
+        }
+        if (!startLineInfo) {
+            return {
+                startParagraph: 0,
+                startLine: 0,
+                startScreenLine: 0,
+                startScreenFullLine: 0,
+                endParagraph: 0,
+                endLine: 0,
+                endScreenLine: 0,
+                endScreenFullLine: 0,
+                pages: [1]
+            };
+        }
+        let end = this.paragraphs.findIndex(x => offsetTop + scrollerHeight <= x.distanceFromTop + x.height);
+        if (end < 0) {
+            end = this.paragraphs.length - 1;
+        }
+        let endLineInfo = null;
+        const endParagraph = this.paragraphs[end];
+        if (endParagraph) {
+            const endParagraphOffsetTop = offsetTop + scrollerHeight - endParagraph.distanceFromTop;
+            endLineInfo = ParagraphHelper.getVisibleLineInfo(endParagraph?.textLinesInfo, endParagraphOffsetTop, -1);
+        }
+        const visiblePages = this.getVisiblePages(offsetTop, scrollerHeight);
+        return {
+            startParagraph: start,
+            startLine: startLineInfo.index,
+            startScreenLine: startLineInfo.screenIndex,
+            startScreenFullLine: startLineInfo.visibleScreenIndex,
+            endParagraph: end,
+            endLine: endLineInfo.index,
+            endScreenLine: endLineInfo.screenIndex,
+            endScreenFullLine: endLineInfo.visibleScreenIndex,
+            pages: visiblePages
+        };
+    }
+    processParagraphsProperties(startParagraphIndex, wrapParagraphIndex) {
+        this.setParagraphIndexes(wrapParagraphIndex);
+        const pagesInfo = { pagesVerticalData: this.pagesVerticalData, pagesSpace: this.pagesSpace };
+        let currentPage = startParagraphIndex === 0 ? 1 : this.paragraphs[startParagraphIndex - 1].lastPageNumber;
+        let pageVerticalData = PageHelper.getVerticalData(currentPage, this.pagesVerticalData);
+        for (let i = startParagraphIndex; i < this.paragraphs.length; i++) {
+            const prevParagraphInfo = this.getPreviousParagraphInfo(i);
+            const paragraph = this.paragraphs[i];
+            paragraph.processParagraphProperties(prevParagraphInfo, pagesInfo, this.customComponents.tables);
+            if (paragraph.firstPageNumber !== currentPage) {
+                currentPage = paragraph.firstPageNumber;
+                pageVerticalData = PageHelper.getVerticalData(paragraph.firstPageNumber, this.pagesVerticalData);
+            }
+            paragraph.distanceFromTop =
+                (paragraph.firstPageNumber - 1) * this.pageHeight +
+                    this.pagesSpace * paragraph.firstPageNumber +
+                    pageVerticalData.marginTop +
+                    paragraph.pagePreviousContentHeight;
+        }
+        let pageHeight = this.pageHeight;
+        if (!pageHeight) {
+            pageHeight = this.getAllParagraphsHeight() + this.documentMargin.top + this.documentMargin.bottom;
+            this.minHeight = pageHeight + 2 * this.pagesSpace;
+            this.defaultVerticalData.contentHeight = pageHeight;
+        }
+        const lastPageNumber = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;
+        this.allPagesHeight = lastPageNumber * (pageHeight + this.pagesSpace) + this.pagesSpace;
+        this.emit('pagesCountChanged', { pagesCount: lastPageNumber, pageHeight: pageHeight + 2 * this.pagesSpace });
+    }
+    getAllParagraphsHeight() {
+        return this.paragraphs.reduce((sum, x) => sum + x.height, 0);
+    }
+    destroy() {
+        this.removeAllListeners('pagesCountChanged');
+    }
+    updatePageVerticalData(edgeType, page, wrapParagraphIndex) {
+        const pageVerticalData = PageHelper.getVerticalData(page, this.pagesVerticalData);
+        const componentHeight = this.customComponents.edges.getComponentHeight(page, edgeType);
+        if (edgeType === EdgeType.Header) {
+            pageVerticalData.marginTop = componentHeight > this.documentMargin.top ? componentHeight : this.documentMargin.top;
+        }
+        else {
+            pageVerticalData.marginBottom = componentHeight > this.documentMargin.bottom ? componentHeight : this.documentMargin.bottom;
+        }
+        const newContentHeight = this.pageHeight - pageVerticalData.marginTop - pageVerticalData.marginBottom;
+        if (newContentHeight === pageVerticalData.contentHeight) {
+            return;
+        }
+        pageVerticalData.contentHeight = newContentHeight;
+        this.processParagraphsProperties(0, wrapParagraphIndex);
+    }
+    getPreviousParagraphInfo(row) {
+        if (!row || !this.paragraphs.length) {
+            return { lastPage: 1, paragraphHeight: 0, paragraphLastLine: -1 };
+        }
+        const prevParagraph = this.paragraphs[row - 1];
+        return prevParagraph.getParagraphData();
+    }
+    getVisiblePages(offsetTop, containerHeight) {
+        const visiblePages = [];
+        let firstVisiblePage = offsetTop / (this.pageHeight + this.pagesSpace);
+        if (firstVisiblePage % 1 === 0) {
+            firstVisiblePage++;
+        }
+        let visiblePagesCount = containerHeight / (this.pageHeight + this.pagesSpace);
+        const partialPageOnScreenPercent = Math.trunc(((visiblePagesCount % 1) + (firstVisiblePage % 1)) * 100);
+        const pageSpaceHeightPercent = Math.trunc((this.pagesSpace / containerHeight) * 100);
+        if (partialPageOnScreenPercent - pageSpaceHeightPercent > 100) {
+            visiblePagesCount++;
+        }
+        visiblePagesCount = Math.ceil(visiblePagesCount);
+        firstVisiblePage = Math.ceil(firstVisiblePage);
+        const documentPagesCount = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;
+        if (firstVisiblePage + visiblePagesCount - 1 > documentPagesCount) {
+            visiblePagesCount = documentPagesCount - firstVisiblePage + 1;
+        }
+        for (let i = 0; i < visiblePagesCount; i++) {
+            visiblePages.push(firstVisiblePage + i);
+        }
+        return visiblePages;
+    }
+    initPagesVerticalData() {
+        if (!this.customComponents.edges ||
+            (!this.customComponents.edges.headersComponents.length && !this.customComponents.edges.footersComponents.length)) {
+            this.pagesVerticalData = [
+                new PageVerticalDataModel({
+                    marginTop: this.documentMargin.top,
+                    marginBottom: this.documentMargin.bottom,
+                    contentHeight: this.pageHeight - this.documentMargin.top - this.documentMargin.bottom,
+                    pageType: PageType.Default
+                })
+            ];
+            return;
+        }
+        const pageTypes = this.customComponents.edges.getUniquePageTypes();
+        this.pagesVerticalData = pageTypes.map(pageType => {
+            const headerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Header);
+            const footerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Footer);
+            const marginTop = Math.max(headerHeight, this.documentMargin.top);
+            const marginBottom = Math.max(footerHeight, this.documentMargin.bottom);
+            return new PageVerticalDataModel({
+                marginTop,
+                marginBottom,
+                contentHeight: this.pageHeight - marginTop - marginBottom,
+                pageType
+            });
+        });
+    }
+    setParagraphIndexes(wrapParagraphIndex) {
+        for (let i = 0; i < this.paragraphs.length; i++) {
+            this.paragraphs[i].startInsertIndex = wrapParagraphIndex[i];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pages.wrap.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/editor/content/display-data/pages.wrap.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from '@angular/core';\n\nimport { DisplayToken } from './display-token.model';\nimport { EdgeType } from '../../components/edges/edge-type.enum';\nimport { EventEmitting } from '../../core/event-emitting';\nimport { ICustomComponents } from '../../components/shared/custom-components.interface';\nimport { LineInfoModel } from './line-info.model';\nimport { NoderTableComponent } from '../../components/table/components/table.component';\nimport { MarginModel } from '../margin.model';\nimport { NumberingHelper } from '../../gadgets/numbering/numbering.helper';\nimport { NumberingModel } from '../../../models/generated/numbering.model';\nimport { PageHelper } from '../../execution/helpers/page.helper';\nimport { PageType } from '../../components/edges/page-type.enum';\nimport { PageVerticalDataModel } from '../page-vertical-data.model';\nimport { Paragraph } from './paragraph';\nimport { ParagraphHelper } from '../../execution/helpers/paragraph.helper';\nimport { ParagraphModel } from '../../../models/generated/paragraph.model';\nimport { VisibleRange } from '../../display/visible-range.interface';\n\nexport class PagesWrap extends EventEmitting {\n    contentWidth: number;\n\n    allPagesHeight = 0;\n\n    minHeight = 0;\n\n    paragraphs: Paragraph[] = [];\n\n    tabTokens: DisplayToken[] = [];\n\n    pagesVerticalData: PageVerticalDataModel[];\n\n    get defaultVerticalData(): PageVerticalDataModel {\n        return this.pagesVerticalData.find(x => x.pageType === PageType.Default);\n    }\n\n    private processTextLinesProperties: (\n        currentParagraph: Paragraph,\n        prevParagraphInfo: { lastPage: number; paragraphHeight: number; paragraphLastLine: number },\n        pagesInfo: { pagesVerticalData: PageVerticalDataModel[]; pagesSpace: number },\n        tables: ComponentRef<NoderTableComponent>[]\n    ) => void;\n\n    constructor(\n        public pagesSpace: number,\n        public documentMargin: MarginModel,\n        public pageWidth: number,\n        public pageHeight = 0,\n        public customComponents: ICustomComponents\n    ) {\n        super();\n        this.minHeight = this.pageHeight + 2 * this.pagesSpace;\n        this.contentWidth = this.pageWidth - this.documentMargin.left - this.documentMargin.right;\n        this.initPagesVerticalData();\n\n        this.processTextLinesProperties = !this.pageHeight\n            ? ParagraphHelper.processTextLinesPropertiesForSinglePage\n            : ParagraphHelper.processTextLinesProperties;\n    }\n\n    getParagraphTop(index: number): number {\n        return this.paragraphs[index] ? this.paragraphs[index].distanceFromTop : 0;\n    }\n\n    getParagraphTopForPrint(index: number): number {\n        if (!this.paragraphs[index]) {\n            return 0;\n        }\n        const paragraph = this.paragraphs[index];\n        const pageNumber = paragraph.pageNumbers[0];\n        let pageBreakHeight = 0;\n        paragraph.textLinesInfo.forEach(linesInfo => {\n            if (linesInfo.isAfterPageBreak) {\n                pageBreakHeight = linesInfo.height;\n            }\n        });\n        return paragraph.distanceFromTop - pageNumber * this.pagesSpace - pageBreakHeight;\n    }\n\n    getParagraphHeight(index: number): number {\n        return this.paragraphs[index] ? this.paragraphs[index].height : 0;\n    }\n\n    remove(index: number, length: number): void {\n        this.paragraphs.splice(index, length);\n    }\n\n    reset(paragraphsLength: number): void {\n        this.paragraphs.length = paragraphsLength;\n    }\n\n    set(row: number, lineInfos: LineInfoModel[], numberings: NumberingModel[], docParagraphs: ParagraphModel[]): void {\n        if (!this.paragraphs[row]) {\n            const numberingData = NumberingHelper.createDataModel(numberings, docParagraphs, row);\n            this.paragraphs[row] = new Paragraph(numberingData, lineInfos[0].offsetBefore, this.processTextLinesProperties);\n        }\n\n        this.paragraphs[row].width = this.contentWidth;\n        this.paragraphs[row].setTextLinesInfo(lineInfos);\n    }\n\n    getVisibleRange(offsetTop: number, scrollerHeight: number): VisibleRange {\n        let start = this.paragraphs.findIndex(x => offsetTop <= x.distanceFromTop + x.height);\n        if (start < 0) {\n            start = 0;\n        }\n\n        let startLineInfo = null;\n        const startParagraph = this.paragraphs[start];\n        if (startParagraph) {\n            const startParagraphOffsetTop = offsetTop - startParagraph.distanceFromTop;\n            startLineInfo = ParagraphHelper.getVisibleLineInfo(startParagraph?.textLinesInfo, startParagraphOffsetTop, 1);\n        }\n\n        if (!startLineInfo) {\n            return {\n                startParagraph: 0,\n                startLine: 0,\n                startScreenLine: 0,\n                startScreenFullLine: 0,\n                endParagraph: 0,\n                endLine: 0,\n                endScreenLine: 0,\n                endScreenFullLine: 0,\n                pages: [1]\n            };\n        }\n\n        let end = this.paragraphs.findIndex(x => offsetTop + scrollerHeight <= x.distanceFromTop + x.height);\n        if (end < 0) {\n            end = this.paragraphs.length - 1;\n        }\n\n        let endLineInfo = null;\n        const endParagraph = this.paragraphs[end];\n        if (endParagraph) {\n            const endParagraphOffsetTop = offsetTop + scrollerHeight - endParagraph.distanceFromTop;\n            endLineInfo = ParagraphHelper.getVisibleLineInfo(endParagraph?.textLinesInfo, endParagraphOffsetTop, -1);\n        }\n\n        const visiblePages = this.getVisiblePages(offsetTop, scrollerHeight);\n\n        return {\n            startParagraph: start,\n            startLine: startLineInfo.index,\n            startScreenLine: startLineInfo.screenIndex,\n            startScreenFullLine: startLineInfo.visibleScreenIndex,\n            endParagraph: end,\n            endLine: endLineInfo.index,\n            endScreenLine: endLineInfo.screenIndex,\n            endScreenFullLine: endLineInfo.visibleScreenIndex,\n            pages: visiblePages\n        };\n    }\n\n    processParagraphsProperties(startParagraphIndex: number, wrapParagraphIndex: number[]): void {\n        this.setParagraphIndexes(wrapParagraphIndex);\n        const pagesInfo = { pagesVerticalData: this.pagesVerticalData, pagesSpace: this.pagesSpace };\n        let currentPage = startParagraphIndex === 0 ? 1 : this.paragraphs[startParagraphIndex - 1].lastPageNumber;\n        let pageVerticalData = PageHelper.getVerticalData(currentPage, this.pagesVerticalData);\n        for (let i = startParagraphIndex; i < this.paragraphs.length; i++) {\n            const prevParagraphInfo = this.getPreviousParagraphInfo(i);\n            const paragraph = this.paragraphs[i];\n            paragraph.processParagraphProperties(prevParagraphInfo, pagesInfo, this.customComponents.tables);\n            if (paragraph.firstPageNumber !== currentPage) {\n                currentPage = paragraph.firstPageNumber;\n                pageVerticalData = PageHelper.getVerticalData(paragraph.firstPageNumber, this.pagesVerticalData);\n            }\n\n            paragraph.distanceFromTop =\n                (paragraph.firstPageNumber - 1) * this.pageHeight +\n                this.pagesSpace * paragraph.firstPageNumber +\n                pageVerticalData.marginTop +\n                paragraph.pagePreviousContentHeight;\n        }\n\n        let pageHeight = this.pageHeight;\n        if (!pageHeight) {\n            pageHeight = this.getAllParagraphsHeight() + this.documentMargin.top + this.documentMargin.bottom;\n            this.minHeight = pageHeight + 2 * this.pagesSpace;\n            this.defaultVerticalData.contentHeight = pageHeight;\n        }\n\n        const lastPageNumber = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;\n        this.allPagesHeight = lastPageNumber * (pageHeight + this.pagesSpace) + this.pagesSpace;\n        this.emit('pagesCountChanged', { pagesCount: lastPageNumber, pageHeight: pageHeight + 2 * this.pagesSpace });\n    }\n\n    getAllParagraphsHeight(): number {\n        return this.paragraphs.reduce((sum, x) => sum + x.height, 0);\n    }\n\n    destroy(): void {\n        this.removeAllListeners('pagesCountChanged');\n    }\n\n    updatePageVerticalData(edgeType: EdgeType, page: number, wrapParagraphIndex: number[]): void {\n        const pageVerticalData = PageHelper.getVerticalData(page, this.pagesVerticalData);\n        const componentHeight = this.customComponents.edges.getComponentHeight(page, edgeType);\n        if (edgeType === EdgeType.Header) {\n            pageVerticalData.marginTop = componentHeight > this.documentMargin.top ? componentHeight : this.documentMargin.top;\n        } else {\n            pageVerticalData.marginBottom = componentHeight > this.documentMargin.bottom ? componentHeight : this.documentMargin.bottom;\n        }\n\n        const newContentHeight = this.pageHeight - pageVerticalData.marginTop - pageVerticalData.marginBottom;\n        if (newContentHeight === pageVerticalData.contentHeight) {\n            return;\n        }\n\n        pageVerticalData.contentHeight = newContentHeight;\n        this.processParagraphsProperties(0, wrapParagraphIndex);\n    }\n\n    private getPreviousParagraphInfo(row: number): { lastPage: number; paragraphHeight: number; paragraphLastLine: number } {\n        if (!row || !this.paragraphs.length) {\n            return { lastPage: 1, paragraphHeight: 0, paragraphLastLine: -1 };\n        }\n\n        const prevParagraph = this.paragraphs[row - 1];\n        return prevParagraph.getParagraphData();\n    }\n\n    private getVisiblePages(offsetTop: number, containerHeight: number): number[] {\n        const visiblePages: number[] = [];\n\n        let firstVisiblePage = offsetTop / (this.pageHeight + this.pagesSpace);\n        if (firstVisiblePage % 1 === 0) {\n            firstVisiblePage++;\n        }\n\n        let visiblePagesCount = containerHeight / (this.pageHeight + this.pagesSpace);\n        const partialPageOnScreenPercent = Math.trunc(((visiblePagesCount % 1) + (firstVisiblePage % 1)) * 100);\n        const pageSpaceHeightPercent = Math.trunc((this.pagesSpace / containerHeight) * 100);\n        if (partialPageOnScreenPercent - pageSpaceHeightPercent > 100) {\n            visiblePagesCount++;\n        }\n\n        visiblePagesCount = Math.ceil(visiblePagesCount);\n        firstVisiblePage = Math.ceil(firstVisiblePage);\n        const documentPagesCount = this.paragraphs[this.paragraphs.length - 1].lastPageNumber;\n        if (firstVisiblePage + visiblePagesCount - 1 > documentPagesCount) {\n            visiblePagesCount = documentPagesCount - firstVisiblePage + 1;\n        }\n\n        for (let i = 0; i < visiblePagesCount; i++) {\n            visiblePages.push(firstVisiblePage + i);\n        }\n\n        return visiblePages;\n    }\n\n    private initPagesVerticalData(): void {\n        if (\n            !this.customComponents.edges ||\n            (!this.customComponents.edges.headersComponents.length && !this.customComponents.edges.footersComponents.length)\n        ) {\n            this.pagesVerticalData = [\n                new PageVerticalDataModel({\n                    marginTop: this.documentMargin.top,\n                    marginBottom: this.documentMargin.bottom,\n                    contentHeight: this.pageHeight - this.documentMargin.top - this.documentMargin.bottom,\n                    pageType: PageType.Default\n                })\n            ];\n            return;\n        }\n\n        const pageTypes = this.customComponents.edges.getUniquePageTypes();\n        this.pagesVerticalData = pageTypes.map(pageType => {\n            const headerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Header);\n            const footerHeight = this.customComponents.edges.getComponentHeightByPageType(pageType, EdgeType.Footer);\n            const marginTop = Math.max(headerHeight, this.documentMargin.top);\n            const marginBottom = Math.max(footerHeight, this.documentMargin.bottom);\n\n            return new PageVerticalDataModel({\n                marginTop,\n                marginBottom,\n                contentHeight: this.pageHeight - marginTop - marginBottom,\n                pageType\n            });\n        });\n    }\n\n    private setParagraphIndexes(wrapParagraphIndex: number[]): void {\n        for (let i = 0; i < this.paragraphs.length; i++) {\n            this.paragraphs[i].startInsertIndex = wrapParagraphIndex[i];\n        }\n    }\n}\n"]}

package/esm2022/lib/editor/content/display-data/paragraph-info.interface.mjs

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

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

@@ -0,0 +1,52 @@
+import { ParagraphHelper } from '../../execution/helpers/paragraph.helper';
+import { TextLineInfo } from './text-line-info';
+export class Paragraph {
+    get firstPageNumber() {
+        return this.pageNumbers[0] || 1;
+    }
+    get lastPageNumber() {
+        return this.pageNumbers[this.pageNumbers.length - 1] || 1;
+    }
+    get firstScreenLine() {
+        return this.textLinesInfo[0].screenLine;
+    }
+    get lastScreenLine() {
+        return this.textLinesInfo[this.textLinesInfo.length - 1].screenLine;
+    }
+    get isEndedByPageBreak() {
+        return this.textLinesInfo[this.textLinesInfo.length - 1].isEndedByPageBreak;
+    }
+    get backgroundColor() {
+        return this.textLinesInfo[0].backgroundColor;
+    }
+    constructor(numberingData, offsetBefore, processTextLinesProperties) {
+        this.numberingData = numberingData;
+        this.offsetBefore = offsetBefore;
+        this.processTextLinesProperties = processTextLinesProperties;
+        this.textLinesInfo = [];
+        this.pagePreviousContentHeight = 0;
+        this.width = 0;
+        this.height = 0;
+        this.pageNumbers = [];
+    }
+    setTextLinesInfo(linesInfos) {
+        this.textLinesInfo = linesInfos.map(lineInfo => new TextLineInfo(this.width, lineInfo.align, lineInfo.indent, lineInfo));
+    }
+    setIsAfterPageBreak(value) {
+        this.textLinesInfo[0].isAfterPageBreak = value;
+    }
+    getParagraphData() {
+        const pageContentHeight = this.pageNumbers.length === 1
+            ? this.height + this.pagePreviousContentHeight
+            : ParagraphHelper.getPageLinesHeight(this.textLinesInfo, this.lastPageNumber);
+        return { lastPage: this.lastPageNumber, paragraphHeight: pageContentHeight, paragraphLastLine: this.lastScreenLine };
+    }
+    processParagraphProperties(prevParagraphInfo, pagesInfo, tables) {
+        this.pagePreviousContentHeight = prevParagraphInfo.paragraphHeight;
+        this.processTextLinesProperties(this, prevParagraphInfo, pagesInfo, tables);
+        ParagraphHelper.processOffsetLineWithNumberingMarker(this.textLinesInfo[0], this.numberingData.height, this.offsetBefore);
+        this.pageNumbers = ParagraphHelper.getParagraphPages(this.textLinesInfo);
+        this.height = ParagraphHelper.getParagraphHeight(this.textLinesInfo);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/content/display-data/text-line-info.mjs

@@ -0,0 +1,34 @@
+import { Alignment } from '../../positioning/alignments.const';
+export class TextLineInfo {
+    constructor(contentWidth, align, indent, fields) {
+        this.paddingLeft = 0;
+        this.offsetBefore = 0;
+        this.offsetAfter = 0;
+        this.firstLinePageOffset = 0; // for selection
+        this.endPageOffset = 0; // for selection
+        this.screenLine = 0;
+        this.isAfterPageBreak = false;
+        this.isEndedByPageBreak = false;
+        if (fields) {
+            Object.assign(this, fields);
+        }
+        const diff = contentWidth - this.width;
+        if (this.width === undefined || diff === 0) {
+            return;
+        }
+        switch (align) {
+            case Alignment.center:
+                this.paddingLeft = indent.left + (diff - indent.left - indent.right) / 2;
+                break;
+            case Alignment.right:
+                this.paddingLeft = diff - indent.right;
+                break;
+            default:
+                this.paddingLeft = indent.left;
+                break;
+        }
+        this.paddingLeft += indent.firstLine;
+        this.paddingLeft -= indent.hanging;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/content/display-data/toolbar-styles.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbGJhci1zdHlsZXMuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvZWRpdG9yL2NvbnRlbnQvZGlzcGxheS1kYXRhL3Rvb2xiYXItc3R5bGVzLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJVG9vbGJhclN0eWxlcyB7XG4gICAgYWxpZ25tZW50PzogYW55O1xuICAgIGJhY2tncm91bmRDb2xvcj86IHN0cmluZztcbiAgICBoaWdobGlnaHRDb2xvcj86IHN0cmluZztcbiAgICBmb250Q29sb3I/OiBzdHJpbmc7XG4gICAgZm9udEZhbWlseT86IHN0cmluZztcbiAgICBmb250U2l6ZT86IG51bWJlcjtcbiAgICBpdGFsaWM/OiBib29sZWFuO1xuICAgIGJvbGQ/OiBib29sZWFuO1xuICAgIHN0cmlrZXRocm91Z2g/OiBib29sZWFuO1xuICAgIHVuZGVybGluZT86IGJvb2xlYW47XG4gICAgc3BhY2VBZnRlcj86IG51bWJlcjtcbiAgICBzcGFjZUJlZm9yZT86IG51bWJlcjtcbiAgICBpbmRlbnRMZWZ0PzogbnVtYmVyO1xuICAgIGluZGVudFJpZ2h0PzogbnVtYmVyO1xuICAgIGlzQnVsbGV0TWFya2VyPzogYm9vbGVhbjtcbiAgICBudW1iZXJpbmdMZXZlbHNTdHlsZXM/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/editor/content/helpers/content-style.helper.mjs

@@ -0,0 +1,96 @@
+import { Alignment } from '../../positioning/alignments.const';
+import { DEFAULT_BACKGROUND_COLOR, DEFAULT_FONT_COLOR, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE } from '../constants/editor.const';
+import { TextStyleModel } from '../../../models/generated/text-style.model';
+export class ContentStyleHelper {
+    static getDefaultStyleValueByKey(key) {
+        switch (key) {
+            case 'fontFamily':
+                return DEFAULT_FONT_FAMILY;
+            case 'fontSize':
+                return DEFAULT_FONT_SIZE;
+            case 'fontColor':
+                return DEFAULT_FONT_COLOR;
+            case 'highlightColor':
+                return DEFAULT_BACKGROUND_COLOR;
+            case 'alignment':
+                return Alignment.left;
+            default:
+                return;
+        }
+    }
+    static getTextStylesString(textStyle) {
+        let result = '';
+        if (textStyle.fontSize) {
+            result += `font-size:${textStyle.fontSize}pt;`;
+        }
+        if (textStyle.fontFamily) {
+            result += `font-family:${textStyle.fontFamily};`;
+        }
+        if (textStyle.fontColor) {
+            result += `color:${textStyle.fontColor};`;
+        }
+        if (textStyle.highlightColor) {
+            result += `background-color:${textStyle.highlightColor};`;
+        }
+        if (textStyle.bold) {
+            result += 'font-weight:bold;';
+        }
+        if (textStyle.italic) {
+            result += 'font-style:italic;';
+        }
+        if (textStyle.underline) {
+            result += 'text-decoration:underline;';
+        }
+        return result;
+    }
+    /**
+     * Returns font styles string from modifier used for canvas calculation
+     */
+    static getFontStylesString(textStyle) {
+        let fontString = '';
+        if (!textStyle) {
+            return fontString;
+        }
+        if (textStyle.italic) {
+            fontString += 'italic ';
+        }
+        if (textStyle.bold) {
+            fontString += 'bold ';
+        }
+        if (textStyle.fontSize) {
+            fontString += `${textStyle.fontSize}pt `;
+        }
+        if (textStyle.fontFamily) {
+            fontString += textStyle.fontFamily;
+        }
+        return fontString;
+    }
+    static areSameTextStyles(first, second) {
+        return (first.highlightColor === second.highlightColor &&
+            first.bold === second.bold &&
+            first.fontColor === second.fontColor &&
+            first.fontFamily === second.fontFamily &&
+            first.fontSize === second.fontSize &&
+            first.isSmallCaps === second.isSmallCaps &&
+            first.italic === second.italic &&
+            first.strikethrough === second.strikethrough &&
+            first.underline === second.underline &&
+            first.verticalAlignment === second.verticalAlignment);
+    }
+    static combineTextStyles(current, parent) {
+        return new TextStyleModel({
+            highlightColor: current.highlightColor ?? parent.highlightColor,
+            bold: current.bold ?? parent.bold,
+            fontColor: current.fontColor ?? parent.fontColor,
+            fontFamily: current.fontFamily ?? parent.fontFamily,
+            fontSize: current.fontSize ?? parent.fontSize,
+            headingStyleId: current.headingStyleId ?? parent.headingStyleId,
+            isSmallCaps: current.isSmallCaps ?? parent.isSmallCaps,
+            italic: current.italic ?? parent.italic,
+            strikethrough: current.strikethrough ?? parent.strikethrough,
+            underline: current.underline ?? parent.underline,
+            verticalAlignment: current.verticalAlignment ?? parent.verticalAlignment
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-style.helper.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/editor/content/helpers/content-style.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Alignment } from '../../positioning/alignments.const';\nimport { DEFAULT_BACKGROUND_COLOR, DEFAULT_FONT_COLOR, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE } from '../constants/editor.const';\nimport { TextStyleModel } from '../../../models/generated/text-style.model';\n\nexport class ContentStyleHelper {\n    static getDefaultStyleValueByKey(key: string): any {\n        switch (key) {\n            case 'fontFamily':\n                return DEFAULT_FONT_FAMILY;\n            case 'fontSize':\n                return DEFAULT_FONT_SIZE;\n            case 'fontColor':\n                return DEFAULT_FONT_COLOR;\n            case 'highlightColor':\n                return DEFAULT_BACKGROUND_COLOR;\n            case 'alignment':\n                return Alignment.left;\n            default:\n                return;\n        }\n    }\n\n    static getTextStylesString(textStyle: TextStyleModel): string {\n        let result = '';\n        if (textStyle.fontSize) {\n            result += `font-size:${textStyle.fontSize}pt;`;\n        }\n\n        if (textStyle.fontFamily) {\n            result += `font-family:${textStyle.fontFamily};`;\n        }\n\n        if (textStyle.fontColor) {\n            result += `color:${textStyle.fontColor};`;\n        }\n\n        if (textStyle.highlightColor) {\n            result += `background-color:${textStyle.highlightColor};`;\n        }\n\n        if (textStyle.bold) {\n            result += 'font-weight:bold;';\n        }\n\n        if (textStyle.italic) {\n            result += 'font-style:italic;';\n        }\n\n        if (textStyle.underline) {\n            result += 'text-decoration:underline;';\n        }\n\n        return result;\n    }\n\n    /**\n     * Returns font styles string from modifier used for canvas calculation\n     */\n    static getFontStylesString(textStyle: TextStyleModel): string {\n        let fontString = '';\n        if (!textStyle) {\n            return fontString;\n        }\n\n        if (textStyle.italic) {\n            fontString += 'italic ';\n        }\n\n        if (textStyle.bold) {\n            fontString += 'bold ';\n        }\n\n        if (textStyle.fontSize) {\n            fontString += `${textStyle.fontSize}pt `;\n        }\n\n        if (textStyle.fontFamily) {\n            fontString += textStyle.fontFamily;\n        }\n\n        return fontString;\n    }\n\n    static areSameTextStyles(first: TextStyleModel, second: TextStyleModel): boolean {\n        return (\n            first.highlightColor === second.highlightColor &&\n            first.bold === second.bold &&\n            first.fontColor === second.fontColor &&\n            first.fontFamily === second.fontFamily &&\n            first.fontSize === second.fontSize &&\n            first.isSmallCaps === second.isSmallCaps &&\n            first.italic === second.italic &&\n            first.strikethrough === second.strikethrough &&\n            first.underline === second.underline &&\n            first.verticalAlignment === second.verticalAlignment\n        );\n    }\n\n    static combineTextStyles(current: TextStyleModel, parent: TextStyleModel): TextStyleModel {\n        return new TextStyleModel({\n            highlightColor: current.highlightColor ?? parent.highlightColor,\n            bold: current.bold ?? parent.bold,\n            fontColor: current.fontColor ?? parent.fontColor,\n            fontFamily: current.fontFamily ?? parent.fontFamily,\n            fontSize: current.fontSize ?? parent.fontSize,\n            headingStyleId: current.headingStyleId ?? parent.headingStyleId,\n            isSmallCaps: current.isSmallCaps ?? parent.isSmallCaps,\n            italic: current.italic ?? parent.italic,\n            strikethrough: current.strikethrough ?? parent.strikethrough,\n            underline: current.underline ?? parent.underline,\n            verticalAlignment: current.verticalAlignment ?? parent.verticalAlignment\n        });\n    }\n}\n"]}

package/esm2022/lib/{+shared/editor → editor/content}/helpers/format.helper.mjs

@@ -20,4 +20,4 @@ export class FormatHelper {
         return result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWF0LmhlbHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9jb250ZW50L2hlbHBlcnMvZm9ybWF0LmhlbHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDckUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBRTVFLE1BQU0sT0FBTyxZQUFZO0lBQ3JCLE1BQU0sQ0FBQyxZQUFZLENBQUMsT0FBc0IsRUFBRSxVQUFrQixFQUFFLFFBQWdCO1FBQzVFLElBQUksTUFBTSxHQUFrQixFQUFFLENBQUM7UUFDL0IsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUU7WUFDMUIsSUFBSSxNQUFNLENBQUMsVUFBVSxJQUFJLFVBQVUsSUFBSSxNQUFNLENBQUMsUUFBUSxJQUFJLFFBQVEsRUFBRTtnQkFDaEUsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLFdBQVcsQ0FBQyxFQUFFLEdBQUcsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO2FBQy9DO2lCQUFNLElBQUksTUFBTSxDQUFDLFVBQVUsR0FBRyxVQUFVLElBQUksTUFBTSxDQUFDLFFBQVEsR0FBRyxRQUFRLEVBQUU7Z0JBQ3JFLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxXQUFXLENBQUMsRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxJQUFJLGNBQWMsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7YUFDM0c7aUJBQU0sSUFBSSxNQUFNLENBQUMsVUFBVSxHQUFHLFVBQVUsSUFBSSxNQUFNLENBQUMsUUFBUSxJQUFJLFVBQVUsRUFBRTtnQkFDeEUsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLFdBQVcsQ0FBQyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsTUFBTSxDQUFDLFFBQVEsRUFBRSxTQUFTLEVBQUUsSUFBSSxjQUFjLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO2FBQzVIO2lCQUFNLElBQUksTUFBTSxDQUFDLFVBQVUsSUFBSSxRQUFRLElBQUksTUFBTSxDQUFDLFFBQVEsR0FBRyxRQUFRLEVBQUU7Z0JBQ3BFLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxXQUFXLENBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxDQUFDLFVBQVUsRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLElBQUksY0FBYyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQzthQUM5SDtTQUNKO1FBQ0QsT0FBTyxNQUFNLENBQUM7SUFDbEIsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybWF0TW9kZWwgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMvZ2VuZXJhdGVkL2Zvcm1hdC5tb2RlbCc7XG5pbXBvcnQgeyBUZXh0U3R5bGVNb2RlbCB9IGZyb20gJy4uLy4uLy4uL21vZGVscy9nZW5lcmF0ZWQvdGV4dC1zdHlsZS5tb2RlbCc7XG5cbmV4cG9ydCBjbGFzcyBGb3JtYXRIZWxwZXIge1xuICAgIHN0YXRpYyBzbGljZVNlY3Rpb24oZm9ybWF0czogRm9ybWF0TW9kZWxbXSwgc3RhcnRJbmRleDogbnVtYmVyLCBlbmRJbmRleDogbnVtYmVyKTogRm9ybWF0TW9kZWxbXSB7XG4gICAgICAgIGxldCByZXN1bHQ6IEZvcm1hdE1vZGVsW10gPSBbXTtcbiAgICAgICAgZm9yIChjb25zdCBmb3JtYXQgb2YgZm9ybWF0cykge1xuICAgICAgICAgICAgaWYgKGZvcm1hdC5zdGFydEluZGV4ID49IHN0YXJ0SW5kZXggJiYgZm9ybWF0LmVuZEluZGV4IDw9IGVuZEluZGV4KSB7XG4gICAgICAgICAgICAgICAgcmVzdWx0LnB1c2gobmV3IEZvcm1hdE1vZGVsKHsgLi4uZm9ybWF0IH0pKTtcbiAgICAgICAgICAgIH0gZWxzZSBpZiAoZm9ybWF0LnN0YXJ0SW5kZXggPCBzdGFydEluZGV4ICYmIGZvcm1hdC5lbmRJbmRleCA+IGVuZEluZGV4KSB7XG4gICAgICAgICAgICAgICAgcmVzdWx0LnB1c2gobmV3IEZvcm1hdE1vZGVsKHsgc3RhcnRJbmRleCwgZW5kSW5kZXgsIHRleHRTdHlsZTogbmV3IFRleHRTdHlsZU1vZGVsKGZvcm1hdC50ZXh0U3R5bGUpIH0pKTtcbiAgICAgICAgICAgIH0gZWxzZSBpZiAoZm9ybWF0LnN0YXJ0SW5kZXggPCBzdGFydEluZGV4ICYmIGZvcm1hdC5lbmRJbmRleCA+PSBzdGFydEluZGV4KSB7XG4gICAgICAgICAgICAgICAgcmVzdWx0LnB1c2gobmV3IEZvcm1hdE1vZGVsKHsgc3RhcnRJbmRleCwgZW5kSW5kZXg6IGZvcm1hdC5lbmRJbmRleCwgdGV4dFN0eWxlOiBuZXcgVGV4dFN0eWxlTW9kZWwoZm9ybWF0LnRleHRTdHlsZSkgfSkpO1xuICAgICAgICAgICAgfSBlbHNlIGlmIChmb3JtYXQuc3RhcnRJbmRleCA8PSBlbmRJbmRleCAmJiBmb3JtYXQuZW5kSW5kZXggPiBlbmRJbmRleCkge1xuICAgICAgICAgICAgICAgIHJlc3VsdC5wdXNoKG5ldyBGb3JtYXRNb2RlbCh7IHN0YXJ0SW5kZXg6IGZvcm1hdC5zdGFydEluZGV4LCBlbmRJbmRleCwgdGV4dFN0eWxlOiBuZXcgVGV4dFN0eWxlTW9kZWwoZm9ybWF0LnRleHRTdHlsZSkgfSkpO1xuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgfVxufVxuIl19

package/esm2022/lib/{+shared/editor → editor/content}/helpers/indexed-element.helper.mjs

@@ -3,4 +3,4 @@ export class IndexedElementHelper {
         return elements.filter(x => x.insertIndex >= startIndex && x.insertIndex <= endIndex);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhlZC1lbGVtZW50LmhlbHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2hlbHBlcnMvaW5kZXhlZC1lbGVtZW50LmhlbHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sb0JBQW9CO0lBQzdCLE1BQU0sQ0FBQyxZQUFZLENBQWlDLFFBQWEsRUFBRSxVQUFrQixFQUFFLFFBQWdCO1FBQ25HLE9BQU8sUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLElBQUksVUFBVSxJQUFJLENBQUMsQ0FBQyxXQUFXLElBQUksUUFBUSxDQUFDLENBQUM7SUFDMUYsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5zZXJ0SW5kZXhJbnRlcmZhY2UgfSBmcm9tICcuLi9pbnRlcmZhY2VzL2luc2VydC1pbmRleC5pbnRlcmZhY2UnO1xuXG5leHBvcnQgY2xhc3MgSW5kZXhlZEVsZW1lbnRIZWxwZXIge1xuICAgIHN0YXRpYyBzbGljZVNlY3Rpb248VCBleHRlbmRzIEluc2VydEluZGV4SW50ZXJmYWNlPihlbGVtZW50czogVFtdLCBzdGFydEluZGV4OiBudW1iZXIsIGVuZEluZGV4OiBudW1iZXIpOiBUW10ge1xuICAgICAgICByZXR1cm4gZWxlbWVudHMuZmlsdGVyKHggPT4geC5pbnNlcnRJbmRleCA+PSBzdGFydEluZGV4ICYmIHguaW5zZXJ0SW5kZXggPD0gZW5kSW5kZXgpO1xuICAgIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhlZC1lbGVtZW50LmhlbHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliL2VkaXRvci9jb250ZW50L2hlbHBlcnMvaW5kZXhlZC1lbGVtZW50LmhlbHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sb0JBQW9CO0lBQzdCLE1BQU0sQ0FBQyxZQUFZLENBQWlDLFFBQWEsRUFBRSxVQUFrQixFQUFFLFFBQWdCO1FBQ25HLE9BQU8sUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLElBQUksVUFBVSxJQUFJLENBQUMsQ0FBQyxXQUFXLElBQUksUUFBUSxDQUFDLENBQUM7SUFDMUYsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5zZXJ0SW5kZXhJbnRlcmZhY2UgfSBmcm9tICcuLi8uLi8uLi9lZGl0b3IvcG9zaXRpb25pbmcvaW5zZXJ0LWluZGV4LmludGVyZmFjZSc7XG5cbmV4cG9ydCBjbGFzcyBJbmRleGVkRWxlbWVudEhlbHBlciB7XG4gICAgc3RhdGljIHNsaWNlU2VjdGlvbjxUIGV4dGVuZHMgSW5zZXJ0SW5kZXhJbnRlcmZhY2U+KGVsZW1lbnRzOiBUW10sIHN0YXJ0SW5kZXg6IG51bWJlciwgZW5kSW5kZXg6IG51bWJlcik6IFRbXSB7XG4gICAgICAgIHJldHVybiBlbGVtZW50cy5maWx0ZXIoeCA9PiB4Lmluc2VydEluZGV4ID49IHN0YXJ0SW5kZXggJiYgeC5pbnNlcnRJbmRleCA8PSBlbmRJbmRleCk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/editor/content/helpers/scaling.helper.mjs

@@ -0,0 +1,9 @@
+export class ScalingHelper {
+    static getRatio(current, original) {
+        return parseFloat((current / original).toFixed(1));
+    }
+    static scale(initial, scale) {
+        return Math.round(initial * scale);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NhbGluZy5oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9lZGl0b3IvY29udGVudC9oZWxwZXJzL3NjYWxpbmcuaGVscGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxhQUFhO0lBQ3RCLE1BQU0sQ0FBQyxRQUFRLENBQUMsT0FBZSxFQUFFLFFBQWdCO1FBQzdDLE9BQU8sVUFBVSxDQUFDLENBQUMsT0FBTyxHQUFHLFFBQVEsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFFRCxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQWUsRUFBRSxLQUFhO1FBQ3ZDLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDLENBQUM7SUFDdkMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFNjYWxpbmdIZWxwZXIge1xuICAgIHN0YXRpYyBnZXRSYXRpbyhjdXJyZW50OiBudW1iZXIsIG9yaWdpbmFsOiBudW1iZXIpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gcGFyc2VGbG9hdCgoY3VycmVudCAvIG9yaWdpbmFsKS50b0ZpeGVkKDEpKTtcbiAgICB9XG5cbiAgICBzdGF0aWMgc2NhbGUoaW5pdGlhbDogbnVtYmVyLCBzY2FsZTogbnVtYmVyKTogbnVtYmVyIHtcbiAgICAgICAgcmV0dXJuIE1hdGgucm91bmQoaW5pdGlhbCAqIHNjYWxlKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/editor/content/margin.model.mjs

@@ -0,0 +1,16 @@
+import { DocumentInfo } from './constants/document-info.const';
+export class MarginModel {
+    constructor(fields) {
+        this.left = DocumentInfo.paddingLeft;
+        this.right = DocumentInfo.paddingRight;
+        this.top = DocumentInfo.paddingTop;
+        this.bottom = DocumentInfo.paddingBottom;
+        this.header = DocumentInfo.paddingHeader;
+        this.footer = DocumentInfo.paddingFooter;
+        if (!fields) {
+            return;
+        }
+        Object.assign(this, fields);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFyZ2luLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvZWRpdG9yL2NvbnRlbnQvbWFyZ2luLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUUvRCxNQUFNLE9BQU8sV0FBVztJQVFwQixZQUFZLE1BQTZCO1FBUHpDLFNBQUksR0FBRyxZQUFZLENBQUMsV0FBVyxDQUFDO1FBQ2hDLFVBQUssR0FBRyxZQUFZLENBQUMsWUFBWSxDQUFDO1FBQ2xDLFFBQUcsR0FBRyxZQUFZLENBQUMsVUFBVSxDQUFDO1FBQzlCLFdBQU0sR0FBRyxZQUFZLENBQUMsYUFBYSxDQUFDO1FBQ3BDLFdBQU0sR0FBRyxZQUFZLENBQUMsYUFBYSxDQUFDO1FBQ3BDLFdBQU0sR0FBRyxZQUFZLENBQUMsYUFBYSxDQUFDO1FBR2hDLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDVCxPQUFPO1NBQ1Y7UUFFRCxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNoQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEb2N1bWVudEluZm8gfSBmcm9tICcuL2NvbnN0YW50cy9kb2N1bWVudC1pbmZvLmNvbnN0JztcblxuZXhwb3J0IGNsYXNzIE1hcmdpbk1vZGVsIHtcbiAgICBsZWZ0ID0gRG9jdW1lbnRJbmZvLnBhZGRpbmdMZWZ0O1xuICAgIHJpZ2h0ID0gRG9jdW1lbnRJbmZvLnBhZGRpbmdSaWdodDtcbiAgICB0b3AgPSBEb2N1bWVudEluZm8ucGFkZGluZ1RvcDtcbiAgICBib3R0b20gPSBEb2N1bWVudEluZm8ucGFkZGluZ0JvdHRvbTtcbiAgICBoZWFkZXIgPSBEb2N1bWVudEluZm8ucGFkZGluZ0hlYWRlcjtcbiAgICBmb290ZXIgPSBEb2N1bWVudEluZm8ucGFkZGluZ0Zvb3RlcjtcblxuICAgIGNvbnN0cnVjdG9yKGZpZWxkcz86IFBhcnRpYWw8TWFyZ2luTW9kZWw+KSB7XG4gICAgICAgIGlmICghZmllbGRzKSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBPYmplY3QuYXNzaWduKHRoaXMsIGZpZWxkcyk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/editor/content/page-vertical-data.model.mjs

@@ -0,0 +1,9 @@
+export class PageVerticalDataModel {
+    constructor(fields) {
+        if (!fields) {
+            return;
+        }
+        Object.assign(this, fields);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnZS12ZXJ0aWNhbC1kYXRhLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvZWRpdG9yL2NvbnRlbnQvcGFnZS12ZXJ0aWNhbC1kYXRhLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxxQkFBcUI7SUFNOUIsWUFBWSxNQUF1QztRQUMvQyxJQUFJLENBQUMsTUFBTSxFQUFFO1lBQ1QsT0FBTztTQUNWO1FBRUQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDaEMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFnZVR5cGUgfSBmcm9tICcuLi9jb21wb25lbnRzL2VkZ2VzL3BhZ2UtdHlwZS5lbnVtJztcblxuZXhwb3J0IGNsYXNzIFBhZ2VWZXJ0aWNhbERhdGFNb2RlbCB7XG4gICAgbWFyZ2luQm90dG9tOiBudW1iZXI7XG4gICAgbWFyZ2luVG9wOiBudW1iZXI7XG4gICAgY29udGVudEhlaWdodDogbnVtYmVyO1xuICAgIHBhZ2VUeXBlOiBQYWdlVHlwZTtcblxuICAgIGNvbnN0cnVjdG9yKGZpZWxkcz86IFBhcnRpYWw8UGFnZVZlcnRpY2FsRGF0YU1vZGVsPikge1xuICAgICAgICBpZiAoIWZpZWxkcykge1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG5cbiAgICAgICAgT2JqZWN0LmFzc2lnbih0aGlzLCBmaWVsZHMpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/lib/{+shared/editor/core/enums → editor/content}/vertical-alignment.enum.mjs

@@ -8,4 +8,4 @@ export var VerticalAlignment;
     VerticalAlignment[VerticalAlignment["Center"] = 5] = "Center";
     VerticalAlignment[VerticalAlignment["Bottom"] = 6] = "Bottom";
 })(VerticalAlignment || (VerticalAlignment = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVydGljYWwtYWxpZ25tZW50LmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jb3JlL2VudW1zL3ZlcnRpY2FsLWFsaWdubWVudC5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGlCQVFYO0FBUkQsV0FBWSxpQkFBaUI7SUFDekIseURBQUksQ0FBQTtJQUNKLHVFQUFXLENBQUE7SUFDWCxtRUFBUyxDQUFBO0lBQ1QsaUVBQVEsQ0FBQTtJQUNSLHVEQUFHLENBQUE7SUFDSCw2REFBTSxDQUFBO0lBQ04sNkRBQU0sQ0FBQTtBQUNWLENBQUMsRUFSVyxpQkFBaUIsS0FBakIsaUJBQWlCLFFBUTVCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gVmVydGljYWxBbGlnbm1lbnQge1xuICAgIE5vbmUsXG4gICAgU3VwZXJTY3JpcHQsXG4gICAgU3ViU2NyaXB0LFxuICAgIEJhc2VsaW5lLFxuICAgIFRvcCxcbiAgICBDZW50ZXIsXG4gICAgQm90dG9tXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVydGljYWwtYWxpZ25tZW50LmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9lZGl0b3IvY29udGVudC92ZXJ0aWNhbC1hbGlnbm1lbnQuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxpQkFRWDtBQVJELFdBQVksaUJBQWlCO0lBQ3pCLHlEQUFJLENBQUE7SUFDSix1RUFBVyxDQUFBO0lBQ1gsbUVBQVMsQ0FBQTtJQUNULGlFQUFRLENBQUE7SUFDUix1REFBRyxDQUFBO0lBQ0gsNkRBQU0sQ0FBQTtJQUNOLDZEQUFNLENBQUE7QUFDVixDQUFDLEVBUlcsaUJBQWlCLEtBQWpCLGlCQUFpQixRQVE1QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFZlcnRpY2FsQWxpZ25tZW50IHtcbiAgICBOb25lLFxuICAgIFN1cGVyU2NyaXB0LFxuICAgIFN1YlNjcmlwdCxcbiAgICBCYXNlbGluZSxcbiAgICBUb3AsXG4gICAgQ2VudGVyLFxuICAgIEJvdHRvbVxufVxuIl19