ngx-vflow 1.8.2 → 1.9.0

package/esm2022/public-api.mjs

@@ -35,16 +35,17 @@ export * from './lib/vflow/directives/connection-controller.directive';
 export * from './lib/vflow/directives/changes-controller.directive';
 export * from './lib/vflow/directives/selectable.directive';
 export * from './lib/vflow/directives/drag-handle.directive';
-// Testing
-export * from './lib/vflow/testing-utils/provide-custom-node-mocks';
-export * from './lib/vflow/testing-utils/component-mocks/vflow-mock.component';
-export * from './lib/vflow/testing-utils/component-mocks/handle-mock.component';
-export * from './lib/vflow/testing-utils/component-mocks/resizable-mock.component';
-export * from './lib/vflow/testing-utils/component-mocks/minimap-mock.component';
-export * from './lib/vflow/testing-utils/component-mocks/node-toolbar-mock.component';
-export * from './lib/vflow/testing-utils/directive-mocks/connection-controller-mock.directive';
-export * from './lib/vflow/testing-utils/directive-mocks/drag-handle-mock.directive';
-export * from './lib/vflow/testing-utils/directive-mocks/selectable-mock.directive';
-export * from './lib/vflow/testing-utils/directive-mocks/template-mock.directive';
-export * from './lib/vflow/testing-utils/vflow-mocks';
-//# sourceMappingURL=data:application/json;base64,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
+// ! Internals
+export { ConnectionModel as ɵConnectionModel } from './lib/vflow/models/connection.model';
+export { HandleModel as ɵHandleModel } from './lib/vflow/models/handle.model';
+export { NodeModel as ɵNodeModel } from './lib/vflow/models/node.model';
+export { ComponentEventBusService as ɵComponentEventBusService } from './lib/vflow/services/component-event-bus.service';
+export { HandleService as ɵHandleService } from './lib/vflow/services/handle.service';
+export { FlowSettingsService as ɵFlowSettingsService } from './lib/vflow/services/flow-settings.service';
+export { FlowEntitiesService as ɵFlowEntitiesService } from './lib/vflow/services/flow-entities.service';
+export { NodeAccessorService as ɵNodeAccessorService } from './lib/vflow/services/node-accessor.service';
+export { ViewportService as ɵViewportService } from './lib/vflow/services/viewport.service';
+export { SelectionService as ɵSelectionService } from './lib/vflow/services/selection.service';
+export { RootPointerDirective as ɵRootPointerDirective } from './lib/vflow/directives/root-pointer.directive';
+export { SpacePointContextDirective as ɵSpacePointContextDirective } from './lib/vflow/directives/space-point-context.directive';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/component-mocks/custom-template-edge-mock.component.mjs

@@ -0,0 +1,16 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CustomTemplateEdgeMockComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CustomTemplateEdgeMockComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: CustomTemplateEdgeMockComponent, isStandalone: true, selector: "g[customTemplateEdge]", ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CustomTemplateEdgeMockComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'g[customTemplateEdge]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLXRlbXBsYXRlLWVkZ2UtbW9jay5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3Rlc3Rpbmcvc3JjL2NvbXBvbmVudC1tb2Nrcy9jdXN0b20tdGVtcGxhdGUtZWRnZS1tb2NrLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVVuRSxNQUFNLE9BQU8sK0JBQStCOytHQUEvQiwrQkFBK0I7bUdBQS9CLCtCQUErQixpRkFKaEMsRUFBRTs7NEZBSUQsK0JBQStCO2tCQU4zQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSx1QkFBdUI7b0JBQ2pDLFFBQVEsRUFBRSxFQUFFO29CQUNaLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO29CQUMvQyxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBc0ludGVyZmFjZSB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB0eXBlIHsgQ3VzdG9tVGVtcGxhdGVFZGdlQ29tcG9uZW50IH0gZnJvbSAnbmd4LXZmbG93JztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnZ1tjdXN0b21UZW1wbGF0ZUVkZ2VdJyxcbiAgdGVtcGxhdGU6ICcnLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgQ3VzdG9tVGVtcGxhdGVFZGdlTW9ja0NvbXBvbmVudCBpbXBsZW1lbnRzIEFzSW50ZXJmYWNlPEN1c3RvbVRlbXBsYXRlRWRnZUNvbXBvbmVudD4ge31cbiJdfQ==

package/esm2022/testing/component-mocks/handle-mock.component.mjs

