@talrace/ngx-noder 0.0.2

package/esm2022/lib/+shared/editor/core/virtual.renderer.mjs

@@ -0,0 +1,356 @@
+import { DistanceModel } from './models/distance.model';
+import { DomHelper } from './helpers/dom.helper';
+import { EdgesLayer } from './layers/edges.layer';
+import { EventEmitting } from './base/event-emitting';
+import { PagesLayer } from './layers/pages.layer';
+import { RenderChangesModel } from './models/render-changes.model';
+import { Renderer } from './renderer';
+import { RenderLoop } from './layers/renderloop';
+import { ScrollBar } from './layers/scrollbar';
+export class VirtualRenderer extends EventEmitting {
+    get isMousePressed() {
+        return this.renderer.isMousePressed;
+    }
+    set isMousePressed(val) {
+        this.renderer.isMousePressed = val;
+    }
+    get cursorLayer() {
+        return this.renderer.cursorLayer;
+    }
+    get loop() {
+        return this.renderer.loop;
+    }
+    set loop(val) {
+        this.renderer.loop = val;
+    }
+    get textarea() {
+        return this.renderer.textarea;
+    }
+    set textarea(val) {
+        this.renderer.textarea = val;
+    }
+    get layerConfig() {
+        return this.renderer.layerConfig;
+    }
+    set layerConfig(val) {
+        this.renderer.layerConfig = val;
+    }
+    constructor(parentContainer, editorService) {
+        super();
+        this.editorService = editorService;
+        this.scrollTop = 0;
+        this.changes = new RenderChangesModel();
+        this.size = {
+            width: 0,
+            height: 0,
+            scrollerHeight: 0,
+            scrollerWidth: 0,
+            dirty: true
+        };
+        this.container = parentContainer;
+        this.createScroller();
+        this.renderer = new Renderer(parentContainer, editorService);
+        this.renderer.layerConfig = this.getDefaultLayerConfig();
+        this.createLayers();
+        this.createScroll();
+        this.createRenderLoop();
+    }
+    renderChanges(changes, force) {
+        changes.apply(this.changes);
+        this.changes = new RenderChangesModel();
+        if (!this.renderer.session || !this.container.offsetWidth || (!changes.any && !force)) {
+            this.changes.apply(changes);
+            return;
+        }
+        if (this.size.dirty) {
+            this.changes.apply(changes);
+            this.onResize(true);
+            return;
+        }
+        // text, scrolling and resize changes can cause the view port size to change
+        if (changes.full || changes.size || changes.text || changes.lines || changes.scroll) {
+            changes.apply(this.computeLayerConfig());
+            this.updateScrollBar();
+            DomHelper.translate(this.renderer.content, 0, -this.layerConfig.offset);
+            DomHelper.setStyle(this.renderer.content.style, 'width', `${this.layerConfig.width}px`);
+            DomHelper.setStyle(this.renderer.content.style, 'height', `${this.layerConfig.height}px`);
+        }
+        // full
+        if (changes.full) {
+            this.renderFull();
+            return;
+        }
+        // scrolling
+        if (changes.scroll) {
+            this.renderScroll(changes);
+        }
+        if (changes.text) {
+            this.renderText();
+        }
+        if (changes.cursor) {
+            this.renderCursor();
+        }
+        if (changes.marker || changes.selection) {
+            this.renderSelection();
+        }
+    }
+    /**
+     * Triggers a resize of the editor
+     **/
+    onResize(force) {
+        const height = this.container.clientHeight || this.container.scrollHeight;
+        const width = this.container.clientWidth || this.container.scrollWidth;
+        const changes = this.updateCachedSize(force, width, height);
+        changes.apply(this.changes);
+        if (force) {
+            this.renderChanges(changes, true);
+        }
+        else {
+            this.loop.schedule(changes);
+        }
+        this.scrollBar.scrollTop = null;
+    }
+    /**
+     * Triggers a partial update of the text, from the range given by the two parameters.
+     **/
+    updateLines(firstRow, lastRow) {
+        this.renderer.updateLines(firstRow, lastRow);
+    }
+    updateCachedSize(force, width, height) {
+        if (width && (force || this.size.width !== width)) {
+            DomHelper.setStyle(this.scroller.style, 'left', 0);
+            this.size.scrollerWidth = Math.max(0, this.container.parentElement.clientWidth - this.scrollBar.width);
+            DomHelper.setStyle(this.scroller.style, 'right', 0);
+        }
+        let changes = new RenderChangesModel();
+        if (height && (force || this.size.height !== height)) {
+            this.size.height = height;
+            changes.size = true;
+            this.size.scrollerHeight = this.size.height;
+            changes.scroll = true;
+        }
+        if (width && (force || this.size.width !== width)) {
+            this.size.width = width;
+            changes.size = true;
+        }
+        this.size.dirty = !width || !height;
+        return changes;
+    }
+    moveTextAreaToCursor() {
+        if (this.isMousePressed || !this.textarea) {
+            return;
+        }
+        let cursorPosition = this.cursorLayer.cursorPosition;
+        if (!cursorPosition) {
+            return;
+        }
+        const posTop = cursorPosition.pageY - this.layerConfig.offset;
+        if (posTop < 0 || posTop > this.layerConfig.height - this.renderer.textareaSize.height) {
+            DomHelper.translate(this.textarea, 0, 0);
+            return;
+        }
+        DomHelper.setStyle(this.textarea.style, 'height', `${this.renderer.textareaSize.height}px`);
+        DomHelper.setStyle(this.textarea.style, 'width', `${this.renderer.textareaSize.width}px`);
+        DomHelper.translate(this.textarea, Math.min(cursorPosition.pageX, this.size.scrollerWidth - this.renderer.textareaSize.width), Math.min(posTop, this.size.height - this.renderer.textareaSize.height));
+    }
+    setSession(session) {
+        this.pagesLayer.setSession(session);
+        this.edgesLayer.setSession(session);
+        this.renderer.setSession(session);
+        this.scrollBar.scrollTop = null;
+    }
+    updateSelection(range) {
+        this.renderer.updateSelection(range);
+    }
+    /**
+     * Triggers a full update of the text, for all the rows.
+     **/
+    updateText() {
+        this.renderer.updateText();
+    }
+    /**
+     * Triggers a full update of all the layers, for all the rows.
+     **/
+    updateFull(force) {
+        this.renderer.updateFull(force);
+    }
+    updateCursor() {
+        this.renderer.updateCursor();
+    }
+    scrollSelectionIntoView(anchor, lead, offset) {
+        // first scroll anchor into view then scroll lead into view
+        this.scrollCursorIntoView(anchor, offset);
+        this.scrollCursorIntoView(lead, offset);
+    }
+    /**
+     * Scrolls the cursor into the first visibile area of the editor
+     **/
+    scrollCursorIntoView(cursor, offset) {
+        if (!this.size.scrollerHeight) {
+            return;
+        }
+        const position = this.cursorLayer.getPixelPosition(cursor);
+        let top = position.pageY + this.scrollTop;
+        if (this.scrollTop > top) {
+            if (offset) {
+                top -= offset * this.container.scrollHeight;
+            }
+            this.renderer.session.setScrollTop(top);
+            this.loop.schedule({ scroll: true });
+        }
+        else if (this.scrollTop + this.container.scrollHeight < top + position.lineHeight) {
+            if (offset) {
+                top += offset * this.container.scrollHeight;
+            }
+            this.renderer.session.setScrollTop(top + position.lineHeight - this.container.scrollHeight);
+            this.loop.schedule({ scroll: true });
+        }
+    }
+    /**
+     * Scrolls the editor to the y pixel indicated.
+     **/
+    scrollTo(scrollTop) {
+        // after calling scrollBar.setScrollTop
+        // scrollbar sends us event with same scrollTop. ignore it
+        if (this.scrollTop === scrollTop) {
+            return;
+        }
+        this.loop.schedule({ scroll: true });
+        this.scrollTop = scrollTop;
+    }
+    /**
+     * Scrolls the editor across y-axe.
+     **/
+    scrollBy(deltaY) {
+        if (!deltaY || !this.scrollBar.isVisible) {
+            return;
+        }
+        this.renderer.session.setScrollTop(this.renderer.session.scrollTop + deltaY);
+    }
+    screenToTextCoordinates(x, y) {
+        return this.renderer.screenToTextCoordinates(x, y);
+    }
+    showCursor() {
+        this.renderer.showCursor();
+    }
+    hideCursor() {
+        this.renderer.hideCursor();
+    }
+    destroy() {
+        this.scrollBar.removeAllListeners('scroll');
+        DomHelper.removeElement(this.scrollBar.element);
+        this.pagesLayer.destroy();
+        this.edgesLayer.destroy();
+        this.renderer.destroy();
+    }
+    computeLayerConfig() {
+        const pagesWrap = this.renderer.session.pagesWrap;
+        const maxHeight = pagesWrap.allPagesHeight;
+        const minHeight = pagesWrap.minHeight;
+        const scrollHidden = maxHeight < this.size.scrollerHeight;
+        const newScrollTop = Math.max(Math.min(this.scrollTop, maxHeight - this.size.scrollerHeight), 0);
+        this.renderer.session.scrollTop = newScrollTop;
+        this.scrollTop = newScrollTop;
+        const canScroll = !scrollHidden && this.size.scrollerHeight - maxHeight < 0;
+        const scrollChanged = this.canScroll !== canScroll;
+        if (scrollChanged) {
+            this.canScroll = canScroll;
+            this.scrollBar.setVisible(canScroll);
+        }
+        const changes = scrollChanged
+            ? this.updateCachedSize(true, this.size.width, this.size.height)
+            : new RenderChangesModel({ scroll: true });
+        const visibleRange = pagesWrap.getVisibleRange(this.scrollTop, this.size.scrollerHeight);
+        this.layerConfig = {
+            width: this.renderer.textLayer.element.clientWidth + pagesWrap.documentMargin.left + pagesWrap.documentMargin.right,
+            height: this.size.scrollerHeight,
+            contentRange: new DistanceModel({ start: visibleRange.startParagraph, end: visibleRange.endParagraph }),
+            minHeight,
+            maxHeight,
+            offset: 0,
+            visibleRange,
+            scrollTop: this.renderer.session.scrollTop,
+            pages: visibleRange.pages
+        };
+        return changes;
+    }
+    updateScrollBar() {
+        this.scrollBar.scrollHeight = this.layerConfig.maxHeight;
+        this.scrollBar.setScrollTop(this.scrollTop);
+    }
+    createScroller() {
+        this.scroller = document.createElement('div');
+        this.scroller.className = 'ace-scroller';
+        this.container.appendChild(this.scroller);
+    }
+    createLayers() {
+        this.edgesLayer = new EdgesLayer(this.renderer.content, this.editorService);
+        this.pagesLayer = new PagesLayer(this.renderer.content);
+    }
+    createScroll() {
+        this.scrollBar = new ScrollBar(this.container.parentElement);
+        this.scrollBar.addEventListener('scroll', (event) => {
+            this.renderer.session.setScrollTop(event.data);
+        });
+    }
+    createRenderLoop() {
+        this.loop = new RenderLoop(changes => this.renderChanges(changes));
+        this.renderer.loop = this.loop;
+        this.loop.schedule({ full: true });
+    }
+    renderScroll(changes) {
+        this.pagesLayer.update(this.layerConfig);
+        if (changes.text || changes.lines) {
+            this.edgesLayer.update(this.layerConfig);
+            this.renderer.textLayer.update(this.layerConfig);
+        }
+        else {
+            this.edgesLayer.scrollPages(this.layerConfig);
+            this.renderer.textLayer.scrollLines(this.layerConfig);
+        }
+        this.renderer.selectionLayer.update(this.layerConfig);
+        if (!this.renderer.cursorLayer.isVisible) {
+            return;
+        }
+        this.cursorLayer.update(this.layerConfig);
+        this.moveTextAreaToCursor();
+    }
+    renderFull() {
+        this.pagesLayer.update(this.layerConfig);
+        this.edgesLayer.update(this.layerConfig);
+        this.renderer.renderFull();
+    }
+    renderText() {
+        this.pagesLayer.update(this.layerConfig);
+        this.renderer.renderText();
+    }
+    renderCursor() {
+        this.renderer.renderCursor();
+    }
+    renderSelection() {
+        this.renderer.renderSelection();
+    }
+    getDefaultLayerConfig() {
+        return {
+            width: 1,
+            contentRange: new DistanceModel({ start: 0, end: 0 }),
+            minHeight: 1,
+            maxHeight: 1,
+            offset: 0,
+            height: 1,
+            scrollTop: 0,
+            pages: [],
+            visibleRange: {
+                startParagraph: 0,
+                startLine: 0,
+                startScreenLine: 0,
+                startScreenFullLine: 0,
+                endParagraph: 0,
+                endLine: 0,
+                endScreenLine: 0,
+                endScreenFullLine: 0
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual.renderer.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/+shared/editor/core/virtual.renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { CursorLayer } from './layers/cursor.layer';\nimport { DistanceModel } from './models/distance.model';\nimport { DomHelper } from './helpers/dom.helper';\nimport { EdgesLayer } from './layers/edges.layer';\nimport { EditorService } from '../interaction/editor.service';\nimport { EditSession } from './edit.session';\nimport { EventEmitting } from './base/event-emitting';\nimport { ILayerConfig } from './interfaces/layer.config';\nimport { PagesLayer } from './layers/pages.layer';\nimport { Point } from './point';\nimport { Range } from './range';\nimport { RenderChangesModel } from './models/render-changes.model';\nimport { Renderer } from './renderer';\nimport { RenderLoop } from './layers/renderloop';\nimport { ScrollBar } from './layers/scrollbar';\n\nexport class VirtualRenderer extends EventEmitting {\n    get isMousePressed(): boolean {\n        return this.renderer.isMousePressed;\n    }\n    set isMousePressed(val: boolean) {\n        this.renderer.isMousePressed = val;\n    }\n\n    get cursorLayer(): CursorLayer {\n        return this.renderer.cursorLayer;\n    }\n\n    get loop(): RenderLoop {\n        return this.renderer.loop;\n    }\n    set loop(val: RenderLoop) {\n        this.renderer.loop = val;\n    }\n\n    get textarea(): HTMLElement {\n        return this.renderer.textarea;\n    }\n    set textarea(val: HTMLElement) {\n        this.renderer.textarea = val;\n    }\n\n    get layerConfig(): ILayerConfig {\n        return this.renderer.layerConfig;\n    }\n    set layerConfig(val: ILayerConfig) {\n        this.renderer.layerConfig = val;\n    }\n\n    container: HTMLElement;\n\n    scroller: HTMLElement;\n\n    edgesLayer: EdgesLayer;\n\n    pagesLayer: PagesLayer;\n\n    scrollBar: ScrollBar;\n\n    canScroll: boolean;\n\n    scrollTop = 0;\n\n    renderer!: Renderer;\n\n    changes = new RenderChangesModel();\n\n    size = {\n        width: 0,\n        height: 0,\n        scrollerHeight: 0,\n        scrollerWidth: 0,\n        dirty: true\n    };\n\n    constructor(parentContainer: HTMLElement, private editorService: EditorService) {\n        super();\n        this.container = parentContainer;\n        this.createScroller();\n        this.renderer = new Renderer(parentContainer, editorService);\n        this.renderer.layerConfig = this.getDefaultLayerConfig();\n        this.createLayers();\n        this.createScroll();\n        this.createRenderLoop();\n    }\n\n    renderChanges(changes: RenderChangesModel, force?: boolean): void {\n        changes.apply(this.changes);\n        this.changes = new RenderChangesModel();\n\n        if (!this.renderer.session || !this.container.offsetWidth || (!changes.any && !force)) {\n            this.changes.apply(changes);\n\n            return;\n        }\n\n        if (this.size.dirty) {\n            this.changes.apply(changes);\n            this.onResize(true);\n\n            return;\n        }\n\n        // text, scrolling and resize changes can cause the view port size to change\n        if (changes.full || changes.size || changes.text || changes.lines || changes.scroll) {\n            changes.apply(this.computeLayerConfig());\n\n            this.updateScrollBar();\n\n            DomHelper.translate(this.renderer.content, 0, -this.layerConfig.offset);\n\n            DomHelper.setStyle(this.renderer.content.style, 'width', `${this.layerConfig.width}px`);\n            DomHelper.setStyle(this.renderer.content.style, 'height', `${this.layerConfig.height}px`);\n        }\n\n        // full\n        if (changes.full) {\n            this.renderFull();\n\n            return;\n        }\n\n        // scrolling\n        if (changes.scroll) {\n            this.renderScroll(changes);\n        }\n\n        if (changes.text) {\n            this.renderText();\n        }\n\n        if (changes.cursor) {\n            this.renderCursor();\n        }\n\n        if (changes.marker || changes.selection) {\n            this.renderSelection();\n        }\n    }\n\n    /**\n     * Triggers a resize of the editor\n     **/\n    onResize(force?: boolean): void {\n        const height = this.container.clientHeight || this.container.scrollHeight;\n        const width = this.container.clientWidth || this.container.scrollWidth;\n        const changes = this.updateCachedSize(force, width, height);\n        changes.apply(this.changes);\n\n        if (force) {\n            this.renderChanges(changes, true);\n        } else {\n            this.loop.schedule(changes);\n        }\n        this.scrollBar.scrollTop = null;\n    }\n\n    /**\n     * Triggers a partial update of the text, from the range given by the two parameters.\n     **/\n    updateLines(firstRow: number, lastRow: number): void {\n        this.renderer.updateLines(firstRow, lastRow);\n    }\n\n    updateCachedSize(force: boolean, width: number, height: number): RenderChangesModel {\n        if (width && (force || this.size.width !== width)) {\n            DomHelper.setStyle(this.scroller.style, 'left', 0);\n            this.size.scrollerWidth = Math.max(0, this.container.parentElement.clientWidth - this.scrollBar.width);\n            DomHelper.setStyle(this.scroller.style, 'right', 0);\n        }\n\n        let changes = new RenderChangesModel();\n        if (height && (force || this.size.height !== height)) {\n            this.size.height = height;\n            changes.size = true;\n\n            this.size.scrollerHeight = this.size.height;\n            changes.scroll = true;\n        }\n\n        if (width && (force || this.size.width !== width)) {\n            this.size.width = width;\n            changes.size = true;\n        }\n\n        this.size.dirty = !width || !height;\n\n        return changes;\n    }\n\n    moveTextAreaToCursor(): void {\n        if (this.isMousePressed || !this.textarea) {\n            return;\n        }\n\n        let cursorPosition = this.cursorLayer.cursorPosition;\n        if (!cursorPosition) {\n            return;\n        }\n\n        const posTop = cursorPosition.pageY - this.layerConfig.offset;\n        if (posTop < 0 || posTop > this.layerConfig.height - this.renderer.textareaSize.height) {\n            DomHelper.translate(this.textarea, 0, 0);\n            return;\n        }\n\n        DomHelper.setStyle(this.textarea.style, 'height', `${this.renderer.textareaSize.height}px`);\n        DomHelper.setStyle(this.textarea.style, 'width', `${this.renderer.textareaSize.width}px`);\n        DomHelper.translate(\n            this.textarea,\n            Math.min(cursorPosition.pageX, this.size.scrollerWidth - this.renderer.textareaSize.width),\n            Math.min(posTop, this.size.height - this.renderer.textareaSize.height)\n        );\n    }\n\n    setSession(session: EditSession): void {\n        this.pagesLayer.setSession(session);\n        this.edgesLayer.setSession(session);\n        this.renderer.setSession(session);\n        this.scrollBar.scrollTop = null;\n    }\n\n    updateSelection(range: Range): void {\n        this.renderer.updateSelection(range);\n    }\n\n    /**\n     * Triggers a full update of the text, for all the rows.\n     **/\n    updateText(): void {\n        this.renderer.updateText();\n    }\n\n    /**\n     * Triggers a full update of all the layers, for all the rows.\n     **/\n    updateFull(force?: boolean): void {\n        this.renderer.updateFull(force);\n    }\n\n    updateCursor(): void {\n        this.renderer.updateCursor();\n    }\n\n    scrollSelectionIntoView(anchor: Point, lead: Point, offset?: number): void {\n        // first scroll anchor into view then scroll lead into view\n        this.scrollCursorIntoView(anchor, offset);\n        this.scrollCursorIntoView(lead, offset);\n    }\n\n    /**\n     * Scrolls the cursor into the first visibile area of the editor\n     **/\n    scrollCursorIntoView(cursor?: Point, offset?: number): void {\n        if (!this.size.scrollerHeight) {\n            return;\n        }\n\n        const position = this.cursorLayer.getPixelPosition(cursor);\n        let top = position.pageY + this.scrollTop;\n\n        if (this.scrollTop > top) {\n            if (offset) {\n                top -= offset * this.container.scrollHeight;\n            }\n\n            this.renderer.session.setScrollTop(top);\n            this.loop.schedule({ scroll: true });\n        } else if (this.scrollTop + this.container.scrollHeight < top + position.lineHeight) {\n            if (offset) {\n                top += offset * this.container.scrollHeight;\n            }\n\n            this.renderer.session.setScrollTop(top + position.lineHeight - this.container.scrollHeight);\n            this.loop.schedule({ scroll: true });\n        }\n    }\n\n    /**\n     * Scrolls the editor to the y pixel indicated.\n     **/\n    scrollTo(scrollTop: number): void {\n        // after calling scrollBar.setScrollTop\n        // scrollbar sends us event with same scrollTop. ignore it\n        if (this.scrollTop === scrollTop) {\n            return;\n        }\n\n        this.loop.schedule({ scroll: true });\n        this.scrollTop = scrollTop;\n    }\n\n    /**\n     * Scrolls the editor across y-axe.\n     **/\n    scrollBy(deltaY: number): void {\n        if (!deltaY || !this.scrollBar.isVisible) {\n            return;\n        }\n\n        this.renderer.session.setScrollTop(this.renderer.session.scrollTop + deltaY);\n    }\n\n    screenToTextCoordinates(x: number, y: number): Point {\n        return this.renderer.screenToTextCoordinates(x, y);\n    }\n\n    showCursor(): void {\n        this.renderer.showCursor();\n    }\n\n    hideCursor(): void {\n        this.renderer.hideCursor();\n    }\n\n    destroy(): void {\n        this.scrollBar.removeAllListeners('scroll');\n        DomHelper.removeElement(this.scrollBar.element);\n        this.pagesLayer.destroy();\n        this.edgesLayer.destroy();\n        this.renderer.destroy();\n    }\n\n    private computeLayerConfig(): RenderChangesModel {\n        const pagesWrap = this.renderer.session.pagesWrap;\n        const maxHeight = pagesWrap.allPagesHeight;\n        const minHeight = pagesWrap.minHeight;\n        const scrollHidden = maxHeight < this.size.scrollerHeight;\n\n        const newScrollTop = Math.max(Math.min(this.scrollTop, maxHeight - this.size.scrollerHeight), 0);\n        this.renderer.session.scrollTop = newScrollTop;\n        this.scrollTop = newScrollTop;\n\n        const canScroll = !scrollHidden && this.size.scrollerHeight - maxHeight < 0;\n        const scrollChanged = this.canScroll !== canScroll;\n        if (scrollChanged) {\n            this.canScroll = canScroll;\n            this.scrollBar.setVisible(canScroll);\n        }\n\n        const changes = scrollChanged\n            ? this.updateCachedSize(true, this.size.width, this.size.height)\n            : new RenderChangesModel({ scroll: true });\n        const visibleRange = pagesWrap.getVisibleRange(this.scrollTop, this.size.scrollerHeight);\n        this.layerConfig = {\n            width: this.renderer.textLayer.element.clientWidth + pagesWrap.documentMargin.left + pagesWrap.documentMargin.right,\n            height: this.size.scrollerHeight,\n            contentRange: new DistanceModel({ start: visibleRange.startParagraph, end: visibleRange.endParagraph }),\n            minHeight,\n            maxHeight,\n            offset: 0,\n            visibleRange,\n            scrollTop: this.renderer.session.scrollTop,\n            pages: visibleRange.pages\n        };\n\n        return changes;\n    }\n\n    private updateScrollBar(): void {\n        this.scrollBar.scrollHeight = this.layerConfig.maxHeight;\n        this.scrollBar.setScrollTop(this.scrollTop);\n    }\n\n    private createScroller(): void {\n        this.scroller = document.createElement('div');\n        this.scroller.className = 'ace-scroller';\n        this.container.appendChild(this.scroller);\n    }\n\n    private createLayers(): void {\n        this.edgesLayer = new EdgesLayer(this.renderer.content, this.editorService);\n        this.pagesLayer = new PagesLayer(this.renderer.content);\n    }\n\n    private createScroll(): void {\n        this.scrollBar = new ScrollBar(this.container.parentElement);\n        this.scrollBar.addEventListener('scroll', (event: { data: number }) => {\n            this.renderer.session.setScrollTop(event.data);\n        });\n    }\n\n    private createRenderLoop(): void {\n        this.loop = new RenderLoop(changes => this.renderChanges(changes));\n        this.renderer.loop = this.loop;\n        this.loop.schedule({ full: true });\n    }\n\n    private renderScroll(changes: RenderChangesModel): void {\n        this.pagesLayer.update(this.layerConfig);\n        if (changes.text || changes.lines) {\n            this.edgesLayer.update(this.layerConfig);\n            this.renderer.textLayer.update(this.layerConfig);\n        } else {\n            this.edgesLayer.scrollPages(this.layerConfig);\n            this.renderer.textLayer.scrollLines(this.layerConfig);\n        }\n\n        this.renderer.selectionLayer.update(this.layerConfig);\n        if (!this.renderer.cursorLayer.isVisible) {\n            return;\n        }\n\n        this.cursorLayer.update(this.layerConfig);\n        this.moveTextAreaToCursor();\n    }\n\n    private renderFull(): void {\n        this.pagesLayer.update(this.layerConfig);\n        this.edgesLayer.update(this.layerConfig);\n        this.renderer.renderFull();\n    }\n\n    private renderText(): void {\n        this.pagesLayer.update(this.layerConfig);\n        this.renderer.renderText();\n    }\n\n    private renderCursor(): void {\n        this.renderer.renderCursor();\n    }\n\n    private renderSelection(): void {\n        this.renderer.renderSelection();\n    }\n\n    private getDefaultLayerConfig(): ILayerConfig {\n        return {\n            width: 1,\n            contentRange: new DistanceModel({ start: 0, end: 0 }),\n            minHeight: 1,\n            maxHeight: 1,\n            offset: 0,\n            height: 1,\n            scrollTop: 0,\n            pages: [],\n            visibleRange: {\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            }\n        };\n    }\n}\n"]}

package/esm2022/lib/+shared/editor/custom-components/external-element/element-toolbar/element-toolbar.component.mjs

@@ -0,0 +1,35 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { ElementDataModel } from '../models/element-data.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/tooltip";
+export class ElementToolbarComponent {
+    constructor() {
+        this.isDisabled = false;
+        this.createElement = new EventEmitter();
+        this.isHide = false;
+    }
+    changeVisibility() {
+        this.isHide = !this.isHide;
+    }
+    async create(model) {
+        const data = await model.factoryMethod();
+        const element = new ElementDataModel(model.type, data.width, data.height, data.guid);
+        this.createElement.emit(element);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: ElementToolbarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: ElementToolbarComponent, selector: "app-element-toolbar", inputs: { isDisabled: "isDisabled", elements: "elements" }, outputs: { createElement: "createElement" }, ngImport: i0, template: "<button\n    class=\"menu\"\n    mat-raised-button\n    (click)=\"changeVisibility()\">\n    <div class=\"icon\">\n        <mat-icon\n            fontSet=\"nc-icon\"\n            fontIcon=\"icon-menu-circle\"></mat-icon>\n    </div>\n</button>\n<div\n    class=\"menu-items\"\n    *ngIf=\"!isHide\">\n    <div class=\"empty-place\"></div>\n    <button\n        *ngFor=\"let element of elements\"\n        mat-icon-button\n        matTooltip=\"{{ element.name }}\"\n        matTooltipPosition=\"left\"\n        (click)=\"create(element)\"\n        [disabled]=\"isDisabled\">\n        <mat-icon\n            fontSet=\"nc-icon\"\n            fontIcon=\"{{ element.icon }}\"></mat-icon>\n    </button>\n</div>\n", styles: [":host{position:absolute}.mat-mdc-button.mat-mdc-button-base,.mat-mdc-raised-button.mat-mdc-button-base,.mat-mdc-unelevated-button.mat-mdc-button-base,.mat-mdc-outlined-button.mat-mdc-button-base{padding-right:21px}.menu-items{z-index:1;top:24px;position:absolute;max-width:50px;display:flex;flex-direction:column;border-radius:0 0 20px 20px;box-shadow:1px 2px 5px #0000001a}.menu-items .empty-place{height:24px}.menu{border-radius:30px 0 0 30px;min-width:56px;width:56px;height:48px;z-index:2}.menu .icon mat-icon{height:22px;width:24px;font-size:24px}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i4.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: ElementToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-element-toolbar', changeDetection: ChangeDetectionStrategy.OnPush, template: "<button\n    class=\"menu\"\n    mat-raised-button\n    (click)=\"changeVisibility()\">\n    <div class=\"icon\">\n        <mat-icon\n            fontSet=\"nc-icon\"\n            fontIcon=\"icon-menu-circle\"></mat-icon>\n    </div>\n</button>\n<div\n    class=\"menu-items\"\n    *ngIf=\"!isHide\">\n    <div class=\"empty-place\"></div>\n    <button\n        *ngFor=\"let element of elements\"\n        mat-icon-button\n        matTooltip=\"{{ element.name }}\"\n        matTooltipPosition=\"left\"\n        (click)=\"create(element)\"\n        [disabled]=\"isDisabled\">\n        <mat-icon\n            fontSet=\"nc-icon\"\n            fontIcon=\"{{ element.icon }}\"></mat-icon>\n    </button>\n</div>\n", styles: [":host{position:absolute}.mat-mdc-button.mat-mdc-button-base,.mat-mdc-raised-button.mat-mdc-button-base,.mat-mdc-unelevated-button.mat-mdc-button-base,.mat-mdc-outlined-button.mat-mdc-button-base{padding-right:21px}.menu-items{z-index:1;top:24px;position:absolute;max-width:50px;display:flex;flex-direction:column;border-radius:0 0 20px 20px;box-shadow:1px 2px 5px #0000001a}.menu-items .empty-place{height:24px}.menu{border-radius:30px 0 0 30px;min-width:56px;width:56px;height:48px;z-index:2}.menu .icon mat-icon{height:22px;width:24px;font-size:24px}\n"] }]
+        }], propDecorators: { isDisabled: [{
+                type: Input
+            }], elements: [{
+                type: Input
+            }], createElement: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/+shared/editor/custom-components/external-element/external-element.service.mjs

@@ -0,0 +1,6 @@
+export class ExternalElementService {
+    constructor() {
+        this.elements = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZXJuYWwtZWxlbWVudC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvK3NoYXJlZC9lZGl0b3IvY3VzdG9tLWNvbXBvbmVudHMvZXh0ZXJuYWwtZWxlbWVudC9leHRlcm5hbC1lbGVtZW50LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUEsTUFBTSxPQUFPLHNCQUFzQjtJQUFuQztRQUNJLGFBQVEsR0FBMkIsRUFBRSxDQUFDO0lBQzFDLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV4dGVybmFsRWxlbWVudE1vZGVsIH0gZnJvbSAnLi9tb2RlbHMvZXh0ZXJuYWwtZWxlbWVudC5tb2RlbCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXh0ZXJuYWxFbGVtZW50SW50ZXJmYWNlIHtcbiAgICBlbGVtZW50czogRXh0ZXJuYWxFbGVtZW50TW9kZWxbXTtcbn1cblxuZXhwb3J0IGNsYXNzIEV4dGVybmFsRWxlbWVudFNlcnZpY2UgaW1wbGVtZW50cyBFeHRlcm5hbEVsZW1lbnRJbnRlcmZhY2Uge1xuICAgIGVsZW1lbnRzOiBFeHRlcm5hbEVsZW1lbnRNb2RlbFtdID0gW107XG59XG4iXX0=

package/esm2022/lib/+shared/editor/custom-components/external-element/external-elements.const.mjs

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+export const EXTERNAL_ELEMENT_SIDENAV = new InjectionToken('EXTERNAL_ELEMENT_SIDENAV');
+export const EXTERNAL_ELEMENT_SERVICE = new InjectionToken('EXTERNAL_ELEMENT_SERVICE');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZXJuYWwtZWxlbWVudHMuY29uc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9jdXN0b20tY29tcG9uZW50cy9leHRlcm5hbC1lbGVtZW50L2V4dGVybmFsLWVsZW1lbnRzLmNvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFLL0MsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsSUFBSSxjQUFjLENBQXVCLDBCQUEwQixDQUFDLENBQUM7QUFFN0csTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsSUFBSSxjQUFjLENBQTJCLDBCQUEwQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBFeHRlcm5hbEVsZW1lbnRJbnRlcmZhY2UgfSBmcm9tICcuL2V4dGVybmFsLWVsZW1lbnQuc2VydmljZSc7XG5pbXBvcnQgeyBFeHRlcm5hbFNpZGVuYXZNb2RlbCB9IGZyb20gJy4vbW9kZWxzL2V4dGVybmFsLXNpZGVuYXYubW9kZWwnO1xuXG5leHBvcnQgY29uc3QgRVhURVJOQUxfRUxFTUVOVF9TSURFTkFWID0gbmV3IEluamVjdGlvblRva2VuPEV4dGVybmFsU2lkZW5hdk1vZGVsPignRVhURVJOQUxfRUxFTUVOVF9TSURFTkFWJyk7XG5cbmV4cG9ydCBjb25zdCBFWFRFUk5BTF9FTEVNRU5UX1NFUlZJQ0UgPSBuZXcgSW5qZWN0aW9uVG9rZW48RXh0ZXJuYWxFbGVtZW50SW50ZXJmYWNlPignRVhURVJOQUxfRUxFTUVOVF9TRVJWSUNFJyk7XG4iXX0=

package/esm2022/lib/+shared/editor/custom-components/external-element/external-sidenav.interface.mjs

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

package/esm2022/lib/+shared/editor/custom-components/external-element/external.component.mjs

@@ -0,0 +1,41 @@
+import { Directive, inject } from '@angular/core';
+import { BaseNoderComponent } from '../shared/abstract/base.component';
+import { EditorService } from '../../interaction/editor.service';
+import { ElementModel } from '../../../../models/generated/element.model';
+import * as i0 from "@angular/core";
+export class NoderExternalComponent extends BaseNoderComponent {
+    constructor() {
+        super(...arguments);
+        this.editorService = inject(EditorService);
+    }
+    focus() {
+        super.focus();
+        if (this.editorService.isViewOnly) {
+            return;
+        }
+        this.editorService.toggleSidenav(true, this.sidenavComponent, this.content, this.contentWidth);
+    }
+    blur() {
+        super.blur();
+        if (this.editorService.isViewOnly) {
+            return;
+        }
+        this.editorService.toggleSidenav(false, this.sidenavComponent, this.content, this.contentWidth);
+    }
+    changeElementHeight(height) {
+        if (this._height !== height) {
+            this.editorService.changeElementStyle(new ElementModel({ ...this.content, height }));
+        }
+    }
+    changeElementWidth(width) {
+        if (this._width !== width) {
+            this.editorService.changeElementStyle(new ElementModel({ ...this.content, width }));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NoderExternalComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.1", type: NoderExternalComponent, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: NoderExternalComponent, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/+shared/editor/custom-components/external-element/models/element-data.model.mjs

@@ -0,0 +1,9 @@
+export class ElementDataModel {
+    constructor(type, width, height, guid) {
+        this.type = type;
+        this.width = width;
+        this.height = height;
+        this.guid = guid;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1kYXRhLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvK3NoYXJlZC9lZGl0b3IvY3VzdG9tLWNvbXBvbmVudHMvZXh0ZXJuYWwtZWxlbWVudC9tb2RlbHMvZWxlbWVudC1kYXRhLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxnQkFBZ0I7SUFDekIsWUFBbUIsSUFBWSxFQUFTLEtBQWEsRUFBUyxNQUFjLEVBQVMsSUFBWTtRQUE5RSxTQUFJLEdBQUosSUFBSSxDQUFRO1FBQVMsVUFBSyxHQUFMLEtBQUssQ0FBUTtRQUFTLFdBQU0sR0FBTixNQUFNLENBQVE7UUFBUyxTQUFJLEdBQUosSUFBSSxDQUFRO0lBQUcsQ0FBQztDQUN4RyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBFbGVtZW50RGF0YU1vZGVsIHtcbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgdHlwZTogbnVtYmVyLCBwdWJsaWMgd2lkdGg6IG51bWJlciwgcHVibGljIGhlaWdodDogbnVtYmVyLCBwdWJsaWMgZ3VpZDogc3RyaW5nKSB7fVxufVxuIl19

package/esm2022/lib/+shared/editor/custom-components/external-element/models/external-element.model.mjs

@@ -0,0 +1,10 @@
+export class ExternalElementModel {
+    constructor(name, icon, type, componentType, factoryMethod) {
+        this.name = name;
+        this.icon = icon;
+        this.type = type;
+        this.componentType = componentType;
+        this.factoryMethod = factoryMethod;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZXJuYWwtZWxlbWVudC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2N1c3RvbS1jb21wb25lbnRzL2V4dGVybmFsLWVsZW1lbnQvbW9kZWxzL2V4dGVybmFsLWVsZW1lbnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxPQUFPLG9CQUFvQjtJQUM3QixZQUNXLElBQVksRUFDWixJQUFZLEVBQ1osSUFBWSxFQUNaLGFBQXVDLEVBQ3ZDLGFBQTJGO1FBSjNGLFNBQUksR0FBSixJQUFJLENBQVE7UUFDWixTQUFJLEdBQUosSUFBSSxDQUFRO1FBQ1osU0FBSSxHQUFKLElBQUksQ0FBUTtRQUNaLGtCQUFhLEdBQWIsYUFBYSxDQUEwQjtRQUN2QyxrQkFBYSxHQUFiLGFBQWEsQ0FBOEU7SUFDbkcsQ0FBQztDQUNQIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBCYXNlTm9kZXJDb21wb25lbnQgfSBmcm9tICcuLi8uLi9zaGFyZWQvYWJzdHJhY3QvYmFzZS5jb21wb25lbnQnO1xuXG5leHBvcnQgY2xhc3MgRXh0ZXJuYWxFbGVtZW50TW9kZWwge1xuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwdWJsaWMgbmFtZTogc3RyaW5nLFxuICAgICAgICBwdWJsaWMgaWNvbjogc3RyaW5nLFxuICAgICAgICBwdWJsaWMgdHlwZTogbnVtYmVyLFxuICAgICAgICBwdWJsaWMgY29tcG9uZW50VHlwZTogVHlwZTxCYXNlTm9kZXJDb21wb25lbnQ+LFxuICAgICAgICBwdWJsaWMgZmFjdG9yeU1ldGhvZDogKCkgPT4gUHJvbWlzZTx7IGd1aWQ6IHN0cmluZzsgdHlwZTogbnVtYmVyOyB3aWR0aDogbnVtYmVyOyBoZWlnaHQ6IG51bWJlciB9PlxuICAgICkge31cbn1cbiJdfQ==

package/esm2022/lib/+shared/editor/custom-components/external-element/models/external-sidenav.model.mjs

@@ -0,0 +1,15 @@
+export class ExternalSidenavModel {
+    constructor(fields) {
+        this.autoFocus = false;
+        this.hasBackdrop = false;
+        this.position = 'end';
+        this.mode = 'over';
+        if (fields) {
+            this.autoFocus = fields.autoFocus ?? this.autoFocus;
+            this.hasBackdrop = fields.hasBackdrop ?? this.hasBackdrop;
+            this.position = fields.position ?? this.position;
+            this.mode = fields.mode ?? this.mode;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZXJuYWwtc2lkZW5hdi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2N1c3RvbS1jb21wb25lbnRzL2V4dGVybmFsLWVsZW1lbnQvbW9kZWxzL2V4dGVybmFsLXNpZGVuYXYubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLG9CQUFvQjtJQVM3QixZQUFtQixNQUFzQztRQVJ6RCxjQUFTLEdBQUcsS0FBSyxDQUFDO1FBRWxCLGdCQUFXLEdBQUcsS0FBSyxDQUFDO1FBRXBCLGFBQVEsR0FBb0IsS0FBSyxDQUFDO1FBRWxDLFNBQUksR0FBb0IsTUFBTSxDQUFDO1FBRzNCLElBQUksTUFBTSxFQUFFO1lBQ1IsSUFBSSxDQUFDLFNBQVMsR0FBRyxNQUFNLENBQUMsU0FBUyxJQUFJLElBQUksQ0FBQyxTQUFTLENBQUM7WUFDcEQsSUFBSSxDQUFDLFdBQVcsR0FBRyxNQUFNLENBQUMsV0FBVyxJQUFJLElBQUksQ0FBQyxXQUFXLENBQUM7WUFDMUQsSUFBSSxDQUFDLFFBQVEsR0FBRyxNQUFNLENBQUMsUUFBUSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUM7WUFDakQsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUM7U0FDeEM7SUFDTCxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgRXh0ZXJuYWxTaWRlbmF2TW9kZWwge1xuICAgIGF1dG9Gb2N1cyA9IGZhbHNlO1xuXG4gICAgaGFzQmFja2Ryb3AgPSBmYWxzZTtcblxuICAgIHBvc2l0aW9uOiAnc3RhcnQnIHwgJ2VuZCcgPSAnZW5kJztcblxuICAgIG1vZGU6ICdvdmVyJyB8ICdzaWRlJyA9ICdvdmVyJztcblxuICAgIHB1YmxpYyBjb25zdHJ1Y3RvcihmaWVsZHM/OiBQYXJ0aWFsPEV4dGVybmFsU2lkZW5hdk1vZGVsPikge1xuICAgICAgICBpZiAoZmllbGRzKSB7XG4gICAgICAgICAgICB0aGlzLmF1dG9Gb2N1cyA9IGZpZWxkcy5hdXRvRm9jdXMgPz8gdGhpcy5hdXRvRm9jdXM7XG4gICAgICAgICAgICB0aGlzLmhhc0JhY2tkcm9wID0gZmllbGRzLmhhc0JhY2tkcm9wID8/IHRoaXMuaGFzQmFja2Ryb3A7XG4gICAgICAgICAgICB0aGlzLnBvc2l0aW9uID0gZmllbGRzLnBvc2l0aW9uID8/IHRoaXMucG9zaXRpb247XG4gICAgICAgICAgICB0aGlzLm1vZGUgPSBmaWVsZHMubW9kZSA/PyB0aGlzLm1vZGU7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=