@foblex/flow 17.0.9 → 17.1.0

package/fesm2022/foblex-flow.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, Directive, ElementRef, Input, HostBinding, EventEmitter, DestroyRef, Output, booleanAttribute, Inject, Component, ChangeDetectionStrategy, ViewChild, Optional, ContentChildren, NgZone, ContentChild, NgModule } from '@angular/core';
-import { RectExtensions, RoundedRect, TransformModelExtensions, PointExtensions, Point, SizeExtensions, LineExtensions, GetIntersections, setRectToElement, adjustRectToMinSize, findClosestAlignment, setRectToViewBox } from '@foblex/2d';
+import { RectExtensions, RoundedRect, TransformModelExtensions, PointExtensions, Point, SizeExtensions, LineExtensions, GetIntersections, findClosestAlignment, setRectToElement, adjustRectToMinSize, setRectToViewBox } from '@foblex/2d';
 import { __decorate } from 'tslib';
 import * as i2 from '@foblex/mediator';
 import { FExecutionRegister, FMediator, FValidatorRegister } from '@foblex/mediator';
@@ -229,6 +229,7 @@ class FComponentsStore {
     fInputs = [];
     fOutlets = [];
     fDraggable;
+    fLineAlignment;
     addComponent(collection, component) {
         collection.push(component);
         this.countChanged();
@@ -3355,7 +3356,6 @@ class FDraggableDataContext {
     onPointerDownScale = 1;
     onPointerDownPosition = new Point(0, 0);
     draggableItems = [];
-    fLineAlignment;
     reset() {
         this.draggableItems = [];
         this.onPointerDownScale = 1;
@@ -3364,6 +3364,9 @@ class FDraggableDataContext {
     markSelectionAsChanged() {
         this.isSelectedChanged = true;
     }
+    isEmpty() {
+        return !this.draggableItems.length;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FDraggableDataContext, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FDraggableDataContext });
 }
@@ -3644,13 +3647,13 @@ class CreateConnectionDragHandler {
         }
     }
     _drawConnectionForCreate(fInputRect, fSide) {
-        const line = this.fMediator.send(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fInputRect, this.fConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fSide));
+        const line = this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fInputRect, this.fConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fSide));
         this.fConnection.setLine(line.point1, this.fOutputWithRect.fConnector.fConnectableSide, line.point2, fSide);
         this.fConnection.redraw();
     }
     _drawSnapConnection(fClosestInput) {
         if (fClosestInput) {
-            const line = this.fMediator.send(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fClosestInput.fRect, this.fSnapConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fClosestInput.fConnector.fConnectableSide));
+            const line = this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fClosestInput.fRect, this.fSnapConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fClosestInput.fConnector.fConnectableSide));
             this.fSnapConnection.show();
             this.fSnapConnection.setLine(line.point1, this.fOutputWithRect.fConnector.fConnectableSide, line.point2, fClosestInput.fConnector.fConnectableSide);
             this.fSnapConnection.redraw();
@@ -4106,13 +4109,16 @@ class ReassignConnectionDragHandler {
         }
     }
     _drawConnection(fInputRect, fSide) {
-        const line = this.fMediator.send(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fInputRect, this.fConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fSide));
+        const line = this._getLineToPointer(fInputRect, fSide);
         this.fConnection.setLine(line.point1, this.fOutputWithRect.fConnector.fConnectableSide, line.point2, fSide);
         this.fConnection.redraw();
     }
+    _getLineToPointer(fInputRect, fSide) {
+        return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fInputRect, this.fConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fSide));
+    }
     _drawSnapConnection(fClosestInput) {
         if (fClosestInput) {
-            const line = this.fMediator.send(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fClosestInput.fRect, this.fSnapConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fClosestInput.fConnector.fConnectableSide));
+            const line = this._getLineToClosestInput(fClosestInput);
             this.fSnapConnection.show();
             this.fSnapConnection.setLine(line.point1, this.fOutputWithRect.fConnector.fConnectableSide, line.point2, fClosestInput.fConnector.fConnectableSide);
             this.fSnapConnection.redraw();
@@ -4121,6 +4127,9 @@ class ReassignConnectionDragHandler {
             this.fSnapConnection?.hide();
         }
     }
+    _getLineToClosestInput(fClosestInput) {
+        return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, fClosestInput.fRect, this.fSnapConnection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, fClosestInput.fConnector.fConnectableSide));
+    }
     getClosetInput(difference) {
         if (!this.fSnapConnection) {
             return undefined;
@@ -4155,44 +4164,45 @@ class FReassignConnectionEvent {
 }
 
 let ReassignConnectionFinalizeExecution = class ReassignConnectionFinalizeExecution {
-    fComponentsStore;
-    fDraggableDataContext;
-    fMediator;
-    get fDraggable() {
-        return this.fComponentsStore.fDraggable;
-    }
-    get dragHandler() {
-        return this.fDraggableDataContext.draggableItems[0];
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
+    get _fDraggable() {
+        return this._fComponentsStore.fDraggable;
     }
-    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fMediator = fMediator;
+    get _fDragHandler() {
+        return this._fDraggableDataContext.draggableItems[0];
     }
     handle(request) {
-        if (!this._isValid()) {
+        if (!this._isDroppedConnectionReassignEvent()) {
             return;
         }
-        this.emitEvent(request.event);
-        this.dragHandler.onPointerUp();
+        this._applyReassignEvent(request.event);
+        this._fDragHandler.onPointerUp();
     }
-    _isValid() {
-        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof ReassignConnectionDragHandler);
+    _isDroppedConnectionReassignEvent() {
+        return this._fDraggableDataContext.draggableItems.some((x) => x instanceof ReassignConnectionDragHandler);
     }
-    emitEvent(event) {
-        const input = this.getInputUnderPointer(event);
-        if (!!input && !this.isReassignToDifferentInput(input)) {
+    _applyReassignEvent(event) {
+        const fInput = this._getInputUnderPointer(event);
+        if (!!fInput && !this._isReassignToDifferentInput(fInput)) {
             return;
         }
-        this.fDraggable.fReassignConnection.emit(new FReassignConnectionEvent(this.dragHandler.fConnection.fId, this.dragHandler.fConnection.fOutputId, this.dragHandler.fConnection.fInputId, input?.fId, event.getPosition()));
+        this._emitReassignConnectionEvent(event, fInput);
     }
-    getInputUnderPointer(event) {
-        return this.fMediator.send(new GetInputUnderPointerRequest(event, this.dragHandler));
+    _getInputUnderPointer(event) {
+        return this._fMediator.send(new GetInputUnderPointerRequest(event, this._fDragHandler));
+    }
+    _isReassignToDifferentInput(fInput) {
+        return this._fDragHandler.fConnection.fInputId !== fInput.fId;
     }
-    isReassignToDifferentInput(inputsUnderPointer) {
-        return this.dragHandler.fConnection.fInputId !== inputsUnderPointer.fId;
+    _emitReassignConnectionEvent(event, fInput) {
+        this._fDraggable.fReassignConnection.emit(this._getEventData(event, fInput));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ReassignConnectionFinalizeExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }, { token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    _getEventData(event, fInput) {
+        return new FReassignConnectionEvent(this._fDragHandler.fConnection.fId, this._fDragHandler.fConnection.fOutputId, this._fDragHandler.fConnection.fInputId, fInput?.fId, event.getPosition());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ReassignConnectionFinalizeExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ReassignConnectionFinalizeExecution });
 };
 ReassignConnectionFinalizeExecution = __decorate([
@@ -4200,7 +4210,7 @@ ReassignConnectionFinalizeExecution = __decorate([
 ], ReassignConnectionFinalizeExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ReassignConnectionFinalizeExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: i2.FMediator }] });
+        }] });
 
 class ReassignConnectionPreparationRequest {
     event;
@@ -4332,66 +4342,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
         }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2.FMediator }] });
 
 class IsArrayHasParentNodeRequest {
-    fNode;
-    fNodes;
-    constructor(fNode, fNodes) {
-        this.fNode = fNode;
-        this.fNodes = fNodes;
-    }
-}
-
-class GetParentNodesRequest {
-    fNode;
-    constructor(fNode) {
-        this.fNode = fNode;
+    fParentNodes;
+    fDraggedNodes;
+    constructor(fParentNodes, fDraggedNodes) {
+        this.fParentNodes = fParentNodes;
+        this.fDraggedNodes = fDraggedNodes;
     }
 }
 
-let GetParentNodesExecution = class GetParentNodesExecution {
-    _fComponentsStore = inject(FComponentsStore);
-    handle(request) {
-        return this._getParentNodes(request.fNode, new Set(), []);
-    }
-    _getParentNodes(fNode, visited, result) {
-        if (visited.has(fNode.fId)) {
-            throw new Error('Circular reference detected in the node hierarchy. Node id: ' + fNode.fId);
-        }
-        visited.add(fNode.fId);
-        const parent = this._fComponentsStore.fNodes.find((x) => x.fId === fNode.fParentId);
-        if (!parent) {
-            return result;
-        }
-        result.push(parent);
-        return this._getParentNodes(parent, visited, result);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetParentNodesExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetParentNodesExecution });
-};
-GetParentNodesExecution = __decorate([
-    FExecutionRegister(GetParentNodesRequest)
-], GetParentNodesExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetParentNodesExecution, decorators: [{
-            type: Injectable
-        }] });
-
 let IsArrayHasParentNodeExecution = class IsArrayHasParentNodeExecution {
-    fMediator;
-    constructor(fMediator) {
-        this.fMediator = fMediator;
-    }
     handle(request) {
-        return this.isParentNodeInArray(this.getParentNodeIds(request.fNode), request.fNodes);
-    }
-    getParentNodeIds(fNode) {
-        return this.getParentNodes(fNode).map((x) => x.fId);
+        return this._isParentNodeInArray(this._getParentNodeIds(request.fParentNodes), request.fDraggedNodes);
     }
-    getParentNodes(fNode) {
-        return this.fMediator.send(new GetParentNodesRequest(fNode));
+    _getParentNodeIds(fParentNodes) {
+        return fParentNodes.map((x) => x.fId);
     }
-    isParentNodeInArray(parentNodeIds, fNodes) {
-        return fNodes.some((x) => parentNodeIds.includes(x.fId));
+    _isParentNodeInArray(parentNodeIds, fDraggedNodes) {
+        return fDraggedNodes.some((x) => parentNodeIds.includes(x.fId));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: IsArrayHasParentNodeExecution, deps: [{ token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: IsArrayHasParentNodeExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: IsArrayHasParentNodeExecution });
 };
 IsArrayHasParentNodeExecution = __decorate([
@@ -4399,7 +4368,7 @@ IsArrayHasParentNodeExecution = __decorate([
 ], IsArrayHasParentNodeExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: IsArrayHasParentNodeExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i2.FMediator }] });
+        }] });
 
 class FNodeIntersectedWithConnections {
     fNodeId;
@@ -4421,27 +4390,30 @@ let IsConnectionUnderNodeExecution = class IsConnectionUnderNodeExecution {
     _fMediator = inject(FMediator);
     _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        const fNode = request.fNode;
-        const fOutputConnectors = this._getNodeOutputConnectors(fNode);
-        const fInputConnectors = this._getNodeInputConnectors(fNode);
-        const canBeConnectedOutputs = fOutputConnectors.filter((x) => x.canBeConnected);
-        const canBeConnectedInputs = fInputConnectors.filter((x) => x.canBeConnected);
-        if (canBeConnectedOutputs.length && canBeConnectedInputs.length) {
-            const fOutputConnections = this._getOutputConnectionsId(canBeConnectedOutputs);
-            const fInputConnections = this._getInputConnectionsId(canBeConnectedInputs);
-            const fConnectionsUnderNode = this._calculateConnectionsUnderNode(fNode).filter((x) => {
-                return !fOutputConnections.includes(x.fId) && !fInputConnections.includes(x.fId);
-            });
-            if (fConnectionsUnderNode.length) {
-                this._fComponentsStore.fDraggable?.fNodeIntersectedWithConnections.emit(new FNodeIntersectedWithConnections(fNode.fId, fConnectionsUnderNode.map((x) => x.fId)));
-            }
+        const fOutputConnectors = this._getOutputConnectors(request.fNode);
+        const fInputConnectors = this._getInputConnectors(request.fNode);
+        if (!fOutputConnectors.length || !fInputConnectors.length) {
+            return;
         }
+        const fOutputConnections = this._getOutputConnectionsId(fOutputConnectors);
+        const fInputConnections = this._getInputConnectionsId(fInputConnectors);
+        const fConnectionsUnderNode = this._calculateConnectionsUnderNode(request.fNode).filter((x) => {
+            return !fOutputConnections.includes(x.fId) && !fInputConnections.includes(x.fId);
+        });
+        if (!fConnectionsUnderNode.length) {
+            return;
+        }
+        this._emitNodeIntersectedWithConnections(request.fNode, fConnectionsUnderNode);
     }
-    _getNodeOutputConnectors(fNode) {
-        return this._fComponentsStore.fOutputs.filter((x) => fNode.isContains(x.hostElement));
+    _getOutputConnectors(fNode) {
+        return this._fComponentsStore.fOutputs.filter((x) => {
+            return fNode.isContains(x.hostElement) && x.canBeConnected;
+        });
     }
-    _getNodeInputConnectors(fNode) {
-        return this._fComponentsStore.fInputs.filter((x) => fNode.isContains(x.hostElement));
+    _getInputConnectors(fNode) {
+        return this._fComponentsStore.fInputs.filter((x) => {
+            return fNode.isContains(x.hostElement) && x.canBeConnected;
+        });
     }
     _getOutputConnectionsId(connectors) {
         const connectorsId = this._getConnectorsId(connectors);
@@ -4465,6 +4437,9 @@ let IsConnectionUnderNodeExecution = class IsConnectionUnderNodeExecution {
     _isConnectionHasIntersectionsWithNode(fConnection, fNodeRect) {
         return GetIntersections.getRoundedRectIntersectionsWithSVGPath(fConnection.fPath.hostElement, fNodeRect).length > 0;
     }
+    _emitNodeIntersectedWithConnections(fNode, fConnections) {
+        this._fComponentsStore.fDraggable?.fNodeIntersectedWithConnections.emit(new FNodeIntersectedWithConnections(fNode.fId, fConnections.map((x) => x.fId)));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: IsConnectionUnderNodeExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: IsConnectionUnderNodeExecution });
 };
@@ -4499,6 +4474,47 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }] });
 