@@ -0,0 +1,24 @@
+import { ChangeDetectionStrategy, Component, input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HandleMockComponent {
+    constructor() {
+        this.position = input.required();
+        this.type = input.required();
+        this.id = input();
+        this.template = input();
+    }
+    // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method
+    ngOnInit() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HandleMockComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: HandleMockComponent, isStandalone: true, selector: "handle", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: true, transformFunction: null }, type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null }, id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, template: { classPropertyName: "template", publicName: "template", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HandleMockComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'handle',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlLW1vY2suY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXZmbG93LWxpYi90ZXN0aW5nL3NyYy9jb21wb25lbnQtbW9ja3MvaGFuZGxlLW1vY2suY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUF1QixNQUFNLGVBQWUsQ0FBQzs7QUFVL0YsTUFBTSxPQUFPLG1CQUFtQjtJQU5oQztRQU9TLGFBQVEsR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFZLENBQUM7UUFDdEMsU0FBSSxHQUFHLEtBQUssQ0FBQyxRQUFRLEVBQXVCLENBQUM7UUFDN0MsT0FBRSxHQUFHLEtBQUssRUFBVSxDQUFDO1FBQ3JCLGFBQVEsR0FBRyxLQUFLLEVBQW9CLENBQUM7S0FJN0M7SUFGQyxxRUFBcUU7SUFDOUQsUUFBUSxLQUFVLENBQUM7K0dBUGYsbUJBQW1CO21HQUFuQixtQkFBbUIsa2pCQUpwQixFQUFFOzs0RkFJRCxtQkFBbUI7a0JBTi9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLFFBQVE7b0JBQ2xCLFFBQVEsRUFBRSxFQUFFO29CQUNaLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO29CQUMvQyxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBpbnB1dCwgVGVtcGxhdGVSZWYsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBIYW5kbGVDb21wb25lbnQsIFBvc2l0aW9uIH0gZnJvbSAnbmd4LXZmbG93JztcbmltcG9ydCB7IEFzSW50ZXJmYWNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdoYW5kbGUnLFxuICB0ZW1wbGF0ZTogJycsXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBIYW5kbGVNb2NrQ29tcG9uZW50IGltcGxlbWVudHMgQXNJbnRlcmZhY2U8SGFuZGxlQ29tcG9uZW50PiwgT25Jbml0IHtcbiAgcHVibGljIHBvc2l0aW9uID0gaW5wdXQucmVxdWlyZWQ8UG9zaXRpb24+KCk7XG4gIHB1YmxpYyB0eXBlID0gaW5wdXQucmVxdWlyZWQ8J3NvdXJjZScgfCAndGFyZ2V0Jz4oKTtcbiAgcHVibGljIGlkID0gaW5wdXQ8c3RyaW5nPigpO1xuICBwdWJsaWMgdGVtcGxhdGUgPSBpbnB1dDxUZW1wbGF0ZVJlZjxhbnk+PigpO1xuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvbm8tZW1wdHktbGlmZWN5Y2xlLW1ldGhvZFxuICBwdWJsaWMgbmdPbkluaXQoKTogdm9pZCB7fVxufVxuIl19

package/esm2022/{lib/vflow/testing-utils → testing}/component-mocks/minimap-mock.component.mjs

@@ -21,4 +21,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWluaW1hcC1tb2NrLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy90ZXN0aW5nLXV0aWxzL2NvbXBvbmVudC1tb2Nrcy9taW5pbWFwLW1vY2suY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFVLE1BQU0sZUFBZSxDQUFDOztBQVVsRixNQUFNLE9BQU8sb0JBQW9CO0lBTmpDO1FBT1MsY0FBUyxHQUFHLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO1FBRTlDLGdCQUFXLEdBQUcsS0FBSyxDQUFDLG9CQUFvQixDQUFDLENBQUM7UUFFMUMsYUFBUSxHQUFHLEtBQUssQ0FBa0IsY0FBYyxDQUFDLENBQUM7UUFFbEQsaUJBQVksR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7S0FJcEM7SUFGQyxxRUFBcUU7SUFDOUQsUUFBUSxLQUFJLENBQUM7K0dBVlQsb0JBQW9CO21HQUFwQixvQkFBb0IsNG1CQUpyQixFQUFFOzs0RkFJRCxvQkFBb0I7a0JBTmhDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLFVBQVU7b0JBQ3BCLFFBQVEsRUFBRSxFQUFFO29CQUNaLFVBQVUsRUFBRSxJQUFJO29CQUNoQixlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTtpQkFDaEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBpbnB1dCwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNaW5pTWFwQ29tcG9uZW50LCBNaW5pTWFwUG9zaXRpb24gfSBmcm9tICcuLi8uLi9wdWJsaWMtY29tcG9uZW50cy9taW5pbWFwL21pbmltYXAuY29tcG9uZW50JztcbmltcG9ydCB7IEFzSW50ZXJmYWNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdtaW5pLW1hcCcsXG4gIHRlbXBsYXRlOiAnJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIE1pbmlNYXBNb2NrQ29tcG9uZW50IGltcGxlbWVudHMgQXNJbnRlcmZhY2U8TWluaU1hcENvbXBvbmVudD4sIE9uSW5pdCB7XG4gIHB1YmxpYyBtYXNrQ29sb3IgPSBpbnB1dChgcmdiYSgyMTUsIDIxNSwgMjE1LCAwLjYpYCk7XG5cbiAgcHVibGljIHN0cm9rZUNvbG9yID0gaW5wdXQoYHJnYigyMDAsIDIwMCwgMjAwKWApO1xuXG4gIHB1YmxpYyBwb3NpdGlvbiA9IGlucHV0PE1pbmlNYXBQb3NpdGlvbj4oJ2JvdHRvbS1yaWdodCcpO1xuXG4gIHB1YmxpYyBzY2FsZU9uSG92ZXIgPSBpbnB1dChmYWxzZSk7XG5cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9uby1lbXB0eS1saWZlY3ljbGUtbWV0aG9kXG4gIHB1YmxpYyBuZ09uSW5pdCgpIHt9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWluaW1hcC1tb2NrLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvdGVzdGluZy9zcmMvY29tcG9uZW50LW1vY2tzL21pbmltYXAtbW9jay5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQVUsTUFBTSxlQUFlLENBQUM7O0FBVWxGLE1BQU0sT0FBTyxvQkFBb0I7SUFOakM7UUFPUyxjQUFTLEdBQUcsS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUM7UUFFOUMsZ0JBQVcsR0FBRyxLQUFLLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUUxQyxhQUFRLEdBQUcsS0FBSyxDQUFrQixjQUFjLENBQUMsQ0FBQztRQUVsRCxpQkFBWSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztLQUlwQztJQUZDLHFFQUFxRTtJQUM5RCxRQUFRLEtBQUksQ0FBQzsrR0FWVCxvQkFBb0I7bUdBQXBCLG9CQUFvQiw0bUJBSnJCLEVBQUU7OzRGQUlELG9CQUFvQjtrQkFOaEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsVUFBVTtvQkFDcEIsUUFBUSxFQUFFLEVBQUU7b0JBQ1osVUFBVSxFQUFFLElBQUk7b0JBQ2hCLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIGlucHV0LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgTWluaU1hcENvbXBvbmVudCwgTWluaU1hcFBvc2l0aW9uIH0gZnJvbSAnbmd4LXZmbG93JztcbmltcG9ydCB7IEFzSW50ZXJmYWNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdtaW5pLW1hcCcsXG4gIHRlbXBsYXRlOiAnJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIE1pbmlNYXBNb2NrQ29tcG9uZW50IGltcGxlbWVudHMgQXNJbnRlcmZhY2U8TWluaU1hcENvbXBvbmVudD4sIE9uSW5pdCB7XG4gIHB1YmxpYyBtYXNrQ29sb3IgPSBpbnB1dChgcmdiYSgyMTUsIDIxNSwgMjE1LCAwLjYpYCk7XG5cbiAgcHVibGljIHN0cm9rZUNvbG9yID0gaW5wdXQoYHJnYigyMDAsIDIwMCwgMjAwKWApO1xuXG4gIHB1YmxpYyBwb3NpdGlvbiA9IGlucHV0PE1pbmlNYXBQb3NpdGlvbj4oJ2JvdHRvbS1yaWdodCcpO1xuXG4gIHB1YmxpYyBzY2FsZU9uSG92ZXIgPSBpbnB1dChmYWxzZSk7XG5cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9uby1lbXB0eS1saWZlY3ljbGUtbWV0aG9kXG4gIHB1YmxpYyBuZ09uSW5pdCgpIHt9XG59XG4iXX0=

package/esm2022/testing/component-mocks/node-toolbar-mock.component.mjs

@@ -0,0 +1,23 @@
+import { ChangeDetectionStrategy, Component, input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NodeToolbarMockComponent {
+    constructor() {
+        this.position = input('top');
+    }
+    // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method
+    ngOnInit() { }
+    // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method
+    ngOnDestroy() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NodeToolbarMockComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: NodeToolbarMockComponent, isStandalone: true, selector: "node-toolbar", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<ng-content />', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NodeToolbarMockComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'node-toolbar',
+                    template: '<ng-content />',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS10b29sYmFyLW1vY2suY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXZmbG93LWxpYi90ZXN0aW5nL3NyYy9jb21wb25lbnQtbW9ja3Mvbm9kZS10b29sYmFyLW1vY2suY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFxQixNQUFNLGVBQWUsQ0FBQzs7QUFVN0YsTUFBTSxPQUFPLHdCQUF3QjtJQU5yQztRQU9TLGFBQVEsR0FBRyxLQUFLLENBQVcsS0FBSyxDQUFDLENBQUM7S0FPMUM7SUFMQyxxRUFBcUU7SUFDOUQsUUFBUSxLQUFJLENBQUM7SUFFcEIscUVBQXFFO0lBQzlELFdBQVcsS0FBSSxDQUFDOytHQVBaLHdCQUF3QjttR0FBeEIsd0JBQXdCLHFOQUp6QixnQkFBZ0I7OzRGQUlmLHdCQUF3QjtrQkFOcEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsY0FBYztvQkFDeEIsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIGlucHV0LCBPbkluaXQsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBQb3NpdGlvbiwgTm9kZVRvb2xiYXJDb21wb25lbnQgfSBmcm9tICduZ3gtdmZsb3cnO1xuaW1wb3J0IHsgQXNJbnRlcmZhY2UgfSBmcm9tICcuLi90eXBlcyc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ25vZGUtdG9vbGJhcicsXG4gIHRlbXBsYXRlOiAnPG5nLWNvbnRlbnQgLz4nLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgTm9kZVRvb2xiYXJNb2NrQ29tcG9uZW50IGltcGxlbWVudHMgQXNJbnRlcmZhY2U8Tm9kZVRvb2xiYXJDb21wb25lbnQ+LCBPbkluaXQsIE9uRGVzdHJveSB7XG4gIHB1YmxpYyBwb3NpdGlvbiA9IGlucHV0PFBvc2l0aW9uPigndG9wJyk7XG5cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9uby1lbXB0eS1saWZlY3ljbGUtbWV0aG9kXG4gIHB1YmxpYyBuZ09uSW5pdCgpIHt9XG5cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9uby1lbXB0eS1saWZlY3ljbGUtbWV0aG9kXG4gIHB1YmxpYyBuZ09uRGVzdHJveSgpIHt9XG59XG4iXX0=

package/esm2022/testing/component-mocks/resizable-mock.component.mjs

@@ -0,0 +1,25 @@
+import { ChangeDetectionStrategy, Component, input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ResizableMockComponent {
+    constructor() {
+        this.resizable = input();
+        this.resizerColor = input('#2e414c');
+        this.gap = input(1.5);
+    }
+    // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method
+    ngOnInit() { }
+    // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method
+    ngAfterViewInit() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResizableMockComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: ResizableMockComponent, isStandalone: true, selector: "[resizable]", inputs: { resizable: { classPropertyName: "resizable", publicName: "resizable", isSignal: true, isRequired: false, transformFunction: null }, resizerColor: { classPropertyName: "resizerColor", publicName: "resizerColor", isSignal: true, isRequired: false, transformFunction: null }, gap: { classPropertyName: "gap", publicName: "gap", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<ng-content />', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResizableMockComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[resizable]',
+                    template: '<ng-content />',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXphYmxlLW1vY2suY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXZmbG93LWxpYi90ZXN0aW5nL3NyYy9jb21wb25lbnQtbW9ja3MvcmVzaXphYmxlLW1vY2suY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUF5QixNQUFNLGVBQWUsQ0FBQzs7QUFVakcsTUFBTSxPQUFPLHNCQUFzQjtJQU5uQztRQU9TLGNBQVMsR0FBRyxLQUFLLEVBQWdCLENBQUM7UUFDbEMsaUJBQVksR0FBRyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDaEMsUUFBRyxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztLQU96QjtJQUxDLHFFQUFxRTtJQUM5RCxRQUFRLEtBQUksQ0FBQztJQUVwQixxRUFBcUU7SUFDOUQsZUFBZSxLQUFJLENBQUM7K0dBVGhCLHNCQUFzQjttR0FBdEIsc0JBQXNCLHNkQUp2QixnQkFBZ0I7OzRGQUlmLHNCQUFzQjtrQkFObEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsYUFBYTtvQkFDdkIsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIGlucHV0LCBPbkluaXQsIEFmdGVyVmlld0luaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgUmVzaXphYmxlQ29tcG9uZW50IH0gZnJvbSAnbmd4LXZmbG93JztcbmltcG9ydCB7IEFzSW50ZXJmYWNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdbcmVzaXphYmxlXScsXG4gIHRlbXBsYXRlOiAnPG5nLWNvbnRlbnQgLz4nLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgUmVzaXphYmxlTW9ja0NvbXBvbmVudCBpbXBsZW1lbnRzIEFzSW50ZXJmYWNlPFJlc2l6YWJsZUNvbXBvbmVudD4sIE9uSW5pdCwgQWZ0ZXJWaWV3SW5pdCB7XG4gIHB1YmxpYyByZXNpemFibGUgPSBpbnB1dDxib29sZWFuIHwgJyc+KCk7XG4gIHB1YmxpYyByZXNpemVyQ29sb3IgPSBpbnB1dCgnIzJlNDE0YycpO1xuICBwdWJsaWMgZ2FwID0gaW5wdXQoMS41KTtcblxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L25vLWVtcHR5LWxpZmVjeWNsZS1tZXRob2RcbiAgcHVibGljIG5nT25Jbml0KCkge31cblxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L25vLWVtcHR5LWxpZmVjeWNsZS1tZXRob2RcbiAgcHVibGljIG5nQWZ0ZXJWaWV3SW5pdCgpIHt9XG59XG4iXX0=

package/esm2022/testing/component-mocks/vflow-mock.component.mjs

@@ -0,0 +1,296 @@
+import { ChangeDetectionStrategy, Component, contentChild, Input, input, output, signal, } from '@angular/core';
+import { NgTemplateOutlet } from '@angular/common';
+import { ɵConnectionModel as ConnectionModel, } from 'ngx-vflow';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { ConnectionTemplateMockDirective, EdgeLabelHtmlTemplateMockDirective, EdgeTemplateMockDirective, GroupNodeTemplateMockDirective, NodeHtmlTemplateMockDirective, } from '../directive-mocks/template-mock.directive';
+import * as i0 from "@angular/core";
+export class VflowMockComponent {
+    constructor() {
+        this.view = [400, 400];
+        this.minZoom = 0.5;
+        this.maxZoom = 3;
+        this.background = '#fff';
+        this.optimization = input({
+            detachedGroupsLayer: false,
+        });
+        this.entitiesSelectable = true;
+        this.keyboardShortcuts = {
+            multiSelection: null,
+        };
+        this.connection = new ConnectionModel({});
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onComponentNodeEvent = output();
+        this.nodeTemplateDirective = contentChild(NodeHtmlTemplateMockDirective);
+        this.groupNodeTemplateDirective = contentChild(GroupNodeTemplateMockDirective);
+        this.edgeTemplateDirective = contentChild(EdgeTemplateMockDirective);
+        this.edgeLabelHtmlDirective = contentChild(EdgeLabelHtmlTemplateMockDirective);
+        this.connectionTemplateDirective = contentChild(ConnectionTemplateMockDirective);
+        this.viewport = signal({
+            x: 0,
+            y: 0,
+            zoom: 1,
+        });
+        this.nodesChange = signal([]);
+        this.edgesChange = signal([]);
+        this.viewportChange$ = toObservable(this.viewport);
+        this.nodesChange$ = toObservable(this.nodesChange);
+        this.edgesChange$ = toObservable(this.edgesChange);
+    }
+    // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method
+    ngOnInit() { }
+    viewportTo(viewport) {
+        this.viewport.set(viewport);
+    }
+    zoomTo(zoom) {
+        this.viewport.update((prev) => ({ ...prev, zoom }));
+    }
+    panTo(point) {
+        this.viewport.update((prev) => ({ ...prev, x: point.x, y: point.y }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    fitView(options) { }
+    documentPointToFlowPoint(point, options) {
+        if (options?.spaces) {
+            return [
+                {
+                    nodeId: null,
+                    x: point.x,
+                    y: point.y,
+                },
+            ];
+        }
+        return point;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getIntesectingNodes(nodeId, options) {
+        return [];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toNodeSpace(nodeId, spaceNodeId) {
+        return { x: 0, y: 0 };
+    }
+    getNode(id) {
+        return this.nodes.find((node) => node.id === id);
+    }
+    getDetachedEdges() {
+        return [];
+    }
+    createSignal(value) {
+        return signal(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VflowMockComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: VflowMockComponent, isStandalone: true, selector: "vflow", inputs: { nodes: { classPropertyName: "nodes", publicName: "nodes", isSignal: false, isRequired: true, transformFunction: null }, edges: { classPropertyName: "edges", publicName: "edges", isSignal: false, isRequired: false, transformFunction: null }, view: { classPropertyName: "view", publicName: "view", isSignal: false, isRequired: false, transformFunction: null }, minZoom: { classPropertyName: "minZoom", publicName: "minZoom", isSignal: false, isRequired: false, transformFunction: null }, maxZoom: { classPropertyName: "maxZoom", publicName: "maxZoom", isSignal: false, isRequired: false, transformFunction: null }, background: { classPropertyName: "background", publicName: "background", isSignal: false, isRequired: false, transformFunction: null }, optimization: { classPropertyName: "optimization", publicName: "optimization", isSignal: true, isRequired: false, transformFunction: null }, entitiesSelectable: { classPropertyName: "entitiesSelectable", publicName: "entitiesSelectable", isSignal: false, isRequired: false, transformFunction: null }, keyboardShortcuts: { classPropertyName: "keyboardShortcuts", publicName: "keyboardShortcuts", isSignal: false, isRequired: false, transformFunction: null }, connection: { classPropertyName: "connection", publicName: "connection", isSignal: false, isRequired: false, transformFunction: (settings) => new ConnectionModel(settings) }, snapGrid: { classPropertyName: "snapGrid", publicName: "snapGrid", isSignal: false, isRequired: false, transformFunction: null }, elevateNodesOnSelect: { classPropertyName: "elevateNodesOnSelect", publicName: "elevateNodesOnSelect", isSignal: false, isRequired: false, transformFunction: null }, elevateEdgesOnSelect: { classPropertyName: "elevateEdgesOnSelect", publicName: "elevateEdgesOnSelect", isSignal: false, isRequired: false, transformFunction: null } }, outputs: { onComponentNodeEvent: "onComponentNodeEvent" }, queries: [{ propertyName: "nodeTemplateDirective", first: true, predicate: NodeHtmlTemplateMockDirective, descendants: true, isSignal: true }, { propertyName: "groupNodeTemplateDirective", first: true, predicate: GroupNodeTemplateMockDirective, descendants: true, isSignal: true }, { propertyName: "edgeTemplateDirective", first: true, predicate: EdgeTemplateMockDirective, descendants: true, isSignal: true }, { propertyName: "edgeLabelHtmlDirective", first: true, predicate: EdgeLabelHtmlTemplateMockDirective, descendants: true, isSignal: true }, { propertyName: "connectionTemplateDirective", first: true, predicate: ConnectionTemplateMockDirective, descendants: true, isSignal: true }], ngImport: i0, template: `
+    <ng-content />
+
+    @for (node of nodes; track $index) {
+      @if (node.type === 'html-template') {
+        <ng-component
+          [ngTemplateOutlet]="nodeTemplateDirective()?.templateRef ?? null"
+          [ngTemplateOutletContext]="{
+            $implicit: {
+              node: node,
+              selected: createSignal(false),
+            },
+          }" />
+      }
+
+      @if (node.type === 'template-group') {
+        <ng-component
+          [ngTemplateOutlet]="groupNodeTemplateDirective()?.templateRef ?? null"
+          [ngTemplateOutletContext]="{
+            $implicit: {
+              node: node,
+              selected: createSignal(false),
+              width: createSignal(node.width),
+              height: createSignal(node.height),
+            },
+          }" />
+      }
+    }
+
+    @for (edge of edges; track $index) {
+      @if (edge.type === 'template') {
+        <ng-component
+          [ngTemplateOutlet]="edgeTemplateDirective()?.templateRef ?? null"
+          [ngTemplateOutletContext]="{
+            $implicit: {
+              edge: edge,
+              selected: createSignal(false),
+              path: createSignal(''),
+              markerStart: createSignal(''),
+              markerEnd: createSignal(''),
+            },
+          }" />
+
+        @if (edge.edgeLabels?.start) {
+          <ng-component
+            [ngTemplateOutlet]="edgeLabelHtmlDirective()?.templateRef ?? null"
+            [ngTemplateOutletContext]="{
+              $implicit: {
+                edge: edge,
+              },
+            }" />
+        }
+
+        @if (edge.edgeLabels?.center) {
+          <ng-component
+            [ngTemplateOutlet]="edgeLabelHtmlDirective()?.templateRef ?? null"
+            [ngTemplateOutletContext]="{
+              $implicit: {
+                edge: edge,
+                label: edge.edgeLabels?.center,
+              },
+            }" />
+        }
+
+        @if (edge.edgeLabels?.end) {
+          <ng-component
+            [ngTemplateOutlet]="edgeLabelHtmlDirective()?.templateRef ?? null"
+            [ngTemplateOutletContext]="{
+              $implicit: {
+                edge: edge,
+                label: edge.edgeLabels?.end,
+              },
+            }" />
+        }
+      }
+    }
+
+    @if (connection.type === 'template') {
+      <ng-component
+        [ngTemplateOutlet]="connectionTemplateDirective()?.templateRef ?? null"
+        [ngTemplateOutletContext]="{
+          $implicit: {
+            path: createSignal(''),
+            marker: createSignal(''),
+          },
+        }" />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VflowMockComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vflow',
+                    template: `
+    <ng-content />
+
+    @for (node of nodes; track $index) {
+      @if (node.type === 'html-template') {
+        <ng-component
+          [ngTemplateOutlet]="nodeTemplateDirective()?.templateRef ?? null"
+          [ngTemplateOutletContext]="{
+            $implicit: {
+              node: node,
+              selected: createSignal(false),
+            },
+          }" />
+      }
+
+      @if (node.type === 'template-group') {
+        <ng-component
+          [ngTemplateOutlet]="groupNodeTemplateDirective()?.templateRef ?? null"
+          [ngTemplateOutletContext]="{
+            $implicit: {
+              node: node,
+              selected: createSignal(false),
+              width: createSignal(node.width),
+              height: createSignal(node.height),
+            },
+          }" />
+      }
+    }
+
+    @for (edge of edges; track $index) {
+      @if (edge.type === 'template') {
+        <ng-component
+          [ngTemplateOutlet]="edgeTemplateDirective()?.templateRef ?? null"
+          [ngTemplateOutletContext]="{
+            $implicit: {
+              edge: edge,
+              selected: createSignal(false),
+              path: createSignal(''),
+              markerStart: createSignal(''),
+              markerEnd: createSignal(''),
+            },
+          }" />
+
+        @if (edge.edgeLabels?.start) {
+          <ng-component
+            [ngTemplateOutlet]="edgeLabelHtmlDirective()?.templateRef ?? null"
+            [ngTemplateOutletContext]="{
+              $implicit: {
+                edge: edge,
+              },
+            }" />
+        }
+
+        @if (edge.edgeLabels?.center) {
+          <ng-component
+            [ngTemplateOutlet]="edgeLabelHtmlDirective()?.templateRef ?? null"
+            [ngTemplateOutletContext]="{
+              $implicit: {
+                edge: edge,
+                label: edge.edgeLabels?.center,
+              },
+            }" />
+        }
+
+        @if (edge.edgeLabels?.end) {
+          <ng-component
+            [ngTemplateOutlet]="edgeLabelHtmlDirective()?.templateRef ?? null"
+            [ngTemplateOutletContext]="{
+              $implicit: {
+                edge: edge,
+                label: edge.edgeLabels?.end,
+              },
+            }" />
+        }
+      }
+    }
+
+    @if (connection.type === 'template') {
+      <ng-component
+        [ngTemplateOutlet]="connectionTemplateDirective()?.templateRef ?? null"
+        [ngTemplateOutletContext]="{
+          $implicit: {
+            path: createSignal(''),
+            marker: createSignal(''),
+          },
+        }" />
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    imports: [NgTemplateOutlet],
+                }]
+        }], propDecorators: { nodes: [{
+                type: Input,
+                args: [{ required: true }]
+            }], edges: [{
+                type: Input
+            }], view: [{
+                type: Input
+            }], minZoom: [{
+                type: Input
+            }], maxZoom: [{
+                type: Input
+            }], background: [{
+                type: Input
+            }], entitiesSelectable: [{
+                type: Input
+            }], keyboardShortcuts: [{
+                type: Input
+            }], connection: [{
+                type: Input,
+                args: [{
+                        transform: (settings) => new ConnectionModel(settings),
+                    }]
+            }], snapGrid: [{
+                type: Input
+            }], elevateNodesOnSelect: [{
+                type: Input
+            }], elevateEdgesOnSelect: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vflow-mock.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-vflow-lib/testing/src/component-mocks/vflow-mock.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  contentChild,\n  Input,\n  input,\n  output,\n  signal,\n  WritableSignal,\n  OnInit,\n} from '@angular/core';\nimport { NgTemplateOutlet } from '@angular/common';\nimport {\n  Node,\n  DynamicNode,\n  Edge,\n  SpacePoint,\n  Point,\n  Background,\n  Optimization,\n  KeyboardShortcuts,\n  ConnectionSettings,\n  ViewportState,\n  NodeChange,\n  EdgeChange,\n  FitViewOptions,\n  VflowComponent,\n  IntersectingNodesOptions,\n  ɵConnectionModel as ConnectionModel,\n} from 'ngx-vflow';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport {\n  ConnectionTemplateMockDirective,\n  EdgeLabelHtmlTemplateMockDirective,\n  EdgeTemplateMockDirective,\n  GroupNodeTemplateMockDirective,\n  NodeHtmlTemplateMockDirective,\n} from '../directive-mocks/template-mock.directive';\nimport { AsInterface } from '../types';\n\n@Component({\n  selector: 'vflow',\n  template: `\n    <ng-content />\n\n    @for (node of nodes; track $index) {\n      @if (node.type === 'html-template') {\n        <ng-component\n          [ngTemplateOutlet]=\"nodeTemplateDirective()?.templateRef ?? null\"\n          [ngTemplateOutletContext]=\"{\n            $implicit: {\n              node: node,\n              selected: createSignal(false),\n            },\n          }\" />\n      }\n\n      @if (node.type === 'template-group') {\n        <ng-component\n          [ngTemplateOutlet]=\"groupNodeTemplateDirective()?.templateRef ?? null\"\n          [ngTemplateOutletContext]=\"{\n            $implicit: {\n              node: node,\n              selected: createSignal(false),\n              width: createSignal(node.width),\n              height: createSignal(node.height),\n            },\n          }\" />\n      }\n    }\n\n    @for (edge of edges; track $index) {\n      @if (edge.type === 'template') {\n        <ng-component\n          [ngTemplateOutlet]=\"edgeTemplateDirective()?.templateRef ?? null\"\n          [ngTemplateOutletContext]=\"{\n            $implicit: {\n              edge: edge,\n              selected: createSignal(false),\n              path: createSignal(''),\n              markerStart: createSignal(''),\n              markerEnd: createSignal(''),\n            },\n          }\" />\n\n        @if (edge.edgeLabels?.start) {\n          <ng-component\n            [ngTemplateOutlet]=\"edgeLabelHtmlDirective()?.templateRef ?? null\"\n            [ngTemplateOutletContext]=\"{\n              $implicit: {\n                edge: edge,\n              },\n            }\" />\n        }\n\n        @if (edge.edgeLabels?.center) {\n          <ng-component\n            [ngTemplateOutlet]=\"edgeLabelHtmlDirective()?.templateRef ?? null\"\n            [ngTemplateOutletContext]=\"{\n              $implicit: {\n                edge: edge,\n                label: edge.edgeLabels?.center,\n              },\n            }\" />\n        }\n\n        @if (edge.edgeLabels?.end) {\n          <ng-component\n            [ngTemplateOutlet]=\"edgeLabelHtmlDirective()?.templateRef ?? null\"\n            [ngTemplateOutletContext]=\"{\n              $implicit: {\n                edge: edge,\n                label: edge.edgeLabels?.end,\n              },\n            }\" />\n        }\n      }\n    }\n\n    @if (connection.type === 'template') {\n      <ng-component\n        [ngTemplateOutlet]=\"connectionTemplateDirective()?.templateRef ?? null\"\n        [ngTemplateOutletContext]=\"{\n          $implicit: {\n            path: createSignal(''),\n            marker: createSignal(''),\n          },\n        }\" />\n    }\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [NgTemplateOutlet],\n})\nexport class VflowMockComponent implements AsInterface<VflowComponent>, OnInit {\n  @Input({ required: true })\n  public readonly nodes!: Node[] | DynamicNode[];\n\n  @Input()\n  public readonly edges!: Edge[];\n\n  @Input()\n  public readonly view: [number, number] | 'auto' = [400, 400];\n\n  @Input()\n  public readonly minZoom = 0.5;\n\n  @Input()\n  public readonly maxZoom = 3;\n\n  @Input()\n  public readonly background: Background | string = '#fff';\n\n  public readonly optimization = input<Optimization>({\n    detachedGroupsLayer: false,\n  });\n\n  @Input()\n  public readonly entitiesSelectable = true;\n\n  @Input()\n  public readonly keyboardShortcuts: KeyboardShortcuts = {\n    multiSelection: null,\n  };\n\n  @Input({\n    transform: (settings: ConnectionSettings) => new ConnectionModel(settings),\n  })\n  public readonly connection: ConnectionModel = new ConnectionModel({});\n\n  @Input()\n  public readonly snapGrid!: [number, number];\n\n  @Input()\n  public elevateNodesOnSelect!: boolean;\n\n  @Input()\n  public elevateEdgesOnSelect!: boolean;\n\n  // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n  public readonly onComponentNodeEvent = output<any>();\n\n  protected nodeTemplateDirective = contentChild(NodeHtmlTemplateMockDirective);\n\n  protected groupNodeTemplateDirective = contentChild(GroupNodeTemplateMockDirective);\n\n  protected edgeTemplateDirective = contentChild(EdgeTemplateMockDirective);\n\n  protected edgeLabelHtmlDirective = contentChild(EdgeLabelHtmlTemplateMockDirective);\n\n  protected connectionTemplateDirective = contentChild(ConnectionTemplateMockDirective);\n\n  public viewport = signal<ViewportState>({\n    x: 0,\n    y: 0,\n    zoom: 1,\n  });\n\n  public nodesChange = signal<NodeChange[]>([]);\n  public edgesChange = signal<EdgeChange[]>([]);\n\n  public viewportChange$ = toObservable(this.viewport);\n\n  public nodesChange$ = toObservable(this.nodesChange);\n  public edgesChange$ = toObservable(this.edgesChange);\n\n  // eslint-disable-next-line @angular-eslint/no-empty-lifecycle-method\n  public ngOnInit() {}\n\n  public viewportTo(viewport: ViewportState): void {\n    this.viewport.set(viewport);\n  }\n\n  public zoomTo(zoom: number): void {\n    this.viewport.update((prev) => ({ ...prev, zoom }));\n  }\n\n  public panTo(point: Point): void {\n    this.viewport.update((prev) => ({ ...prev, x: point.x, y: point.y }));\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  public fitView(options?: FitViewOptions): void {}\n\n  public documentPointToFlowPoint(point: Point, options?: { spaces: false }): Point;\n  public documentPointToFlowPoint(point: Point, options: { spaces: true }): SpacePoint[];\n  public documentPointToFlowPoint(point: Point, options?: { spaces: boolean }): unknown {\n    if (options?.spaces) {\n      return [\n        {\n          nodeId: null,\n          x: point.x,\n          y: point.y,\n        },\n      ];\n    }\n\n    return point;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  public getIntesectingNodes(nodeId: string, options?: IntersectingNodesOptions): Node[] | DynamicNode[] {\n    return [];\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  public toNodeSpace(nodeId: string, spaceNodeId: string): Point {\n    return { x: 0, y: 0 };\n  }\n\n  public getNode<T = unknown>(id: string): Node<T> | DynamicNode<T> | undefined {\n    return this.nodes.find((node) => node.id === id);\n  }\n\n  public getDetachedEdges(): Edge[] {\n    return [];\n  }\n\n  protected createSignal<T>(value: T): WritableSignal<T> {\n    return signal(value);\n  }\n}\n"]}

package/esm2022/testing/directive-mocks/connection-controller-mock.directive.mjs

@@ -0,0 +1,27 @@
+import { Directive, output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConnectionControllerMockDirective {
+    constructor() {
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onConnect = output();
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onReconnect = output();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    startConnection(handle) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    startReconnection(handle) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    validateConnection(handle) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    resetValidateConnection(targetHandle) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    endConnection() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConnectionControllerMockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ConnectionControllerMockDirective, isStandalone: true, selector: "[onConnect]", outputs: { onConnect: "onConnect", onReconnect: "onReconnect" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConnectionControllerMockDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[onConnect]', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi1jb250cm9sbGVyLW1vY2suZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXZmbG93LWxpYi90ZXN0aW5nL3NyYy9kaXJlY3RpdmUtbW9ja3MvY29ubmVjdGlvbi1jb250cm9sbGVyLW1vY2suZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU1sRCxNQUFNLE9BQU8saUNBQWlDO0lBRDlDO1FBRUUsK0RBQStEO1FBQy9DLGNBQVMsR0FBRyxNQUFNLEVBQWMsQ0FBQztRQUVqRCwrREFBK0Q7UUFDL0MsZ0JBQVcsR0FBRyxNQUFNLEVBQXFCLENBQUM7S0FnQjNEO0lBZEMsNkRBQTZEO0lBQ3RELGVBQWUsQ0FBQyxNQUFtQixJQUFTLENBQUM7SUFFcEQsNkRBQTZEO0lBQ3RELGlCQUFpQixDQUFDLE1BQW1CLElBQVMsQ0FBQztJQUV0RCw2REFBNkQ7SUFDdEQsa0JBQWtCLENBQUMsTUFBbUIsSUFBUyxDQUFDO0lBRXZELDZEQUE2RDtJQUN0RCx1QkFBdUIsQ0FBQyxZQUF5QixJQUFTLENBQUM7SUFFbEUsNkRBQTZEO0lBQ3RELGFBQWEsS0FBVSxDQUFDOytHQXBCcEIsaUNBQWlDO21HQUFqQyxpQ0FBaUM7OzRGQUFqQyxpQ0FBaUM7a0JBRDdDLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUsYUFBYSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIG91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29ubmVjdGlvbiwgUmVjb25uZWN0aW9uRXZlbnQgfSBmcm9tICduZ3gtdmZsb3cnO1xuaW1wb3J0IHsgQXNJbnRlcmZhY2UgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgdHlwZSB7IENvbm5lY3Rpb25Db250cm9sbGVyRGlyZWN0aXZlLCDJtUhhbmRsZU1vZGVsIGFzIEhhbmRsZU1vZGVsIH0gZnJvbSAnbmd4LXZmbG93JztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW29uQ29ubmVjdF0nLCBzdGFuZGFsb25lOiB0cnVlIH0pXG5leHBvcnQgY2xhc3MgQ29ubmVjdGlvbkNvbnRyb2xsZXJNb2NrRGlyZWN0aXZlIGltcGxlbWVudHMgQXNJbnRlcmZhY2U8Q29ubmVjdGlvbkNvbnRyb2xsZXJEaXJlY3RpdmU+IHtcbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9uby1vdXRwdXQtb24tcHJlZml4XG4gIHB1YmxpYyByZWFkb25seSBvbkNvbm5lY3QgPSBvdXRwdXQ8Q29ubmVjdGlvbj4oKTtcblxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L25vLW91dHB1dC1vbi1wcmVmaXhcbiAgcHVibGljIHJlYWRvbmx5IG9uUmVjb25uZWN0ID0gb3V0cHV0PFJlY29ubmVjdGlvbkV2ZW50PigpO1xuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW51c2VkLXZhcnNcbiAgcHVibGljIHN0YXJ0Q29ubmVjdGlvbihoYW5kbGU6IEhhbmRsZU1vZGVsKTogdm9pZCB7fVxuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW51c2VkLXZhcnNcbiAgcHVibGljIHN0YXJ0UmVjb25uZWN0aW9uKGhhbmRsZTogSGFuZGxlTW9kZWwpOiB2b2lkIHt9XG5cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuICBwdWJsaWMgdmFsaWRhdGVDb25uZWN0aW9uKGhhbmRsZTogSGFuZGxlTW9kZWwpOiB2b2lkIHt9XG5cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuICBwdWJsaWMgcmVzZXRWYWxpZGF0ZUNvbm5lY3Rpb24odGFyZ2V0SGFuZGxlOiBIYW5kbGVNb2RlbCk6IHZvaWQge31cblxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG4gIHB1YmxpYyBlbmRDb25uZWN0aW9uKCk6IHZvaWQge31cbn1cbiJdfQ==

package/esm2022/testing/directive-mocks/drag-handle-mock.directive.mjs

@@ -0,0 +1,11 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DragHandleMockDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DragHandleMockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: DragHandleMockDirective, isStandalone: true, selector: "[dragHandle]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DragHandleMockDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[dragHandle]', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1oYW5kbGUtbW9jay5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3Rlc3Rpbmcvc3JjL2RpcmVjdGl2ZS1tb2Nrcy9kcmFnLWhhbmRsZS1tb2NrLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUsxQyxNQUFNLE9BQU8sdUJBQXVCOytHQUF2Qix1QkFBdUI7bUdBQXZCLHVCQUF1Qjs7NEZBQXZCLHVCQUF1QjtrQkFEbkMsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSxjQUFjLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQXNJbnRlcmZhY2UgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgdHlwZSB7IERyYWdIYW5kbGVEaXJlY3RpdmUgfSBmcm9tICduZ3gtdmZsb3cnO1xuXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICdbZHJhZ0hhbmRsZV0nLCBzdGFuZGFsb25lOiB0cnVlIH0pXG5leHBvcnQgY2xhc3MgRHJhZ0hhbmRsZU1vY2tEaXJlY3RpdmUgaW1wbGVtZW50cyBBc0ludGVyZmFjZTxEcmFnSGFuZGxlRGlyZWN0aXZlPiB7fVxuIl19

package/esm2022/{lib/vflow/testing-utils → testing}/directive-mocks/selectable-mock.directive.mjs

@@ -11,4 +11,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     standalone: true,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0YWJsZS1tb2NrLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy90ZXN0aW5nLXV0aWxzL2RpcmVjdGl2ZS1tb2Nrcy9zZWxlY3RhYmxlLW1vY2suZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBUTFDLE1BQU0sT0FBTyx1QkFBdUI7K0dBQXZCLHVCQUF1QjttR0FBdkIsdUJBQXVCOzs0RkFBdkIsdUJBQXVCO2tCQUpuQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxjQUFjO29CQUN4QixVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFzSW50ZXJmYWNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuaW1wb3J0IHsgU2VsZWN0YWJsZURpcmVjdGl2ZSB9IGZyb20gJy4uLy4uL2RpcmVjdGl2ZXMvc2VsZWN0YWJsZS5kaXJlY3RpdmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VsZWN0YWJsZV0nLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBTZWxlY3RhYmxlTW9ja0RpcmVjdGl2ZSBpbXBsZW1lbnRzIEFzSW50ZXJmYWNlPFNlbGVjdGFibGVEaXJlY3RpdmU+IHt9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0YWJsZS1tb2NrLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvdGVzdGluZy9zcmMvZGlyZWN0aXZlLW1vY2tzL3NlbGVjdGFibGUtbW9jay5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFRMUMsTUFBTSxPQUFPLHVCQUF1QjsrR0FBdkIsdUJBQXVCO21HQUF2Qix1QkFBdUI7OzRGQUF2Qix1QkFBdUI7a0JBSm5DLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGNBQWM7b0JBQ3hCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQXNJbnRlcmZhY2UgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgdHlwZSB7IFNlbGVjdGFibGVEaXJlY3RpdmUgfSBmcm9tICduZ3gtdmZsb3cnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VsZWN0YWJsZV0nLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBTZWxlY3RhYmxlTW9ja0RpcmVjdGl2ZSBpbXBsZW1lbnRzIEFzSW50ZXJmYWNlPFNlbGVjdGFibGVEaXJlY3RpdmU+IHt9XG4iXX0=

package/esm2022/{lib/vflow/testing-utils → testing}/directive-mocks/template-mock.directive.mjs

@@ -98,4 +98,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     selector: 'ng-template[handle]',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/ngx-vflow-testing.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LXZmbG93LXRlc3RpbmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3Rlc3Rpbmcvc3JjL25neC12Zmxvdy10ZXN0aW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=