@talrace/ngx-noder 0.0.7

package/esm2022/lib/+shared/editor/editor.component.mjs

@@ -0,0 +1,103 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewChild } from '@angular/core';
+import { DocxModel } from '../../models/generated/docx.model';
+import { Editor } from './core/editor';
+import { EDITOR_VERSION } from './core/constants/editor-version.const';
+import { EXTERNAL_ELEMENT_SERVICE, EXTERNAL_ELEMENT_SIDENAV } from './custom-components/external-element/external-elements.const';
+import { FontMetrics } from './core/helpers/font-metrics.helper';
+import * as i0 from "@angular/core";
+import * as i1 from "./custom-components/shared/services/component/component.service";
+import * as i2 from "./interaction/editor.service";
+import * as i3 from "./execution/regulator.service";
+import * as i4 from "../services/commands.service";
+import * as i5 from "@angular/cdk/clipboard";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/sidenav";
+import * as i8 from "./custom-components/external-element/element-toolbar/element-toolbar.component";
+export class EditorComponent {
+    get isViewOnly$() {
+        return this.editorService.isViewOnly$;
+    }
+    set content(model) {
+        if (model) {
+            const deepCopy = JSON.parse(JSON.stringify(model));
+            this._content = new DocxModel(deepCopy);
+        }
+        this.initEditor(this._content);
+    }
+    get content() {
+        return this._content;
+    }
+    constructor(cdr, componentService, editorService, injector, regulatorService, commandsService, clipboard) {
+        this.cdr = cdr;
+        this.componentService = componentService;
+        this.editorService = editorService;
+        this.injector = injector;
+        this.regulatorService = regulatorService;
+        this.commandsService = commandsService;
+        this.clipboard = clipboard;
+        this.class = 'base-editor';
+        this.subscriptions = [];
+        this.sidenavComponentRef = null;
+        this.elements = this.injector.get(EXTERNAL_ELEMENT_SERVICE).elements;
+        this.sidenavProperties = this.injector.get(EXTERNAL_ELEMENT_SIDENAV);
+        FontMetrics.checkVersion(EDITOR_VERSION);
+    }
+    ngOnDestroy() {
+        this.editor?.destroy();
+        this.regulatorService.clearAllSessions();
+        this.subscriptions.forEach(x => x?.unsubscribe());
+        this.subscriptions.splice(0);
+    }
+    initEditor(content) {
+        this.ngOnDestroy();
+        this.editor = new Editor(content, this.container, this.editorService, this.regulatorService, this.commandsService, this.clipboard);
+        this.subscriptions.push(this.toggleSidenavSubscription());
+    }
+    createElement(model) {
+        this.editor.createCustomElement(model);
+        this.editor.focus();
+    }
+    toggleSidenavSubscription() {
+        return this.editorService.toggleSidenav$.subscribe(data => {
+            if (this.sidenav.opened === data.open) {
+                return;
+            }
+            if (data.open) {
+                this.sidenavComponentRef = this.componentService.createComponent(data.component, {
+                    model: data.model,
+                    contentWidth: data.contentWidth
+                });
+                this.componentService.attachComponent(this.sidenavContainer.nativeElement, this.sidenavComponentRef);
+            }
+            else {
+                this.componentService.removeComponent(this.sidenavComponentRef);
+                this.sidenavComponentRef = null;
+            }
+            this.sidenav.toggle().catch(() => {
+                // continue regardless of error
+            });
+            this.cdr.markForCheck();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: EditorComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.ComponentService }, { token: i2.EditorService }, { token: i0.Injector }, { token: i3.RegulatorService }, { token: i4.CommandsService }, { token: i5.Clipboard }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: EditorComponent, selector: "app-editor", inputs: { content: "content" }, host: { properties: { "class": "this.class" } }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, static: true }, { propertyName: "sidenavContainer", first: true, predicate: ["drawerContainer"], descendants: true, static: true }, { propertyName: "sidenav", first: true, predicate: ["drawer"], descendants: true, static: true }], ngImport: i0, template: "<mat-drawer-container\n    class=\"sidenav-container\"\n    [hasBackdrop]=\"sidenavProperties.hasBackdrop\">\n    <mat-drawer-content>\n        <div class=\"container\">\n            <div\n                #container\n                class=\"edit-container\"></div>\n            <app-element-toolbar\n                *ngIf=\"elements.length\"\n                [elements]=\"elements\"\n                [isDisabled]=\"isViewOnly$ | async\"\n                (createElement)=\"createElement($event)\"></app-element-toolbar>\n        </div>\n    </mat-drawer-content>\n    <mat-drawer\n        #drawer\n        [autoFocus]=\"sidenavProperties.autoFocus\"\n        [position]=\"sidenavProperties.position\"\n        [mode]=\"sidenavProperties.mode\">\n        <div\n            #drawerContainer\n            class=\"drawer-container\"></div>\n    </mat-drawer>\n</mat-drawer-container>\n", styles: [":host{flex:1;display:flex;position:relative}.sidenav-container{width:100%}.container{height:100%;display:flex;justify-content:center}app-element-toolbar{right:15px;top:50px}:host::ng-deep .ace-editor{position:relative;line-height:1;font-size:12pt;font-family:Courier New,Courier,monospace;text-align:left;width:100%;height:100%}:host::ng-deep .ace-scroller{position:absolute;overflow:hidden;top:0;bottom:0;-webkit-user-select:none;user-select:none;cursor:text}:host::ng-deep .ace-scrollbar{overflow:hidden scroll;contain:strict;position:absolute;right:0;bottom:0;z-index:6;top:0}:host::ng-deep .ace-scrollbar-inner{position:absolute;cursor:text;left:0;top:0}:host::ng-deep .ace-text-input{position:absolute;z-index:0;width:.5em;height:1em;opacity:0;background:transparent;appearance:none;border:none;resize:none;overflow:hidden;font:inherit;padding:0 1px;margin:0 -1px;contain:strict;-webkit-user-select:text;user-select:text}:host::ng-deep .ace-layer{z-index:1;position:absolute;word-wrap:normal;white-space:pre;height:100%;width:100%;box-sizing:border-box;pointer-events:none}:host::ng-deep .ace-text-layer{font:inherit!important;position:absolute;contain:style size layout;pointer-events:auto}:host::ng-deep .ace-edges-layer{z-index:2}:host::ng-deep .ace-line{display:flex;align-items:baseline;line-height:normal}:host::ng-deep .ace-line .hyperlink-hover{cursor:pointer}:host::ng-deep .ace-line>*{display:inline-block;font-kerning:none}:host::ng-deep .ace-line>*.paragraph-symbol{align-self:flex-end}:host::ng-deep .ace-content{position:inherit;box-sizing:border-box;min-width:100%;contain:style size layout;inset:0}:host::ng-deep .ace-line-group{display:inline-flex}:host::ng-deep .ace-line-group .lines-container{width:100%}:host::ng-deep .ace-line-group .numberingMarker{display:inline-flex}:host::ng-deep .ace-line-group .numberingMarker span{align-self:end}:host::ng-deep .ace-text-layer>.ace-line,:host::ng-deep .ace-text-layer>.ace-line-group,:host::ng-deep .ace-edges-layer>.ace-line,:host::ng-deep .ace-edges-layer>.ace-line-group{contain:style size layout;position:absolute;top:0;left:0;right:0}:host::ng-deep .ace-text-layer>.ace-line-group:has(.focused){z-index:1}:host::ng-deep .ace-line-group:has(.lines-container>.ace-line:first-child>span:not(:empty)){align-items:baseline}:host::ng-deep .ace-cursor-layer{z-index:4}:host::ng-deep .ace-cursor-layer.selecting{display:none}:host::ng-deep .ace-cursor{z-index:4;position:absolute;box-sizing:border-box;border-left:2px solid;transform:translateZ(0)}:host::ng-deep .ace-hidden-cursors .ace-cursor{opacity:0}:host::ng-deep .ace-hidden-cursors{visibility:hidden}:host::ng-deep .ace-animate-blinking .ace-cursor{animation-duration:1s;animation-timing-function:step-end;animation-name:blink-ace-animate;animation-iteration-count:infinite}:host::ng-deep .ace-animate-blinking.ace-smooth-blinking .ace-cursor{animation-duration:1s;animation-timing-function:ease-in-out;animation-name:blink-ace-animate-smooth}@keyframes blink-ace-animate{0%,to{opacity:1}60%{opacity:0}}@keyframes blink-ace-animate-smooth{0%,to{opacity:1}45%{opacity:1}60%{opacity:0}85%{opacity:0}}:host::ng-deep .ace-selection-layer .ace-selection{position:absolute;z-index:5}:host::ng-deep .ace-selection-layer.text-selection .ace-selection{background-color:#5ea8f766}:host::ng-deep .ace-selection-layer.notes-highlight .ace-selection{background:#ff06}:host::ng-deep .ace-underline{text-decoration:underline}:host::ng-deep .ace-bold{font-weight:700}:host::ng-deep .ace-italic{font-style:italic}:host::ng-deep .page{width:100%;position:absolute}:host::ng-deep .page-label{position:absolute;top:40px;right:96px;font-family:Courier New,Courier,monospace;font-size:16px;line-height:1}:host::ng-deep .font-baseline{visibility:hidden;height:500px}:host::ng-deep .font-baseline span:after{content:\"\";height:100%;display:inline-block}:host::ng-deep .ruler-line{position:absolute;top:0;bottom:0;width:0;border-left:1px solid rgba(0,0,0,.4);opacity:.5;display:none;z-index:1}:host::ng-deep .ruler-line.visible{display:block}:host::ng-deep .drawer-container .mat-button-toggle-button{height:48px;border-radius:4px}:host::ng-deep .drawer-container .mat-button-toggle-checked button{height:48px;border-radius:4px}\n"], dependencies: [{ kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i7.MatDrawer, selector: "mat-drawer", inputs: ["position", "mode", "disableClose", "autoFocus", "opened"], outputs: ["openedChange", "opened", "openedStart", "closed", "closedStart", "positionChanged"], exportAs: ["matDrawer"] }, { kind: "component", type: i7.MatDrawerContainer, selector: "mat-drawer-container", inputs: ["autosize", "hasBackdrop"], outputs: ["backdropClick"], exportAs: ["matDrawerContainer"] }, { kind: "component", type: i7.MatDrawerContent, selector: "mat-drawer-content" }, { kind: "component", type: i8.ElementToolbarComponent, selector: "app-element-toolbar", inputs: ["isDisabled", "elements"], outputs: ["createElement"] }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: EditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-editor', changeDetection: ChangeDetectionStrategy.OnPush, template: "<mat-drawer-container\n    class=\"sidenav-container\"\n    [hasBackdrop]=\"sidenavProperties.hasBackdrop\">\n    <mat-drawer-content>\n        <div class=\"container\">\n            <div\n                #container\n                class=\"edit-container\"></div>\n            <app-element-toolbar\n                *ngIf=\"elements.length\"\n                [elements]=\"elements\"\n                [isDisabled]=\"isViewOnly$ | async\"\n                (createElement)=\"createElement($event)\"></app-element-toolbar>\n        </div>\n    </mat-drawer-content>\n    <mat-drawer\n        #drawer\n        [autoFocus]=\"sidenavProperties.autoFocus\"\n        [position]=\"sidenavProperties.position\"\n        [mode]=\"sidenavProperties.mode\">\n        <div\n            #drawerContainer\n            class=\"drawer-container\"></div>\n    </mat-drawer>\n</mat-drawer-container>\n", styles: [":host{flex:1;display:flex;position:relative}.sidenav-container{width:100%}.container{height:100%;display:flex;justify-content:center}app-element-toolbar{right:15px;top:50px}:host::ng-deep .ace-editor{position:relative;line-height:1;font-size:12pt;font-family:Courier New,Courier,monospace;text-align:left;width:100%;height:100%}:host::ng-deep .ace-scroller{position:absolute;overflow:hidden;top:0;bottom:0;-webkit-user-select:none;user-select:none;cursor:text}:host::ng-deep .ace-scrollbar{overflow:hidden scroll;contain:strict;position:absolute;right:0;bottom:0;z-index:6;top:0}:host::ng-deep .ace-scrollbar-inner{position:absolute;cursor:text;left:0;top:0}:host::ng-deep .ace-text-input{position:absolute;z-index:0;width:.5em;height:1em;opacity:0;background:transparent;appearance:none;border:none;resize:none;overflow:hidden;font:inherit;padding:0 1px;margin:0 -1px;contain:strict;-webkit-user-select:text;user-select:text}:host::ng-deep .ace-layer{z-index:1;position:absolute;word-wrap:normal;white-space:pre;height:100%;width:100%;box-sizing:border-box;pointer-events:none}:host::ng-deep .ace-text-layer{font:inherit!important;position:absolute;contain:style size layout;pointer-events:auto}:host::ng-deep .ace-edges-layer{z-index:2}:host::ng-deep .ace-line{display:flex;align-items:baseline;line-height:normal}:host::ng-deep .ace-line .hyperlink-hover{cursor:pointer}:host::ng-deep .ace-line>*{display:inline-block;font-kerning:none}:host::ng-deep .ace-line>*.paragraph-symbol{align-self:flex-end}:host::ng-deep .ace-content{position:inherit;box-sizing:border-box;min-width:100%;contain:style size layout;inset:0}:host::ng-deep .ace-line-group{display:inline-flex}:host::ng-deep .ace-line-group .lines-container{width:100%}:host::ng-deep .ace-line-group .numberingMarker{display:inline-flex}:host::ng-deep .ace-line-group .numberingMarker span{align-self:end}:host::ng-deep .ace-text-layer>.ace-line,:host::ng-deep .ace-text-layer>.ace-line-group,:host::ng-deep .ace-edges-layer>.ace-line,:host::ng-deep .ace-edges-layer>.ace-line-group{contain:style size layout;position:absolute;top:0;left:0;right:0}:host::ng-deep .ace-text-layer>.ace-line-group:has(.focused){z-index:1}:host::ng-deep .ace-line-group:has(.lines-container>.ace-line:first-child>span:not(:empty)){align-items:baseline}:host::ng-deep .ace-cursor-layer{z-index:4}:host::ng-deep .ace-cursor-layer.selecting{display:none}:host::ng-deep .ace-cursor{z-index:4;position:absolute;box-sizing:border-box;border-left:2px solid;transform:translateZ(0)}:host::ng-deep .ace-hidden-cursors .ace-cursor{opacity:0}:host::ng-deep .ace-hidden-cursors{visibility:hidden}:host::ng-deep .ace-animate-blinking .ace-cursor{animation-duration:1s;animation-timing-function:step-end;animation-name:blink-ace-animate;animation-iteration-count:infinite}:host::ng-deep .ace-animate-blinking.ace-smooth-blinking .ace-cursor{animation-duration:1s;animation-timing-function:ease-in-out;animation-name:blink-ace-animate-smooth}@keyframes blink-ace-animate{0%,to{opacity:1}60%{opacity:0}}@keyframes blink-ace-animate-smooth{0%,to{opacity:1}45%{opacity:1}60%{opacity:0}85%{opacity:0}}:host::ng-deep .ace-selection-layer .ace-selection{position:absolute;z-index:5}:host::ng-deep .ace-selection-layer.text-selection .ace-selection{background-color:#5ea8f766}:host::ng-deep .ace-selection-layer.notes-highlight .ace-selection{background:#ff06}:host::ng-deep .ace-underline{text-decoration:underline}:host::ng-deep .ace-bold{font-weight:700}:host::ng-deep .ace-italic{font-style:italic}:host::ng-deep .page{width:100%;position:absolute}:host::ng-deep .page-label{position:absolute;top:40px;right:96px;font-family:Courier New,Courier,monospace;font-size:16px;line-height:1}:host::ng-deep .font-baseline{visibility:hidden;height:500px}:host::ng-deep .font-baseline span:after{content:\"\";height:100%;display:inline-block}:host::ng-deep .ruler-line{position:absolute;top:0;bottom:0;width:0;border-left:1px solid rgba(0,0,0,.4);opacity:.5;display:none;z-index:1}:host::ng-deep .ruler-line.visible{display:block}:host::ng-deep .drawer-container .mat-button-toggle-button{height:48px;border-radius:4px}:host::ng-deep .drawer-container .mat-button-toggle-checked button{height:48px;border-radius:4px}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.ComponentService }, { type: i2.EditorService }, { type: i0.Injector }, { type: i3.RegulatorService }, { type: i4.CommandsService }, { type: i5.Clipboard }], propDecorators: { content: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { static: true }]
+            }], sidenavContainer: [{
+                type: ViewChild,
+                args: ['drawerContainer', { static: true }]
+            }], sidenav: [{
+                type: ViewChild,
+                args: ['drawer', { static: true }]
+            }], class: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/+shared/editor/editor.component.ts","../../../../../../projects/ngx-noder/src/lib/+shared/editor/editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ComponentRef,\n    ElementRef,\n    HostBinding,\n    Injector,\n    Input,\n    OnDestroy,\n    ViewChild\n} from '@angular/core';\nimport { Clipboard } from '@angular/cdk/clipboard';\nimport { MatDrawer } from '@angular/material/sidenav';\nimport { Observable, Subscription } from 'rxjs';\n\nimport { CommandsService } from '../services/commands.service';\nimport { ComponentService } from './custom-components/shared/services/component/component.service';\nimport { DocxModel } from '../../models/generated/docx.model';\nimport { Editor } from './core/editor';\nimport { EDITOR_VERSION } from './core/constants/editor-version.const';\nimport { EditorService } from './interaction/editor.service';\nimport { ElementDataModel } from './custom-components/external-element/models/element-data.model';\nimport { EXTERNAL_ELEMENT_SERVICE, EXTERNAL_ELEMENT_SIDENAV } from './custom-components/external-element/external-elements.const';\nimport { ExternalElementModel } from './custom-components/external-element/models/external-element.model';\nimport { ExternalSidenavModel } from './custom-components/external-element/models/external-sidenav.model';\nimport { FontMetrics } from './core/helpers/font-metrics.helper';\nimport { RegulatorService } from './execution/regulator.service';\n\n@Component({\n    selector: 'app-editor',\n    templateUrl: './editor.component.html',\n    styleUrls: ['./editor.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class EditorComponent implements OnDestroy {\n    get isViewOnly$(): Observable<boolean> {\n        return this.editorService.isViewOnly$;\n    }\n\n    @Input()\n    set content(model: DocxModel) {\n        if (model) {\n            const deepCopy = JSON.parse(JSON.stringify(model));\n            this._content = new DocxModel(deepCopy as DocxModel);\n        }\n\n        this.initEditor(this._content);\n    }\n    get content(): DocxModel {\n        return this._content;\n    }\n    private _content: DocxModel;\n\n    @ViewChild('container', { static: true }) container: ElementRef<HTMLElement>;\n\n    @ViewChild('drawerContainer', { static: true }) sidenavContainer: ElementRef<HTMLElement>;\n\n    @ViewChild('drawer', { static: true }) sidenav: MatDrawer;\n\n    @HostBinding('class') class = 'base-editor';\n\n    editor: Editor;\n\n    elements: ExternalElementModel[];\n\n    sidenavProperties: ExternalSidenavModel;\n\n    readonly subscriptions: Subscription[] = [];\n\n    private sidenavComponentRef: ComponentRef<any> | null = null;\n\n    constructor(\n        private cdr: ChangeDetectorRef,\n        private componentService: ComponentService,\n        private editorService: EditorService,\n        private injector: Injector,\n        private regulatorService: RegulatorService,\n        private commandsService: CommandsService,\n        private clipboard: Clipboard\n    ) {\n        this.elements = this.injector.get(EXTERNAL_ELEMENT_SERVICE).elements;\n        this.sidenavProperties = this.injector.get(EXTERNAL_ELEMENT_SIDENAV);\n        FontMetrics.checkVersion(EDITOR_VERSION);\n    }\n\n    ngOnDestroy(): void {\n        this.editor?.destroy();\n        this.regulatorService.clearAllSessions();\n        this.subscriptions.forEach(x => x?.unsubscribe());\n        this.subscriptions.splice(0);\n    }\n\n    initEditor(content: DocxModel): void {\n        this.ngOnDestroy();\n        this.editor = new Editor(content, this.container, this.editorService, this.regulatorService, this.commandsService, this.clipboard);\n        this.subscriptions.push(this.toggleSidenavSubscription());\n    }\n\n    createElement(model: ElementDataModel) {\n        this.editor.createCustomElement(model);\n        this.editor.focus();\n    }\n\n    toggleSidenavSubscription(): Subscription {\n        return this.editorService.toggleSidenav$.subscribe(data => {\n            if (this.sidenav.opened === data.open) {\n                return;\n            }\n            if (data.open) {\n                this.sidenavComponentRef = this.componentService.createComponent(data.component, {\n                    model: data.model,\n                    contentWidth: data.contentWidth\n                });\n                this.componentService.attachComponent(this.sidenavContainer.nativeElement, this.sidenavComponentRef);\n            } else {\n                this.componentService.removeComponent(this.sidenavComponentRef);\n                this.sidenavComponentRef = null;\n            }\n            this.sidenav.toggle().catch(() => {\n                // continue regardless of error\n            });\n            this.cdr.markForCheck();\n        });\n    }\n}\n","<mat-drawer-container\n    class=\"sidenav-container\"\n    [hasBackdrop]=\"sidenavProperties.hasBackdrop\">\n    <mat-drawer-content>\n        <div class=\"container\">\n            <div\n                #container\n                class=\"edit-container\"></div>\n            <app-element-toolbar\n                *ngIf=\"elements.length\"\n                [elements]=\"elements\"\n                [isDisabled]=\"isViewOnly$ | async\"\n                (createElement)=\"createElement($event)\"></app-element-toolbar>\n        </div>\n    </mat-drawer-content>\n    <mat-drawer\n        #drawer\n        [autoFocus]=\"sidenavProperties.autoFocus\"\n        [position]=\"sidenavProperties.position\"\n        [mode]=\"sidenavProperties.mode\">\n        <div\n            #drawerContainer\n            class=\"drawer-container\"></div>\n    </mat-drawer>\n</mat-drawer-container>\n"]}

package/esm2022/lib/+shared/editor/editor.module.mjs

@@ -0,0 +1,85 @@
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatIconModule } from '@angular/material/icon';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { CommandsService } from '../services/commands.service';
+import { ComponentService } from './custom-components/shared/services/component/component.service';
+import { CustomContentService } from './custom-components/shared/services/custom-content/custom-content.service';
+import { EditorComponent } from './editor.component';
+import { ElementToolbarComponent } from './custom-components/external-element/element-toolbar/element-toolbar.component';
+import { EXTERNAL_ELEMENT_SERVICE, EXTERNAL_ELEMENT_SIDENAV } from './custom-components/external-element/external-elements.const';
+import { ExternalElementService } from './custom-components/external-element/external-element.service';
+import { ExternalSidenavModel } from './custom-components/external-element/models/external-sidenav.model';
+import { ImageApiService } from './custom-components/image/services/image-api.service';
+import { NoderEdgeComponent } from './core/components/edges/edge.component';
+import { NoderImageComponent } from './custom-components/image/components/image.component';
+import { NoderTabComponent } from './custom-components/tab/tab.component';
+import { NoderTableCellComponent } from './custom-components/table/components/table-cell.component';
+import { NoderTableComponent } from './custom-components/table/components/table.component';
+import { OverlayService } from './custom-components/shared/services/overlay/overlay.service';
+import { RegulatorService } from './execution/regulator.service';
+import { ResizerComponent } from './custom-components/image/resizer/resizer.component';
+import { TableOverlayMenuComponent } from './custom-components/table/overlay-menu/overlay-menu.component';
+import * as i0 from "@angular/core";
+export class EditorModule {
+    static forRoot(options) {
+        return {
+            ngModule: EditorModule,
+            providers: [
+                { provide: EXTERNAL_ELEMENT_SIDENAV, useValue: new ExternalSidenavModel(options?.sidenav) },
+                { provide: EXTERNAL_ELEMENT_SERVICE, useClass: options?.elementService ?? ExternalElementService }
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: EditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.2.1", ngImport: i0, type: EditorModule, declarations: [EditorComponent,
+            ElementToolbarComponent,
+            NoderEdgeComponent,
+            NoderImageComponent,
+            NoderTabComponent,
+            NoderTableCellComponent,
+            NoderTableComponent,
+            ResizerComponent,
+            TableOverlayMenuComponent], imports: [CommonModule, MatButtonModule, MatDialogModule, MatIconModule, MatSidenavModule, MatTooltipModule, ReactiveFormsModule], exports: [EditorComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: EditorModule, providers: [
+            ComponentService,
+            CustomContentService,
+            ImageApiService,
+            OverlayService,
+            RegulatorService,
+            ExternalElementService,
+            CommandsService
+        ], imports: [CommonModule, MatButtonModule, MatDialogModule, MatIconModule, MatSidenavModule, MatTooltipModule, ReactiveFormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: EditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        EditorComponent,
+                        ElementToolbarComponent,
+                        NoderEdgeComponent,
+                        NoderImageComponent,
+                        NoderTabComponent,
+                        NoderTableCellComponent,
+                        NoderTableComponent,
+                        ResizerComponent,
+                        TableOverlayMenuComponent
+                    ],
+                    imports: [CommonModule, MatButtonModule, MatDialogModule, MatIconModule, MatSidenavModule, MatTooltipModule, ReactiveFormsModule],
+                    providers: [
+                        ComponentService,
+                        CustomContentService,
+                        ImageApiService,
+                        OverlayService,
+                        RegulatorService,
+                        ExternalElementService,
+                        CommandsService
+                    ],
+                    exports: [EditorComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/+shared/editor/execution/models/cell-session-source.model.mjs

@@ -0,0 +1,19 @@
+import { TableCellModel } from '../../../../models/generated/table-cell.model';
+import { TargetModel } from '../../../../models/generated/target.model';
+import { TargetType } from '../../operations/enums/target-type.enum';
+export class CellSessionSourceModel {
+    constructor(table, cellComponent) {
+        this.table = table;
+        this.cellComponent = cellComponent;
+        this.edgeEditPage = null;
+    }
+    getTarget() {
+        const tableCell = new TableCellModel({
+            insertIndex: this.table.insertIndex,
+            row: this.cellComponent.rowIndex,
+            column: this.cellComponent.cellIndex
+        });
+        return new TargetModel({ type: TargetType.TableCell, tableCell, edgeEditPage: this.edgeEditPage });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/+shared/editor/execution/models/edge-session-source.model.mjs

@@ -0,0 +1,15 @@
+import { EdgeTargetModel } from '../../../../models/generated/edge-target.model';
+import { TargetModel } from '../../../../models/generated/target.model';
+import { TargetType } from '../../operations/enums/target-type.enum';
+export class EdgeSessionSourceModel {
+    constructor(pageType, type) {
+        this.pageType = pageType;
+        this.type = type;
+        this.edgeEditPage = null;
+    }
+    getTarget() {
+        const edgeData = new EdgeTargetModel({ pageType: this.pageType, type: this.type });
+        return new TargetModel({ type: TargetType.Edge, edgeData, edgeEditPage: this.edgeEditPage });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/+shared/editor/execution/models/general-properties.model.mjs

@@ -0,0 +1,11 @@
+import { DEFAULT_TAB_WIDTH } from '../../core/constants/editor.const';
+export class GeneralPropertiesModel {
+    constructor(fields) {
+        if (!fields) {
+            return;
+        }
+        fields.defaultTabWidth ??= DEFAULT_TAB_WIDTH;
+        Object.assign(this, fields);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhbC1wcm9wZXJ0aWVzLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvK3NoYXJlZC9lZGl0b3IvZXhlY3V0aW9uL21vZGVscy9nZW5lcmFsLXByb3BlcnRpZXMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFHdEUsTUFBTSxPQUFPLHNCQUFzQjtJQUsvQixZQUFZLE1BQXdDO1FBQ2hELElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDVCxPQUFPO1NBQ1Y7UUFFRCxNQUFNLENBQUMsZUFBZSxLQUFLLGlCQUFpQixDQUFDO1FBRTdDLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERFRkFVTFRfVEFCX1dJRFRIIH0gZnJvbSAnLi4vLi4vY29yZS9jb25zdGFudHMvZWRpdG9yLmNvbnN0JztcbmltcG9ydCB7IE51bWJlcmluZ01vZGVsIH0gZnJvbSAnLi4vLi4vLi4vLi4vbW9kZWxzL2dlbmVyYXRlZC9udW1iZXJpbmcubW9kZWwnO1xuXG5leHBvcnQgY2xhc3MgR2VuZXJhbFByb3BlcnRpZXNNb2RlbCB7XG4gICAgZGVmYXVsdFRhYldpZHRoOiBudW1iZXI7XG4gICAgbnVtYmVyaW5nczogTnVtYmVyaW5nTW9kZWxbXTtcbiAgICBtYXhFZGdlSGVpZ2h0OiBudW1iZXI7XG5cbiAgICBjb25zdHJ1Y3RvcihmaWVsZHM/OiBQYXJ0aWFsPEdlbmVyYWxQcm9wZXJ0aWVzTW9kZWw+KSB7XG4gICAgICAgIGlmICghZmllbGRzKSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBmaWVsZHMuZGVmYXVsdFRhYldpZHRoID8/PSBERUZBVUxUX1RBQl9XSURUSDtcblxuICAgICAgICBPYmplY3QuYXNzaWduKHRoaXMsIGZpZWxkcyk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/+shared/editor/execution/models/main-session-source.model.mjs

@@ -0,0 +1,8 @@
+import { TargetModel } from '../../../../models/generated/target.model';
+import { TargetType } from '../../operations/enums/target-type.enum';
+export class MainSessionSourceModel {
+    getTarget() {
+        return new TargetModel({ type: TargetType.Document, edgeEditPage: null });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi1zZXNzaW9uLXNvdXJjZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2V4ZWN1dGlvbi9tb2RlbHMvbWFpbi1zZXNzaW9uLXNvdXJjZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDeEUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBRXJFLE1BQU0sT0FBTyxzQkFBc0I7SUFDeEIsU0FBUztRQUNaLE9BQU8sSUFBSSxXQUFXLENBQUMsRUFBRSxJQUFJLEVBQUUsVUFBVSxDQUFDLFFBQVEsRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUM5RSxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZXNzaW9uU291cmNlTW9kZWwgfSBmcm9tICcuL3Nlc3Npb24tc291cmNlLm1vZGVsJztcbmltcG9ydCB7IFRhcmdldE1vZGVsIH0gZnJvbSAnLi4vLi4vLi4vLi4vbW9kZWxzL2dlbmVyYXRlZC90YXJnZXQubW9kZWwnO1xuaW1wb3J0IHsgVGFyZ2V0VHlwZSB9IGZyb20gJy4uLy4uL29wZXJhdGlvbnMvZW51bXMvdGFyZ2V0LXR5cGUuZW51bSc7XG5cbmV4cG9ydCBjbGFzcyBNYWluU2Vzc2lvblNvdXJjZU1vZGVsIGltcGxlbWVudHMgU2Vzc2lvblNvdXJjZU1vZGVsIHtcbiAgICBwdWJsaWMgZ2V0VGFyZ2V0KCk6IFRhcmdldE1vZGVsIHtcbiAgICAgICAgcmV0dXJuIG5ldyBUYXJnZXRNb2RlbCh7IHR5cGU6IFRhcmdldFR5cGUuRG9jdW1lbnQsIGVkZ2VFZGl0UGFnZTogbnVsbCB9KTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/+shared/editor/execution/models/session-source.model.mjs

@@ -0,0 +1,3 @@
+export class SessionSourceModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1zb3VyY2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi8rc2hhcmVkL2VkaXRvci9leGVjdXRpb24vbW9kZWxzL3Nlc3Npb24tc291cmNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBZ0Isa0JBQWtCO0NBR3ZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGFyZ2V0TW9kZWwgfSBmcm9tICcuLi8uLi8uLi8uLi9tb2RlbHMvZ2VuZXJhdGVkL3RhcmdldC5tb2RlbCc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBTZXNzaW9uU291cmNlTW9kZWwge1xuICAgIGVkZ2VFZGl0UGFnZT86IG51bWJlcjtcbiAgICBhYnN0cmFjdCBnZXRUYXJnZXQoKTogVGFyZ2V0TW9kZWw7XG59XG4iXX0=

package/esm2022/lib/+shared/editor/execution/models/session.model.mjs

@@ -0,0 +1,10 @@
+export class SessionModel {
+    constructor(session, renderer, sessionId, parentSessionId, source) {
+        this.session = session;
+        this.renderer = renderer;
+        this.sessionId = sessionId;
+        this.parentSessionId = parentSessionId;
+        this.source = source;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ub2Rlci9zcmMvbGliLytzaGFyZWQvZWRpdG9yL2V4ZWN1dGlvbi9tb2RlbHMvc2Vzc2lvbi5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLE9BQU8sWUFBWTtJQUNyQixZQUNXLE9BQW9CLEVBQ3BCLFFBQW9DLEVBQ3BDLFNBQWlCLEVBQ2pCLGVBQThCLEVBQzlCLE1BQTBCO1FBSjFCLFlBQU8sR0FBUCxPQUFPLENBQWE7UUFDcEIsYUFBUSxHQUFSLFFBQVEsQ0FBNEI7UUFDcEMsY0FBUyxHQUFULFNBQVMsQ0FBUTtRQUNqQixvQkFBZSxHQUFmLGVBQWUsQ0FBZTtRQUM5QixXQUFNLEdBQU4sTUFBTSxDQUFvQjtJQUNsQyxDQUFDO0NBQ1AiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFZGl0U2Vzc2lvbiB9IGZyb20gJy4uLy4uL2NvcmUvZWRpdC5zZXNzaW9uJztcbmltcG9ydCB7IFJlbmRlcmVyIH0gZnJvbSAnLi4vLi4vY29yZS9yZW5kZXJlcic7XG5pbXBvcnQgeyBTZXNzaW9uU291cmNlTW9kZWwgfSBmcm9tICcuL3Nlc3Npb24tc291cmNlLm1vZGVsJztcbmltcG9ydCB7IFZpcnR1YWxSZW5kZXJlciB9IGZyb20gJy4uLy4uL2NvcmUvdmlydHVhbC5yZW5kZXJlcic7XG5cbmV4cG9ydCBjbGFzcyBTZXNzaW9uTW9kZWwge1xuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwdWJsaWMgc2Vzc2lvbjogRWRpdFNlc3Npb24sXG4gICAgICAgIHB1YmxpYyByZW5kZXJlcjogUmVuZGVyZXIgfCBWaXJ0dWFsUmVuZGVyZXIsXG4gICAgICAgIHB1YmxpYyBzZXNzaW9uSWQ6IG51bWJlcixcbiAgICAgICAgcHVibGljIHBhcmVudFNlc3Npb25JZDogbnVtYmVyIHwgbnVsbCxcbiAgICAgICAgcHVibGljIHNvdXJjZTogU2Vzc2lvblNvdXJjZU1vZGVsXG4gICAgKSB7fVxufVxuIl19

package/esm2022/lib/+shared/editor/execution/regulator.service.mjs

@@ -0,0 +1,193 @@
+import { Injectable } from '@angular/core';
+import { CellSessionSourceModel } from './models/cell-session-source.model';
+import { DEFAULT_EDGE_MAX_HEIGHT_MULTIPLIER } from '../core/constants/editor.const';
+import { Document } from '../core/document';
+import { DocumentInfo } from '../core/constants/document-info.const';
+import { EdgeSessionSourceModel } from './models/edge-session-source.model';
+import { EditSession } from '../core/edit.session';
+import { GeneralPropertiesModel } from './models/general-properties.model';
+import { MainSessionSourceModel } from './models/main-session-source.model';
+import { Renderer } from '../core/renderer';
+import { SessionModel } from './models/session.model';
+import { TargetType } from '../operations/enums/target-type.enum';
+import { VirtualRenderer } from '../core/virtual.renderer';
+import * as i0 from "@angular/core";
+import * as i1 from "../custom-components/shared/services/custom-content/custom-content.service";
+import * as i2 from "../interaction/editor.service";
+export class RegulatorService {
+    constructor(customContentService, editorService) {
+        this.customContentService = customContentService;
+        this.editorService = editorService;
+        this.sessions = [];
+        this.sessionIdIncrement = 0;
+        this.edgeEditingPage = null;
+    }
+    addMainSession(model, margins, container) {
+        const currentSessionId = ++this.sessionIdIncrement;
+        const document = new Document(model, margins, DocumentInfo.pagesSpace, model.pageWidth, model.pageHeight);
+        const renderer = new VirtualRenderer(container.nativeElement, this.editorService);
+        const session = new EditSession(document, currentSessionId, this.customContentService, model, this.selection, new GeneralPropertiesModel({
+            numberings: model.numberings,
+            defaultTabWidth: model.defaultTabWidth,
+            maxEdgeHeight: model.pageHeight * DEFAULT_EDGE_MAX_HEIGHT_MULTIPLIER
+        }));
+        renderer.setSession(session);
+        renderer.scrollTo(session.scrollTop);
+        session.contentWidth = document.pageWidth - (document.pageMargin.left + document.pageMargin.right);
+        this.editorService.styles = session.stylesMap;
+        this.mainSession = new SessionModel(session, renderer, currentSessionId, null, new MainSessionSourceModel());
+        this.sessions.push(this.mainSession);
+        this.currentSession = this.mainSession;
+    }
+    addCellSession(table, margins, component, properties) {
+        const currentSessionId = ++this.sessionIdIncrement;
+        const document = new Document(component.cell, margins, 0, component.width, 0);
+        const renderer = new Renderer(component.container.nativeElement, this.editorService);
+        const session = new EditSession(document, currentSessionId, this.customContentService, component.cell, this.selection, properties);
+        renderer.setSession(session);
+        const contentWidth = component.width - (document.pageMargin.left + document.pageMargin.right);
+        session.contentWidth = contentWidth === 0 ? 1 : contentWidth;
+        const source = new CellSessionSourceModel(table, component);
+        const newSession = new SessionModel(session, renderer, currentSessionId, component.parentSessionId, source);
+        this.sessions.push(newSession);
+        return newSession;
+    }
+    addEdgeSession(component) {
+        const currentSessionId = ++this.sessionIdIncrement;
+        const document = new Document(component.model, component.margins, 0, component.width, 0);
+        const renderer = new Renderer(component.container.nativeElement, this.editorService);
+        const session = new EditSession(document, currentSessionId, this.customContentService, component.model, this.selection, component.properties);
+        renderer.setSession(session);
+        session.contentWidth = component.width - (document.pageMargin.left + document.pageMargin.right);
+        const source = new EdgeSessionSourceModel(component.model.pageType, component.type);
+        const newSession = new SessionModel(session, renderer, currentSessionId, component.parentSessionId, source);
+        this.sessions.push(newSession);
+        return newSession;
+    }
+    removeSession(sessionId) {
+        const index = this.sessions.findIndex(x => x.sessionId === sessionId);
+        this.sessions[index].session.destroy();
+        this.sessions[index].renderer.destroy();
+        this.sessions.splice(index, 1);
+    }
+    setMainSessionAsCurrent() {
+        if (this.mainSession.sessionId === this.currentSession.sessionId) {
+            return;
+        }
+        this.toggleEdgeEditMode();
+        this.setCurrentSession(this.mainSession);
+    }
+    setCustomSessionAsCurrent(sessionId) {
+        if (sessionId === this.currentSession.sessionId) {
+            return;
+        }
+        this.toggleEdgeEditMode();
+        this.setCurrentSessionById(sessionId);
+    }
+    setEdgeSessionAsCurrent(sessionId, clickedPage) {
+        this.toggleEdgeEditMode(clickedPage);
+        if (sessionId === this.currentSession.sessionId) {
+            this.currentSession.source.edgeEditPage = clickedPage;
+            return;
+        }
+        this.setCurrentSessionById(sessionId);
+    }
+    setTargetedSessionAsCurrent(targets) {
+        const targetedSession = this.getTargetedSession(targets);
+        if (targetedSession.sessionId === this.currentSession.sessionId) {
+            return;
+        }
+        const session = this.sessions.find(x => x.sessionId === targetedSession.sessionId);
+        const edgeEditPage = targets.length ? targets[targets.length - 1].edgeEditPage : null;
+        this.toggleEdgeEditMode(edgeEditPage);
+        this.setCurrentSession(session);
+    }
+    setCurrentSessionById(sessionId) {
+        const index = this.sessions.findIndex(x => x.sessionId === sessionId);
+        this.setCurrentSession(this.sessions[index]);
+    }
+    setCurrentSession(session) {
+        this.selection.clearSelection();
+        this.currentSession.renderer.hideCursor();
+        this.currentSession.renderer.updateSelection(this.selection.range);
+        this.currentSession = session;
+        this.currentSession.renderer.showCursor();
+        this.currentSession.source.edgeEditPage = this.edgeEditingPage;
+    }
+    getSession(sessionId) {
+        const session = this.sessions.find(x => x.sessionId === sessionId);
+        return session.session;
+    }
+    setSelection(selection) {
+        this.selection = selection;
+    }
+    clearAllSessions() {
+        this.sessions.forEach(session => {
+            session.session.destroy();
+            session.renderer.destroy();
+        });
+        this.sessions = [];
+    }
+    getCurrentSessionTargets() {
+        return this.getTargets(this.currentSession);
+    }
+    getTargets(session) {
+        const result = [];
+        let parentSession = this.sessions.find(x => x.sessionId === session.parentSessionId);
+        while (parentSession) {
+            const target = session.source.getTarget();
+            result.splice(0, 0, target);
+            session = parentSession;
+            parentSession = this.sessions.find(x => x.sessionId === parentSession.parentSessionId);
+        }
+        return result;
+    }
+    getEdgeTarget(sessionId) {
+        let session = this.sessions.find(x => x.sessionId === sessionId);
+        let parentSession = this.sessions.find(x => x.sessionId === session.parentSessionId);
+        while (parentSession) {
+            const target = session.source.getTarget();
+            if (target.type === TargetType.Edge) {
+                return target;
+            }
+            session = parentSession;
+            parentSession = this.sessions.find(x => x.sessionId === parentSession.parentSessionId);
+        }
+        return null;
+    }
+    getTargetedSession(targets) {
+        let result = this.mainSession.session;
+        for (const target of targets) {
+            switch (target.type) {
+                case TargetType.Document:
+                    break;
+                case TargetType.TableCell: {
+                    const table = result.customComponents.tables.find(x => x.instance.content.insertIndex === target.tableCell.insertIndex);
+                    result = table.instance.getCellSession(target.tableCell.row, target.tableCell.column);
+                    break;
+                }
+                case TargetType.Edge: {
+                    const edge = result.customComponents.edges.getComponentByPageType(target.edgeData.pageType, target.edgeData.type);
+                    result = edge.instance.edgeSession.session;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    toggleEdgeEditMode(clickedPage = null) {
+        this.edgeEditingPage = clickedPage;
+        if (!this.mainSession.session.customComponents.edges) {
+            return;
+        }
+        this.mainSession.session.customComponents.edges.toggleEditMode(!!this.edgeEditingPage);
+        const mainRenderer = this.mainSession.renderer;
+        mainRenderer.edgesLayer.update(mainRenderer.layerConfig);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: RegulatorService, deps: [{ token: i1.CustomContentService }, { token: i2.EditorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: RegulatorService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: RegulatorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CustomContentService }, { type: i2.EditorService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"regulator.service.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-noder/src/lib/+shared/editor/execution/regulator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable } from '@angular/core';\n\nimport { CellSessionSourceModel } from './models/cell-session-source.model';\nimport { CustomContentService } from '../custom-components/shared/services/custom-content/custom-content.service';\nimport { DEFAULT_EDGE_MAX_HEIGHT_MULTIPLIER } from '../core/constants/editor.const';\nimport { Document } from '../core/document';\nimport { DocumentInfo } from '../core/constants/document-info.const';\nimport { DocxModel } from '../../../models/generated/docx.model';\nimport { EdgeSessionSourceModel } from './models/edge-session-source.model';\nimport { EdgeType } from '../core/components/edges/edge-type.enum';\nimport { EditorService } from '../interaction/editor.service';\nimport { EditSession } from '../core/edit.session';\nimport { GeneralPropertiesModel } from './models/general-properties.model';\nimport { MainSessionSourceModel } from './models/main-session-source.model';\nimport { MarginModel } from '../core/models/margin.model';\nimport { NoderEdgeComponent } from '../core/components/edges/edge.component';\nimport { NoderTableCellComponent } from '../custom-components/table/components/table-cell.component';\nimport { PageType } from '../core/enums/page-type.enum';\nimport { Renderer } from '../core/renderer';\nimport { Selection } from '../positioning/selection';\nimport { SessionModel } from './models/session.model';\nimport { TableModel } from '../../../models/generated/table.model';\nimport { TargetModel } from '../../../models/generated/target.model';\nimport { TargetType } from '../operations/enums/target-type.enum';\nimport { VirtualRenderer } from '../core/virtual.renderer';\n\n@Injectable()\nexport class RegulatorService {\n    mainSession: SessionModel;\n\n    sessions: SessionModel[] = [];\n\n    currentSession: SessionModel;\n\n    selection: Selection;\n\n    sessionIdIncrement = 0;\n\n    edgeEditingPage: number | null = null;\n\n    constructor(private customContentService: CustomContentService, private editorService: EditorService) {}\n\n    addMainSession(model: DocxModel, margins: MarginModel, container: ElementRef<HTMLElement>): void {\n        const currentSessionId = ++this.sessionIdIncrement;\n        const document = new Document(model, margins, DocumentInfo.pagesSpace, model.pageWidth, model.pageHeight);\n        const renderer = new VirtualRenderer(container.nativeElement, this.editorService);\n        const session = new EditSession(\n            document,\n            currentSessionId,\n            this.customContentService,\n            model,\n            this.selection,\n            new GeneralPropertiesModel({\n                numberings: model.numberings,\n                defaultTabWidth: model.defaultTabWidth,\n                maxEdgeHeight: model.pageHeight * DEFAULT_EDGE_MAX_HEIGHT_MULTIPLIER\n            })\n        );\n        renderer.setSession(session);\n        renderer.scrollTo(session.scrollTop);\n        session.contentWidth = document.pageWidth - (document.pageMargin.left + document.pageMargin.right);\n        this.editorService.styles = session.stylesMap;\n        this.mainSession = new SessionModel(session, renderer, currentSessionId, null, new MainSessionSourceModel());\n        this.sessions.push(this.mainSession);\n        this.currentSession = this.mainSession;\n    }\n\n    addCellSession(\n        table: TableModel,\n        margins: MarginModel,\n        component: NoderTableCellComponent,\n        properties: GeneralPropertiesModel\n    ): SessionModel {\n        const currentSessionId = ++this.sessionIdIncrement;\n        const document = new Document(component.cell, margins, 0, component.width, 0);\n        const renderer = new Renderer(component.container.nativeElement, this.editorService);\n        const session = new EditSession(document, currentSessionId, this.customContentService, component.cell, this.selection, properties);\n        renderer.setSession(session);\n        const contentWidth = component.width - (document.pageMargin.left + document.pageMargin.right);\n        session.contentWidth = contentWidth === 0 ? 1 : contentWidth;\n        const source = new CellSessionSourceModel(table, component);\n        const newSession = new SessionModel(session, renderer, currentSessionId, component.parentSessionId, source);\n        this.sessions.push(newSession);\n        return newSession;\n    }\n\n    addEdgeSession(component: NoderEdgeComponent): SessionModel {\n        const currentSessionId = ++this.sessionIdIncrement;\n        const document = new Document(component.model, component.margins, 0, component.width, 0);\n        const renderer = new Renderer(component.container.nativeElement, this.editorService);\n        const session = new EditSession(\n            document,\n            currentSessionId,\n            this.customContentService,\n            component.model,\n            this.selection,\n            component.properties\n        );\n        renderer.setSession(session);\n        session.contentWidth = component.width - (document.pageMargin.left + document.pageMargin.right);\n        const source = new EdgeSessionSourceModel(component.model.pageType as PageType, component.type);\n        const newSession = new SessionModel(session, renderer, currentSessionId, component.parentSessionId, source);\n        this.sessions.push(newSession);\n        return newSession;\n    }\n\n    removeSession(sessionId: number) {\n        const index = this.sessions.findIndex(x => x.sessionId === sessionId);\n        this.sessions[index].session.destroy();\n        this.sessions[index].renderer.destroy();\n        this.sessions.splice(index, 1);\n    }\n\n    setMainSessionAsCurrent(): void {\n        if (this.mainSession.sessionId === this.currentSession.sessionId) {\n            return;\n        }\n        this.toggleEdgeEditMode();\n        this.setCurrentSession(this.mainSession);\n    }\n\n    setCustomSessionAsCurrent(sessionId: number): void {\n        if (sessionId === this.currentSession.sessionId) {\n            return;\n        }\n        this.toggleEdgeEditMode();\n        this.setCurrentSessionById(sessionId);\n    }\n\n    setEdgeSessionAsCurrent(sessionId: number, clickedPage: number) {\n        this.toggleEdgeEditMode(clickedPage);\n        if (sessionId === this.currentSession.sessionId) {\n            this.currentSession.source.edgeEditPage = clickedPage;\n            return;\n        }\n        this.setCurrentSessionById(sessionId);\n    }\n\n    setTargetedSessionAsCurrent(targets: TargetModel[]): void {\n        const targetedSession = this.getTargetedSession(targets);\n        if (targetedSession.sessionId === this.currentSession.sessionId) {\n            return;\n        }\n        const session = this.sessions.find(x => x.sessionId === targetedSession.sessionId);\n        const edgeEditPage = targets.length ? targets[targets.length - 1].edgeEditPage : null;\n        this.toggleEdgeEditMode(edgeEditPage);\n        this.setCurrentSession(session);\n    }\n\n    setCurrentSessionById(sessionId: number): void {\n        const index = this.sessions.findIndex(x => x.sessionId === sessionId);\n        this.setCurrentSession(this.sessions[index]);\n    }\n\n    setCurrentSession(session: SessionModel): void {\n        this.selection.clearSelection();\n        this.currentSession.renderer.hideCursor();\n        this.currentSession.renderer.updateSelection(this.selection.range);\n        this.currentSession = session;\n        this.currentSession.renderer.showCursor();\n        this.currentSession.source.edgeEditPage = this.edgeEditingPage;\n    }\n\n    getSession(sessionId: number): EditSession {\n        const session = this.sessions.find(x => x.sessionId === sessionId);\n        return session.session;\n    }\n\n    setSelection(selection: Selection): void {\n        this.selection = selection;\n    }\n\n    clearAllSessions(): void {\n        this.sessions.forEach(session => {\n            session.session.destroy();\n            session.renderer.destroy();\n        });\n        this.sessions = [];\n    }\n\n    getCurrentSessionTargets(): TargetModel[] {\n        return this.getTargets(this.currentSession);\n    }\n\n    getTargets(session: SessionModel): TargetModel[] {\n        const result: TargetModel[] = [];\n        let parentSession = this.sessions.find(x => x.sessionId === session.parentSessionId);\n        while (parentSession) {\n            const target = session.source.getTarget();\n            result.splice(0, 0, target);\n            session = parentSession;\n            parentSession = this.sessions.find(x => x.sessionId === parentSession.parentSessionId);\n        }\n        return result;\n    }\n\n    getEdgeTarget(sessionId: number): TargetModel | null {\n        let session = this.sessions.find(x => x.sessionId === sessionId);\n        let parentSession = this.sessions.find(x => x.sessionId === session.parentSessionId);\n        while (parentSession) {\n            const target = session.source.getTarget();\n            if (target.type === TargetType.Edge) {\n                return target;\n            }\n\n            session = parentSession;\n            parentSession = this.sessions.find(x => x.sessionId === parentSession.parentSessionId);\n        }\n\n        return null;\n    }\n\n    getTargetedSession(targets: TargetModel[]): EditSession {\n        let result = this.mainSession.session;\n        for (const target of targets) {\n            switch (target.type) {\n                case TargetType.Document:\n                    break;\n                case TargetType.TableCell: {\n                    const table = result.customComponents.tables.find(x => x.instance.content.insertIndex === target.tableCell.insertIndex);\n                    result = table.instance.getCellSession(target.tableCell.row, target.tableCell.column);\n                    break;\n                }\n                case TargetType.Edge: {\n                    const edge = result.customComponents.edges.getComponentByPageType(\n                        target.edgeData.pageType as PageType,\n                        target.edgeData.type as EdgeType\n                    );\n                    result = edge.instance.edgeSession.session;\n                    break;\n                }\n            }\n        }\n        return result;\n    }\n\n    toggleEdgeEditMode(clickedPage: number | null = null): void {\n        this.edgeEditingPage = clickedPage;\n        if (!this.mainSession.session.customComponents.edges) {\n            return;\n        }\n\n        this.mainSession.session.customComponents.edges.toggleEditMode(!!this.edgeEditingPage);\n        const mainRenderer = this.mainSession.renderer as VirtualRenderer;\n        mainRenderer.edgesLayer.update(mainRenderer.layerConfig);\n    }\n}\n"]}

package/esm2022/lib/+shared/editor/helpers/break.helper.mjs

@@ -0,0 +1,18 @@
+import { CUSTOM_ELEMENT_MARKER } from '../custom-components/shared/constants/custom-content-markers.const';
+import { NEW_LINE_MARKUP } from '../core/constants/editor.const';
+export class BreakHelper {
+    static getBreakType(model, char, insertIndex) {
+        if (char !== CUSTOM_ELEMENT_MARKER) {
+            return null;
+        }
+        return model.breaks.find(x => x.insertIndex === insertIndex)?.breakType ?? null;
+    }
+    static removeBreakMarker(breaks, text, fragmentStartIndex) {
+        const index = text.at(-1) === NEW_LINE_MARKUP ? -2 : -1;
+        if (text.at(index) === CUSTOM_ELEMENT_MARKER && breaks.some(x => x.insertIndex === fragmentStartIndex + text.length + index)) {
+            return index === -1 ? text.substring(0, text.length + index) : text.substring(0, text.length + index).concat(text.at(-1));
+        }
+        return text;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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