+class CalculateCommonNodeMoveRestrictionsRequest {
+    restrictions;
+    constructor(restrictions) {
+        this.restrictions = restrictions;
+    }
+}
+
+let CalculateCommonNodeMoveRestrictionsExecution = class CalculateCommonNodeMoveRestrictionsExecution {
+    handle(request) {
+        return this._calculateCommonRestrictions(request.restrictions);
+    }
+    _calculateCommonRestrictions(restrictions) {
+        return restrictions.reduce((result, x) => this._clampRestrictions(result, x), restrictions[0]);
+    }
+    _clampRestrictions(common, x) {
+        common.min = this._clampMinRestrictions(common.min, x.min);
+        common.max = this._clampMaxRestrictions(common.max, x.max);
+        return common;
+    }
+    _clampMinRestrictions(common, node) {
+        return {
+            x: Math.max(common.x, node.x),
+            y: Math.max(common.y, node.y),
+        };
+    }
+    _clampMaxRestrictions(common, node) {
+        return {
+            x: Math.min(common.x, node.x),
+            y: Math.min(common.y, node.y),
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveRestrictionsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveRestrictionsExecution });
+};
+CalculateCommonNodeMoveRestrictionsExecution = __decorate([
+    FExecutionRegister(CalculateCommonNodeMoveRestrictionsRequest)
+], CalculateCommonNodeMoveRestrictionsExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveRestrictionsExecution, decorators: [{
+            type: Injectable
+        }] });
+
 class PutInputConnectionHandlersToArrayRequest {
     nodeDragHandler;
     outputIds;
@@ -4565,11 +4581,11 @@ class ConnectionDragHandler extends ConnectionBaseDragHandler {
     constructor(fMediator, fComponentsStore, connection) {
         super(fMediator, fComponentsStore, connection);
     }
-    setOutputRestrictions(min, max) {
-        this.sourceRestrictions = { min, max };
+    setOutputRestrictions(restrictions) {
+        this.sourceRestrictions = restrictions;
     }
-    setInputRestrictions(min, max) {
-        this.targetRestrictions = { min, max };
+    setInputRestrictions(restrictions) {
+        this.targetRestrictions = restrictions;
     }
     onPointerMove(difference) {
         this.redrawConnection(this.getNewLineValue(difference));
@@ -4580,30 +4596,24 @@ class ConnectionDragHandler extends ConnectionBaseDragHandler {
 }
 
 class ConnectionTargetDragHandler extends ConnectionBaseDragHandler {
-    minDistance;
-    maxDistance;
-    constructor(fMediator, fComponentsStore, connection, minDistance, maxDistance) {
+    restrictions;
+    constructor(fMediator, fComponentsStore, connection, restrictions) {
         super(fMediator, fComponentsStore, connection);
-        this.minDistance = minDistance;
-        this.maxDistance = maxDistance;
+        this.restrictions = restrictions;
     }
     onPointerMove(difference) {
         this.redrawConnection(this.getNewLineValue(difference));
     }
     getNewLineValue(difference) {
-        return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, RoundedRect.fromRoundedRect(this.fInputWithRect.fRect).addPoint(this.getRestrictedDifference({ ...difference }, { min: this.minDistance, max: this.maxDistance })), this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
+        return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fOutputWithRect.fRect, RoundedRect.fromRoundedRect(this.fInputWithRect.fRect).addPoint(this.getRestrictedDifference({ ...difference }, this.restrictions)), this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
     }
 }
 
 let PutInputConnectionHandlersToArrayExecution = class PutInputConnectionHandlersToArrayExecution {
-    fComponentsStore;
-    fMediator;
-    get fConnections() {
-        return this.fComponentsStore.fConnections;
-    }
-    constructor(fComponentsStore, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fMediator = fMediator;
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
+    get _fConnections() {
+        return this._fComponentsStore.fConnections;
     }
     handle(request) {
         this.getInputConnections(request.nodeDragHandler.fNode).forEach((connection) => {
@@ -4618,10 +4628,10 @@ let PutInputConnectionHandlersToArrayExecution = class PutInputConnectionHandler
     }
     getInputConnections(node) {
         const inputIds = new Set(this.getInputsForNode(node).map((x) => x.fId));
-        return this.fConnections.filter((x) => inputIds.has(x.fInputId));
+        return this._fConnections.filter((x) => inputIds.has(x.fInputId));
     }
     getInputsForNode(node) {
-        return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
+        return this._fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
     }
     getExistingConnectionHandlerIndex(result, connection) {
         return result.findIndex((x) => x instanceof ConnectionDragHandler && x.connection.fId === connection.fId);
@@ -4637,17 +4647,17 @@ let PutInputConnectionHandlersToArrayExecution = class PutInputConnectionHandler
         return result;
     }
     getNewConnectionHandler(connection, nodeDragHandler) {
-        const handler = new ConnectionDragHandler(this.fMediator, this.fComponentsStore, connection);
-        handler.setInputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        const handler = new ConnectionDragHandler(this._fMediator, this._fComponentsStore, connection);
+        handler.setInputRestrictions(nodeDragHandler.restrictions);
         return handler;
     }
     updateExistingConnectionHandler(result, index, nodeDragHandler) {
-        result[index].setInputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        result[index].setInputRestrictions(nodeDragHandler.restrictions);
     }
     getNewSourceConnectionHandler(connection, nodeDragHandler) {
-        return new ConnectionTargetDragHandler(this.fMediator, this.fComponentsStore, connection, nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        return new ConnectionTargetDragHandler(this._fMediator, this._fComponentsStore, connection, nodeDragHandler.restrictions);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, deps: [{ token: FComponentsStore }, { token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution });
 };
 PutInputConnectionHandlersToArrayExecution = __decorate([
@@ -4655,7 +4665,7 @@ PutInputConnectionHandlersToArrayExecution = __decorate([
 ], PutInputConnectionHandlersToArrayExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2.FMediator }] });
+        }] });
 
 class PutOutputConnectionHandlersToArrayRequest {
     nodeDragHandler;
@@ -4669,18 +4679,16 @@ class PutOutputConnectionHandlersToArrayRequest {
 }
 
 class ConnectionSourceDragHandler extends ConnectionBaseDragHandler {
-    minDistance;
-    maxDistance;
-    constructor(fMediator, fComponentsStore, connection, minDistance, maxDistance) {
+    restrictions;
+    constructor(fMediator, fComponentsStore, connection, restrictions) {
         super(fMediator, fComponentsStore, connection);
-        this.minDistance = minDistance;
-        this.maxDistance = maxDistance;
+        this.restrictions = restrictions;
     }
     onPointerMove(difference) {
         this.redrawConnection(this.getNewLineValue(difference));
     }
     getNewLineValue(difference) {
-        return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(RoundedRect.fromRoundedRect(this.fOutputWithRect.fRect).addPoint(this.getRestrictedDifference({ ...difference }, { min: this.minDistance, max: this.maxDistance })), this.fInputWithRect.fRect, this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
+        return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(RoundedRect.fromRoundedRect(this.fOutputWithRect.fRect).addPoint(this.getRestrictedDifference({ ...difference }, this.restrictions)), this.fInputWithRect.fRect, this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
     }
 }
 
@@ -4727,14 +4735,14 @@ let PutOutputConnectionHandlersToArrayExecution = class PutOutputConnectionHandl
     }
     getNewConnectionHandler(connection, nodeDragHandler) {
         const handler = new ConnectionDragHandler(this.fMediator, this.fComponentsStore, connection);
-        handler.setOutputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        handler.setOutputRestrictions(nodeDragHandler.restrictions);
         return handler;
     }
     updateExistingConnectionHandler(result, index, nodeDragHandler) {
-        result[index].setOutputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        result[index].setOutputRestrictions(nodeDragHandler.restrictions);
     }
     getNewSourceConnectionHandler(connection, nodeDragHandler) {
-        return new ConnectionSourceDragHandler(this.fMediator, this.fComponentsStore, connection, nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        return new ConnectionSourceDragHandler(this.fMediator, this.fComponentsStore, connection, nodeDragHandler.restrictions);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution, deps: [{ token: FComponentsStore }, { token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution });
@@ -4746,7 +4754,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2.FMediator }] });
 
-class GetNodeMoveRestrictionsRequest {
+class CalculateNodeMoveRestrictionsRequest {
     fNode;
     hasParentNodeInSelected;
     constructor(fNode, hasParentNodeInSelected) {
@@ -4755,32 +4763,32 @@ class GetNodeMoveRestrictionsRequest {
     }
 }
 
-let GetNodeMoveRestrictionsExecution = class GetNodeMoveRestrictionsExecution {
+let CalculateNodeMoveRestrictionsExecution = class CalculateNodeMoveRestrictionsExecution {
     _fMediator = inject(FMediator);
     handle(request) {
-        if (request.fNode.fParentId && !request.hasParentNodeInSelected) {
-            const fParentNodeRect = this.getParentNodeRect(request.fNode);
-            const fCurrentNodeRect = this._getNodeRect(request.fNode);
-            return {
-                min: PointExtensions.initialize(fParentNodeRect.x - fCurrentNodeRect.x, fParentNodeRect.y - fCurrentNodeRect.y),
-                max: PointExtensions.initialize((fParentNodeRect.x + fParentNodeRect.width) - (fCurrentNodeRect.x + fCurrentNodeRect.width), (fParentNodeRect.y + fParentNodeRect.height) - (fCurrentNodeRect.y + fCurrentNodeRect.height))
-            };
+        if (!request.fNode.fParentId || request.hasParentNodeInSelected) {
+            return { ...DEFAULT_RESTRICTIONS };
         }
-        return { ...DEFAULT_RESTRICTIONS };
+        const fParentNodeRect = this._getParentNodeRect(request.fNode);
+        const fCurrentNodeRect = this._getNodeRect(request.fNode);
+        return {
+            min: PointExtensions.initialize(fParentNodeRect.x - fCurrentNodeRect.x, fParentNodeRect.y - fCurrentNodeRect.y),
+            max: PointExtensions.initialize((fParentNodeRect.x + fParentNodeRect.width) - (fCurrentNodeRect.x + fCurrentNodeRect.width), (fParentNodeRect.y + fParentNodeRect.height) - (fCurrentNodeRect.y + fCurrentNodeRect.height))
+        };
     }
     _getNodeRect(fNode) {
-        return this._fMediator.send(new GetNormalizedElementRectRequest(fNode.hostElement, false));
+        return this._fMediator.execute(new GetNormalizedElementRectRequest(fNode.hostElement, false));
     }
-    getParentNodeRect(fNode) {
-        return this._fMediator.send(new GetNormalizedParentNodeRectRequest(fNode));
+    _getParentNodeRect(fNode) {
+        return this._fMediator.execute(new GetNormalizedParentNodeRectRequest(fNode));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeMoveRestrictionsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeMoveRestrictionsExecution });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveRestrictionsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveRestrictionsExecution });
 };
-GetNodeMoveRestrictionsExecution = __decorate([
-    FExecutionRegister(GetNodeMoveRestrictionsRequest)
-], GetNodeMoveRestrictionsExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeMoveRestrictionsExecution, decorators: [{
+CalculateNodeMoveRestrictionsExecution = __decorate([
+    FExecutionRegister(CalculateNodeMoveRestrictionsRequest)
+], CalculateNodeMoveRestrictionsExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveRestrictionsExecution, decorators: [{
             type: Injectable
         }] });
 const DEFAULT_RESTRICTIONS = {
@@ -4796,32 +4804,27 @@ class CreateMoveNodesDragModelFromSelectionRequest {
 }
 
 class NodeDragHandler {
-    fDraggableDataContext;
-    fComponentsStore;
+    _fComponentsStore;
     fNode;
-    minDistance;
-    maxDistance;
+    restrictions;
     _onPointerDownPosition = PointExtensions.initialize();
-    constructor(fDraggableDataContext, fComponentsStore, fNode, minDistance, maxDistance) {
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fComponentsStore = fComponentsStore;
+    constructor(_fComponentsStore, fNode, restrictions) {
+        this._fComponentsStore = _fComponentsStore;
         this.fNode = fNode;
-        this.minDistance = minDistance;
-        this.maxDistance = maxDistance;
+        this.restrictions = restrictions;
         this._onPointerDownPosition = { ...fNode.position };
     }
     onPointerMove(difference) {
-        const restrictedDifference = this._getDifference(difference, { min: this.minDistance, max: this.maxDistance });
+        const restrictedDifference = this._getDifference(difference);
         this._redraw(this._getPosition(restrictedDifference));
-        this.fDraggableDataContext.fLineAlignment?.handle(restrictedDifference);
     }
     _getPosition(difference) {
         return Point.fromPoint(this._onPointerDownPosition).add(difference);
     }
-    _getDifference(difference, restrictions) {
+    _getDifference(difference) {
         return {
-            x: Math.min(Math.max(difference.x, restrictions.min.x), restrictions.max.x),
-            y: Math.min(Math.max(difference.y, restrictions.min.y), restrictions.max.y)
+            x: Math.min(Math.max(difference.x, this.restrictions.min.x), this.restrictions.max.x),
+            y: Math.min(Math.max(difference.y, this.restrictions.min.y), this.restrictions.max.y)
         };
     }
     _redraw(position) {
@@ -4832,13 +4835,12 @@ class NodeDragHandler {
         this.fNode.positionChange.emit(this.fNode.position);
     }
     getDifferenceWithCellSize(difference) {
-        const restrictedDifference = this._getDifference(difference, { min: this.minDistance, max: this.maxDistance });
-        const position = this._getPosition(restrictedDifference);
+        const position = this._getPosition(this._getDifference(difference));
         return Point.fromPoint(this._applyCellSize(position)).sub(this._onPointerDownPosition);
     }
     _applyCellSize(position) {
-        const hCellSize = this.fComponentsStore.fDraggable.hCellSize;
-        const vCellSize = this.fComponentsStore.fDraggable.vCellSize;
+        const hCellSize = this._fComponentsStore.fDraggable.hCellSize;
+        const vCellSize = this._fComponentsStore.fDraggable.vCellSize;
         return {
             x: Math.round(position.x / hCellSize) * hCellSize,
             y: Math.round(position.y / vCellSize) * vCellSize
@@ -4866,10 +4868,10 @@ let CreateMoveNodesDragModelFromSelectionExecution = class CreateMoveNodesDragMo
     _fComponentsStore = inject(FComponentsStore);
     _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
-        const itemsToDrag = this._getNodesWithRestrictions(this._getSelectedNodes(request.nodeWithDisabledSelection));
-        return this.getDragHandlersWithConnections(this.getDragHandlersFromNodes(itemsToDrag), this.getAllOutputIds(itemsToDrag), this.getAllInputIds(itemsToDrag));
+        const fItemsToDrag = this._getNodesWithRestrictions(this._getDraggedNodes(request.nodeWithDisabledSelection));
+        return this.getDragHandlersWithConnections(this.getDragHandlersFromNodes(fItemsToDrag), this.getAllOutputIds(fItemsToDrag), this.getAllInputIds(fItemsToDrag));
     }
-    _getSelectedNodes(nodeWithDisabledSelection) {
+    _getDraggedNodes(nodeWithDisabledSelection) {
         const result = this._getNodesFromSelection();
         if (nodeWithDisabledSelection) {
             result.push(nodeWithDisabledSelection);
@@ -4882,32 +4884,46 @@ let CreateMoveNodesDragModelFromSelectionExecution = class CreateMoveNodesDragMo
             .filter((x) => !!x);
     }
     _findNode(hostElement) {
-        return this._fComponentsStore.fNodes.find(n => n.isContains(hostElement));
+        return this._fComponentsStore.fNodes
+            .find(n => n.isContains(hostElement));
     }
-    _getNodesWithRestrictions(nodesToDrag) {
+    _getNodesWithRestrictions(fDraggedNodes) {
         const result = [];
-        nodesToDrag.forEach((x) => {
-            const hasParentNodeInSelected = this._fMediator.send(new IsArrayHasParentNodeRequest(x, nodesToDrag));
-            const restrictions = this._fMediator.send(new GetNodeMoveRestrictionsRequest(x, hasParentNodeInSelected));
-            const parentNodes = this._fMediator.send(new GetParentNodesRequest(x));
-            result.push({ node: x, parentNodes, ...restrictions }, ...this.getChildrenItemsToDrag(x, restrictions));
+        fDraggedNodes.forEach((x) => {
+            const fParentNodes = this._fMediator.execute(new GetParentNodesRequest(x));
+            const restrictions = this._getNodeMoveRestrictions(x, fParentNodes, fDraggedNodes);
+            result.push({ fDraggedNode: x, fParentNodes, ...restrictions }, ...this._getChildrenItemsToDrag(x, restrictions));
         });
+        this._applyCommonRestrictions(result);
         return result;
     }
-    getChildrenItemsToDrag(node, restrictions) {
-        return this.getChildrenNodes(node.fId).map((x) => ({ node: x, ...restrictions }));
+    _getNodeMoveRestrictions(fNode, fParentNodes, fDraggedNodes) {
+        return this._fMediator.execute(new CalculateNodeMoveRestrictionsRequest(fNode, this._isParentNodeInArray(fParentNodes, fDraggedNodes)));
     }
-    getChildrenNodes(fId) {
-        return this._fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId));
+    _isParentNodeInArray(fParentNodes, fDraggedNodes) {
+        return this._fMediator.execute(new IsArrayHasParentNodeRequest(fParentNodes, fDraggedNodes));
+    }
+    _getChildrenItemsToDrag(node, restrictions) {
+        return this._getChildrenNodes(node.fId).map((x) => ({ fDraggedNode: x, ...restrictions }));
+    }
+    _getChildrenNodes(fId) {
+        return this._fMediator.execute(new GetDeepChildrenNodesAndGroupsRequest(fId));
+    }
+    _applyCommonRestrictions(restrictions) {
+        const commonRestrictions = this._fMediator.execute(new CalculateCommonNodeMoveRestrictionsRequest(restrictions));
+        restrictions.forEach((x) => {
+            x.min = commonRestrictions.min;
+            x.max = commonRestrictions.max;
+        });
     }
     getAllOutputIds(items) {
-        return flatMap(items, (item) => this.getOutputsForNode(item.node).map((x) => x.fId));
+        return flatMap(items, (item) => this.getOutputsForNode(item.fDraggedNode).map((x) => x.fId));
     }
     getOutputsForNode(node) {
         return this._fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
     }
     getAllInputIds(items) {
-        return flatMap(items, (item) => this.getInputsForNode(item.node).map((x) => x.fId));
+        return flatMap(items, (item) => this.getInputsForNode(item.fDraggedNode).map((x) => x.fId));
     }
     getInputsForNode(node) {
         return this._fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
@@ -4915,15 +4931,15 @@ let CreateMoveNodesDragModelFromSelectionExecution = class CreateMoveNodesDragMo
     getDragHandlersFromNodes(items) {
         let result = [];
         items.forEach((node) => {
-            result.push(new NodeDragHandler(this._fDraggableDataContext, this._fComponentsStore, node.node, node.min, node.max), ...(node.parentNodes || []).map(() => new NodeResizeByChildDragHandler(this._fDraggableDataContext)));
+            result.push(new NodeDragHandler(this._fComponentsStore, node.fDraggedNode, { min: node.min, max: node.max }), ...(node.fParentNodes || []).map(() => new NodeResizeByChildDragHandler(this._fDraggableDataContext)));
         });
         return result;
     }
     getDragHandlersWithConnections(handlers, outputIds, inputIds) {
         let result = handlers;
-        handlers.filter((x) => x instanceof NodeDragHandler).forEach((dragHandler) => {
-            this._fMediator.send(new PutOutputConnectionHandlersToArrayRequest(dragHandler, inputIds, result));
-            this._fMediator.send(new PutInputConnectionHandlersToArrayRequest(dragHandler, outputIds, result));
+        handlers.filter((x) => x instanceof NodeDragHandler).forEach((x) => {
+            this._fMediator.execute(new PutOutputConnectionHandlersToArrayRequest(x, inputIds, result));
+            this._fMediator.execute(new PutInputConnectionHandlersToArrayRequest(x, outputIds, result));
         });
         return result;
     }
@@ -4938,125 +4954,345 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
         }] });
 
 const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS = [
-    GetNodeMoveRestrictionsExecution,
+    CalculateCommonNodeMoveRestrictionsExecution,
+    CalculateNodeMoveRestrictionsExecution,
     PutInputConnectionHandlersToArrayExecution,
     PutOutputConnectionHandlersToArrayExecution,
     CreateMoveNodesDragModelFromSelectionExecution,
 ];
 
-class NodeDragToParentFinalizeRequest {
-    event;
-    constructor(event) {
-        this.event = event;
-    }
+class LineAlignmentPreparationRequest {
 }
 
-class NodeDragToParentDragHandler {
-    fComponentsStore;
-    fDraggableDataContext;
-    notDraggedNodesRects;
-    DEBOUNCE_TIME = 15;
-    get _transform() {
-        return this.fComponentsStore.fCanvas.transform;
-    }
-    _onPointerDownPosition = PointExtensions.initialize();
+class LineAlignmentDragHandler {
+    _fComponentsStore;
+    _lineService;
+    _size;
+    _draggedNodeRect;
+    _rects;
+    _restrictions;
     _debounceTimer = null;
-    fNodeWithRect = null;
-    constructor(fComponentsStore, fDraggableDataContext, notDraggedNodesRects) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.notDraggedNodesRects = notDraggedNodesRects;
-        this._onPointerDownPosition = this.fDraggableDataContext.onPointerDownPosition;
-    }
-    _toggleParentNode(difference) {
-        const isInclude = this._isNodeInsideAnotherNode(this._getNewPosition(difference));
-        if (isInclude) {
-            this._markIncludeNode(isInclude);
-        }
-        else {
-            this._unmarkIncludeNode();
-        }
-    }
-    _getNewPosition(difference) {
-        return Point.fromPoint(this._onPointerDownPosition).add(difference).mult(this._transform.scale);
-    }
-    _isNodeInsideAnotherNode(point) {
-        return this.notDraggedNodesRects.find((x) => RectExtensions.isIncludePoint(x.rect, point));
+    _transform;
+    constructor(_fComponentsStore, _lineService, _size, _draggedNodeRect, _rects, _restrictions) {
+        this._fComponentsStore = _fComponentsStore;
+        this._lineService = _lineService;
+        this._size = _size;
+        this._draggedNodeRect = _draggedNodeRect;
+        this._rects = _rects;
+        this._restrictions = _restrictions;
+        this._transform = this._fComponentsStore.fCanvas?.transform;
     }
     onPointerMove(difference) {
+        const restrictedDifference = this._getDifference(difference);
         if (this._debounceTimer) {
             clearTimeout(this._debounceTimer);
         }
-        this._debounceTimer = setTimeout(() => this._toggleParentNode(difference), this.DEBOUNCE_TIME);
+        this._debounceTimer = setTimeout(() => this._drawIntersectingLines(restrictedDifference), 15);
     }
-    _markIncludeNode(nodeWithRect) {
-        this._unmarkIncludeNode();
-        this.fNodeWithRect = nodeWithRect;
-        nodeWithRect.node.setClass('f-parent-for-drop');
+    _drawIntersectingLines(difference) {
+        const intersect = this.findNearestCoordinate(difference);
+        if (intersect.xResult.value !== undefined) {
+            this._lineService.drawVerticalLine(intersect.xResult.value, this._size, this._transform);
+        }
+        else {
+            this._lineService.hideVerticalLine();
+        }
+        if (intersect.yResult.value !== undefined) {
+            this._lineService.drawHorizontalLine(intersect.yResult.value, this._size, this._transform);
+        }
+        else {
+            this._lineService.hideHorizontalLine();
+        }
     }
-    _unmarkIncludeNode() {
-        this.fNodeWithRect?.node.removeClass('f-parent-for-drop');
-        this.fNodeWithRect = null;
+    _getDifference(difference) {
+        return {
+            x: Math.min(Math.max(difference.x, this._restrictions.min.x), this._restrictions.max.x),
+            y: Math.min(Math.max(difference.y, this._restrictions.min.y), this._restrictions.max.y)
+        };
+    }
+    findNearestCoordinate(difference) {
+        const rect = RectExtensions.addPoint(this._draggedNodeRect, difference);
+        return findClosestAlignment(this._rects, rect, this._fComponentsStore.fLineAlignment.fAlignThreshold);
     }
     onPointerUp() {
-        this._unmarkIncludeNode();
+        this._lineService.hideVerticalLine();
+        this._lineService.hideHorizontalLine();
         if (this._debounceTimer) {
             clearTimeout(this._debounceTimer);
             this._debounceTimer = null;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentDragHandler, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: NodeDragToParentDragHandler, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentDragHandler, decorators: [{
-            type: Directive
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: undefined }] });
-
-class FDropToGroupEvent {
-    fTargetNode;
-    fNodes;
-    fDropPosition;
-    constructor(fTargetNode, fNodes, fDropPosition) {
-        this.fTargetNode = fTargetNode;
-        this.fNodes = fNodes;
-        this.fDropPosition = fDropPosition;
-    }
 }
 
-let NodeDragToParentFinalizeExecution = class NodeDragToParentFinalizeExecution {
-    fComponentsStore;
-    fDraggableDataContext;
-    constructor(fComponentsStore, fDraggableDataContext) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
-    handle(request) {
-        if (!this._isValid()) {
-            return;
-        }
-        const item = this.getDragHandleItem();
-        if (item.fNodeWithRect) {
-            this.emitDroppedChildrenEvent(item.fNodeWithRect.node.fId, request.event);
-        }
-        item.onPointerUp?.();
+class LineElement {
+    hostElement;
+    element;
+    constructor(fBrowser, hostElement) {
+        this.hostElement = hostElement;
+        this.element = fBrowser.document.createElement('div');
+        this.hostElement.appendChild(this.element);
+        this.element.classList.add('f-line');
     }
-    _isValid() {
-        return this.fDraggableDataContext.draggableItems
-            .some((x) => x instanceof NodeDragToParentDragHandler);
+    hide() {
+        this.element.style.display = 'none';
     }
-    emitDroppedChildrenEvent(fTargetId, event) {
-        this.fComponentsStore.fDraggable?.fDropToGroup.emit(new FDropToGroupEvent(fTargetId, this.getDraggedNodeIds(), event.getPosition()));
+    show() {
+        this.element.style.display = 'block';
     }
-    getDragHandleItem() {
-        const result = this.findDragHandleItem();
-        if (!result) {
-            throw new Error('NodeDragToParentDragHandler not found');
-        }
-        return result;
+    draw(object) {
+        this.element.style.position = 'absolute';
+        Object.keys(object).forEach((key) => {
+            // @ts-ignore
+            this.element.style[key] = object[key] + 'px';
+        });
     }
-    findDragHandleItem() {
-        return this.fDraggableDataContext.draggableItems
-            .find((x) => x instanceof NodeDragToParentDragHandler);
+}
+
+class LineService {
+    hostElement;
+    fHorizontalLine;
+    fVerticalLine;
+    constructor(fBrowser, hostElement) {
+        this.hostElement = hostElement;
+        this.fHorizontalLine = new LineElement(fBrowser, this.hostElement);
+        this.fVerticalLine = new LineElement(fBrowser, this.hostElement);
+        this.fHorizontalLine.hide();
+        this.fVerticalLine.hide();
+    }
+    drawVerticalLine(x, size, transform) {
+        this.fVerticalLine.show();
+        this.fVerticalLine.draw({
+            left: x * transform.scale + transform.position.x + transform.scaledPosition.x,
+            top: 0,
+            width: 1,
+            height: size.height
+        });
+    }
+    drawHorizontalLine(y, size, transform) {
+        this.fHorizontalLine.show();
+        this.fHorizontalLine.draw({
+            left: 0,
+            top: y * transform.scale + transform.position.y + transform.scaledPosition.y,
+            width: size.width,
+            height: 1
+        });
+    }
+    hideVerticalLine() {
+        this.fVerticalLine.hide();
+    }
+    hideHorizontalLine() {
+        this.fHorizontalLine.hide();
+    }
+}
+
+const F_LINE_ALIGNMENT = new InjectionToken('F_LINE_ALIGNMENT');
+class FLineAlignmentBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: FLineAlignmentBase, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentBase, decorators: [{
+            type: Directive
+        }] });
+
+class FLineAlignmentComponent extends FLineAlignmentBase {
+    fAlignThreshold = 10;
+    _fMediator = inject(FMediator);
+    _elementReference = inject(ElementRef);
+    get hostElement() {
+        return this._elementReference.nativeElement;
+    }
+    ngOnInit() {
+        this._fMediator.execute(new AddLineAlignmentToStoreRequest(this));
+    }
+    ngOnDestroy() {
+        this._fMediator.execute(new RemoveLineAlignmentFromStoreRequest());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FLineAlignmentComponent, selector: "f-line-alignment", inputs: { fAlignThreshold: "fAlignThreshold" }, host: { classAttribute: "f-line-alignment f-component" }, providers: [
+            { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }
+        ], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0, template: "", isInline: true, styles: [":host{display:block;position:absolute;left:0;top:0;width:100%;height:100%;overflow:hidden;pointer-events:none;-webkit-user-select:none;user-select:none}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "f-line-alignment", template: "", exportAs: "fComponent", host: {
+                        'class': 'f-line-alignment f-component'
+                    }, providers: [
+                        { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }
+                    ], styles: [":host{display:block;position:absolute;left:0;top:0;width:100%;height:100%;overflow:hidden;pointer-events:none;-webkit-user-select:none;user-select:none}\n"] }]
+        }], propDecorators: { fAlignThreshold: [{
+                type: Input
+            }] } });
+
+const F_LINE_ALIGNMENT_PROVIDERS = [
+    FLineAlignmentComponent
+];
+
+let LineAlignmentPreparationExecution = class LineAlignmentPreparationExecution {
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
+    _fBrowser = inject(BrowserService);
+    _lineService;
+    handle(request) {
+        this._addLineAlignmentDragHandler(this._getDraggedNodes());
+    }
+    _getDraggedNodes() {
+        return this._fDraggableDataContext.draggableItems
+            .filter((x) => x instanceof NodeDragHandler)
+            .map((x) => x.fNode);
+    }
+    _addLineAlignmentDragHandler(fNodes) {
+        this._fDraggableDataContext.draggableItems.push(new LineAlignmentDragHandler(this._fComponentsStore, this._lineService || this._createLineService(), this._getFlowHostSize(), this._getDraggedNodesBoundingRect(fNodes), this._getStaticNodeRects(fNodes), this._getCommonRestrictions()));
+    }
+    _getFlowHostSize() {
+        return this._fMediator.send(new GetFlowHostElementRequest())
+            .getBoundingClientRect();
+    }
+    _createLineService() {
+        this._lineService = new LineService(this._fBrowser, this._fComponentsStore.fLineAlignment.hostElement);
+        return this._lineService;
+    }
+    _getDraggedNodesBoundingRect(fNodes) {
+        return RectExtensions.union(fNodes.map((x) => {
+            return this._fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false));
+        })) || RectExtensions.initialize();
+    }
+    _getStaticNodeRects(fNodes) {
+        return this._getStaticNodes(fNodes).map((x) => {
+            return this._fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false));
+        });
+    }
+    _getStaticNodes(fNodes) {
+        return this._fComponentsStore.fNodes
+            .filter((x) => !fNodes.includes(x));
+    }
+    _getCommonRestrictions() {
+        return this._fDraggableDataContext.draggableItems
+            .filter((x) => x instanceof NodeDragHandler)[0].restrictions;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: LineAlignmentPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: LineAlignmentPreparationExecution });
+};
+LineAlignmentPreparationExecution = __decorate([
+    FExecutionRegister(LineAlignmentPreparationRequest)
+], LineAlignmentPreparationExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: LineAlignmentPreparationExecution, decorators: [{
+            type: Injectable
+        }] });
+
+class NodeDragToParentFinalizeRequest {
+    event;
+    constructor(event) {
+        this.event = event;
+    }
+}
+
+class NodeDragToParentDragHandler {
+    fComponentsStore;
+    fDraggableDataContext;
+    notDraggedNodesRects;
+    DEBOUNCE_TIME = 15;
+    get _transform() {
+        return this.fComponentsStore.fCanvas.transform;
+    }
+    _onPointerDownPosition = PointExtensions.initialize();
+    _debounceTimer = null;
+    fNodeWithRect = null;
+    constructor(fComponentsStore, fDraggableDataContext, notDraggedNodesRects) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.notDraggedNodesRects = notDraggedNodesRects;
+        this._onPointerDownPosition = this.fDraggableDataContext.onPointerDownPosition;
+    }
+    _toggleParentNode(difference) {
+        const isInclude = this._isNodeInsideAnotherNode(this._getNewPosition(difference));
+        if (isInclude) {
+            this._markIncludeNode(isInclude);
+        }
+        else {
+            this._unmarkIncludeNode();
+        }
+    }
+    _getNewPosition(difference) {
+        return Point.fromPoint(this._onPointerDownPosition).add(difference).mult(this._transform.scale);
+    }
+    _isNodeInsideAnotherNode(point) {
+        return this.notDraggedNodesRects.find((x) => RectExtensions.isIncludePoint(x.rect, point));
+    }
+    onPointerMove(difference) {
+        if (this._debounceTimer) {
+            clearTimeout(this._debounceTimer);
+        }
+        this._debounceTimer = setTimeout(() => this._toggleParentNode(difference), this.DEBOUNCE_TIME);
+    }
+    _markIncludeNode(nodeWithRect) {
+        this._unmarkIncludeNode();
+        this.fNodeWithRect = nodeWithRect;
+        nodeWithRect.node.setClass('f-parent-for-drop');
+    }
+    _unmarkIncludeNode() {
+        this.fNodeWithRect?.node.removeClass('f-parent-for-drop');
+        this.fNodeWithRect = null;
+    }
+    onPointerUp() {
+        this._unmarkIncludeNode();
+        if (this._debounceTimer) {
+            clearTimeout(this._debounceTimer);
+            this._debounceTimer = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentDragHandler, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: NodeDragToParentDragHandler, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentDragHandler, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: undefined }] });
+
+class FDropToGroupEvent {
+    fTargetNode;
+    fNodes;
+    fDropPosition;
+    constructor(fTargetNode, fNodes, fDropPosition) {
+        this.fTargetNode = fTargetNode;
+        this.fNodes = fNodes;
+        this.fDropPosition = fDropPosition;
+    }
+}
+
+let NodeDragToParentFinalizeExecution = class NodeDragToParentFinalizeExecution {
+    fComponentsStore;
+    fDraggableDataContext;
+    constructor(fComponentsStore, fDraggableDataContext) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(request) {
+        if (!this._isValid()) {
+            return;
+        }
+        const item = this.getDragHandleItem();
+        if (item.fNodeWithRect) {
+            this.emitDroppedChildrenEvent(item.fNodeWithRect.node.fId, request.event);
+        }
+        item.onPointerUp?.();
+    }
+    _isValid() {
+        return this.fDraggableDataContext.draggableItems
+            .some((x) => x instanceof NodeDragToParentDragHandler);
+    }
+    emitDroppedChildrenEvent(fTargetId, event) {
+        this.fComponentsStore.fDraggable?.fDropToGroup.emit(new FDropToGroupEvent(fTargetId, this.getDraggedNodeIds(), event.getPosition()));
+    }
+    getDragHandleItem() {
+        const result = this.findDragHandleItem();
+        if (!result) {
+            throw new Error('NodeDragToParentDragHandler not found');
+        }
+        return result;
+    }
+    findDragHandleItem() {
+        return this.fDraggableDataContext.draggableItems
+            .find((x) => x instanceof NodeDragToParentDragHandler);
     }
     getDraggedNodeIds() {
         return this.fDraggableDataContext.draggableItems
@@ -5184,27 +5420,38 @@ let NodeMovePreparationExecution = class NodeMovePreparationExecution {
     get _fHost() {
         return this._fComponentsStore.fFlow.hostElement;
     }
+    _fNode;
     handle(request) {
-        const itemsToDrag = this._calculateDraggableItems(this._getNode(request.event.targetElement));
-        this._initializeLineAlignment(itemsToDrag);
+        if (!this._isValid(request)) {
+            return;
+        }
         this._fDraggableDataContext.onPointerDownScale = this._transform.scale;
         this._fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
             .elementTransform(this._fHost).div(this._transform.scale);
-        this._fDraggableDataContext.draggableItems = itemsToDrag;
-    }
-    _getNode(targetElement) {
-        const result = this._fComponentsStore.fNodes.find(n => n.isContains(targetElement));
-        if (!result) {
-            throw new Error('Node not found');
+        this._fDraggableDataContext.draggableItems = this._calculateDraggedItems(this._fNode);
+        if (this._fComponentsStore.fLineAlignment) {
+            this._fMediator.execute(new LineAlignmentPreparationRequest());
         }
-        return result;
+    }
+    _isValid(request) {
+        return this._fDraggableDataContext.isEmpty()
+            && this._isDragHandleElement(request.event.targetElement)
+            && !!this._getNode(request.event.targetElement);
+    }
+    _isDragHandleElement(element) {
+        return isClosestElementHasClass(element, '.f-drag-handle');
+    }
+    _getNode(element) {
+        this._fNode = this._fComponentsStore.fNodes
+            .find(x => x.isContains(element) && !x.fDraggingDisabled);
+        return this._fNode;
     }
     //We drag nodes from selection model
-    _calculateDraggableItems(fNode) {
+    _calculateDraggedItems(fNode) {
         let result = [];
         if (!fNode.fSelectionDisabled) {
             // Need to select node before drag
-            this._fMediator.send(new SelectAndUpdateNodeLayerRequest(fNode));
+            this._fMediator.execute(new SelectAndUpdateNodeLayerRequest(fNode));
             result = this._dragModelFromSelection();
         }
         else {
@@ -5214,14 +5461,7 @@ let NodeMovePreparationExecution = class NodeMovePreparationExecution {
         return result;
     }
     _dragModelFromSelection(nodeWithDisabledSelection) {
-        return this._fMediator.send(new CreateMoveNodesDragModelFromSelectionRequest(nodeWithDisabledSelection));
-    }
-    _initializeLineAlignment(itemsToDrag) {
-        this._fDraggableDataContext.fLineAlignment?.initialize(this._fComponentsStore.fNodes, this._filterNodesFromDraggableItems(itemsToDrag));
-    }
-    _filterNodesFromDraggableItems(items) {
-        return items.filter((x) => x instanceof NodeDragHandler)
-            .map(x => x.fNode);
+        return this._fMediator.execute(new CreateMoveNodesDragModelFromSelectionRequest(nodeWithDisabledSelection));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMovePreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMovePreparationExecution });
@@ -5233,39 +5473,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }] });
 
-let NodeMovePreparationValidator = class NodeMovePreparationValidator {
-    _fComponentsStore = inject(FComponentsStore);
-    _fDraggableDataContext = inject(FDraggableDataContext);
-    handle(request) {
-        return this._isDragHandlesEmpty()
-            && this._isDragHandleElement(request.event.targetElement)
-            && this._isNodeCanBeDragged(this._getNode(request.event.targetElement));
-    }
-    _isDragHandlesEmpty() {
-        return !this._fDraggableDataContext.draggableItems.length;
-    }
-    _isDragHandleElement(element) {
-        return isClosestElementHasClass(element, '.f-drag-handle');
-    }
-    _isNodeCanBeDragged(fNode) {
-        return !!fNode && !fNode.fDraggingDisabled;
-    }
-    _getNode(element) {
-        return this._fComponentsStore.fNodes.find(x => x.isContains(element));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMovePreparationValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMovePreparationValidator });
-};
-NodeMovePreparationValidator = __decorate([
-    FValidatorRegister(NodeMovePreparationRequest)
-], NodeMovePreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMovePreparationValidator, decorators: [{
-            type: Injectable
-        }] });
-
 const NODE_MOVE_PREPARATION_PROVIDERS = [
     NodeMovePreparationExecution,
-    NodeMovePreparationValidator,
 ];
 
 class NodeMoveFinalizeRequest {
@@ -5291,7 +5500,6 @@ let NodeMoveFinalizeExecution = class NodeMoveFinalizeExecution {
             .find((x) => x instanceof NodeDragHandler);
         const differenceWithCellSize = firstNodeOrGroup.getDifferenceWithCellSize(difference);
         this._finalizeMove(differenceWithCellSize);
-        this._fDraggableDataContext.fLineAlignment?.complete();
         this._applyConnectionUnderDroppedNode();
     }
     _isValid() {
@@ -5316,7 +5524,9 @@ let NodeMoveFinalizeExecution = class NodeMoveFinalizeExecution {
         return this._applyLineAlignmentDifference(difference, this._getLineAlignmentDifference(difference));
     }
     _getLineAlignmentDifference(difference) {
-        return this._fDraggableDataContext.fLineAlignment?.findNearestCoordinate(difference);
+        return this._fDraggableDataContext.draggableItems
+            .find((x) => x instanceof LineAlignmentDragHandler)
+            ?.findNearestCoordinate(difference);
     }
     _applyLineAlignmentDifference(difference, intersection) {
         if (intersection) {
@@ -5344,6 +5554,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
 
 const NODE_PROVIDERS = [
     ...CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS,
+    LineAlignmentPreparationExecution,
     NodeMoveFinalizeExecution,
     ...NODE_MOVE_PREPARATION_PROVIDERS,
     ...NODE_DRAG_TO_PARENT_PREPARATION_PROVIDERS,
@@ -7638,23 +7849,21 @@ class GetFlowStateConnectionsRequest {
 }
 
 let GetFlowStateConnectionsExecution = class GetFlowStateConnectionsExecution {
-    fComponentsStore;
-    constructor(fComponentsStore) {
-        this.fComponentsStore = fComponentsStore;
-    }
+    _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        return this.fComponentsStore.fConnections.map((x) => {
-            return {
-                id: x.fId,
-                fOutputId: x.fOutputId,
-                fInputId: x.fInputId,
-                fType: x.fType,
-                fBehavior: x.fBehavior,
-                isSelected: x.isSelected()
-            };
-        });
+        return this._fComponentsStore.fConnections.map(this._mapToConnectionState);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateConnectionsExecution, deps: [{ token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable });
+    _mapToConnectionState(x) {
+        return {
+            id: x.fId,
+            fOutputId: x.fOutputId,
+            fInputId: x.fInputId,
+            fType: x.fType,
+            fBehavior: x.fBehavior,
+            isSelected: x.isSelected()
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateConnectionsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateConnectionsExecution });
 };
 GetFlowStateConnectionsExecution = __decorate([
@@ -7662,7 +7871,7 @@ GetFlowStateConnectionsExecution = __decorate([
 ], GetFlowStateConnectionsExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateConnectionsExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }] });
+        }] });
 
 class GetFlowStateNodesRequest {
     type;
@@ -7683,13 +7892,13 @@ let GetFlowStateNodesExecution = class GetFlowStateNodesExecution {
                 parent: x.fParentId,
                 position: x.position,
                 size: x.size,
-                fOutputs: this.getOutputs(x.hostElement),
-                fInputs: this.getInputs(x.hostElement),
+                fOutputs: this._getOutputs(x.hostElement),
+                fInputs: this._getInputs(x.hostElement),
                 isSelected: x.isSelected()
             };
         });
     }
-    getOutputs(hostElement) {
+    _getOutputs(hostElement) {
         return this.fComponentsStore.fOutputs.filter((x) => hostElement.contains(x.hostElement)).map((x) => {
             return {
                 id: x.fId,
@@ -7697,7 +7906,7 @@ let GetFlowStateNodesExecution = class GetFlowStateNodesExecution {
             };
         });
     }
-    getInputs(hostElement) {
+    _getInputs(hostElement) {
         return this.fComponentsStore.fInputs.filter((x) => hostElement.contains(x.hostElement)).map((x) => {
             return {
                 id: x.fId,
@@ -7719,25 +7928,21 @@ class GetFlowStateRequest {
 }
 
 let GetFlowStateExecution = class GetFlowStateExecution {
-    fComponentsStore;
-    fMediator;
-    constructor(fComponentsStore, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fMediator = fMediator;
-    }
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
     handle(payload) {
         return {
-            position: this.getCanvasPosition(this.fComponentsStore.fCanvas.transform),
-            scale: this.fComponentsStore.fCanvas.transform.scale,
-            nodes: this.fMediator.send(new GetFlowStateNodesRequest(FNodeDirective)),
-            groups: this.fMediator.send(new GetFlowStateNodesRequest(FGroupDirective)),
-            connections: this.fMediator.send(new GetFlowStateConnectionsRequest())
+            position: this._getCanvasPosition(this._fComponentsStore.fCanvas.transform),
+            scale: this._fComponentsStore.fCanvas.transform.scale,
+            nodes: this._fMediator.send(new GetFlowStateNodesRequest(FNodeDirective)),
+            groups: this._fMediator.send(new GetFlowStateNodesRequest(FGroupDirective)),
+            connections: this._fMediator.send(new GetFlowStateConnectionsRequest())
         };
     }
-    getCanvasPosition(transform) {
+    _getCanvasPosition(transform) {
         return PointExtensions.sum(transform.position, transform.scaledPosition);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateExecution, deps: [{ token: FComponentsStore }, { token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateExecution });
 };
 GetFlowStateExecution = __decorate([
@@ -7745,7 +7950,7 @@ GetFlowStateExecution = __decorate([
 ], GetFlowStateExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetFlowStateExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2.FMediator }] });
+        }] });
 
 const GET_FLOW_STATE_PROVIDERS = [
     GetFlowStateExecution,
@@ -7789,7 +7994,7 @@ class AddLineAlignmentToStoreRequest {
 let AddLineAlignmentToStoreExecution = class AddLineAlignmentToStoreExecution {
     _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        //this._fComponentsStore.fFlow = request.fComponent;
+        this._fComponentsStore.fLineAlignment = request.fComponent;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: AddLineAlignmentToStoreExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: AddLineAlignmentToStoreExecution });
@@ -7807,7 +8012,7 @@ class RemoveLineAlignmentFromStoreRequest {
 let RemoveLineAlignmentFromStoreExecution = class RemoveLineAlignmentFromStoreExecution {
     _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        this._fComponentsStore.fFlow = undefined;
+        this._fComponentsStore.fLineAlignment = undefined;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: RemoveLineAlignmentFromStoreExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: RemoveLineAlignmentFromStoreExecution });
@@ -7873,15 +8078,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
         }] });
 
 class CalculateNodesBoundingBoxNormalizedPositionRequest {
+    fNodes;
+    constructor(fNodes) {
+        this.fNodes = fNodes;
+    }
 }
 
 let CalculateNodesBoundingBoxNormalizedPositionExecution = class CalculateNodesBoundingBoxNormalizedPositionExecution {
     _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        return RectExtensions.union(this._getNodesRects());
+        return RectExtensions.union(this._getNodesRects(request.fNodes || this._fComponentsStore.fNodes));
     }
-    _getNodesRects() {
-        return this._fComponentsStore.fNodes.map((x) => {
+    _getNodesRects(fNodes) {
+        return fNodes.map((x) => {
             return this._getElementRect(x, RectExtensions.fromElement(x.hostElement));
         });
     }
@@ -7952,6 +8161,40 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }] });
 
+class GetParentNodesRequest {
+    fNode;
+    constructor(fNode) {
+        this.fNode = fNode;
+    }
+}
+
+let GetParentNodesExecution = class GetParentNodesExecution {
+    _fComponentsStore = inject(FComponentsStore);
+    handle(request) {
+        return this._getParentNodes(request.fNode, new Set(), []);
+    }
+    _getParentNodes(fNode, visited, result) {
+        if (visited.has(fNode.fId)) {
+            throw new Error('Circular reference detected in the node hierarchy. Node id: ' + fNode.fId);
+        }
+        visited.add(fNode.fId);
+        const parent = this._fComponentsStore.fNodes.find((x) => x.fId === fNode.fParentId);
+        if (!parent) {
+            return result;
+        }
+        result.push(parent);
+        return this._getParentNodes(parent, visited, result);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetParentNodesExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetParentNodesExecution });
+};
+GetParentNodesExecution = __decorate([
+    FExecutionRegister(GetParentNodesRequest)
+], GetParentNodesExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetParentNodesExecution, decorators: [{
+            type: Injectable
+        }] });
+
 class UpdateNodeWhenStateOrSizeChangedRequest {
     fComponent;
     destroyRef;
@@ -8195,6 +8438,22 @@ function isMobile() {
     return /android|iPad|iPhone|iPod/i.test(navigator.userAgent || navigator.vendor || window['opera']);
 }
 
+function LogExecutionTime(label) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            console.time(label || String(propertyKey));
+            const result = originalMethod.apply(this, args);
+            if (result instanceof Promise) {
+                return result.finally(() => console.timeEnd(label || String(propertyKey)));
+            }
+            console.timeEnd(label || String(propertyKey));
+            return result;
+        };
+        return descriptor;
+    };
+}
+
 const COMMON_PROVIDERS = [
     ...F_CANVAS_FEATURES,
     ...F_CONNECTION_FEATURES,
@@ -8570,171 +8829,6 @@ const F_CANVAS_PROVIDERS = [
     FCanvasComponent,
 ];
 
-class LineElement {
-    hostElement;
-    element;
-    constructor(fBrowser, hostElement) {
-        this.hostElement = hostElement;
-        this.element = fBrowser.document.createElement('div');
-        this.hostElement.appendChild(this.element);
-        this.element.classList.add('f-line');
-    }
-    hide() {
-        this.element.style.display = 'none';
-    }
-    show() {
-        this.element.style.display = 'block';
-    }
-    draw(object) {
-        this.element.style.position = 'absolute';
-        Object.keys(object).forEach((key) => {
-            // @ts-ignore
-            this.element.style[key] = object[key] + 'px';
-        });
-    }
-}
-
-class LineService {
-    hostElement;
-    fHorizontalLine;
-    fVerticalLine;
-    constructor(fBrowser, hostElement) {
-        this.hostElement = hostElement;
-        this.fHorizontalLine = new LineElement(fBrowser, this.hostElement);
-        this.fVerticalLine = new LineElement(fBrowser, this.hostElement);
-        this.fHorizontalLine.hide();
-        this.fVerticalLine.hide();
-    }
-    drawVerticalLine(x, size, transform) {
-        this.fVerticalLine.show();
-        this.fVerticalLine.draw({
-            left: x * transform.scale + transform.position.x + transform.scaledPosition.x,
-            top: 0,
-            width: 1,
-            height: size.height
-        });
-    }
-    drawHorizontalLine(y, size, transform) {
-        this.fHorizontalLine.show();
-        this.fHorizontalLine.draw({
-            left: 0,
-            top: y * transform.scale + transform.position.y + transform.scaledPosition.y,
-            width: size.width,
-            height: 1
-        });
-    }
-    hideVerticalLine() {
-        this.fVerticalLine.hide();
-    }
-    hideHorizontalLine() {
-        this.fHorizontalLine.hide();
-    }
-}
-
-const F_LINE_ALIGNMENT = new InjectionToken('F_LINE_ALIGNMENT');
-class FLineAlignmentBase {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: FLineAlignmentBase, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentBase, decorators: [{
-            type: Directive
-        }] });
-
-class FLineAlignmentComponent extends FLineAlignmentBase {
-    elementReference;
-    fDraggableDataContext;
-    DEBOUNCE_TIME = 10;
-    fAlignThreshold = 10;
-    get hostElement() {
-        return this.elementReference.nativeElement;
-    }
-    lineService;
-    size = SizeExtensions.initialize();
-    draggedNodeRect = RectExtensions.initialize();
-    rects = [];
-    _fMediator = inject(FMediator);
-    _fCanvas;
-    _debounceTimer = null;
-    get _transform() {
-        return this._fCanvas.transform;
-    }
-    constructor(elementReference, fDraggableDataContext, fBrowser) {
-        super();
-        this.elementReference = elementReference;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.lineService = new LineService(fBrowser, this.hostElement);
-    }
-    ngAfterViewInit() {
-        this._fCanvas = this._fMediator.send(new GetCanvasRequest());
-        this.fDraggableDataContext.fLineAlignment = this;
-    }
-    initialize(allNodes, currentNodes) {
-        this.size = this._fMediator.send(new GetFlowHostElementRequest()).getBoundingClientRect();
-        this.rects = [];
-        const draggedNodeRects = currentNodes.map((x) => {
-            return this._fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false));
-        });
-        this.draggedNodeRect = RectExtensions.union(draggedNodeRects) || RectExtensions.initialize();
-        const allNodesExcludeCurrents = allNodes.filter((x) => {
-            return !currentNodes.includes(x);
-        });
-        this.rects = allNodesExcludeCurrents.map((x) => {
-            return this._fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false));
-        });
-    }
-    handle(difference) {
-        if (this._debounceTimer) {
-            clearTimeout(this._debounceTimer);
-        }
-        this._debounceTimer = setTimeout(() => this.drawIntersectingLines(difference), this.DEBOUNCE_TIME);
-    }
-    drawIntersectingLines(difference) {
-        const intersect = this.findNearestCoordinate(difference);
-        if (intersect.xResult.value !== undefined) {
-            this.lineService.drawVerticalLine(intersect.xResult.value, this.size, this._transform);
-        }
-        else {
-            this.lineService.hideVerticalLine();
-        }
-        if (intersect.yResult.value !== undefined) {
-            this.lineService.drawHorizontalLine(intersect.yResult.value, this.size, this._transform);
-        }
-        else {
-            this.lineService.hideHorizontalLine();
-        }
-    }
-    findNearestCoordinate(difference) {
-        const rect = RectExtensions.addPoint(this.draggedNodeRect, difference);
-        return findClosestAlignment(this.rects, rect, this.fAlignThreshold);
-    }
-    complete() {
-        this.lineService.hideVerticalLine();
-        this.lineService.hideHorizontalLine();
-        if (this._debounceTimer) {
-            clearTimeout(this._debounceTimer);
-            this._debounceTimer = null;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentComponent, deps: [{ token: i0.ElementRef }, { token: FDraggableDataContext }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FLineAlignmentComponent, selector: "f-line-alignment", inputs: { fAlignThreshold: "fAlignThreshold" }, host: { classAttribute: "f-line-alignment f-component" }, providers: [
-            { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }
-        ], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0, template: "", isInline: true, styles: [":host{display:block;position:absolute;left:0;top:0;width:100%;height:100%;overflow:hidden;pointer-events:none;-webkit-user-select:none;user-select:none}\n"] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FLineAlignmentComponent, decorators: [{
-            type: Component,
-            args: [{ selector: "f-line-alignment", template: "", exportAs: "fComponent", host: {
-                        'class': 'f-line-alignment f-component'
-                    }, providers: [
-                        { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }
-                    ], styles: [":host{display:block;position:absolute;left:0;top:0;width:100%;height:100%;overflow:hidden;pointer-events:none;-webkit-user-select:none;user-select:none}\n"] }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: FDraggableDataContext }, { type: i1.BrowserService }], propDecorators: { fAlignThreshold: [{
-                type: Input
-            }] } });
-
-const F_LINE_ALIGNMENT_PROVIDERS = [
-    FLineAlignmentComponent
-];
-
 class FMinimapData {
     element;
     scale;
@@ -9187,5 +9281,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AddBackgroundToStoreExecution, AddBackgroundToStoreRequest, AddCanvasToStoreExecution, AddCanvasToStoreRequest, AddConnectionForCreateToStoreExecution, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStoreExecution, AddConnectionMarkerToStoreRequest, AddConnectionToStoreExecution, AddConnectionToStoreRequest, AddDndToStoreExecution, AddDndToStoreRequest, AddFlowToStoreExecution, AddFlowToStoreRequest, AddInputToStoreExecution, AddInputToStoreRequest, AddLineAlignmentToStoreExecution, AddLineAlignmentToStoreRequest, AddNodeToStoreExecution, AddNodeToStoreRequest, AddOutletToStoreExecution, AddOutletToStoreRequest, AddOutputToStoreExecution, AddOutputToStoreRequest, AddPatternToBackgroundExecution, AddPatternToBackgroundRequest, AddSnapConnectionToStoreExecution, AddSnapConnectionToStoreRequest, ApplyChildResizeRestrictionsExecution, ApplyChildResizeRestrictionsRequest, ApplyParentResizeRestrictionsExecution, ApplyParentResizeRestrictionsRequest, CANVAS_MOVE_FINALIZE_PROVIDERS, CANVAS_MOVE_PREPARATION_PROVIDERS, CANVAS_PROVIDERS, COMMON_PROVIDERS, CONNECTIONS_PROVIDERS, CONNECTION_GRADIENT, CONNECTION_PATH, CONNECTION_TEXT, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateCenterBetweenPointsHandler, CalculateCenterBetweenPointsRequest, CalculateChangedPositionExecution, CalculateChangedPositionRequest, CalculateChangedSizeExecution, CalculateChangedSizeRequest, CalculateConnectionCenterHandler, CalculateConnectionCenterRequest, CalculateConnectionLineByBehaviorExecution, CalculateConnectionLineByBehaviorRequest, CalculateConnectorConnectableSideHandler, CalculateConnectorConnectableSideRequest, CalculateFlowPointFromMinimapPointExecution, CalculateFlowPointFromMinimapPointRequest, CalculateNodesBoundingBoxExecution, CalculateNodesBoundingBoxNormalizedPositionExecution, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CanvasDragHandler, CanvasMoveFinalizeExecution, CanvasMoveFinalizeRequest, CanvasMovePreparationExecution, CanvasMovePreparationRequest, CanvasMovePreparationValidator, CenterGroupOrNodeExecution, CenterGroupOrNodeRequest, ClearSelectionExecution, ClearSelectionRequest, ConnectionBaseDragHandler, ConnectionDragHandler, ConnectionSourceDragHandler, ConnectionTargetDragHandler, CreateConnectionDragHandler, CreateConnectionDragHandlerExecution, CreateConnectionDragHandlerRequest, CreateConnectionFinalizeExecution, CreateConnectionFinalizeRequest, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparationExecution, CreateConnectionFromOutputPreparationRequest, CreateConnectionFromOutputPreparationValidator, CreateConnectionMarkersExecution, CreateConnectionMarkersRequest, CreateConnectionPreparationExecution, CreateConnectionPreparationRequest, CreateMoveNodesDragModelFromSelectionExecution, CreateMoveNodesDragModelFromSelectionRequest, DRAG_AND_DROP_COMMON_PROVIDERS, EFConnectableSide, EFConnectionBehavior, EFConnectionType, EFMarkerType, EFResizeHandleType, EXTERNAL_ITEM_FINALIZE_PROVIDERS, EXTERNAL_ITEM_PREPARATION_PROVIDERS, EmitSelectionChangeEventExecution, EmitSelectionChangeEventRequest, EndDragSequenceExecution, EndDragSequenceRequest, ExternalItemDragHandler, ExternalItemFinalizeExecution, ExternalItemFinalizeRequest, ExternalItemPreparationExecution, ExternalItemPreparationRequest, ExternalItemPreparationValidator, FBackgroundBase, FBackgroundComponent, FBezierPathBuilder, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FComponentsStore, FConnectionBase, FConnectionCenterDirective, FConnectionComponent, FConnectionDragHandleComponent, FConnectionFactory, FConnectionForCreateComponent, FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective, FConnectorBase, FCreateConnectionEvent, FCreateNodeEvent, FDragHandleDirective, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItemBase, FExternalItemDirective, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FGroupDirective, FLineAlignmentBase, FLineAlignmentComponent, FMarkerBase, FMarkerDirective, FMinimapCanvasDirective, FMinimapComponent, FMinimapData, FMinimapDragHandler, FMinimapFlowDirective, FMinimapViewDirective, FNodeBase, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FReassignConnectionEvent, FRectPatternComponent, FResizeChannel, FResizeHandleDirective, FRotateHandleDirective, FSegmentPathBuilder, FSelectionAreaBase, FSelectionAreaComponent, FSelectionChangeEvent, FSnapConnectionComponent, FStraightPathBuilder, FZoomBase, FZoomDirective, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CANVAS, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_DRAG_HANDLE_CLASS, F_CONNECTION_FEATURES, F_CONNECTION_IDENTIFIERS, F_CONNECTION_PROVIDERS, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_DRAG_AND_DROP_PLUGIN, F_DRAG_HANDLE, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_LINE_ALIGNMENT, F_LINE_ALIGNMENT_FEATURES, F_LINE_ALIGNMENT_PROVIDERS, F_MARKER, F_MINIMAP_DRAG_AND_DROP_PROVIDERS, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_RESIZE_HANDLE, F_SELECTED_CLASS, F_SELECTION_AREA_DRAG_AND_DROP_PROVIDERS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_ZOOM, F_ZOOM_PROVIDERS, FindClosestInputExecution, FindClosestInputRequest, FitToFlowExecution, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetAllCanBeConnectedInputPositionsExecution, GetAllCanBeConnectedInputPositionsRequest, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletRequest, GetCanBeConnectedOutputByOutletValidator, GetCanBeSelectedItemsExecution, GetCanBeSelectedItemsRequest, GetCanvasExecution, GetCanvasRequest, GetConnectorWithRectExecution, GetConnectorWithRectRequest, GetCurrentSelectionExecution, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroupsExecution, GetDeepChildrenNodesAndGroupsRequest, GetElementRoundedRectExecution, GetElementRoundedRectRequest, GetFlowExecution, GetFlowHostElementExecution, GetFlowHostElementRequest, GetFlowRequest, GetFlowStateConnectionsExecution, GetFlowStateConnectionsRequest, GetFlowStateExecution, GetFlowStateNodesExecution, GetFlowStateNodesRequest, GetFlowStateRequest, GetInputUnderPointerExecution, GetInputUnderPointerRequest, GetInputUnderPointerValidator, GetNodeMoveRestrictionsExecution, GetNodeMoveRestrictionsRequest, GetNodePaddingExecution, GetNodePaddingRequest, GetNodeResizeRestrictionsExecution, GetNodeResizeRestrictionsRequest, GetNodesExecution, GetNodesRequest, GetNormalizedChildrenNodesRectExecution, GetNormalizedChildrenNodesRectRequest, GetNormalizedElementRectExecution, GetNormalizedElementRectRequest, GetNormalizedParentNodeRectExecution, GetNormalizedParentNodeRectRequest, GetNormalizedPointExecution, GetNormalizedPointRequest, GetParentNodesExecution, GetParentNodesRequest, InitializeDragSequenceExecution, InitializeDragSequenceRequest, InputCanvasPositionExecution, InputCanvasPositionRequest, InputCanvasScaleExecution, InputCanvasScaleRequest, IsArrayHasParentNodeExecution, IsArrayHasParentNodeRequest, IsConnectionUnderNodeExecution, IsConnectionUnderNodeRequest, IsDragStartedExecution, IsDragStartedRequest, LineElement, LineService, ListenCountChangesExecution, ListenCountChangesRequest, ListenDataChangesExecution, ListenDataChangesRequest, ListenTransformChangesExecution, ListenTransformChangesRequest, MINIMAP_DRAG_FINALIZE_PROVIDERS, MINIMAP_DRAG_PREPARATION_PROVIDERS, MinimapCalculateSvgScaleAndViewBoxExecution, MinimapCalculateSvgScaleAndViewBoxRequest, MinimapCalculateViewBoxExecution, MinimapCalculateViewBoxRequest, MinimapDragFinalizeExecution, MinimapDragFinalizeRequest, MinimapDragFinalizeValidator, MinimapDragPreparationExecution, MinimapDragPreparationRequest, MinimapDragPreparationValidator, MinimapDrawNodesExecution, MinimapDrawNodesRequest, MoveFrontElementsBeforeTargetElementExecution, MoveFrontElementsBeforeTargetElementRequest, NODE_DRAG_TO_PARENT_FINALIZE_PROVIDERS, NODE_DRAG_TO_PARENT_PREPARATION_PROVIDERS, NODE_MOVE_PREPARATION_PROVIDERS, NODE_PROVIDERS, NODE_RESIZE_FINALIZE_PROVIDERS, NODE_RESIZE_PREPARATION_PROVIDERS, NODE_RESIZE_PROVIDERS, NodeDragHandler, NodeDragToParentDragHandler, NodeDragToParentFinalizeExecution, NodeDragToParentFinalizeRequest, NodeDragToParentPreparationExecution, NodeDragToParentPreparationRequest, NodeDragToParentPreparationValidator, NodeMoveFinalizeExecution, NodeMoveFinalizeRequest, NodeMovePreparationExecution, NodeMovePreparationRequest, NodeMovePreparationValidator, NodeResizeByChildDragHandler, NodeResizeDragHandler, NodeResizeFinalizeExecution, NodeResizeFinalizeRequest, NodeResizePreparationExecution, NodeResizePreparationRequest, NodeResizePreparationValidator, NotifyDataChangedExecution, NotifyDataChangedRequest, NotifyTransformChangedExecution, NotifyTransformChangedRequest, OnPointerMoveExecution, OnPointerMoveRequest, PrepareDragSequenceExecution, PrepareDragSequenceRequest, PreventDefaultIsExternalItemExecution, PreventDefaultIsExternalItemRequest, PutInputConnectionHandlersToArrayExecution, PutInputConnectionHandlersToArrayRequest, PutOutputConnectionHandlersToArrayExecution, PutOutputConnectionHandlersToArrayRequest, RESIZE_DIRECTIONS, ReassignConnectionDragHandler, ReassignConnectionFinalizeExecution, ReassignConnectionFinalizeRequest, ReassignConnectionPreparationExecution, ReassignConnectionPreparationRequest, RedrawCanvasWithAnimationExecution, RedrawCanvasWithAnimationRequest, RedrawConnectionsExecution, RedrawConnectionsRequest, RemoveBackgroundFromStoreExecution, RemoveBackgroundFromStoreRequest, RemoveCanvasFromStoreExecution, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStoreExecution, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStoreExecution, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStoreExecution, RemoveConnectionMarkerFromStoreRequest, RemoveDndFromStoreExecution, RemoveDndFromStoreRequest, RemoveFlowFromStoreExecution, RemoveFlowFromStoreRequest, RemoveInputFromStoreExecution, RemoveInputFromStoreRequest, RemoveLineAlignmentFromStoreExecution, RemoveLineAlignmentFromStoreRequest, RemoveNodeFromStoreExecution, RemoveNodeFromStoreRequest, RemoveOutletFromStoreExecution, RemoveOutletFromStoreRequest, RemoveOutputFromStoreExecution, RemoveOutputFromStoreRequest, RemoveSnapConnectionFromStoreExecution, RemoveSnapConnectionFromStoreRequest, ResetScaleAndCenterExecution, ResetScaleAndCenterRequest, ResetScaleExecution, ResetScaleRequest, SELECTION_AREA_FINALIZE_PROVIDERS, SELECTION_AREA_PREPARATION_PROVIDERS, SINGLE_SELECT_PROVIDERS, SelectAllExecution, SelectAllRequest, SelectAndUpdateNodeLayerExecution, SelectAndUpdateNodeLayerRequest, SelectExecution, SelectRequest, SelectionAreaDragHandle, SelectionAreaFinalizeExecution, SelectionAreaFinalizeRequest, SelectionAreaFinalizeValidator, SelectionAreaPreparationExecution, SelectionAreaPreparationRequest, SelectionAreaPreparationValidator, SetBackgroundTransformExecution, SetBackgroundTransformRequest, SingleSelectExecution, SingleSelectRequest, SortItemLayersExecution, SortItemLayersRequest, SortItemsByParentExecution, SortItemsByParentRequest, SortNodeLayersExecution, SortNodeLayersRequest, StartDragSequenceExecution, StartDragSequenceRequest, UpdateItemAndChildrenLayersExecution, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChangedExecution, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScaleExecution, UpdateScaleRequest, createSVGElement, debounceTime, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getExternalItem, getMarkerEndId, getMarkerSelectedEndId, getMarkerSelectedStartId, getMarkerStartId, isExternalItem, isMobile, isNode, isNodeOutlet, isNodeOutput, mixinChangeSelection, mixinChangeVisibility, notifyOnStart, transitionEnd };
+export { AddBackgroundToStoreExecution, AddBackgroundToStoreRequest, AddCanvasToStoreExecution, AddCanvasToStoreRequest, AddConnectionForCreateToStoreExecution, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStoreExecution, AddConnectionMarkerToStoreRequest, AddConnectionToStoreExecution, AddConnectionToStoreRequest, AddDndToStoreExecution, AddDndToStoreRequest, AddFlowToStoreExecution, AddFlowToStoreRequest, AddInputToStoreExecution, AddInputToStoreRequest, AddLineAlignmentToStoreExecution, AddLineAlignmentToStoreRequest, AddNodeToStoreExecution, AddNodeToStoreRequest, AddOutletToStoreExecution, AddOutletToStoreRequest, AddOutputToStoreExecution, AddOutputToStoreRequest, AddPatternToBackgroundExecution, AddPatternToBackgroundRequest, AddSnapConnectionToStoreExecution, AddSnapConnectionToStoreRequest, ApplyChildResizeRestrictionsExecution, ApplyChildResizeRestrictionsRequest, ApplyParentResizeRestrictionsExecution, ApplyParentResizeRestrictionsRequest, CANVAS_MOVE_FINALIZE_PROVIDERS, CANVAS_MOVE_PREPARATION_PROVIDERS, CANVAS_PROVIDERS, COMMON_PROVIDERS, CONNECTIONS_PROVIDERS, CONNECTION_GRADIENT, CONNECTION_PATH, CONNECTION_TEXT, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateCenterBetweenPointsHandler, CalculateCenterBetweenPointsRequest, CalculateChangedPositionExecution, CalculateChangedPositionRequest, CalculateChangedSizeExecution, CalculateChangedSizeRequest, CalculateCommonNodeMoveRestrictionsExecution, CalculateCommonNodeMoveRestrictionsRequest, CalculateConnectionCenterHandler, CalculateConnectionCenterRequest, CalculateConnectionLineByBehaviorExecution, CalculateConnectionLineByBehaviorRequest, CalculateConnectorConnectableSideHandler, CalculateConnectorConnectableSideRequest, CalculateFlowPointFromMinimapPointExecution, CalculateFlowPointFromMinimapPointRequest, CalculateNodeMoveRestrictionsExecution, CalculateNodeMoveRestrictionsRequest, CalculateNodesBoundingBoxExecution, CalculateNodesBoundingBoxNormalizedPositionExecution, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CanvasDragHandler, CanvasMoveFinalizeExecution, CanvasMoveFinalizeRequest, CanvasMovePreparationExecution, CanvasMovePreparationRequest, CanvasMovePreparationValidator, CenterGroupOrNodeExecution, CenterGroupOrNodeRequest, ClearSelectionExecution, ClearSelectionRequest, ConnectionBaseDragHandler, ConnectionDragHandler, ConnectionSourceDragHandler, ConnectionTargetDragHandler, CreateConnectionDragHandler, CreateConnectionDragHandlerExecution, CreateConnectionDragHandlerRequest, CreateConnectionFinalizeExecution, CreateConnectionFinalizeRequest, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparationExecution, CreateConnectionFromOutputPreparationRequest, CreateConnectionFromOutputPreparationValidator, CreateConnectionMarkersExecution, CreateConnectionMarkersRequest, CreateConnectionPreparationExecution, CreateConnectionPreparationRequest, CreateMoveNodesDragModelFromSelectionExecution, CreateMoveNodesDragModelFromSelectionRequest, DRAG_AND_DROP_COMMON_PROVIDERS, EFConnectableSide, EFConnectionBehavior, EFConnectionType, EFMarkerType, EFResizeHandleType, EXTERNAL_ITEM_FINALIZE_PROVIDERS, EXTERNAL_ITEM_PREPARATION_PROVIDERS, EmitSelectionChangeEventExecution, EmitSelectionChangeEventRequest, EndDragSequenceExecution, EndDragSequenceRequest, ExternalItemDragHandler, ExternalItemFinalizeExecution, ExternalItemFinalizeRequest, ExternalItemPreparationExecution, ExternalItemPreparationRequest, ExternalItemPreparationValidator, FBackgroundBase, FBackgroundComponent, FBezierPathBuilder, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FComponentsStore, FConnectionBase, FConnectionCenterDirective, FConnectionComponent, FConnectionDragHandleComponent, FConnectionFactory, FConnectionForCreateComponent, FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective, FConnectorBase, FCreateConnectionEvent, FCreateNodeEvent, FDragHandleDirective, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItemBase, FExternalItemDirective, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FGroupDirective, FLineAlignmentBase, FLineAlignmentComponent, FMarkerBase, FMarkerDirective, FMinimapCanvasDirective, FMinimapComponent, FMinimapData, FMinimapDragHandler, FMinimapFlowDirective, FMinimapViewDirective, FNodeBase, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FReassignConnectionEvent, FRectPatternComponent, FResizeChannel, FResizeHandleDirective, FRotateHandleDirective, FSegmentPathBuilder, FSelectionAreaBase, FSelectionAreaComponent, FSelectionChangeEvent, FSnapConnectionComponent, FStraightPathBuilder, FZoomBase, FZoomDirective, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CANVAS, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_DRAG_HANDLE_CLASS, F_CONNECTION_FEATURES, F_CONNECTION_IDENTIFIERS, F_CONNECTION_PROVIDERS, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_DRAG_AND_DROP_PLUGIN, F_DRAG_HANDLE, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_LINE_ALIGNMENT, F_LINE_ALIGNMENT_FEATURES, F_LINE_ALIGNMENT_PROVIDERS, F_MARKER, F_MINIMAP_DRAG_AND_DROP_PROVIDERS, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_RESIZE_HANDLE, F_SELECTED_CLASS, F_SELECTION_AREA_DRAG_AND_DROP_PROVIDERS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_ZOOM, F_ZOOM_PROVIDERS, FindClosestInputExecution, FindClosestInputRequest, FitToFlowExecution, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetAllCanBeConnectedInputPositionsExecution, GetAllCanBeConnectedInputPositionsRequest, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletRequest, GetCanBeConnectedOutputByOutletValidator, GetCanBeSelectedItemsExecution, GetCanBeSelectedItemsRequest, GetCanvasExecution, GetCanvasRequest, GetConnectorWithRectExecution, GetConnectorWithRectRequest, GetCurrentSelectionExecution, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroupsExecution, GetDeepChildrenNodesAndGroupsRequest, GetElementRoundedRectExecution, GetElementRoundedRectRequest, GetFlowExecution, GetFlowHostElementExecution, GetFlowHostElementRequest, GetFlowRequest, GetFlowStateConnectionsExecution, GetFlowStateConnectionsRequest, GetFlowStateExecution, GetFlowStateNodesExecution, GetFlowStateNodesRequest, GetFlowStateRequest, GetInputUnderPointerExecution, GetInputUnderPointerRequest, GetInputUnderPointerValidator, GetNodePaddingExecution, GetNodePaddingRequest, GetNodeResizeRestrictionsExecution, GetNodeResizeRestrictionsRequest, GetNodesExecution, GetNodesRequest, GetNormalizedChildrenNodesRectExecution, GetNormalizedChildrenNodesRectRequest, GetNormalizedElementRectExecution, GetNormalizedElementRectRequest, GetNormalizedParentNodeRectExecution, GetNormalizedParentNodeRectRequest, GetNormalizedPointExecution, GetNormalizedPointRequest, GetParentNodesExecution, GetParentNodesRequest, InitializeDragSequenceExecution, InitializeDragSequenceRequest, InputCanvasPositionExecution, InputCanvasPositionRequest, InputCanvasScaleExecution, InputCanvasScaleRequest, IsArrayHasParentNodeExecution, IsArrayHasParentNodeRequest, IsConnectionUnderNodeExecution, IsConnectionUnderNodeRequest, IsDragStartedExecution, IsDragStartedRequest, LineAlignmentDragHandler, LineAlignmentPreparationExecution, LineAlignmentPreparationRequest, LineElement, LineService, ListenCountChangesExecution, ListenCountChangesRequest, ListenDataChangesExecution, ListenDataChangesRequest, ListenTransformChangesExecution, ListenTransformChangesRequest, LogExecutionTime, MINIMAP_DRAG_FINALIZE_PROVIDERS, MINIMAP_DRAG_PREPARATION_PROVIDERS, MinimapCalculateSvgScaleAndViewBoxExecution, MinimapCalculateSvgScaleAndViewBoxRequest, MinimapCalculateViewBoxExecution, MinimapCalculateViewBoxRequest, MinimapDragFinalizeExecution, MinimapDragFinalizeRequest, MinimapDragFinalizeValidator, MinimapDragPreparationExecution, MinimapDragPreparationRequest, MinimapDragPreparationValidator, MinimapDrawNodesExecution, MinimapDrawNodesRequest, MoveFrontElementsBeforeTargetElementExecution, MoveFrontElementsBeforeTargetElementRequest, NODE_DRAG_TO_PARENT_FINALIZE_PROVIDERS, NODE_DRAG_TO_PARENT_PREPARATION_PROVIDERS, NODE_MOVE_PREPARATION_PROVIDERS, NODE_PROVIDERS, NODE_RESIZE_FINALIZE_PROVIDERS, NODE_RESIZE_PREPARATION_PROVIDERS, NODE_RESIZE_PROVIDERS, NodeDragHandler, NodeDragToParentDragHandler, NodeDragToParentFinalizeExecution, NodeDragToParentFinalizeRequest, NodeDragToParentPreparationExecution, NodeDragToParentPreparationRequest, NodeDragToParentPreparationValidator, NodeMoveFinalizeExecution, NodeMoveFinalizeRequest, NodeMovePreparationExecution, NodeMovePreparationRequest, NodeResizeByChildDragHandler, NodeResizeDragHandler, NodeResizeFinalizeExecution, NodeResizeFinalizeRequest, NodeResizePreparationExecution, NodeResizePreparationRequest, NodeResizePreparationValidator, NotifyDataChangedExecution, NotifyDataChangedRequest, NotifyTransformChangedExecution, NotifyTransformChangedRequest, OnPointerMoveExecution, OnPointerMoveRequest, PrepareDragSequenceExecution, PrepareDragSequenceRequest, PreventDefaultIsExternalItemExecution, PreventDefaultIsExternalItemRequest, PutInputConnectionHandlersToArrayExecution, PutInputConnectionHandlersToArrayRequest, PutOutputConnectionHandlersToArrayExecution, PutOutputConnectionHandlersToArrayRequest, RESIZE_DIRECTIONS, ReassignConnectionDragHandler, ReassignConnectionFinalizeExecution, ReassignConnectionFinalizeRequest, ReassignConnectionPreparationExecution, ReassignConnectionPreparationRequest, RedrawCanvasWithAnimationExecution, RedrawCanvasWithAnimationRequest, RedrawConnectionsExecution, RedrawConnectionsRequest, RemoveBackgroundFromStoreExecution, RemoveBackgroundFromStoreRequest, RemoveCanvasFromStoreExecution, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStoreExecution, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStoreExecution, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStoreExecution, RemoveConnectionMarkerFromStoreRequest, RemoveDndFromStoreExecution, RemoveDndFromStoreRequest, RemoveFlowFromStoreExecution, RemoveFlowFromStoreRequest, RemoveInputFromStoreExecution, RemoveInputFromStoreRequest, RemoveLineAlignmentFromStoreExecution, RemoveLineAlignmentFromStoreRequest, RemoveNodeFromStoreExecution, RemoveNodeFromStoreRequest, RemoveOutletFromStoreExecution, RemoveOutletFromStoreRequest, RemoveOutputFromStoreExecution, RemoveOutputFromStoreRequest, RemoveSnapConnectionFromStoreExecution, RemoveSnapConnectionFromStoreRequest, ResetScaleAndCenterExecution, ResetScaleAndCenterRequest, ResetScaleExecution, ResetScaleRequest, SELECTION_AREA_FINALIZE_PROVIDERS, SELECTION_AREA_PREPARATION_PROVIDERS, SINGLE_SELECT_PROVIDERS, SelectAllExecution, SelectAllRequest, SelectAndUpdateNodeLayerExecution, SelectAndUpdateNodeLayerRequest, SelectExecution, SelectRequest, SelectionAreaDragHandle, SelectionAreaFinalizeExecution, SelectionAreaFinalizeRequest, SelectionAreaFinalizeValidator, SelectionAreaPreparationExecution, SelectionAreaPreparationRequest, SelectionAreaPreparationValidator, SetBackgroundTransformExecution, SetBackgroundTransformRequest, SingleSelectExecution, SingleSelectRequest, SortItemLayersExecution, SortItemLayersRequest, SortItemsByParentExecution, SortItemsByParentRequest, SortNodeLayersExecution, SortNodeLayersRequest, StartDragSequenceExecution, StartDragSequenceRequest, UpdateItemAndChildrenLayersExecution, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChangedExecution, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScaleExecution, UpdateScaleRequest, createSVGElement, debounceTime, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getExternalItem, getMarkerEndId, getMarkerSelectedEndId, getMarkerSelectedStartId, getMarkerStartId, isExternalItem, isMobile, isNode, isNodeOutlet, isNodeOutput, mixinChangeSelection, mixinChangeVisibility, notifyOnStart, transitionEnd };
 //# sourceMappingURL=foblex-flow.mjs.map