@foblex/flow 17.1.1 → 17.2.0

package/fesm2022/foblex-flow.mjs

@@ -1,11 +1,11 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, Directive, ElementRef, Input, HostBinding, EventEmitter, DestroyRef, booleanAttribute, Output, Inject, Component, ChangeDetectionStrategy, ViewChild, Optional, numberAttribute, ContentChildren, NgZone, ContentChild, Renderer2, NgModule } from '@angular/core';
-import { RectExtensions, RoundedRect, TransformModelExtensions, PointExtensions, Point, LineExtensions, GetIntersections, SizeExtensions, findClosestAlignment, setRectToElement, adjustRectToMinSize, setRectToViewBox } from '@foblex/2d';
+import { InjectionToken, inject, Injectable, Directive, ElementRef, Input, HostBinding, EventEmitter, DestroyRef, booleanAttribute, Output, Inject, Component, ChangeDetectionStrategy, ViewChild, Optional, numberAttribute, ContentChildren, Injector, NgZone, ContentChild, Renderer2, NgModule } from '@angular/core';
+import { RectExtensions, RoundedRect, TransformModelExtensions, PointExtensions, SizeExtensions, Point, LineExtensions, GetIntersections, findClosestAlignment, setRectToElement, adjustRectToMinSize, setRectToViewBox } from '@foblex/2d';
 import { __decorate } from 'tslib';
 import * as i2$1 from '@foblex/mediator';
-import { FExecutionRegister, FMediator, FValidatorRegister } from '@foblex/mediator';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
 import * as i1 from '@foblex/platform';
-import { BrowserService, EOperationSystem } from '@foblex/platform';
+import { BrowserService, PlatformService, EOperationSystem } from '@foblex/platform';
 import { normalizeDomElementId, castToEnum, flatMap, isClosestElementHasClass, getDataAttrValueFromClosestElementWithClass, deepCloneNode } from '@foblex/utils';
 import * as i2 from '@angular/common';
 import { CommonModule } from '@angular/common';
@@ -437,7 +437,7 @@ let CenterGroupOrNodeExecution = class CenterGroupOrNodeExecution {
             return;
         }
         this.toCenter(this.getNodeRect(fNode), this.getFlowRect(), fNode.position);
-        this._fMediator.send(new RedrawCanvasWithAnimationRequest(request.animated));
+        this._fMediator.execute(new RedrawCanvasWithAnimationRequest(request.animated));
     }
     toCenter(fNodeRect, fFlowRect, position) {
         this.transform.scaledPosition = PointExtensions.initialize();
@@ -478,12 +478,12 @@ let FitToFlowExecution = class FitToFlowExecution {
     }
     _fMediator = inject(FMediator);
     handle(request) {
-        const fNodesRect = this._fMediator.send(new CalculateNodesBoundingBoxRequest()) || RectExtensions.initialize();
+        const fNodesRect = this._fMediator.execute(new CalculateNodesBoundingBoxRequest()) || RectExtensions.initialize();
         if (fNodesRect.width === 0 || fNodesRect.height === 0) {
             return;
         }
         this.fitToParent(fNodesRect, RectExtensions.fromElement(this._fComponentsStore.fFlow.hostElement), this._fComponentsStore.fNodes.map((x) => x.position), request.toCenter);
-        this._fMediator.send(new RedrawCanvasWithAnimationRequest(request.animated));
+        this._fMediator.execute(new RedrawCanvasWithAnimationRequest(request.animated));
     }
     fitToParent(rect, parentRect, points, toCenter) {
         this.transform.scaledPosition = PointExtensions.initialize();
@@ -693,12 +693,12 @@ let ResetScaleAndCenterExecution = class ResetScaleAndCenterExecution {
     }
     _fMediator = inject(FMediator);
     handle(request) {
-        const fNodesRect = this._fMediator.send(new CalculateNodesBoundingBoxRequest()) || RectExtensions.initialize();
+        const fNodesRect = this._fMediator.execute(new CalculateNodesBoundingBoxRequest()) || RectExtensions.initialize();
         if (fNodesRect.width === 0 || fNodesRect.height === 0) {
             return;
         }
         this.oneToOneCentering(fNodesRect, RectExtensions.fromElement(this._fComponentsStore.fFlow.hostElement), this._fComponentsStore.fNodes.map((x) => x.position));
-        this._fMediator.send(new RedrawCanvasWithAnimationRequest(request.animated));
+        this._fMediator.execute(new RedrawCanvasWithAnimationRequest(request.animated));
     }
     oneToOneCentering(rect, parentRect, points) {
         this.transform.scaledPosition = PointExtensions.initialize();
@@ -1042,10 +1042,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
 
 var EFResizeHandleType;
 (function (EFResizeHandleType) {
+    EFResizeHandleType["LEFT"] = "left";
     EFResizeHandleType["LEFT_TOP"] = "left-top";
+    EFResizeHandleType["TOP"] = "top";
     EFResizeHandleType["RIGHT_TOP"] = "right-top";
-    EFResizeHandleType["LEFT_BOTTOM"] = "left-bottom";
+    EFResizeHandleType["RIGHT"] = "right";
     EFResizeHandleType["RIGHT_BOTTOM"] = "right-bottom";
+    EFResizeHandleType["BOTTOM"] = "bottom";
+    EFResizeHandleType["LEFT_BOTTOM"] = "left-bottom";
 })(EFResizeHandleType || (EFResizeHandleType = {}));
 
 const F_RESIZE_HANDLE = new InjectionToken('F_RESIZE_HANDLE');
@@ -1059,7 +1063,7 @@ class FResizeHandleDirective {
         return this._elementReference.nativeElement;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FResizeHandleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FResizeHandleDirective, selector: "[fResizeHandle]", inputs: { type: ["fResizeHandleType", "type", (x) => castToEnum(x, 'fResizeHandleType', EFResizeHandleType)] }, host: { properties: { "attr.data-f-resize-handle-type": "type", "class": "this.typeClass" }, classAttribute: "f-resize-handle f-component" }, providers: [{ provide: F_RESIZE_HANDLE, useExisting: FResizeHandleDirective }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FResizeHandleDirective, selector: "[fResizeHandle]", inputs: { type: ["fResizeHandleType", "type", (x) => castToEnum(x, 'fResizeHandleType', EFResizeHandleType)] }, host: { properties: { "attr.data-f-resize-handle-type": "type.toUpperCase()", "class": "this.typeClass" }, classAttribute: "f-resize-handle f-component" }, providers: [{ provide: F_RESIZE_HANDLE, useExisting: FResizeHandleDirective }], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FResizeHandleDirective, decorators: [{
             type: Directive,
@@ -1067,7 +1071,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
                     selector: "[fResizeHandle]",
                     host: {
                         class: `f-resize-handle f-component`,
-                        '[attr.data-f-resize-handle-type]': 'type',
+                        '[attr.data-f-resize-handle-type]': 'type.toUpperCase()',
                     },
                     providers: [{ provide: F_RESIZE_HANDLE, useExisting: FResizeHandleDirective }],
                 }]
@@ -1135,12 +1139,12 @@ function mixinChangeSelection(base) {
     return class extends base {
         fId = '';
         fSelectionDisabled = false;
-        deselect() {
-            this.deselectChild?.();
+        unmarkAsSelected() {
+            this.unmarkChildrenAsSelected?.();
             this.hostElement.classList.remove(F_SELECTED_CLASS);
         }
-        select() {
-            this.selectChild?.();
+        markAsSelected() {
+            this.markChildrenAsSelected?.();
             if (!this.isSelected()) {
                 this.hostElement.classList.add(F_SELECTED_CLASS);
             }
@@ -1148,9 +1152,9 @@ function mixinChangeSelection(base) {
         isSelected() {
             return this.hostElement.classList.contains(F_SELECTED_CLASS);
         }
-        selectChild() {
+        markChildrenAsSelected() {
         }
-        deselectChild() {
+        unmarkChildrenAsSelected() {
         }
         constructor(...args) {
             super(...args);
@@ -1227,16 +1231,22 @@ class FGroupDirective extends FNodeBase {
     fId = `f-group-${uniqueId$b++}`;
     fParentId = null;
     set position(value) {
-        this._position = PointExtensions.castToPoint(value);
-        this.refresh();
+        if (!PointExtensions.isEqual(this._position, value)) {
+            this._position = value;
+            this.redraw();
+            this.refresh();
+        }
     }
     get position() {
         return this._position;
     }
     positionChange = new EventEmitter();
     set size(value) {
-        this._size = value;
-        this.refresh();
+        if (!this.size || !SizeExtensions.isEqual(this._size, value)) {
+            this._size = value;
+            this.redraw();
+            this.refresh();
+        }
     }
     get size() {
         return this._size;
@@ -1261,14 +1271,14 @@ class FGroupDirective extends FNodeBase {
         this.setStyle('left', '0');
         this.setStyle('top', '0');
         super.redraw();
-        this._fMediator.send(new AddNodeToStoreRequest(this));
+        this._fMediator.execute(new AddNodeToStoreRequest(this));
     }
     setStyle(styleName, value) {
         this.renderer.setStyle(this.hostElement, styleName, value);
     }
     redraw() {
         super.redraw();
-        this._fMediator.send(new NotifyTransformChangedRequest());
+        this._fMediator.execute(new NotifyTransformChangedRequest());
     }
     ngAfterViewInit() {
         if (!this.fBrowser.isBrowser()) {
@@ -1277,13 +1287,13 @@ class FGroupDirective extends FNodeBase {
         this._listenStateSizeChanges();
     }
     _listenStateSizeChanges() {
-        this._fMediator.send(new UpdateNodeWhenStateOrSizeChangedRequest(this, this._destroyRef));
+        this._fMediator.execute(new UpdateNodeWhenStateOrSizeChangedRequest(this, this._destroyRef));
     }
     refresh() {
         this.stateChanges.notify();
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveNodeFromStoreRequest(this));
+        this._fMediator.execute(new RemoveNodeFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FGroupDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FGroupDirective, selector: "[fGroup]", inputs: { fId: ["fGroupId", "fId"], fParentId: ["fGroupParentId", "fParentId"], position: ["fGroupPosition", "position"], size: ["fGroupSize", "size"], fDraggingDisabled: ["fGroupDraggingDisabled", "fDraggingDisabled", booleanAttribute], fSelectionDisabled: ["fGroupSelectionDisabled", "fSelectionDisabled", booleanAttribute], fIncludePadding: ["fIncludePadding", "fIncludePadding", booleanAttribute], fConnectOnNode: ["fConnectOnNode", "fConnectOnNode", booleanAttribute] }, outputs: { positionChange: "fGroupPositionChange", sizeChange: "fGroupSizeChange" }, host: { properties: { "attr.data-f-group-id": "fId", "class.f-group-dragging-disabled": "fDraggingDisabled", "class.f-group-selection-disabled": "fSelectionDisabled" }, classAttribute: "f-group f-component" }, providers: [
@@ -1344,16 +1354,22 @@ class FNodeDirective extends FNodeBase {
     fId = `f-node-${uniqueId$a++}`;
     fParentId = null;
     set position(value) {
-        this._position = PointExtensions.castToPoint(value);
-        this.refresh();
+        if (!PointExtensions.isEqual(this._position, value)) {
+            this._position = value;
+            this.redraw();
+            this.refresh();
+        }
     }
     get position() {
         return this._position;
     }
     positionChange = new EventEmitter();
     set size(value) {
-        this._size = value;
-        this.refresh();
+        if (!this.size || !SizeExtensions.isEqual(this._size, value)) {
+            this._size = value;
+            this.redraw();
+            this.refresh();
+        }
     }
     get size() {
         return this._size;
@@ -1379,14 +1395,14 @@ class FNodeDirective extends FNodeBase {
         this.setStyle('left', '0');
         this.setStyle('top', '0');
         super.redraw();
-        this._fMediator.send(new AddNodeToStoreRequest(this));
+        this._fMediator.execute(new AddNodeToStoreRequest(this));
     }
     setStyle(styleName, value) {
         this.renderer.setStyle(this.hostElement, styleName, value);
     }
     redraw() {
         super.redraw();
-        this._fMediator.send(new NotifyTransformChangedRequest());
+        this._fMediator.execute(new NotifyTransformChangedRequest());
     }
     ngAfterViewInit() {
         if (!this.fBrowser.isBrowser()) {
@@ -1395,13 +1411,13 @@ class FNodeDirective extends FNodeBase {
         this._listenStateSizeChanges();
     }
     _listenStateSizeChanges() {
-        this._fMediator.send(new UpdateNodeWhenStateOrSizeChangedRequest(this, this._destroyRef));
+        this._fMediator.execute(new UpdateNodeWhenStateOrSizeChangedRequest(this, this._destroyRef));
     }
     refresh() {
         this.stateChanges.notify();
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveNodeFromStoreRequest(this));
+        this._fMediator.execute(new RemoveNodeFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FNodeDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FNodeDirective, selector: "[fNode]", inputs: { fId: ["fNodeId", "fId"], fParentId: ["fNodeParentId", "fParentId"], position: ["fNodePosition", "position"], size: ["fNodeSize", "size"], fDraggingDisabled: ["fNodeDraggingDisabled", "fDraggingDisabled", booleanAttribute], fSelectionDisabled: ["fNodeSelectionDisabled", "fSelectionDisabled", booleanAttribute], fIncludePadding: ["fIncludePadding", "fIncludePadding", booleanAttribute], fConnectOnNode: ["fConnectOnNode", "fConnectOnNode", booleanAttribute] }, outputs: { positionChange: "fNodePositionChange", sizeChange: "fNodeSizeChange" }, host: { properties: { "attr.data-f-node-id": "fId", "class.f-node-dragging-disabled": "fDraggingDisabled", "class.f-node-selection-disabled": "fSelectionDisabled" }, classAttribute: "f-node f-component" }, providers: [
@@ -1482,7 +1498,7 @@ class FNodeInputDirective extends FNodeInputBase {
         return this._elementReference.nativeElement;
     }
     ngOnInit() {
-        this._fMediator.send(new AddInputToStoreRequest(this));
+        this._fMediator.execute(new AddInputToStoreRequest(this));
         this._fNode.addConnector(this);
     }
     ngOnChanges(changes) {
@@ -1502,7 +1518,7 @@ class FNodeInputDirective extends FNodeInputBase {
     }
     ngOnDestroy() {
         this._fNode.removeConnector(this);
-        this._fMediator.send(new RemoveInputFromStoreRequest(this));
+        this._fMediator.execute(new RemoveInputFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FNodeInputDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FNodeInputDirective, selector: "[fNodeInput]", inputs: { fId: ["fInputId", "fId"], multiple: ["fInputMultiple", "multiple"], disabled: ["fInputDisabled", "disabled", booleanAttribute], userFConnectableSide: ["fInputConnectableSide", "userFConnectableSide", (value) => castToEnum(value, 'fInputConnectableSide', EFConnectableSide)] }, host: { properties: { "attr.data-f-input-id": "fId", "class.f-node-input-multiple": "multiple", "class.f-node-input-disabled": "disabled" }, classAttribute: "f-component f-node-input" }, providers: [{ provide: F_NODE_INPUT, useExisting: FNodeInputDirective }], exportAs: ["fNodeInput"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });
@@ -1576,10 +1592,10 @@ class FNodeOutletDirective extends FNodeOutletBase {
         return this._elementReference.nativeElement;
     }
     ngOnInit() {
-        this._fMediator.send(new AddOutletToStoreRequest(this));
+        this._fMediator.execute(new AddOutletToStoreRequest(this));
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveOutletFromStoreRequest(this));
+        this._fMediator.execute(new RemoveOutletFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FNodeOutletDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FNodeOutletDirective, selector: "[fNodeOutlet]", inputs: { fId: ["fOutletId", "fId"], disabled: ["fOutletDisabled", "disabled", booleanAttribute], isConnectionFromOutlet: "isConnectionFromOutlet", canBeConnectedInputs: ["fCanBeConnectedInputs", "canBeConnectedInputs"] }, host: { properties: { "attr.data-f-outlet-id": "fId", "class.f-node-outlet-disabled": "disabled" }, classAttribute: "f-component f-node-outlet" }, providers: [{ provide: F_NODE_OUTLET, useExisting: FNodeOutletDirective }], exportAs: ["fNodeOutlet"], usesInheritance: true, ngImport: i0 });
@@ -1643,7 +1659,7 @@ class FNodeOutputDirective extends FNodeOutputBase {
         return this._elementReference.nativeElement;
     }
     ngOnInit() {
-        this._fMediator.send(new AddOutputToStoreRequest(this));
+        this._fMediator.execute(new AddOutputToStoreRequest(this));
         this._fNode.addConnector(this);
     }
     ngOnChanges(changes) {
@@ -1663,7 +1679,7 @@ class FNodeOutputDirective extends FNodeOutputBase {
     }
     ngOnDestroy() {
         this._fNode.removeConnector(this);
-        this._fMediator.send(new RemoveOutputFromStoreRequest(this));
+        this._fMediator.execute(new RemoveOutputFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FNodeOutputDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FNodeOutputDirective, selector: "[fNodeOutput]", inputs: { fId: ["fOutputId", "fId"], multiple: ["fOutputMultiple", "multiple"], disabled: ["fOutputDisabled", "disabled", booleanAttribute], userFConnectableSide: ["fOutputConnectableSide", "userFConnectableSide", (value) => castToEnum(value, 'fOutputConnectableSide', EFConnectableSide)], isSelfConnectable: "isSelfConnectable", canBeConnectedInputs: ["fCanBeConnectedInputs", "canBeConnectedInputs"] }, host: { properties: { "attr.data-f-output-id": "fId", "class.f-node-output-multiple": "multiple", "class.f-node-output-disabled": "disabled", "class.f-node-output-self-connectable": "isSelfConnectable" }, classAttribute: "f-component f-node-output" }, providers: [{ provide: F_NODE_OUTPUT, useExisting: FNodeOutputDirective }], exportAs: ["fNodeOutput"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });
@@ -1933,13 +1949,15 @@ class FConnectionTextPathDirective {
         this.fBrowser = fBrowser;
     }
     ngOnInit() {
-        this.hostElement.setAttribute('startOffset', this.base.fTextStartOffset || '50%');
         this.hostElement.setAttribute('text-anchor', `middle`);
         this.symbolWidth = this.getSymbolWidth(this.base.fText || '');
     }
     getBBox() {
         return this.hostElement.getBBox();
     }
+    redraw() {
+        this.hostElement.setAttribute('startOffset', this.base.fTextStartOffset || '50%');
+    }
     getFontStyles(element) {
         const computedStyles = this.fBrowser.window.getComputedStyle(element);
         return {
@@ -2003,6 +2021,7 @@ class FConnectionTextComponent {
         this.base = base;
     }
     redraw(line) {
+        this.textPathDirective.redraw();
         const isTextReverse = FConnectionTextComponent.isTextReverse(line);
         const dyValue = this.calculateDy(this.textPathDirective.fontSize, isTextReverse);
         this.hostElement.setAttribute('dy', dyValue);
@@ -2324,10 +2343,10 @@ class FConnectionBase extends MIXIN_BASE {
     getTransform(position) {
         return `position: absolute; pointerEvents: all; transform: translate(-50%, -50%); left: ${position.x}px; top: ${position.y}px`;
     }
-    selectChild() {
+    markChildrenAsSelected() {
         this.fPath.select();
     }
-    deselectChild() {
+    unmarkChildrenAsSelected() {
         this.fPath.deselect();
     }
     redraw() {
@@ -2400,16 +2419,16 @@ class FConnectionForCreateComponent extends FConnectionBase {
         super(elementReference, fConnectionFactory);
     }
     ngOnInit() {
-        this._fMediator.send(new AddConnectionForCreateToStoreRequest(this));
+        this._fMediator.execute(new AddConnectionForCreateToStoreRequest(this));
     }
     ngAfterViewInit() {
         this.hide();
     }
     ngOnChanges() {
-        this._fMediator.send(new NotifyDataChangedRequest());
+        this._fMediator.execute(new NotifyDataChangedRequest());
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveConnectionForCreateFromStoreRequest());
+        this._fMediator.execute(new RemoveConnectionForCreateFromStoreRequest());
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FConnectionForCreateComponent, deps: [{ token: i0.ElementRef }, { token: FConnectionFactory }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.4", type: FConnectionForCreateComponent, selector: "f-connection-for-create", inputs: { fStartColor: "fStartColor", fEndColor: "fEndColor", fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType" }, host: { classAttribute: "f-component f-connection f-connection-for-create" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], queries: [{ propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
@@ -2491,13 +2510,13 @@ class FConnectionComponent extends FConnectionBase {
         super(elementReference, fConnectionFactory);
     }
     ngOnInit() {
-        this._fMediator.send(new AddConnectionToStoreRequest(this));
+        this._fMediator.execute(new AddConnectionToStoreRequest(this));
     }
     ngOnChanges() {
-        this._fMediator.send(new NotifyDataChangedRequest());
+        this._fMediator.execute(new NotifyDataChangedRequest());
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveConnectionFromStoreRequest(this));
+        this._fMediator.execute(new RemoveConnectionFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FConnectionComponent, deps: [{ token: i0.ElementRef }, { token: FConnectionFactory }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.4", type: FConnectionComponent, selector: "f-connection", inputs: { fId: ["fConnectionId", "fId"], fText: "fText", fTextStartOffset: "fTextStartOffset", fStartColor: "fStartColor", fEndColor: "fEndColor", fOutputId: "fOutputId", fInputId: "fInputId", fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType", fDraggingDisabled: ["fReassignDisabled", "fDraggingDisabled", booleanAttribute], fSelectionDisabled: ["fSelectionDisabled", "fSelectionDisabled", booleanAttribute] }, host: { properties: { "attr.id": "fId", "class.f-connection-selection-disabled": "fSelectionDisabled", "class.f-connection-reassign-disabled": "fDraggingDisabled" }, classAttribute: "f-component f-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionComponent }], queries: [{ propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], exportAs: ["fComponent"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\" style=\"overflow: visible; display: block; vertical-align: middle;\">\n  <defs #defs></defs>\n  <ng-content></ng-content>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path [attr.d]=\"path\"></path>\n      <circle f-connection-drag-handle r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n  <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
@@ -2604,10 +2623,10 @@ class FMarkerDirective extends FMarkerBase {
         this.hostElement.style.display = 'none';
     }
     ngOnInit() {
-        this._fMediator.send(new AddConnectionMarkerToStoreRequest(this));
+        this._fMediator.execute(new AddConnectionMarkerToStoreRequest(this));
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveConnectionMarkerFromStoreRequest(this));
+        this._fMediator.execute(new RemoveConnectionMarkerFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FMarkerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: FMarkerDirective, selector: "svg[fMarker]", inputs: { hostElement: "hostElement", width: "width", height: "height", refX: "refX", refY: "refY", type: "type", orient: "orient", markerUnits: "markerUnits" }, host: { classAttribute: "f-component f-marker" }, providers: [{ provide: F_MARKER, useExisting: FMarkerDirective }], usesInheritance: true, ngImport: i0 });
@@ -2671,16 +2690,16 @@ class FSnapConnectionComponent extends FConnectionBase {
         super(elementReference, fConnectionFactory);
     }
     ngOnInit() {
-        this._fMediator.send(new AddSnapConnectionToStoreRequest(this));
+        this._fMediator.execute(new AddSnapConnectionToStoreRequest(this));
     }
     ngAfterViewInit() {
         this.hide();
     }
     ngOnChanges() {
-        this._fMediator.send(new NotifyDataChangedRequest());
+        this._fMediator.execute(new NotifyDataChangedRequest());
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveSnapConnectionFromStoreRequest());
+        this._fMediator.execute(new RemoveSnapConnectionFromStoreRequest());
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FSnapConnectionComponent, deps: [{ token: i0.ElementRef }, { token: FConnectionFactory }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.4", type: FSnapConnectionComponent, selector: "f-snap-connection", inputs: { fStartColor: "fStartColor", fEndColor: "fEndColor", fSnapThreshold: ["fSnapThreshold", "fSnapThreshold", numberAttribute], fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType" }, host: { classAttribute: "f-component f-connection f-snap-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FSnapConnectionComponent }], queries: [{ propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
@@ -2836,7 +2855,7 @@ let GetNormalizedElementRectExecution = class GetNormalizedElementRectExecution
         return new RoundedRect(position.x, position.y, size.width, size.height, systemRect.radius1, systemRect.radius2, systemRect.radius3, systemRect.radius4);
     }
     _getElementRoundedRect(request) {
-        return request.isRoundedRect ? this._fMediator.send(new GetElementRoundedRectRequest(request.element)) : RoundedRect.fromRect(RectExtensions.fromElement(request.element));
+        return request.isRoundedRect ? this._fMediator.execute(new GetElementRoundedRectRequest(request.element)) : RoundedRect.fromRect(RectExtensions.fromElement(request.element));
     }
     _normalizePosition(rect) {
         return Point.fromPoint(rect).elementTransform(this._fComponentsStore.flowHost).sub(this._transform.scaledPosition).sub(this._transform.position).div(this._transform.scale);
@@ -2888,13 +2907,13 @@ let RedrawConnectionsExecution = class RedrawConnectionsExecution {
         this.setMarkers(connection);
         connection.setLine(line.point1, output.fConnectableSide, line.point2, input.fConnectableSide);
         connection.initialize();
-        connection.isSelected() ? connection.select() : null;
+        connection.isSelected() ? connection.markAsSelected() : null;
     }
     getLine(output, input, connection) {
         return this.fMediator.execute(new CalculateConnectionLineByBehaviorRequest(this.fMediator.execute(new GetNormalizedElementRectRequest(output.hostElement, true)), this.fMediator.execute(new GetNormalizedElementRectRequest(input.hostElement, true)), connection.fBehavior, output.fConnectableSide, input.fConnectableSide));
     }
     setMarkers(connection) {
-        this.fMediator.send(new CreateConnectionMarkersRequest(connection));
+        this.fMediator.execute(new CreateConnectionMarkersRequest(connection));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: RedrawConnectionsExecution, deps: [{ token: FComponentsStore }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: RedrawConnectionsExecution });
@@ -3297,39 +3316,43 @@ function RequiredOutput() {
 }
 
 class GetCanBeConnectedOutputByOutletRequest {
-    outlet;
-    constructor(outlet) {
-        this.outlet = outlet;
+    fOutlet;
+    constructor(fOutlet) {
+        this.fOutlet = fOutlet;
     }
 }
 
 let GetCanBeConnectedOutputByOutletExecution = class GetCanBeConnectedOutputByOutletExecution {
-    fComponentsStore;
-    get fNodes() {
-        return this.fComponentsStore.fNodes;
-    }
-    get fOutputs() {
-        return this.fComponentsStore.fOutputs;
+    _fComponentStore = inject(FComponentsStore);
+    get _fNodes() {
+        return this._fComponentStore.fNodes;
     }
-    constructor(fComponentsStore) {
-        this.fComponentsStore = fComponentsStore;
+    get _fOutputs() {
+        return this._fComponentStore.fOutputs;
     }
+    _fNode;
     handle(request) {
-        const outputs = this.getConnectableOutputs(this.getNode(request.outlet));
-        if (!outputs.length) {
-            throw RequiredOutput();
+        if (!this._isValid(request)) {
+            return;
         }
-        return outputs.length > 0 ? outputs[0] : undefined;
+        const fOutputs = this._getConnectableOutputs();
+        if (!fOutputs.length) {
+            throw new Error('The fNode must contain at least one fOutput if there is an fOutlet');
+        }
+        return fOutputs[0];
     }
-    getConnectableOutputs(node) {
-        return this.fOutputs.filter((x) => {
-            return node.isContains(x.hostElement) && x.canBeConnected;
-        });
+    _isValid(request) {
+        return !!this._getNode(request.fOutlet);
+    }
+    _getNode(fOutlet) {
+        this._fNode = this._fNodes.find((x) => x.isContains(fOutlet.hostElement));
+        return this._fNode;
     }
-    getNode(outlet) {
-        return this.fNodes.find((x) => x.isContains(outlet.hostElement));
+    _getConnectableOutputs() {
+        return this._fOutputs
+            .filter((x) => this._fNode.isContains(x.hostElement) && x.canBeConnected);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletExecution, deps: [{ token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletExecution });
 };
 GetCanBeConnectedOutputByOutletExecution = __decorate([
@@ -3337,28 +3360,7 @@ GetCanBeConnectedOutputByOutletExecution = __decorate([
 ], GetCanBeConnectedOutputByOutletExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }] });
-
-let GetCanBeConnectedOutputByOutletValidator = class GetCanBeConnectedOutputByOutletValidator {
-    fComponentsStore;
-    get fNodes() {
-        return this.fComponentsStore.fNodes;
-    }
-    constructor(fComponentsStore) {
-        this.fComponentsStore = fComponentsStore;
-    }
-    handle(request) {
-        return !!this.fNodes.find((x) => x.isContains(request.outlet.hostElement));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletValidator, deps: [{ token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletValidator });
-};
-GetCanBeConnectedOutputByOutletValidator = __decorate([
-    FValidatorRegister(GetCanBeConnectedOutputByOutletRequest)
-], GetCanBeConnectedOutputByOutletValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeConnectedOutputByOutletValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }] });
+        }] });
 
 class FCreateConnectionEvent {
     fOutputId;
@@ -3371,10 +3373,29 @@ class FCreateConnectionEvent {
     }
 }
 
+class FInjector {
+    static _injector;
+    static set(injector) {
+        this._injector = injector;
+    }
+    static clear() {
+        this._injector = undefined;
+    }
+    static get() {
+        if (!this._injector) {
+            throw new Error('No injector available');
+        }
+        return this._injector;
+    }
+}
+function fInject(token) {
+    return FInjector.get().get(token);
+}
+
 class CreateConnectionDragHandler {
-    _fMediator;
-    _fComponentsStore;
-    _fOutput;
+    _fOutputOrOutlet;
+    _fMediator = fInject(FMediator);
+    _fComponentsStore = fInject(FComponentsStore);
     _toConnectorRect = new RoundedRect();
     get _fConnection() {
         return this._fComponentsStore.fTempConnection;
@@ -3384,33 +3405,31 @@ class CreateConnectionDragHandler {
     }
     _fOutputWithRect;
     _canBeConnectedInputs = [];
-    constructor(_fMediator, _fComponentsStore, _fOutput, _onPointerDownPosition) {
-        this._fMediator = _fMediator;
-        this._fComponentsStore = _fComponentsStore;
-        this._fOutput = _fOutput;
+    constructor(_fOutputOrOutlet, _onPointerDownPosition) {
+        this._fOutputOrOutlet = _fOutputOrOutlet;
         this._toConnectorRect = RoundedRect.fromRect(RectExtensions.initialize(_onPointerDownPosition.x, _onPointerDownPosition.y));
     }
     prepareDragSequence() {
         this._getAndMarkCanBeConnectedInputs();
         this._initializeSnapConnection();
         this._initializeConnectionForCreate();
-        this._fOutputWithRect = this._fMediator.execute(new GetConnectorAndRectRequest(this._fOutput));
+        this._fOutputWithRect = this._fMediator.execute(new GetConnectorAndRectRequest(this._fOutputOrOutlet));
         this._fConnection.show();
         this.onPointerMove(PointExtensions.initialize());
     }
     _getAndMarkCanBeConnectedInputs() {
-        this._canBeConnectedInputs = this._fMediator.execute(new GetAllCanBeConnectedInputsAndRectsRequest(this._fOutput));
+        this._canBeConnectedInputs = this._fMediator.execute(new GetAllCanBeConnectedInputsAndRectsRequest(this._fOutputOrOutlet));
         this._fMediator.execute(new MarkAllCanBeConnectedInputsRequest(this._canBeConnectedInputs.map((x) => x.fConnector)));
     }
     _initializeSnapConnection() {
         if (!this._fSnapConnection) {
             return;
         }
-        this._fSnapConnection.fOutputId = this._fOutput.fId;
+        this._fSnapConnection.fOutputId = this._fOutputOrOutlet.fId;
         this._fSnapConnection.initialize();
     }
     _initializeConnectionForCreate() {
-        this._fConnection.fOutputId = this._fOutput.fId;
+        this._fConnection.fOutputId = this._fOutputOrOutlet.fId;
         this._fConnection.initialize();
     }
     onPointerMove(difference) {
@@ -3451,7 +3470,7 @@ class CreateConnectionDragHandler {
     getData() {
         return {
             toConnectorRect: this._toConnectorRect,
-            fOutputId: this._fOutput.fId,
+            fOutputId: this._fOutputOrOutlet.fId,
             canBeConnectedInputs: this._canBeConnectedInputs
         };
     }
@@ -3483,7 +3502,7 @@ let CreateConnectionFinalizeExecution = class CreateConnectionFinalizeExecution
         if (!output) {
             throw OutputNotFound(this._getDragHandlerData().fOutputId);
         }
-        return isNodeOutlet(output.hostElement) ? this.fMediator.send(new GetCanBeConnectedOutputByOutletRequest(output)) : output;
+        return isNodeOutlet(output.hostElement) ? this.fMediator.execute(new GetCanBeConnectedOutputByOutletRequest(output)) : output;
     }
     getOutput() {
         return this.fComponentsStore.fOutputs.find((x) => x.fId === this._getDragHandlerData().fOutputId);
@@ -3495,7 +3514,7 @@ let CreateConnectionFinalizeExecution = class CreateConnectionFinalizeExecution
         this.fComponentsStore.fDraggable?.fCreateConnection.emit(new FCreateConnectionEvent(this.getTargetOutput(this.getOutput() || this.getOutlet()).fId, this._getInputUnderPointer(event)?.fId, event.getPosition()));
     }
     _getInputUnderPointer(event) {
-        return this.fMediator.send(new FindInputAtPositionRequest(event.getPosition(), this._getDragHandlerData().toConnectorRect, this._getDragHandlerData().canBeConnectedInputs));
+        return this.fMediator.execute(new FindInputAtPositionRequest(event.getPosition(), this._getDragHandlerData().toConnectorRect, this._getDragHandlerData().canBeConnectedInputs));
     }
     _getDragHandlerData() {
         return this._fDragHandler.getData();
@@ -3510,94 +3529,90 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: i2$1.FMediator }] });
 
-class CreateConnectionDragHandlerRequest {
+class CreateConnectionDragHandlerPreparationRequest {
     onPointerDownPosition;
-    fOutput;
-    constructor(onPointerDownPosition, fOutput) {
+    fOutputOrOutlet;
+    constructor(onPointerDownPosition, fOutputOrOutlet) {
         this.onPointerDownPosition = onPointerDownPosition;
-        this.fOutput = fOutput;
+        this.fOutputOrOutlet = fOutputOrOutlet;
     }
 }
 
-let CreateConnectionDragHandlerExecution = class CreateConnectionDragHandlerExecution {
-    fComponentsStore;
-    fDraggableDataContext;
-    fMediator;
-    get flowHost() {
-        return this.fComponentsStore.flowHost;
-    }
-    get transform() {
-        return this.fComponentsStore.fCanvas.transform;
+let CreateConnectionDragHandlerPreparationExecution = class CreateConnectionDragHandlerPreparationExecution {
+    _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
+    get _fHost() {
+        return this._fComponentsStore.fFlow.hostElement;
     }
-    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fMediator = fMediator;
+    get _transform() {
+        return this._fComponentsStore.fCanvas.transform;
     }
     handle(request) {
-        this.fDraggableDataContext.onPointerDownScale = this.transform.scale;
+        this._fDraggableDataContext.onPointerDownScale = this._transform.scale;
         const positionRelativeToFlowComponent = Point.fromPoint(request.onPointerDownPosition)
-            .elementTransform(this.flowHost).div(this.transform.scale);
-        this.fDraggableDataContext.onPointerDownPosition = positionRelativeToFlowComponent;
-        const positionRelativeToCanvasComponent = Point.fromPoint(positionRelativeToFlowComponent).mult(this.transform.scale)
-            .sub(this.transform.position).sub(this.transform.scaledPosition).div(this.transform.scale);
-        this.fDraggableDataContext.draggableItems = [
-            new CreateConnectionDragHandler(this.fMediator, this.fComponentsStore, request.fOutput, positionRelativeToCanvasComponent)
+            .elementTransform(this._fHost).div(this._transform.scale);
+        this._fDraggableDataContext.onPointerDownPosition = positionRelativeToFlowComponent;
+        const positionRelativeToCanvasComponent = Point.fromPoint(positionRelativeToFlowComponent).mult(this._transform.scale)
+            .sub(this._transform.position).sub(this._transform.scaledPosition).div(this._transform.scale);
+        this._fDraggableDataContext.draggableItems = [
+            new CreateConnectionDragHandler(request.fOutputOrOutlet, positionRelativeToCanvasComponent)
         ];
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionDragHandlerExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionDragHandlerExecution });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionDragHandlerPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionDragHandlerPreparationExecution });
 };
-CreateConnectionDragHandlerExecution = __decorate([
-    FExecutionRegister(CreateConnectionDragHandlerRequest)
-], CreateConnectionDragHandlerExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionDragHandlerExecution, decorators: [{
+CreateConnectionDragHandlerPreparationExecution = __decorate([
+    FExecutionRegister(CreateConnectionDragHandlerPreparationRequest)
+], CreateConnectionDragHandlerPreparationExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionDragHandlerPreparationExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: i2$1.FMediator }] });
+        }] });
 
 class CreateConnectionFromOutletPreparationRequest {
     event;
-    constructor(event) {
+    fNode;
+    constructor(event, fNode) {
         this.event = event;
+        this.fNode = fNode;
     }
 }
 
 let CreateConnectionFromOutletPreparationExecution = class CreateConnectionFromOutletPreparationExecution {
-    fComponentsStore;
-    fMediator;
-    constructor(fComponentsStore, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fMediator = fMediator;
-    }
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        const { event } = request;
-        const node = this.fComponentsStore
-            .fNodes.find(n => n.isContains(event.targetElement));
-        const outlet = this.fComponentsStore.fOutlets.find((x) => {
-            return x.hostElement.contains(event.targetElement);
-        });
-        if (!outlet) {
-            throw new Error('Outlet not found');
+        const fOutlet = this._getNodeOutlet(request.fNode);
+        const fOutputs = this._getNodeOutputs(request.fNode);
+        fOutlet.setOutputs(fOutputs);
+        if (!fOutlet.canBeConnected) {
+            return;
         }
-        const nodeOutputs = this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
-        outlet.setOutputs(nodeOutputs);
-        if (outlet.canBeConnected) {
-            if (outlet.isConnectionFromOutlet) {
-                this.createDragHandler(event.getPosition(), outlet);
-            }
-            else {
-                const output = this.fMediator.send(new GetCanBeConnectedOutputByOutletRequest(outlet));
-                if (!output) {
-                    throw RequiredOutput();
-                }
-                this.createDragHandler(event.getPosition(), output);
-            }
+        if (fOutlet.isConnectionFromOutlet) {
+            this._createDragHandler(request.event.getPosition(), fOutlet);
+        }
+        else {
+            this._createDragHandler(request.event.getPosition(), this._getConnectableOutput(fOutlet));
+        }
+    }
+    _getNodeOutlet(fNode) {
+        const result = this._fComponentsStore.fOutlets
+            .find((x) => fNode.isContains(x.hostElement));
+        if (!result) {
+            throw new Error('Outlet not found');
         }
+        return result;
+    }
+    _getNodeOutputs(fNode) {
+        return this._fComponentsStore.fOutputs
+            .filter((x) => fNode.isContains(x.hostElement));
+    }
+    _createDragHandler(position, fOutputOrOutlet) {
+        this._fMediator.execute(new CreateConnectionDragHandlerPreparationRequest(position, fOutputOrOutlet));
     }
-    createDragHandler(position, fOutput) {
-        this.fMediator.send(new CreateConnectionDragHandlerRequest(position, fOutput));
+    _getConnectableOutput(fOutlet) {
+        return this._fMediator.execute(new GetCanBeConnectedOutputByOutletRequest(fOutlet));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutletPreparationExecution, deps: [{ token: FComponentsStore }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutletPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutletPreparationExecution });
 };
 CreateConnectionFromOutletPreparationExecution = __decorate([
@@ -3605,38 +3620,48 @@ CreateConnectionFromOutletPreparationExecution = __decorate([
 ], CreateConnectionFromOutletPreparationExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutletPreparationExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2$1.FMediator }] });
+        }] });
 
 class CreateConnectionFromOutputPreparationRequest {
     event;
-    constructor(event) {
+    fNode;
+    constructor(event, fNode) {
         this.event = event;
+        this.fNode = fNode;
     }
 }
 
 let CreateConnectionFromOutputPreparationExecution = class CreateConnectionFromOutputPreparationExecution {
-    fComponentsStore;
-    fMediator;
-    constructor(fComponentsStore, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fMediator = fMediator;
-    }
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
     handle(request) {
-        const { event } = request;
-        const fOutput = this.fComponentsStore.fOutputs.find((x) => {
-            return x.hostElement.contains(event.targetElement);
-        });
-        if (!fOutput) {
-            throw new Error('Output not found');
+        if (!this._isValid(request)) {
+            return;
         }
+        const fOutput = this._getOutput(request.event.targetElement);
         if (fOutput.canBeConnected) {
-            this.createDragHandler(event.getPosition(), fOutput);
+            this._fMediator.execute(new CreateConnectionDragHandlerPreparationRequest(request.event.getPosition(), fOutput));
         }
     }
-    createDragHandler(position, fOutput) {
-        this.fMediator.send(new CreateConnectionDragHandlerRequest(position, fOutput));
+    _isValid(request) {
+        return this._isNodeOutput(request.event.targetElement, request.fNode);
+    }
+    _isNodeOutput(element, fNode) {
+        return isNodeOutput(element) && !this._getNodeOutlets(fNode).length;
+    }
+    _getNodeOutlets(node) {
+        return this._fComponentsStore.fOutlets
+            .filter((x) => node.isContains(x.hostElement));
+    }
+    _getOutput(element) {
+        const result = this._fComponentsStore.fOutputs
+            .find((x) => x.hostElement.contains(element));
+        if (!result) {
+            throw new Error('Output not found');
+        }
+        return result;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationExecution, deps: [{ token: FComponentsStore }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationExecution });
 };
 CreateConnectionFromOutputPreparationExecution = __decorate([
@@ -3644,40 +3669,14 @@ CreateConnectionFromOutputPreparationExecution = __decorate([
 ], CreateConnectionFromOutputPreparationExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2$1.FMediator }] });
-
-let CreateConnectionFromOutputPreparationValidator = class CreateConnectionFromOutputPreparationValidator {
-    fComponentsStore;
-    constructor(fComponentsStore) {
-        this.fComponentsStore = fComponentsStore;
-    }
-    handle(request) {
-        return this.isNodeOutput(request.event.targetElement, this.getNode(request.event));
-    }
-    getNode(event) {
-        return this.fComponentsStore
-            .fNodes.find(n => n.isContains(event.targetElement));
-    }
-    isNodeOutput(targetElement, node) {
-        return isNodeOutput(targetElement) && !this.getOutlets(node).length;
-    }
-    getOutlets(node) {
-        return this.fComponentsStore.fOutlets.filter((x) => node.isContains(x.hostElement));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationValidator, deps: [{ token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationValidator });
-};
-CreateConnectionFromOutputPreparationValidator = __decorate([
-    FValidatorRegister(CreateConnectionFromOutputPreparationRequest)
-], CreateConnectionFromOutputPreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionFromOutputPreparationValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }] });
+        }] });
 
 class CreateConnectionPreparationRequest {
     event;
-    constructor(event) {
+    fTrigger;
+    constructor(event, fTrigger) {
         this.event = event;
+        this.fTrigger = fTrigger;
     }
 }
 
@@ -3685,32 +3684,28 @@ let CreateConnectionPreparationExecution = class CreateConnectionPreparationExec
     _fMediator = inject(FMediator);
     _fComponentsStore = inject(FComponentsStore);
     _fDraggableDataContext = inject(FDraggableDataContext);
+    _fNode;
     handle(request) {
         if (!this._isValid(request)) {
             return;
         }
         if (isNodeOutlet(request.event.targetElement)) {
-            this._fMediator.send(new CreateConnectionFromOutletPreparationRequest(request.event));
+            this._fMediator.execute(new CreateConnectionFromOutletPreparationRequest(request.event, this._fNode));
         }
-        else if (this._isNodeOutput(request.event.targetElement, this._getNode(request.event))) {
-            this._fMediator.send(new CreateConnectionFromOutputPreparationRequest(request.event));
+        else if (isNodeOutput(request.event.targetElement)) {
+            this._fMediator.execute(new CreateConnectionFromOutputPreparationRequest(request.event, this._fNode));
         }
     }
     _isValid(request) {
         return !!this._getNode(request.event) && this._isValidConditions();
     }
     _getNode(event) {
-        return this._fComponentsStore
+        this._fNode = this._fComponentsStore
             .fNodes.find(n => n.isContains(event.targetElement));
+        return this._fNode;
     }
     _isValidConditions() {
-        return !this._fDraggableDataContext.draggableItems.length && !!this._fComponentsStore.fTempConnection;
-    }
-    _isNodeOutput(targetElement, node) {
-        return isNodeOutput(targetElement) && !this._getOutlets(node).length;
-    }
-    _getOutlets(node) {
-        return this._fComponentsStore.fOutlets.filter((x) => node.isContains(x.hostElement));
+        return this._fDraggableDataContext.isEmpty() && !!this._fComponentsStore.fTempConnection;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateConnectionPreparationExecution });
@@ -3730,9 +3725,9 @@ class ReassignConnectionFinalizeRequest {
 }
 
 class ReassignConnectionDragHandler {
-    _fMediator;
-    _fComponentsStore;
     _fConnection;
+    _fMediator = fInject(FMediator);
+    _fComponentsStore = fInject(FComponentsStore);
     _toConnectorRect = new RoundedRect();
     get _fSnapConnection() {
         return this._fComponentsStore.fSnapConnection;
@@ -3754,9 +3749,7 @@ class ReassignConnectionDragHandler {
         }
         return result;
     }
-    constructor(_fMediator, _fComponentsStore, _fConnection) {
-        this._fMediator = _fMediator;
-        this._fComponentsStore = _fComponentsStore;
+    constructor(_fConnection) {
         this._fConnection = _fConnection;
         this._toConnectorRect = RoundedRect.fromRect(RectExtensions.initialize(this._fConnection.line.point2.x, this._fConnection.line.point2.y));
     }
@@ -3813,7 +3806,7 @@ class ReassignConnectionDragHandler {
         return fClosestInput && fClosestInput.distance < this._fSnapConnection.fSnapThreshold ? fClosestInput : undefined;
     }
     onPointerUp() {
-        this._drawConnection(this._fInputWithRect.fRect, this._fInputWithRect.fConnector.fConnectableSide);
+        this._drawConnection(this._toConnectorRect, this._fInputWithRect.fConnector.fConnectableSide);
         this._fSnapConnection?.hide();
         this._fMediator.execute(new UnmarkAllCanBeConnectedInputsRequest(this._canBeConnectedInputs.map((x) => x.fConnector)));
     }
@@ -3872,7 +3865,7 @@ let ReassignConnectionFinalizeExecution = class ReassignConnectionFinalizeExecut
         this._emitReassignConnectionEvent(event, fInput);
     }
     _getInputUnderPointer(event) {
-        return this._fMediator.send(new FindInputAtPositionRequest(event.getPosition(), this._getDragHandlerData().toConnectorRect, this._getDragHandlerData().canBeConnectedInputs));
+        return this._fMediator.execute(new FindInputAtPositionRequest(event.getPosition(), this._getDragHandlerData().toConnectorRect, this._getDragHandlerData().canBeConnectedInputs));
     }
     _isReassignToDifferentInput(fInput) {
         return this._fDragHandler.getConnection().fInputId !== fInput.fId;
@@ -3899,8 +3892,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
 
 class ReassignConnectionPreparationRequest {
     event;
-    constructor(event) {
+    fTrigger;
+    constructor(event, fTrigger) {
         this.event = event;
+        this.fTrigger = fTrigger;
     }
 }
 
@@ -3926,7 +3921,7 @@ let ReassignConnectionPreparationExecution = class ReassignConnectionPreparation
         this._fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
             .elementTransform(this._fHost).div(this._transform.scale);
         this._fDraggableDataContext.draggableItems = [
-            new ReassignConnectionDragHandler(this._fMediator, this._fComponentsStore, this._fConnection)
+            new ReassignConnectionDragHandler(this._fConnection)
         ];
         setTimeout(() => this._updateConnectionLayer());
     }
@@ -3967,12 +3962,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
 
 const CONNECTIONS_PROVIDERS = [
     CreateConnectionFinalizeExecution,
-    CreateConnectionDragHandlerExecution,
+    CreateConnectionDragHandlerPreparationExecution,
     CreateConnectionFromOutletPreparationExecution,
     GetCanBeConnectedOutputByOutletExecution,
-    GetCanBeConnectedOutputByOutletValidator,
     CreateConnectionFromOutputPreparationExecution,
-    CreateConnectionFromOutputPreparationValidator,
     CreateConnectionPreparationExecution,
     ReassignConnectionFinalizeExecution,
     ReassignConnectionPreparationExecution,
@@ -4009,10 +4002,10 @@ let GetNormalizedParentNodeRectExecution = class GetNormalizedParentNodeRectExec
         return RectExtensions.initialize(rect.x + padding[0], rect.y + padding[1], rect.width - padding[0] - padding[2], rect.height - padding[1] - padding[3]);
     }
     _getNodeRect(fNode) {
-        return this.fMediator.send(new GetNormalizedElementRectRequest(fNode.hostElement, false));
+        return this.fMediator.execute(new GetNormalizedElementRectRequest(fNode.hostElement, false));
     }
     getNodePadding(node, rect) {
-        return this.fMediator.send(new GetNodePaddingRequest(node, rect));
+        return this.fMediator.execute(new GetNodePaddingRequest(node, rect));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNormalizedParentNodeRectExecution, deps: [{ token: FComponentsStore }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNormalizedParentNodeRectExecution });
@@ -4114,7 +4107,7 @@ let IsConnectionUnderNodeExecution = class IsConnectionUnderNodeExecution {
         return connectors.map((x) => x.fId);
     }
     _calculateConnectionsUnderNode(fNode) {
-        const fNodeRect = this._fMediator.send(new GetNormalizedElementRectRequest(fNode.hostElement, true));
+        const fNodeRect = this._fMediator.execute(new GetNormalizedElementRectRequest(fNode.hostElement, true));
         return this._fComponentsStore.fConnections.filter((x) => this._isConnectionHasIntersectionsWithNode(x, fNodeRect));
     }
     _isConnectionHasIntersectionsWithNode(fConnection, fNodeRect) {
@@ -4157,19 +4150,122 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }] });
 
-class CalculateCommonNodeMoveRestrictionsRequest {
-    restrictions;
-    constructor(restrictions) {
-        this.restrictions = restrictions;
+class BaseConnectionDragHandler {
+    fConnection;
+    _fMediator = fInject(FMediator);
+    _fComponentStore = fInject(FComponentsStore);
+    _fOutputWithRect;
+    _fInputWithRect;
+    get _fOutput() {
+        const result = this._fComponentStore.fOutputs.find((x) => x.fId === this.fConnection.fOutputId);
+        if (!result) {
+            throw new Error(this._connectorNotFoundPrefix(`fOutput with id ${this.fConnection.fOutputId} not found`));
+        }
+        return result;
+    }
+    get _fInput() {
+        const result = this._fComponentStore.fInputs.find((x) => x.fId === this.fConnection.fInputId);
+        if (!result) {
+            throw new Error(this._connectorNotFoundPrefix(`fInput with id ${this.fConnection.fInputId} not found`));
+        }
+        return result;
+    }
+    _sourceDifference = PointExtensions.initialize();
+    _targetDifference = PointExtensions.initialize();
+    constructor(fConnection) {
+        this.fConnection = fConnection;
+        this._initialize();
+    }
+    _initialize() {
+        this._fOutputWithRect = this._fMediator.execute(new GetConnectorAndRectRequest(this._fOutput));
+        this._fInputWithRect = this._fMediator.execute(new GetConnectorAndRectRequest(this._fInput));
+    }
+    setSourceDifference(difference) {
+        this._sourceDifference = difference;
+    }
+    setTargetDifference(difference) {
+        this._targetDifference = difference;
+    }
+    redraw() {
+        this._redrawConnection(this._recalculateConnection());
+    }
+    _recalculateConnection() {
+        return this._fMediator.execute(new CalculateConnectionLineByBehaviorRequest(RoundedRect.fromRoundedRect(this._fOutputWithRect.fRect).addPoint(this._sourceDifference), RoundedRect.fromRoundedRect(this._fInputWithRect.fRect).addPoint(this._targetDifference), this.fConnection.fBehavior, this._fOutputWithRect.fConnector.fConnectableSide, this._fInputWithRect.fConnector.fConnectableSide));
+    }
+    _redrawConnection(line) {
+        this.fConnection.setLine(line.point1, this._fOutputWithRect.fConnector.fConnectableSide, line.point2, this._fInputWithRect.fConnector.fConnectableSide);
+        this.fConnection.redraw();
+    }
+    _connectorNotFoundPrefix(message) {
+        return `ConnectionDragHandler Error: Connection From (fOutput)${this.fConnection.fOutputId} To (fInput)${this.fConnection.fInputId}. ${message}. Please ensure that all f-connections are associated with existing connectors`;
+    }
+}
+
+class SourceConnectionDragHandler extends BaseConnectionDragHandler {
+    constructor(fConnection) {
+        super(fConnection);
+    }
+    setSourceDifference(difference) {
+        super.setSourceDifference(difference);
+        this.redraw();
+    }
+}
+
+class SourceTargetConnectionDragHandler extends BaseConnectionDragHandler {
+    _callTracker = new Map();
+    constructor(fConnection) {
+        super(fConnection);
+    }
+    setSourceDifference(difference) {
+        super.setSourceDifference(difference);
+        this._checkAndTriggerAction();
+    }
+    setTargetDifference(difference) {
+        super.setTargetDifference(difference);
+        this._checkAndTriggerAction();
+    }
+    _checkAndTriggerAction() {
+        if ([...this._callTracker.values()].every(Boolean)) {
+            this._callTracker.clear();
+            this.redraw();
+        }
+    }
+}
+
+class TargetConnectionDragHandler extends BaseConnectionDragHandler {
+    constructor(fConnection) {
+        super(fConnection);
+    }
+    setTargetDifference(difference) {
+        super.setTargetDifference(difference);
+        this.redraw();
+    }
+}
+
+class CalculateCommonNodeMoveLimitsRequest {
+    limits;
+    constructor(limits) {
+        this.limits = limits;
     }
 }
 
-let CalculateCommonNodeMoveRestrictionsExecution = class CalculateCommonNodeMoveRestrictionsExecution {
+let CalculateCommonNodeMoveLimitsExecution = class CalculateCommonNodeMoveLimitsExecution {
+    _fComponentsStore = inject(FComponentsStore);
+    get _vCellSize() {
+        return this._fComponentsStore.fDraggable.vCellSize;
+    }
+    get _hCellSize() {
+        return this._fComponentsStore.fDraggable.hCellSize;
+    }
     handle(request) {
-        return this._calculateCommonRestrictions(request.restrictions);
+        return this._calculateCommonLimits(request.limits);
     }
-    _calculateCommonRestrictions(restrictions) {
-        return restrictions.reduce((result, x) => this._clampRestrictions(result, x), restrictions[0]);
+    _calculateCommonLimits(limits) {
+        this._snapLimitToGrid(limits[0]);
+        return limits.reduce((result, x) => {
+            this._snapLimitToGrid(x);
+            return this._clampRestrictions(result, x);
+        }, limits[0]);
     }
     _clampRestrictions(common, x) {
         common.min = this._clampMinRestrictions(common.min, x.min);
@@ -4188,246 +4284,146 @@ let CalculateCommonNodeMoveRestrictionsExecution = class CalculateCommonNodeMove
             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 });
+    _snapLimitToGrid(restriction) {
+        const { min, max, position } = restriction;
+        restriction.min = {
+            x: this._snapLimitToGridMinimum(position.x + min.x, this._hCellSize) - position.x,
+            y: this._snapLimitToGridMinimum(position.y + min.y, this._vCellSize) - position.y,
+        };
+        restriction.max = {
+            x: this._snapLimitToGridMaximum(position.x + max.x, this._hCellSize) - position.x,
+            y: this._snapLimitToGridMaximum(position.y + max.y, this._vCellSize) - position.y,
+        };
+    }
+    _snapLimitToGridMinimum(value, cellSize) {
+        return Math.ceil(value / cellSize) * cellSize;
+    }
+    _snapLimitToGridMaximum(value, cellSize) {
+        return Math.floor(value / cellSize) * cellSize;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveLimitsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveLimitsExecution });
 };
-CalculateCommonNodeMoveRestrictionsExecution = __decorate([
-    FExecutionRegister(CalculateCommonNodeMoveRestrictionsRequest)
-], CalculateCommonNodeMoveRestrictionsExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveRestrictionsExecution, decorators: [{
+CalculateCommonNodeMoveLimitsExecution = __decorate([
+    FExecutionRegister(CalculateCommonNodeMoveLimitsRequest)
+], CalculateCommonNodeMoveLimitsExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateCommonNodeMoveLimitsExecution, decorators: [{
             type: Injectable
         }] });
 
 class PutInputConnectionHandlersToArrayRequest {
-    nodeDragHandler;
+    fDragHandler;
     outputIds;
     result;
-    constructor(nodeDragHandler, outputIds, result) {
-        this.nodeDragHandler = nodeDragHandler;
+    constructor(fDragHandler, outputIds, result) {
+        this.fDragHandler = fDragHandler;
         this.outputIds = outputIds;
         this.result = result;
     }
 }
 
-class ConnectionBaseDragHandler {
-    fMediator;
-    fComponentsStore;
-    connection;
-    fOutputWithRect;
-    fInputWithRect;
-    constructor(fMediator, fComponentsStore, connection) {
-        this.fMediator = fMediator;
-        this.fComponentsStore = fComponentsStore;
-        this.connection = connection;
+let PutInputConnectionHandlersToArrayExecution = class PutInputConnectionHandlersToArrayExecution {
+    _fComponentsStore = inject(FComponentsStore);
+    get _fConnections() {
+        return this._fComponentsStore.fConnections;
     }
-    prepareDragSequence() {
-        this.fOutputWithRect = this.fMediator.send(new GetConnectorAndRectRequest(this.getOutput()));
-        this.fInputWithRect = this.fMediator.send(new GetConnectorAndRectRequest(this.getInput()));
+    handle(request) {
+        this._getInputConnections(request.fDragHandler.fNode).forEach((fConnection) => {
+            this._createAndSetConnectionToNodeHandler(fConnection, request);
+        });
     }
-    getOutput() {
-        const result = this.fComponentsStore.fOutputs.find((x) => x.fId === this.connection.fOutputId);
-        if (!result) {
-            throw new Error(this.connectorNotFoundPrefix(`fOutput with id ${this.connection.fOutputId} not found`));
+    _getInputConnections(fNode) {
+        const ids = new Set(this._getNodeInputIds(fNode));
+        return this._fConnections.filter((x) => ids.has(x.fInputId));
+    }
+    _getNodeInputIds(fNode) {
+        return this._fComponentsStore.fInputs
+            .filter((x) => fNode.isContains(x.hostElement))
+            .map((x) => x.fId);
+    }
+    _createAndSetConnectionToNodeHandler(fConnection, request) {
+        let fHandler = this._getExistingConnectionHandler(request.result, fConnection);
+        if (!fHandler) {
+            fHandler = this._createConnectionHandler(request.outputIds, fConnection);
+            request.result.push(fHandler);
         }
-        return result;
+        request.fDragHandler.fTargetHandlers.push(fHandler);
     }
-    getInput() {
-        const result = this.fComponentsStore.fInputs.find((x) => x.fId === this.connection.fInputId);
-        if (!result) {
-            throw new Error(this.connectorNotFoundPrefix(`fInput with id ${this.connection.fInputId} not found`));
+    _getExistingConnectionHandler(fHandlers, fConnection) {
+        return fHandlers.find((x) => x.fConnection.fId === fConnection.fId);
+    }
+    _createConnectionHandler(outputIds, fConnection) {
+        let result;
+        if (outputIds.includes(fConnection.fOutputId)) {
+            result = new SourceTargetConnectionDragHandler(fConnection);
+        }
+        else {
+            result = new TargetConnectionDragHandler(fConnection);
         }
         return result;
     }
-    connectorNotFoundPrefix(message) {
-        return `ConnectionDragHandler Error: Connection From (fOutput)${this.connection.fOutputId} To (fInput)${this.connection.fInputId}. ${message}. Please ensure that all f-connections are associated with existing connectors`;
+    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([
+    FExecutionRegister(PutInputConnectionHandlersToArrayRequest)
+], PutInputConnectionHandlersToArrayExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, decorators: [{
+            type: Injectable
+        }] });
+
+class PutOutputConnectionHandlersToArrayRequest {
+    fDragHandler;
+    inputIds;
+    result;
+    constructor(fDragHandler, inputIds, result) {
+        this.fDragHandler = fDragHandler;
+        this.inputIds = inputIds;
+        this.result = result;
     }
-    getRestrictedDifference(difference, restrictions) {
-        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)
-        };
-    }
-    redrawConnection(line) {
-        this.connection.setLine(line.point1, this.fOutputWithRect.fConnector.fConnectableSide, line.point2, this.fInputWithRect.fConnector.fConnectableSide);
-        this.connection.redraw();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ConnectionBaseDragHandler, deps: [{ token: i2$1.FMediator }, { token: FComponentsStore }, { token: FConnectionBase }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: ConnectionBaseDragHandler, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ConnectionBaseDragHandler, decorators: [{
-            type: Directive
-        }], ctorParameters: () => [{ type: i2$1.FMediator }, { type: FComponentsStore }, { type: FConnectionBase }] });
 
-class ConnectionDragHandler extends ConnectionBaseDragHandler {
-    sourceRestrictions;
-    targetRestrictions;
-    constructor(fMediator, fComponentsStore, connection) {
-        super(fMediator, fComponentsStore, connection);
-    }
-    setOutputRestrictions(restrictions) {
-        this.sourceRestrictions = restrictions;
-    }
-    setInputRestrictions(restrictions) {
-        this.targetRestrictions = 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 }, this.sourceRestrictions)), RoundedRect.fromRoundedRect(this.fInputWithRect.fRect).addPoint(this.getRestrictedDifference({ ...difference }, this.targetRestrictions)), this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
-    }
-}
-
-class ConnectionTargetDragHandler extends ConnectionBaseDragHandler {
-    restrictions;
-    constructor(fMediator, fComponentsStore, connection, restrictions) {
-        super(fMediator, fComponentsStore, connection);
-        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 }, this.restrictions)), this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
-    }
-}
-
-let PutInputConnectionHandlersToArrayExecution = class PutInputConnectionHandlersToArrayExecution {
-    _fMediator = inject(FMediator);
+let PutOutputConnectionHandlersToArrayExecution = class PutOutputConnectionHandlersToArrayExecution {
     _fComponentsStore = inject(FComponentsStore);
     get _fConnections() {
         return this._fComponentsStore.fConnections;
     }
     handle(request) {
-        this.getInputConnections(request.nodeDragHandler.fNode).forEach((connection) => {
-            const index = this.getExistingConnectionHandlerIndex(request.result, connection);
-            if (index !== -1) {
-                this.updateExistingConnectionHandler(request.result, index, request.nodeDragHandler);
-            }
-            else {
-                request.result.push(this.createNewConnectionHandler(request.nodeDragHandler, request.outputIds, connection));
-            }
+        this._getOutputConnections(request.fDragHandler.fNode).forEach((fConnection) => {
+            this._createAndSetConnectionToNodeHandler(fConnection, request);
         });
     }
-    getInputConnections(node) {
-        const inputIds = new Set(this.getInputsForNode(node).map((x) => x.fId));
-        return this._fConnections.filter((x) => inputIds.has(x.fInputId));
+    _getOutputConnections(node) {
+        const ids = new Set(this._getNodeOutputIds(node));
+        return this._fConnections.filter((x) => ids.has(x.fOutputId));
     }
-    getInputsForNode(node) {
-        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);
+    _getNodeOutputIds(node) {
+        return this._fComponentsStore.fOutputs
+            .filter((x) => node.isContains(x.hostElement))
+            .map((x) => x.fId);
     }
-    createNewConnectionHandler(nodeDragHandler, outputIds, connection) {
-        let result;
-        if (outputIds.includes(connection.fOutputId)) {
-            result = this.getNewConnectionHandler(connection, nodeDragHandler);
-        }
-        else {
-            result = this.getNewSourceConnectionHandler(connection, nodeDragHandler);
+    _createAndSetConnectionToNodeHandler(fConnection, request) {
+        let fHandler = this._getExistingConnectionHandler(request.result, fConnection);
+        if (!fHandler) {
+            fHandler = this._createConnectionHandler(request.inputIds, fConnection);
+            request.result.push(fHandler);
         }
-        return result;
-    }
-    getNewConnectionHandler(connection, nodeDragHandler) {
-        const handler = new ConnectionDragHandler(this._fMediator, this._fComponentsStore, connection);
-        handler.setInputRestrictions(nodeDragHandler.restrictions);
-        return handler;
-    }
-    updateExistingConnectionHandler(result, index, nodeDragHandler) {
-        result[index].setInputRestrictions(nodeDragHandler.restrictions);
+        request.fDragHandler.fSourceHandlers.push(fHandler);
     }
-    getNewSourceConnectionHandler(connection, nodeDragHandler) {
-        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: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution });
-};
-PutInputConnectionHandlersToArrayExecution = __decorate([
-    FExecutionRegister(PutInputConnectionHandlersToArrayRequest)
-], PutInputConnectionHandlersToArrayExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, decorators: [{
-            type: Injectable
-        }] });
-
-class PutOutputConnectionHandlersToArrayRequest {
-    nodeDragHandler;
-    inputIds;
-    result;
-    constructor(nodeDragHandler, inputIds, result) {
-        this.nodeDragHandler = nodeDragHandler;
-        this.inputIds = inputIds;
-        this.result = result;
-    }
-}
-
-class ConnectionSourceDragHandler extends ConnectionBaseDragHandler {
-    restrictions;
-    constructor(fMediator, fComponentsStore, connection, restrictions) {
-        super(fMediator, fComponentsStore, connection);
-        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 }, this.restrictions)), this.fInputWithRect.fRect, this.connection.fBehavior, this.fOutputWithRect.fConnector.fConnectableSide, this.fInputWithRect.fConnector.fConnectableSide));
-    }
-}
-
-let PutOutputConnectionHandlersToArrayExecution = class PutOutputConnectionHandlersToArrayExecution {
-    fComponentsStore;
-    fMediator;
-    get fConnections() {
-        return this.fComponentsStore.fConnections;
-    }
-    constructor(fComponentsStore, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fMediator = fMediator;
+    _getExistingConnectionHandler(fHandlers, fConnection) {
+        return fHandlers.find((x) => x.fConnection.fId === fConnection.fId);
     }
-    handle(request) {
-        this.getOutputConnections(request.nodeDragHandler.fNode).forEach((connection) => {
-            const index = this.getExistingConnectionHandlerIndex(request.result, connection);
-            if (index !== -1) {
-                this.updateExistingConnectionHandler(request.result, index, request.nodeDragHandler);
-            }
-            else {
-                request.result.push(this.createNewConnectionHandler(request.nodeDragHandler, request.inputIds, connection));
-            }
-        });
-    }
-    getOutputConnections(node) {
-        const outputsIds = new Set(this.getOutputsForNode(node).map((x) => x.fId));
-        return this.fConnections.filter((x) => outputsIds.has(x.fOutputId));
-    }
-    getOutputsForNode(node) {
-        return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
-    }
-    getExistingConnectionHandlerIndex(result, connection) {
-        return result.findIndex((x) => x instanceof ConnectionDragHandler && x.connection.fId === connection.fId);
-    }
-    createNewConnectionHandler(nodeDragHandler, inputIds, connection) {
+    _createConnectionHandler(inputIds, fConnection) {
         let result;
-        if (inputIds.includes(connection.fInputId)) {
-            result = this.getNewConnectionHandler(connection, nodeDragHandler);
+        if (inputIds.includes(fConnection.fInputId)) {
+            result = new SourceTargetConnectionDragHandler(fConnection);
         }
         else {
-            result = this.getNewSourceConnectionHandler(connection, nodeDragHandler);
+            result = new SourceConnectionDragHandler(fConnection);
         }
         return result;
     }
-    getNewConnectionHandler(connection, nodeDragHandler) {
-        const handler = new ConnectionDragHandler(this.fMediator, this.fComponentsStore, connection);
-        handler.setOutputRestrictions(nodeDragHandler.restrictions);
-        return handler;
-    }
-    updateExistingConnectionHandler(result, index, nodeDragHandler) {
-        result[index].setOutputRestrictions(nodeDragHandler.restrictions);
-    }
-    getNewSourceConnectionHandler(connection, nodeDragHandler) {
-        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$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution });
 };
 PutOutputConnectionHandlersToArrayExecution = __decorate([
@@ -4435,9 +4431,9 @@ PutOutputConnectionHandlersToArrayExecution = __decorate([
 ], PutOutputConnectionHandlersToArrayExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2$1.FMediator }] });
+        }] });
 
-class CalculateNodeMoveRestrictionsRequest {
+class CalculateNodeMoveLimitsRequest {
     fNode;
     hasParentNodeInSelected;
     constructor(fNode, hasParentNodeInSelected) {
@@ -4446,35 +4442,42 @@ class CalculateNodeMoveRestrictionsRequest {
     }
 }
 
-let CalculateNodeMoveRestrictionsExecution = class CalculateNodeMoveRestrictionsExecution {
+let CalculateNodeMoveLimitsExecution = class CalculateNodeMoveLimitsExecution {
     _fMediator = inject(FMediator);
     handle(request) {
         if (!request.fNode.fParentId || request.hasParentNodeInSelected) {
-            return { ...DEFAULT_RESTRICTIONS };
+            return { ...DEFAULT_LIMITS };
         }
-        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))
-        };
+        return this._calculateDifference(this._fParentRect(request.fNode), this._fNodeRect(request.fNode));
     }
-    _getNodeRect(fNode) {
+    _fNodeRect(fNode) {
         return this._fMediator.execute(new GetNormalizedElementRectRequest(fNode.hostElement, false));
     }
-    _getParentNodeRect(fNode) {
+    _fParentRect(fNode) {
         return this._fMediator.execute(new GetNormalizedParentNodeRectRequest(fNode));
     }
-    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 });
+    _calculateDifference(fParentRect, fRect) {
+        return {
+            min: this._calculateMinimumDifference(fParentRect, fRect),
+            max: this._calculateMaximumDifference(fParentRect, fRect)
+        };
+    }
+    _calculateMinimumDifference(fParentRect, fRect) {
+        return PointExtensions.initialize(fParentRect.x - fRect.x, fParentRect.y - fRect.y);
+    }
+    _calculateMaximumDifference(fParentRect, fRect) {
+        return PointExtensions.initialize((fParentRect.x + fParentRect.width) - (fRect.x + fRect.width), (fParentRect.y + fParentRect.height) - (fRect.y + fRect.height));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveLimitsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveLimitsExecution });
 };
-CalculateNodeMoveRestrictionsExecution = __decorate([
-    FExecutionRegister(CalculateNodeMoveRestrictionsRequest)
-], CalculateNodeMoveRestrictionsExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveRestrictionsExecution, decorators: [{
+CalculateNodeMoveLimitsExecution = __decorate([
+    FExecutionRegister(CalculateNodeMoveLimitsRequest)
+], CalculateNodeMoveLimitsExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CalculateNodeMoveLimitsExecution, decorators: [{
             type: Injectable
         }] });
-const DEFAULT_RESTRICTIONS = {
+const DEFAULT_LIMITS = {
     min: PointExtensions.initialize(-Infinity, -Infinity),
     max: PointExtensions.initialize(Infinity, Infinity)
 };
@@ -4487,28 +4490,23 @@ class CreateMoveNodesDragModelFromSelectionRequest {
 }
 
 class NodeDragHandler {
-    _fComponentsStore;
     fNode;
-    restrictions;
+    fSourceHandlers;
+    fTargetHandlers;
     _onPointerDownPosition = PointExtensions.initialize();
-    constructor(_fComponentsStore, fNode, restrictions) {
-        this._fComponentsStore = _fComponentsStore;
+    constructor(fNode, fSourceHandlers = [], fTargetHandlers = []) {
         this.fNode = fNode;
-        this.restrictions = restrictions;
+        this.fSourceHandlers = fSourceHandlers;
+        this.fTargetHandlers = fTargetHandlers;
         this._onPointerDownPosition = { ...fNode.position };
     }
     onPointerMove(difference) {
-        const restrictedDifference = this._getDifference(difference);
-        this._redraw(this._getPosition(restrictedDifference));
+        this._redraw(this._calculateNewPosition(difference));
+        this.fSourceHandlers.forEach((x) => x.setSourceDifference(difference));
+        this.fTargetHandlers.forEach((x) => x.setTargetDifference(difference));
     }
-    _getPosition(difference) {
-        return Point.fromPoint(this._onPointerDownPosition).add(difference);
-    }
-    _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)
-        };
+    _calculateNewPosition(difference) {
+        return PointExtensions.sum(this._onPointerDownPosition, difference);
     }
     _redraw(position) {
         this.fNode.updatePosition(position);
@@ -4517,32 +4515,77 @@ class NodeDragHandler {
     onPointerUp() {
         this.fNode.positionChange.emit(this.fNode.position);
     }
-    getDifferenceWithCellSize(difference) {
-        const position = this._getPosition(this._getDifference(difference));
-        return Point.fromPoint(this._applyCellSize(position)).sub(this._onPointerDownPosition);
+}
+
+class PointBoundsLimiter {
+    _onPointerDown;
+    _limit;
+    _fComponentsStore = fInject(FComponentsStore);
+    _vCellSize = this._fComponentsStore.fDraggable.vCellSize;
+    _hCellSize = this._fComponentsStore.fDraggable.hCellSize;
+    constructor(_onPointerDown, _limit) {
+        this._onPointerDown = _onPointerDown;
+        this._limit = _limit;
     }
-    _applyCellSize(position) {
-        const hCellSize = this._fComponentsStore.fDraggable.hCellSize;
-        const vCellSize = this._fComponentsStore.fDraggable.vCellSize;
+    limit(difference, adjustCellSize) {
+        const { min, max } = this._limit;
+        const { x, y } = this._cellSizeStrategies[+adjustCellSize](difference);
         return {
-            x: Math.round(position.x / hCellSize) * hCellSize,
-            y: Math.round(position.y / vCellSize) * vCellSize
+            x: this._clamp(x, min.x, max.x),
+            y: this._clamp(y, min.y, max.y),
         };
     }
-}
-
-//TODO: Implement this class
-class NodeResizeByChildDragHandler {
-    fDraggableDataContext;
-    onPointerDownPosition = PointExtensions.initialize();
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
+    _cellSizeStrategies = {
+        0: this._skipCellSize.bind(this),
+        1: this._applyCellSize.bind(this)
+    };
+    _applyCellSize(difference) {
+        return {
+            x: this._snapToGrid(this._onPointerDown.x + difference.x, this._hCellSize) - this._onPointerDown.x,
+            y: this._snapToGrid(this._onPointerDown.y + difference.y, this._vCellSize) - this._onPointerDown.y
+        };
     }
-    prepareDragSequence() {
+    _skipCellSize(difference) {
+        return difference;
     }
+    _clamp(value, min, max) {
+        return Math.min(Math.max(value, min), max);
+    }
+    _snapToGrid(value, cellSize) {
+        return Math.round(value / cellSize) * cellSize;
+    }
+}
+
+// import { FMediator } from '@foblex/mediator';
+class SummaryNodeDragHandler {
+    limits;
+    fHandlers;
+    commonRect;
+    // private _fMediator = fInject(FMediator);
+    _fComponentStore = fInject(FComponentsStore);
+    _fBoundsLimiter;
+    constructor(limits, fHandlers, commonRect) {
+        this.limits = limits;
+        this.fHandlers = fHandlers;
+        this.commonRect = commonRect;
+        //this._onPointerDownPosition = this._getDraggedNodesBoundingRect();
+        this._fBoundsLimiter = new PointBoundsLimiter(this.commonRect, limits);
+    }
+    // private _getDraggedNodesBoundingRect(): IRect {
+    //   return RectExtensions.union(this.fHandlers.map((x) => {
+    //     return this._fMediator.execute<IRect>(new GetNormalizedElementRectRequest(x.fNode.hostElement, false));
+    //   })) || RectExtensions.initialize();
+    // }
     onPointerMove(difference) {
+        const adjustCellSize = this._fComponentStore.fDraggable.fCellSizeWhileDragging;
+        const differenceWithRestrictions = this._fBoundsLimiter.limit(difference, adjustCellSize);
+        this.fHandlers.forEach((x) => x.onPointerMove(differenceWithRestrictions));
     }
     onPointerUp() {
+        this.fHandlers.forEach((x) => x.onPointerUp());
+    }
+    calculateRestrictedDifference(difference) {
+        return this._fBoundsLimiter.limit(difference, true);
     }
 }
 
@@ -4551,8 +4594,12 @@ let CreateMoveNodesDragModelFromSelectionExecution = class CreateMoveNodesDragMo
     _fComponentsStore = inject(FComponentsStore);
     _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
-        const fItemsToDrag = this._getNodesWithRestrictions(this._getDraggedNodes(request.nodeWithDisabledSelection));
-        return this.getDragHandlersWithConnections(this.getDragHandlersFromNodes(fItemsToDrag), this.getAllOutputIds(fItemsToDrag), this.getAllInputIds(fItemsToDrag));
+        const fDraggedNodes = this._getDraggedNodes(request.nodeWithDisabledSelection);
+        const fNodesToDrag = this._getNodesToDragWithCommonLimits(fDraggedNodes);
+        const fDragHandlers = this._mapToNodeDragHandlers(fNodesToDrag);
+        this._setConnectionsHandlersToNodes(fDragHandlers, this._getAllOutputIds(fNodesToDrag), this._getAllInputIds(fNodesToDrag));
+        const commonLimits = this._calculateCommonLimits(this._getNodesMoveLimits(fNodesToDrag, [], fDraggedNodes));
+        return new SummaryNodeDragHandler(commonLimits, fDragHandlers, this._getDraggedNodesBoundingRect(fNodesToDrag));
     }
     _getDraggedNodes(nodeWithDisabledSelection) {
         const result = this._getNodesFromSelection();
@@ -4570,61 +4617,58 @@ let CreateMoveNodesDragModelFromSelectionExecution = class CreateMoveNodesDragMo
         return this._fComponentsStore.fNodes
             .find(n => n.isContains(hostElement));
     }
-    _getNodesWithRestrictions(fDraggedNodes) {
-        const result = [];
-        fDraggedNodes.forEach((x) => {
+    _getNodesToDragWithCommonLimits(fDraggedNodes) {
+        return fDraggedNodes.reduce((result, x) => {
+            result.push(x);
+            return result.concat(this._getChildrenNodes(x.fId));
+        }, []);
+    }
+    _getNodesMoveLimits(fNodes, fParentNodes, fDraggedNodes) {
+        return fDraggedNodes.map((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));
+            return { position: x.position, ...this._getNodeMoveLimits(x, fParentNodes, fDraggedNodes) };
         });
-        this._applyCommonRestrictions(result);
-        return result;
     }
-    _getNodeMoveRestrictions(fNode, fParentNodes, fDraggedNodes) {
-        return this._fMediator.execute(new CalculateNodeMoveRestrictionsRequest(fNode, this._isParentNodeInArray(fParentNodes, fDraggedNodes)));
+    _getNodeMoveLimits(fNode, fParentNodes, fDraggedNodes) {
+        return this._fMediator.execute(new CalculateNodeMoveLimitsRequest(fNode, this._isParentNodeInArray(fParentNodes, fDraggedNodes)));
     }
     _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;
-        });
+    _calculateCommonLimits(limits) {
+        return this._fMediator.execute(new CalculateCommonNodeMoveLimitsRequest(limits));
     }
-    getAllOutputIds(items) {
-        return flatMap(items, (item) => this.getOutputsForNode(item.fDraggedNode).map((x) => x.fId));
+    _getAllOutputIds(fNodes) {
+        return flatMap(fNodes, (fNode) => this._getNodeOutputIds(fNode));
+    }
+    _getNodeOutputIds(fNode) {
+        return this._fComponentsStore.fOutputs.filter((x) => fNode.fId === x.fNodeId)
+            .map((x) => x.fId);
     }
-    getOutputsForNode(node) {
-        return this._fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
+    _getAllInputIds(fNodes) {
+        return flatMap(fNodes, (fNode) => this._getNodeInputIds(fNode));
     }
-    getAllInputIds(items) {
-        return flatMap(items, (item) => this.getInputsForNode(item.fDraggedNode).map((x) => x.fId));
+    _getNodeInputIds(fNode) {
+        return this._fComponentsStore.fInputs.filter((x) => fNode.fId === x.fNodeId)
+            .map((x) => x.fId);
     }
-    getInputsForNode(node) {
-        return this._fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
+    _mapToNodeDragHandlers(items) {
+        return items.map((x) => new NodeDragHandler(x));
     }
-    getDragHandlersFromNodes(items) {
-        let result = [];
-        items.forEach((node) => {
-            result.push(new NodeDragHandler(this._fComponentsStore, node.fDraggedNode, { min: node.min, max: node.max }), ...(node.fParentNodes || []).map(() => new NodeResizeByChildDragHandler(this._fDraggableDataContext)));
+    _setConnectionsHandlersToNodes(handlers, outputIds, inputIds) {
+        const fConnectionHandlers = [];
+        handlers.forEach((fNodeHandler) => {
+            this._fMediator.execute(new PutOutputConnectionHandlersToArrayRequest(fNodeHandler, inputIds, fConnectionHandlers));
+            this._fMediator.execute(new PutInputConnectionHandlersToArrayRequest(fNodeHandler, outputIds, fConnectionHandlers));
         });
-        return result;
     }
-    getDragHandlersWithConnections(handlers, outputIds, inputIds) {
-        let result = handlers;
-        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;
+    _getDraggedNodesBoundingRect(fNodes) {
+        return RectExtensions.union(fNodes.map((x) => {
+            return this._fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false));
+        })) || RectExtensions.initialize();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateMoveNodesDragModelFromSelectionExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: CreateMoveNodesDragModelFromSelectionExecution });
@@ -4637,27 +4681,32 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
         }] });
 
 const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS = [
-    CalculateCommonNodeMoveRestrictionsExecution,
-    CalculateNodeMoveRestrictionsExecution,
+    CalculateCommonNodeMoveLimitsExecution,
+    CalculateNodeMoveLimitsExecution,
     PutInputConnectionHandlersToArrayExecution,
     PutOutputConnectionHandlersToArrayExecution,
     CreateMoveNodesDragModelFromSelectionExecution,
 ];
 
 class LineAlignmentPreparationRequest {
+    fNodes;
+    commonRect;
+    constructor(fNodes, commonRect) {
+        this.fNodes = fNodes;
+        this.commonRect = commonRect;
+    }
 }
 
 class LineAlignmentDragHandler {
-    _fComponentsStore;
     _lineService;
     _size;
     _draggedNodeRect;
     _rects;
     _restrictions;
+    _fComponentsStore = fInject(FComponentsStore);
     _debounceTimer = null;
     _transform;
-    constructor(_fComponentsStore, _lineService, _size, _draggedNodeRect, _rects, _restrictions) {
-        this._fComponentsStore = _fComponentsStore;
+    constructor(_lineService, _size, _draggedNodeRect, _rects, _restrictions) {
         this._lineService = _lineService;
         this._size = _size;
         this._draggedNodeRect = _draggedNodeRect;
@@ -4817,29 +4866,19 @@ let LineAlignmentPreparationExecution = class LineAlignmentPreparationExecution
     _fBrowser = inject(BrowserService);
     _lineService;
     handle(request) {
-        this._addLineAlignmentDragHandler(this._getDraggedNodes());
-    }
-    _getDraggedNodes() {
-        return this._fDraggableDataContext.draggableItems
-            .filter((x) => x instanceof NodeDragHandler)
-            .map((x) => x.fNode);
+        this._addLineAlignmentDragHandler(request.fNodes, request.commonRect);
     }
-    _addLineAlignmentDragHandler(fNodes) {
-        this._fDraggableDataContext.draggableItems.push(new LineAlignmentDragHandler(this._fComponentsStore, this._lineService || this._createLineService(), this._getFlowHostSize(), this._getDraggedNodesBoundingRect(fNodes), this._getStaticNodeRects(fNodes), this._getCommonRestrictions()));
+    _addLineAlignmentDragHandler(fNodes, commonRect) {
+        this._fDraggableDataContext.draggableItems.push(new LineAlignmentDragHandler(this._lineService || this._createLineService(), this._getFlowHostSize(), commonRect, this._getStaticNodeRects(fNodes), this._getCommonRestrictions()));
     }
     _getFlowHostSize() {
-        return this._fMediator.send(new GetFlowHostElementRequest())
+        return this._fMediator.execute(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));
@@ -4851,7 +4890,7 @@ let LineAlignmentPreparationExecution = class LineAlignmentPreparationExecution
     }
     _getCommonRestrictions() {
         return this._fDraggableDataContext.draggableItems
-            .filter((x) => x instanceof NodeDragHandler)[0].restrictions;
+            .filter((x) => x instanceof SummaryNodeDragHandler)[0].limits;
     }
     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 });
@@ -4979,7 +5018,7 @@ let NodeDragToParentFinalizeExecution = class NodeDragToParentFinalizeExecution
     }
     getDraggedNodeIds() {
         return this.fDraggableDataContext.draggableItems
-            .filter((x) => x instanceof NodeDragHandler)
+            .find((x) => x instanceof SummaryNodeDragHandler).fHandlers
             .map((x) => x.fNode.fId);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentFinalizeExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -5022,6 +5061,9 @@ let NodeDragToParentPreparationExecution = class NodeDragToParentPreparationExec
         this.fComponentsStore = fComponentsStore;
     }
     handle(request) {
+        if (!this._isValid()) {
+            return;
+        }
         const fNode = this.fComponentsStore
             .fNodes.find(n => n.isContains(request.event.targetElement));
         if (!fNode) {
@@ -5029,10 +5071,14 @@ let NodeDragToParentPreparationExecution = class NodeDragToParentPreparationExec
         }
         this.fDraggableDataContext.draggableItems.push(new NodeDragToParentDragHandler(this.fComponentsStore, this.fDraggableDataContext, this._getNotDraggedNodesRects()));
     }
+    _isValid() {
+        return this.fDraggableDataContext.draggableItems
+            .some((x) => x instanceof SummaryNodeDragHandler);
+    }
     _getNotDraggedNodesRects() {
         const draggedNodes = this._addParentNodes(this._getNodesBeingDragged());
         return this._getNotDraggedNodes(draggedNodes).map((x) => {
-            const rect = this.fMediator.send(new GetNormalizedElementRectRequest(x.hostElement, false));
+            const rect = this.fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false));
             return {
                 node: x,
                 rect: RectExtensions.initialize(rect.x + this.fCanvasPosition.x, rect.y + this.fCanvasPosition.y, rect.width * this.transform.scale, rect.height * this.transform.scale)
@@ -5041,12 +5087,12 @@ let NodeDragToParentPreparationExecution = class NodeDragToParentPreparationExec
     }
     _getNodesBeingDragged() {
         return this.fDraggableDataContext.draggableItems
-            .filter((x) => x instanceof NodeDragHandler)
-            .map((x) => x.fNode);
+            .find((x) => x instanceof SummaryNodeDragHandler)
+            .fHandlers.map((x) => x.fNode);
     }
     _addParentNodes(fNodes) {
         return fNodes.reduce((result, x) => {
-            result.push(x, ...this.fMediator.send(new GetParentNodesRequest(x)));
+            result.push(x, ...this.fMediator.execute(new GetParentNodesRequest(x)));
             return result;
         }, []);
     }
@@ -5063,29 +5109,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i2$1.FMediator }, { type: FDraggableDataContext }, { type: FComponentsStore }] });
 
-let NodeDragToParentPreparationValidator = class NodeDragToParentPreparationValidator {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
-    handle(request) {
-        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof NodeDragHandler);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentPreparationValidator, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentPreparationValidator });
-};
-NodeDragToParentPreparationValidator = __decorate([
-    FValidatorRegister(NodeDragToParentPreparationRequest)
-], NodeDragToParentPreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeDragToParentPreparationValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
-
-const NODE_DRAG_TO_PARENT_PREPARATION_PROVIDERS = [
-    NodeDragToParentPreparationExecution,
-    NodeDragToParentPreparationValidator,
-];
-
 class NodeMovePreparationRequest {
     event;
     constructor(event) {
@@ -5108,12 +5131,13 @@ let NodeMovePreparationExecution = class NodeMovePreparationExecution {
         if (!this._isValid(request)) {
             return;
         }
+        const summaryDragHandler = this._calculateDraggedItems(this._fNode);
         this._fDraggableDataContext.onPointerDownScale = this._transform.scale;
         this._fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
             .elementTransform(this._fHost).div(this._transform.scale);
-        this._fDraggableDataContext.draggableItems = this._calculateDraggedItems(this._fNode);
+        this._fDraggableDataContext.draggableItems = [summaryDragHandler];
         if (this._fComponentsStore.fLineAlignment) {
-            this._fMediator.execute(new LineAlignmentPreparationRequest());
+            this._fMediator.execute(new LineAlignmentPreparationRequest(summaryDragHandler.fHandlers.map((x) => x.fNode), summaryDragHandler.commonRect));
         }
     }
     _isValid(request) {
@@ -5131,7 +5155,7 @@ let NodeMovePreparationExecution = class NodeMovePreparationExecution {
     }
     //We drag nodes from selection model
     _calculateDraggedItems(fNode) {
-        let result = [];
+        let result;
         if (!fNode.fSelectionDisabled) {
             // Need to select node before drag
             this._fMediator.execute(new SelectAndUpdateNodeLayerRequest(fNode));
@@ -5180,13 +5204,12 @@ let NodeMoveFinalizeExecution = class NodeMoveFinalizeExecution {
         }
         const difference = this._getDifferenceWithLineAlignment(this._getDifferenceBetweenPreparationAndFinalize(request.event.getPosition()));
         const firstNodeOrGroup = this._fDraggableDataContext.draggableItems
-            .find((x) => x instanceof NodeDragHandler);
-        const differenceWithCellSize = firstNodeOrGroup.getDifferenceWithCellSize(difference);
-        this._finalizeMove(differenceWithCellSize);
+            .find((x) => x instanceof SummaryNodeDragHandler);
+        this._finalizeMove(firstNodeOrGroup.calculateRestrictedDifference(difference));
         this._applyConnectionUnderDroppedNode();
     }
     _isValid() {
-        return this._fDraggableDataContext.draggableItems.some((x) => x instanceof NodeDragHandler);
+        return this._fDraggableDataContext.draggableItems.some((x) => x instanceof SummaryNodeDragHandler);
     }
     _finalizeMove(difference) {
         this._getItems().forEach((x) => {
@@ -5219,12 +5242,17 @@ let NodeMoveFinalizeExecution = class NodeMoveFinalizeExecution {
         return difference;
     }
     _applyConnectionUnderDroppedNode() {
-        const isDraggedJustOneNode = this._fDraggableDataContext.draggableItems[0] instanceof NodeDragHandler;
-        if (isDraggedJustOneNode && this._fComponentsStore.fDraggable?.emitWhenNodeIntersectedWithConnection) {
-            const fNode = this._fDraggableDataContext.draggableItems[0].fNode;
+        if (this._isDraggedJustOneNode() && this._fComponentsStore.fDraggable?.fEmitOnNodeIntersect) {
+            const fNode = this._getFirstNodeOrGroup();
             setTimeout(() => this._fMediator.execute(new IsConnectionUnderNodeRequest(fNode)));
         }
     }
+    _isDraggedJustOneNode() {
+        return this._fDraggableDataContext.draggableItems[0].fHandlers.length === 1;
+    }
+    _getFirstNodeOrGroup() {
+        return this._fDraggableDataContext.draggableItems[0].fHandlers[0].fNode;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMoveFinalizeExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeMoveFinalizeExecution });
 };
@@ -5240,7 +5268,7 @@ const NODE_PROVIDERS = [
     LineAlignmentPreparationExecution,
     NodeMoveFinalizeExecution,
     ...NODE_MOVE_PREPARATION_PROVIDERS,
-    ...NODE_DRAG_TO_PARENT_PREPARATION_PROVIDERS,
+    NodeDragToParentPreparationExecution,
     ...NODE_DRAG_TO_PARENT_FINALIZE_PROVIDERS
 ];
 
@@ -5253,37 +5281,41 @@ class ApplyChildResizeRestrictionsRequest {
     }
 }
 
-const OFFSET$1 = 0;
+const CHILD_RESIZE_OFFSET = 0;
 let ApplyChildResizeRestrictionsExecution = class ApplyChildResizeRestrictionsExecution {
     handle(request) {
-        this.applyRestrictions(request.rect, request.restrictionsRect);
+        this._apply(request.rect, request.restrictionsRect);
     }
-    applyRestrictions(rect, restrictionsRect) {
-        this.left(rect, restrictionsRect);
-        this.top(rect, restrictionsRect);
-        this.right(rect, restrictionsRect);
-        this.bottom(rect, restrictionsRect);
+    _apply(rect, restrictionsRect) {
+        this._restrictLeft(rect, restrictionsRect);
+        this._restrictTop(rect, restrictionsRect);
+        this._restrictRight(rect, restrictionsRect);
+        this._restrictBottom(rect, restrictionsRect);
     }
-    left(rect, restrictionsRect) {
-        if (rect.x > restrictionsRect.x - OFFSET$1) {
-            rect.width += rect.x - restrictionsRect.x - OFFSET$1;
-            rect.x = restrictionsRect.x - OFFSET$1;
+    _restrictLeft(rect, restrictions) {
+        const delta = rect.x - (restrictions.x - CHILD_RESIZE_OFFSET);
+        if (delta > 0) {
+            rect.x -= delta;
+            rect.width += delta;
         }
     }
-    top(rect, restrictionsRect) {
-        if (rect.y > restrictionsRect.y - OFFSET$1) {
-            rect.height += rect.y - restrictionsRect.y - OFFSET$1;
-            rect.y = restrictionsRect.y - OFFSET$1;
+    _restrictTop(rect, restrictions) {
+        const delta = rect.y - (restrictions.y - CHILD_RESIZE_OFFSET);
+        if (delta > 0) {
+            rect.y -= delta;
+            rect.height += delta;
         }
     }
-    right(rect, restrictionsRect) {
-        if (rect.x + rect.width <= restrictionsRect.x + restrictionsRect.width + OFFSET$1) {
-            rect.width = restrictionsRect.x + restrictionsRect.width - rect.x + OFFSET$1;
+    _restrictRight(rect, restrictions) {
+        const maxRight = restrictions.x + restrictions.width + CHILD_RESIZE_OFFSET;
+        if (rect.x + rect.width <= maxRight) {
+            rect.width = maxRight - rect.x;
         }
     }
-    bottom(rect, restrictionsRect) {
-        if (rect.y + rect.height <= restrictionsRect.y + restrictionsRect.height + OFFSET$1) {
-            rect.height = restrictionsRect.y + restrictionsRect.height - rect.y + OFFSET$1;
+    _restrictBottom(rect, restrictions) {
+        const maxBottom = restrictions.y + restrictions.height + CHILD_RESIZE_OFFSET;
+        if (rect.y + rect.height <= maxBottom) {
+            rect.height = maxBottom - rect.y;
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ApplyChildResizeRestrictionsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -5362,9 +5394,13 @@ class CalculateChangedPositionRequest {
 }
 
 const RESIZE_DIRECTIONS = {
+    [EFResizeHandleType.LEFT]: { x: -1, y: 0 },
     [EFResizeHandleType.LEFT_TOP]: { x: -1, y: -1 },
+    [EFResizeHandleType.TOP]: { x: 0, y: -1 },
     [EFResizeHandleType.RIGHT_TOP]: { x: 1, y: -1 },
+    [EFResizeHandleType.RIGHT]: { x: 1, y: 0 },
     [EFResizeHandleType.RIGHT_BOTTOM]: { x: 1, y: 1 },
+    [EFResizeHandleType.BOTTOM]: { x: 0, y: 1 },
     [EFResizeHandleType.LEFT_BOTTOM]: { x: -1, y: 1 },
 };
 
@@ -5442,10 +5478,10 @@ let GetNormalizedChildrenNodesRectExecution = class GetNormalizedChildrenNodesRe
             this.concatRectWithParentPadding(childNodeRect, request.paddings) : null;
     }
     getChildrenNodes(fId) {
-        return this.fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId));
+        return this.fMediator.execute(new GetDeepChildrenNodesAndGroupsRequest(fId));
     }
     normalizeRect(fNode) {
-        return this.fMediator.send(new GetNormalizedElementRectRequest(fNode.hostElement, false));
+        return this.fMediator.execute(new GetNormalizedElementRectRequest(fNode.hostElement, false));
     }
     concatRectWithParentPadding(rect, padding) {
         return RectExtensions.initialize(rect.x - padding[0], rect.y - padding[1], rect.width + padding[0] + padding[2], rect.height + +padding[1] + padding[3]);
@@ -5470,24 +5506,25 @@ class GetNodeResizeRestrictionsRequest {
 }
 
 let GetNodeResizeRestrictionsExecution = class GetNodeResizeRestrictionsExecution {
-    fMediator;
-    constructor(fMediator) {
-        this.fMediator = fMediator;
-    }
+    _fMediator = inject(FMediator);
     handle(request) {
-        const fNodePaddings = this.getNodePaddings(request.fNode, request.rect);
-        const childRect = this.fMediator.send(new GetNormalizedChildrenNodesRectRequest(request.fNode, fNodePaddings));
-        const parentRect = this.fMediator.send(new GetNormalizedParentNodeRectRequest(request.fNode));
+        const paddings = this._calculateNodePaddings(request.fNode, request.rect);
         return {
-            parentRect,
-            childRect,
-            minSize: SizeExtensions.initialize(fNodePaddings[0] + fNodePaddings[2], fNodePaddings[1] + fNodePaddings[3])
+            parentBounds: this._getNormalizedParentBounds(request.fNode),
+            childrenBounds: this._getNormalizedChildrenBounds(request.fNode, paddings),
+            minimumSize: SizeExtensions.initialize(paddings[0] + paddings[2], paddings[1] + paddings[3])
         };
     }
-    getNodePaddings(node, rect) {
-        return this.fMediator.send(new GetNodePaddingRequest(node, rect));
+    _calculateNodePaddings(node, rect) {
+        return this._fMediator.execute(new GetNodePaddingRequest(node, rect));
+    }
+    _getNormalizedParentBounds(fNode) {
+        return this._fMediator.execute(new GetNormalizedParentNodeRectRequest(fNode));
+    }
+    _getNormalizedChildrenBounds(fNode, fNodePaddings) {
+        return this._fMediator.execute(new GetNormalizedChildrenNodesRectRequest(fNode, fNodePaddings));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeResizeRestrictionsExecution, deps: [{ token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeResizeRestrictionsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeResizeRestrictionsExecution });
 };
 GetNodeResizeRestrictionsExecution = __decorate([
@@ -5495,7 +5532,7 @@ GetNodeResizeRestrictionsExecution = __decorate([
 ], GetNodeResizeRestrictionsExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetNodeResizeRestrictionsExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i2$1.FMediator }] });
+        }] });
 
 class NodeResizeFinalizeRequest {
     event;
@@ -5505,69 +5542,77 @@ class NodeResizeFinalizeRequest {
 }
 
 class NodeResizeDragHandler {
-    fMediator;
-    fNode;
-    fResizeHandleType;
-    originalRect;
-    restrictions;
-    childRestrictions = () => {
-    };
-    constructor(fMediator, fNode, fResizeHandleType) {
-        this.fMediator = fMediator;
-        this.fNode = fNode;
-        this.fResizeHandleType = fResizeHandleType;
+    _fNode;
+    _fResizeHandleType;
+    _fMediator = fInject(FMediator);
+    _originalRect;
+    _resizeRestrictions;
+    constructor(_fNode, _fResizeHandleType) {
+        this._fNode = _fNode;
+        this._fResizeHandleType = _fResizeHandleType;
     }
     prepareDragSequence() {
-        this.originalRect = this.fMediator.send(new GetNormalizedElementRectRequest(this.fNode.hostElement, false));
-        this.restrictions = this.fMediator.send(new GetNodeResizeRestrictionsRequest(this.fNode, this.originalRect));
-        if (this.restrictions.childRect) {
-            this.childRestrictions = (rect, restrictionsRect) => {
-                this.applyChildRestrictions(rect, restrictionsRect);
-            };
-        }
+        this._originalRect = this._getOriginalNodeRect();
+        this._resizeRestrictions = this._getNodeResizeRestrictions();
+    }
+    _getOriginalNodeRect() {
+        return this._fMediator.execute(new GetNormalizedElementRectRequest(this._fNode.hostElement, false));
+    }
+    _getNodeResizeRestrictions() {
+        return this._fMediator.execute(new GetNodeResizeRestrictionsRequest(this._fNode, this._originalRect));
     }
     onPointerMove(difference) {
-        const changedRect = this.changePosition(difference, this.changeSize(difference, this.restrictions.minSize));
-        this.childRestrictions(changedRect, this.restrictions.childRect);
-        this.applyParentRestrictions(changedRect, this.restrictions.parentRect);
-        this.fNode.updatePosition(changedRect);
-        this.fNode.updateSize(changedRect);
-        this.fNode.redraw();
+        this._applyResizeChanges(this._calculateChangedRect(difference));
     }
-    changeSize(difference, minSize) {
-        return this.fMediator.send(new CalculateChangedSizeRequest(this.originalRect, difference, this.fResizeHandleType));
+    _calculateChangedRect(difference) {
+        return this._calculatePosition(difference, this._calculateSize(difference, this._resizeRestrictions.minimumSize));
     }
-    changePosition(difference, changedRect) {
-        return this.fMediator.send(new CalculateChangedPositionRequest(this.originalRect, changedRect, difference, this.fResizeHandleType));
+    _calculateSize(difference, minimumSize) {
+        return this._fMediator.execute(new CalculateChangedSizeRequest(this._originalRect, difference, this._fResizeHandleType));
     }
-    applyChildRestrictions(rect, restrictionsRect) {
-        this.fMediator.send(new ApplyChildResizeRestrictionsRequest(rect, restrictionsRect));
+    _calculatePosition(difference, changedSize) {
+        return this._fMediator.execute(new CalculateChangedPositionRequest(this._originalRect, changedSize, difference, this._fResizeHandleType));
     }
-    applyParentRestrictions(rect, restrictionsRect) {
-        this.fMediator.send(new ApplyParentResizeRestrictionsRequest(rect, restrictionsRect));
+    _applyResizeChanges(changedRect) {
+        if (this._resizeRestrictions.childrenBounds) {
+            this._applyChildRestrictions(changedRect, this._resizeRestrictions.childrenBounds);
+        }
+        this._applyParentRestrictions(changedRect, this._resizeRestrictions.parentBounds);
+        this._updateNodeRendering(changedRect);
+    }
+    _updateNodeRendering(changedRect) {
+        this._fNode.updatePosition(changedRect);
+        this._fNode.updateSize(changedRect);
+        this._fNode.redraw();
+    }
+    _applyChildRestrictions(changedRect, restrictions) {
+        this._fMediator.execute(new ApplyChildResizeRestrictionsRequest(changedRect, restrictions));
+    }
+    _applyParentRestrictions(changedRect, restrictions) {
+        this._fMediator.execute(new ApplyParentResizeRestrictionsRequest(changedRect, restrictions));
     }
     onPointerUp() {
-        this.fNode.sizeChange.emit(RectExtensions.initialize(this.fNode.position.x, this.fNode.position.y, this.fNode.size?.width, this.fNode.size?.height));
+        this._fNode.sizeChange.emit(this._getNewRect());
+    }
+    _getNewRect() {
+        return RectExtensions.initialize(this._fNode.position.x, this._fNode.position.y, this._fNode.size?.width, this._fNode.size?.height);
     }
 }
 
 let NodeResizeFinalizeExecution = class NodeResizeFinalizeExecution {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
+    _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
         if (!this._isValid()) {
             return;
         }
-        this.fDraggableDataContext.draggableItems.forEach((x) => {
+        this._fDraggableDataContext.draggableItems.forEach((x) => {
             x.onPointerUp?.();
         });
     }
     _isValid() {
-        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof NodeResizeDragHandler);
+        return this._fDraggableDataContext.draggableItems.some((x) => x instanceof NodeResizeDragHandler);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizeFinalizeExecution, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizeFinalizeExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizeFinalizeExecution });
 };
 NodeResizeFinalizeExecution = __decorate([
@@ -5575,7 +5620,7 @@ NodeResizeFinalizeExecution = __decorate([
 ], NodeResizeFinalizeExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizeFinalizeExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
+        }] });
 
 const NODE_RESIZE_FINALIZE_PROVIDERS = [
     NodeResizeFinalizeExecution,
@@ -5589,87 +5634,60 @@ class NodeResizePreparationRequest {
 }
 
 let NodeResizePreparationExecution = class NodeResizePreparationExecution {
-    fComponentsStore;
-    fDraggableDataContext;
-    fMediator;
-    get transform() {
-        return this.fComponentsStore.fCanvas.transform;
-    }
-    get flowHost() {
-        return this.fComponentsStore.fFlow.hostElement;
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
+    get _transform() {
+        return this._fComponentsStore.fCanvas.transform;
     }
-    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fMediator = fMediator;
+    get _fHost() {
+        return this._fComponentsStore.fFlow.hostElement;
     }
+    _fNode;
     handle(request) {
-        this.selectAndUpdateNodeLayer(request.event.targetElement);
-        const handleType = getDataAttrValueFromClosestElementWithClass(request.event.targetElement, 'fResizeHandleType', '.f-resize-handle');
-        const itemsToDrag = [
-            new NodeResizeDragHandler(this.fMediator, this.getNode(request.event.targetElement), EFResizeHandleType[handleType])
+        if (!this._isValid(request)) {
+            return;
+        }
+        this._selectAndUpdateNodeLayer();
+        this._fDraggableDataContext.onPointerDownScale = this._transform.scale;
+        this._fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
+            .elementTransform(this._fHost).div(this._transform.scale);
+        const resizeHandleType = EFResizeHandleType[this._getHandleType(request.event.targetElement)];
+        this._fDraggableDataContext.draggableItems = [
+            new NodeResizeDragHandler(this._fNode, resizeHandleType)
         ];
-        this.fDraggableDataContext.onPointerDownScale = this.transform.scale;
-        this.fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
-            .elementTransform(this.flowHost).div(this.transform.scale);
-        this.fDraggableDataContext.draggableItems = itemsToDrag;
-    }
-    selectAndUpdateNodeLayer(targetElement) {
-        this.fMediator.send(new SelectAndUpdateNodeLayerRequest(this.getNode(targetElement)));
     }
-    getNode(targetElement) {
-        return this.fComponentsStore
-            .fNodes.find(n => n.isContains(targetElement));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationExecution });
-};
-NodeResizePreparationExecution = __decorate([
-    FExecutionRegister(NodeResizePreparationRequest)
-], NodeResizePreparationExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationExecution, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: i2$1.FMediator }] });
-
-let NodeResizePreparationValidator = class NodeResizePreparationValidator {
-    fComponentsStore;
-    fDraggableDataContext;
-    constructor(fComponentsStore, fDraggableDataContext) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
+    _isValid(request) {
+        return this._fDraggableDataContext.isEmpty()
+            && this._isDragHandleElement(request.event.targetElement)
+            && this._isNodeCanBeDragged(this._getNode(request.event.targetElement));
     }
-    handle(request) {
-        return this.isDragHandlesEmpty()
-            && this.isDragHandleElement(request.event.targetElement)
-            && this.isNodeCanBeDragged(this.getNode(request.event.targetElement));
+    _isDragHandleElement(element) {
+        return isClosestElementHasClass(element, '.f-resize-handle');
     }
-    isDragHandlesEmpty() {
-        return !this.fDraggableDataContext.draggableItems.length;
+    _isNodeCanBeDragged(fNode) {
+        return !!fNode && !fNode.fDraggingDisabled;
     }
-    getNode(targetElement) {
-        return this.fComponentsStore
-            .fNodes.find(n => n.isContains(targetElement));
+    _getNode(element) {
+        this._fNode = this._fComponentsStore
+            .fNodes.find(x => x.isContains(element));
+        return this._fNode;
     }
-    isNodeCanBeDragged(node) {
-        return !!node && !node.fDraggingDisabled;
+    _selectAndUpdateNodeLayer() {
+        this._fMediator.execute(new SelectAndUpdateNodeLayerRequest(this._fNode));
     }
-    isDragHandleElement(targetElement) {
-        return isClosestElementHasClass(targetElement, '.f-resize-handle');
+    _getHandleType(element) {
+        return getDataAttrValueFromClosestElementWithClass(element, 'fResizeHandleType', '.f-resize-handle');
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationValidator, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationValidator });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationExecution });
 };
-NodeResizePreparationValidator = __decorate([
-    FValidatorRegister(NodeResizePreparationRequest)
-], NodeResizePreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationValidator, decorators: [{
+NodeResizePreparationExecution = __decorate([
+    FExecutionRegister(NodeResizePreparationRequest)
+], NodeResizePreparationExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: NodeResizePreparationExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }] });
-
-const NODE_RESIZE_PREPARATION_PROVIDERS = [
-    NodeResizePreparationExecution,
-    NodeResizePreparationValidator,
-];
+        }] });
 
 const NODE_RESIZE_PROVIDERS = [
     ApplyChildResizeRestrictionsExecution,
@@ -5679,101 +5697,137 @@ const NODE_RESIZE_PROVIDERS = [
     GetNormalizedChildrenNodesRectExecution,
     GetNodeResizeRestrictionsExecution,
     ...NODE_RESIZE_FINALIZE_PROVIDERS,
-    ...NODE_RESIZE_PREPARATION_PROVIDERS,
+    NodeResizePreparationExecution,
 ];
 
 class SingleSelectRequest {
     event;
-    constructor(event) {
+    fMultiSelectTrigger;
+    constructor(event, fMultiSelectTrigger) {
         this.event = event;
+        this.fMultiSelectTrigger = fMultiSelectTrigger;
     }
 }
 
+/**
+ * Implements the functionality for selecting elements in a graphical interface.
+ * This class handles both single and multi-selection, updating the selection state
+ * of elements and managing related data.
+ *
+ * Logic flow:
+ * 1. **Validate the selection event**:
+ *    - The event is considered valid if it occurs within the flow boundaries
+ *      and there are no active draggable data operations.
+ *
+ * 2. **Determine the target element to select**:
+ *    - The target element is determined based on the event’s target.
+ *      It can be a node, a group of nodes, or a connection.
+ *    - If no element is found, the current selection state is cleared.
+ *
+ * 3. **Update element layers**:
+ *    - If an element is found, its visual layer and the layers of its child elements are updated.
+ *
+ * 4. **Single or multi-selection**:
+ *    - If the event meets the criteria for multi-selection (e.g., a modifier key is pressed),
+ *      multi-selection logic is applied.
+ *    - Otherwise, single-selection logic is used.
+ *
+ * 5. **Single-selection logic**:
+ *    - If the element is not selected and can be selected:
+ *      - Clear the selection of all other elements.
+ *      - Mark the current element as selected.
+ *    - If the element cannot be selected, the current selection is cleared.
+ *
+ * 6. **Multi-selection logic**:
+ *    - If the element is already selected, it is removed from the selection.
+ *    - If the element is not selected and can be selected, it is added to the selection.
+ *
+ * 7. **Manage selection state**:
+ *    - Adding or removing an element from the selection triggers the corresponding methods.
+ *    - Selection state is tracked in the shared context for future use.
+ */
 let SingleSelectExecution = class SingleSelectExecution {
-    fPlatform;
-    fComponentsStore;
-    fDraggableDataContext;
-    fMediator;
-    constructor(fPlatform, fComponentsStore, fDraggableDataContext, fMediator) {
-        this.fPlatform = fPlatform;
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fMediator = fMediator;
-    }
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
         if (!this._isValid(request)) {
             return;
         }
-        const { event } = request;
-        const item = this.getSelectableItem(event);
-        if (item) {
-            this.fMediator.send(new UpdateItemAndChildrenLayersRequest(item, item.hostElement.parentElement));
-        }
-        this.isMultiselectEnabled(event) ? this.multiSelect(item) : this.singleSelect(item);
+        const fItem = this._getItemToSelect(request.event);
+        setTimeout(() => this._updateItemAndChildrenLayers(fItem));
+        this._isMultiSelect(request) ? this._multiSelect(fItem) : this._singleSelect(fItem);
     }
     _isValid(request) {
-        return this.fComponentsStore.fFlow.hostElement.contains(request.event.targetElement)
-            && !this.fDraggableDataContext.draggableItems.length;
+        return this._isEventInFlowBounds(request.event) && this._fDraggableDataContext.isEmpty();
     }
-    getSelectableItem(event) {
-        return this._findNode(event.targetElement) || this.getConnectionHandler(event.targetElement);
+    _isEventInFlowBounds(event) {
+        return this._fComponentsStore.fFlow.hostElement.contains(event.targetElement);
     }
-    _findNode(targetElement) {
-        return this.fComponentsStore.fNodes.find(n => n.isContains(targetElement));
+    _getItemToSelect(event) {
+        return this._getNodeOrGroup(event.targetElement) || this._getConnection(event.targetElement);
     }
-    getConnectionHandler(element) {
-        return this.fComponentsStore.fConnections.find(c => c.isContains(element) || c.fConnectionCenter?.nativeElement?.contains(element));
+    _getNodeOrGroup(targetElement) {
+        return this._fComponentsStore.fNodes.find((x) => (x).isContains(targetElement));
     }
-    isMultiselectEnabled(event) {
-        return this.isCommandButton(this.fPlatform.getOS(), event.originalEvent) ||
-            this.isShiftPressed(event.originalEvent);
+    _getConnection(element) {
+        return this._fComponentsStore.fConnections
+            .find(c => c.isContains(element) || c.fConnectionCenter?.nativeElement?.contains(element));
     }
-    isShiftPressed(event) {
-        return event.shiftKey;
+    _updateItemAndChildrenLayers(fItem) {
+        if (fItem) {
+            this._fMediator.execute(new UpdateItemAndChildrenLayersRequest(fItem, fItem.hostElement.parentElement));
+        }
     }
-    isCommandButton(platform, event) {
-        return platform === EOperationSystem.MAC_OS ? event.metaKey : event.ctrlKey;
+    _isMultiSelect(request) {
+        return isValidEventTrigger(request.event.originalEvent, request.fMultiSelectTrigger);
     }
-    singleSelect(item) {
-        if (item) {
-            if (!item.isSelected() && !item.fSelectionDisabled) {
-                this.clearSelection();
-                this.selectItem(item);
+    _singleSelect(fItem) {
+        if (fItem) {
+            if (this._isItemNotSelectedAndSelectable(fItem)) {
+                this._clearSelection();
+                this._selectItem(fItem);
             }
-            else if (item.fSelectionDisabled) {
-                this.clearSelection();
+            else if (fItem.fSelectionDisabled) {
+                this._clearSelection();
             }
         }
         else {
-            this.clearSelection();
+            this._clearSelection();
         }
     }
-    multiSelect(item) {
-        if (item && !item.fSelectionDisabled) {
-            item.isSelected() ? this.deselectItem(item) : this.selectItem(item);
-        }
+    _isItemNotSelectedAndSelectable(item) {
+        return !item.isSelected() && !item.fSelectionDisabled;
     }
-    deselectItem(item) {
-        const index = this.fDraggableDataContext.selectedItems.indexOf(item);
-        if (index > -1) {
-            this.fDraggableDataContext.selectedItems.splice(index, 1);
+    _clearSelection() {
+        this._fDraggableDataContext.selectedItems.forEach((x) => {
+            x.unmarkAsSelected();
+            this._fDraggableDataContext.markSelectionAsChanged();
+        });
+        this._fDraggableDataContext.selectedItems = [];
+    }
+    _multiSelect(fItem) {
+        if (fItem && !fItem.fSelectionDisabled) {
+            fItem.isSelected() ? this._deselectItem(fItem) : this._selectItem(fItem);
         }
-        item.deselect();
-        this.fDraggableDataContext.markSelectionAsChanged();
     }
-    selectItem(item) {
-        this.fDraggableDataContext.selectedItems.push(item);
-        item.select();
-        this.fDraggableDataContext.markSelectionAsChanged();
+    _deselectItem(fItem) {
+        this._removeItemFromSelectedItems(fItem);
+        fItem.unmarkAsSelected();
+        this._fDraggableDataContext.markSelectionAsChanged();
     }
-    clearSelection() {
-        this.fDraggableDataContext.selectedItems.forEach((x) => {
-            x.deselect();
-            this.fDraggableDataContext.markSelectionAsChanged();
-        });
-        this.fDraggableDataContext.selectedItems = [];
+    _removeItemFromSelectedItems(fItem) {
+        const indexInSelection = this._fDraggableDataContext.selectedItems.indexOf(fItem);
+        if (indexInSelection > -1) {
+            this._fDraggableDataContext.selectedItems.splice(indexInSelection, 1);
+        }
+    }
+    _selectItem(fItem) {
+        this._fDraggableDataContext.selectedItems.push(fItem);
+        fItem.markAsSelected();
+        this._fDraggableDataContext.markSelectionAsChanged();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SingleSelectExecution, deps: [{ token: i1.PlatformService }, { token: FComponentsStore }, { token: FDraggableDataContext }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SingleSelectExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SingleSelectExecution });
 };
 SingleSelectExecution = __decorate([
@@ -5781,7 +5835,7 @@ SingleSelectExecution = __decorate([
 ], SingleSelectExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SingleSelectExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i1.PlatformService }, { type: FComponentsStore }, { type: FDraggableDataContext }, { type: i2$1.FMediator }] });
+        }] });
 
 const SINGLE_SELECT_PROVIDERS = [
     SingleSelectExecution,
@@ -5807,13 +5861,12 @@ class ExternalItemFinalizeRequest {
 
 class ExternalItemDragHandler {
     externalItem;
-    fBrowser;
+    _fBrowser = fInject(BrowserService);
     placeholder;
     onPointerDownRect = RectExtensions.initialize();
     difference = PointExtensions.initialize();
-    constructor(externalItem, fBrowser) {
+    constructor(externalItem) {
         this.externalItem = externalItem;
-        this.fBrowser = fBrowser;
     }
     getStyle(position) {
         return `position: absolute; left: 0; top: 0; transform: translate(${position.x}px, ${position.y}px)`;
@@ -5822,12 +5875,12 @@ class ExternalItemDragHandler {
         this.onPointerDownRect = this.getExternalItemRect();
         this.placeholder = deepCloneNode(this.externalItem.hostElement);
         this.placeholder.setAttribute('style', this.getStyle(Point.fromPoint(this.onPointerDownRect)));
-        this.fBrowser.document.body.appendChild(this.placeholder);
+        this._fBrowser.document.body.appendChild(this.placeholder);
     }
     getExternalItemRect() {
         const rect = this.externalItem.hostElement.getBoundingClientRect();
-        const scrollTop = this.fBrowser.window.pageYOffset || this.fBrowser.document.documentElement.scrollTop;
-        const scrollLeft = this.fBrowser.window.pageXOffset || this.fBrowser.document.documentElement.scrollLeft;
+        const scrollTop = this._fBrowser.window.pageYOffset || this._fBrowser.document.documentElement.scrollTop;
+        const scrollLeft = this._fBrowser.window.pageXOffset || this._fBrowser.document.documentElement.scrollLeft;
         const offsetTop = rect.top + scrollTop;
         const offsetLeft = rect.left + scrollLeft;
         return RectExtensions.initialize(offsetLeft, offsetTop, rect.width, rect.height);
@@ -5838,7 +5891,7 @@ class ExternalItemDragHandler {
         this.placeholder.setAttribute('style', this.getStyle(position));
     }
     onPointerUp() {
-        this.fBrowser.document.body.removeChild(this.placeholder);
+        this._fBrowser.document.body.removeChild(this.placeholder);
     }
 }
 
@@ -5894,7 +5947,7 @@ let ExternalItemFinalizeExecution = class ExternalItemFinalizeExecution {
         return elements.length ? this.flowHost.contains(elements[0]) : false;
     }
     getRectInCanvas() {
-        return this.fMediator.send(new GetNormalizedElementRectRequest(this.dragHandler.placeholder, false));
+        return this.fMediator.execute(new GetNormalizedElementRectRequest(this.dragHandler.placeholder, false));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemFinalizeExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }, { token: i2$1.FMediator }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemFinalizeExecution });
@@ -5918,30 +5971,32 @@ class ExternalItemPreparationRequest {
 }
 
 let ExternalItemPreparationExecution = class ExternalItemPreparationExecution {
-    fComponentsStore;
-    fDraggableDataContext;
-    fExternalItemService;
-    fBrowser;
-    get flowHost() {
-        return this.fComponentsStore.fFlow.hostElement;
-    }
-    constructor(fComponentsStore, fDraggableDataContext, fExternalItemService, fBrowser) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fExternalItemService = fExternalItemService;
-        this.fBrowser = fBrowser;
+    _fExternalItemService = inject(FExternalItemService);
+    _fDraggableDataContext = inject(FDraggableDataContext);
+    _fComponentsStore = inject(FComponentsStore);
+    get _fHost() {
+        return this._fComponentsStore.fFlow.hostElement;
     }
     handle(request) {
-        this.fDraggableDataContext.onPointerDownScale = 1;
-        this.fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition()).elementTransform(this.flowHost);
-        this.fDraggableDataContext.draggableItems = [
-            new ExternalItemDragHandler(this.getExternalItem(request.event.targetElement), this.fBrowser)
+        if (!this._isValid(request)) {
+            return;
+        }
+        this._fDraggableDataContext.onPointerDownScale = 1;
+        this._fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition()).elementTransform(this._fHost);
+        this._fDraggableDataContext.draggableItems = [
+            new ExternalItemDragHandler(this._getExternalItem(request.event.targetElement))
         ];
     }
-    getExternalItem(targetElement) {
-        return this.fExternalItemService.getItem(getExternalItem(targetElement));
+    _isValid(request) {
+        return this._isValidExternalItem(request.event.targetElement, this._getExternalItem(request.event.targetElement));
+    }
+    _isValidExternalItem(element, fExternalItem) {
+        return isExternalItem(element) && !!fExternalItem && !fExternalItem.fDisabled;
+    }
+    _getExternalItem(targetElement) {
+        return this._fExternalItemService.getItem(getExternalItem(targetElement));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }, { token: FExternalItemService }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationExecution });
 };
 ExternalItemPreparationExecution = __decorate([
@@ -5949,33 +6004,10 @@ ExternalItemPreparationExecution = __decorate([
 ], ExternalItemPreparationExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: FExternalItemService }, { type: i1.BrowserService }] });
-
-let ExternalItemPreparationValidator = class ExternalItemPreparationValidator {
-    fExternalItemService;
-    constructor(fExternalItemService) {
-        this.fExternalItemService = fExternalItemService;
-    }
-    handle(request) {
-        const externalItem = this.getExternalItem(request.event.targetElement);
-        return isExternalItem(request.event.targetElement) && !!externalItem && !externalItem.fDisabled;
-    }
-    getExternalItem(targetElement) {
-        return this.fExternalItemService.getItem(getExternalItem(targetElement));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationValidator, deps: [{ token: FExternalItemService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationValidator });
-};
-ExternalItemPreparationValidator = __decorate([
-    FValidatorRegister(ExternalItemPreparationRequest)
-], ExternalItemPreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ExternalItemPreparationValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FExternalItemService }] });
+        }] });
 
 const EXTERNAL_ITEM_PREPARATION_PROVIDERS = [
     ExternalItemPreparationExecution,
-    ExternalItemPreparationValidator,
 ];
 
 class PreventDefaultIsExternalItemRequest {
@@ -6125,50 +6157,61 @@ class FDraggableDirective extends FDraggableBase {
     _fBrowser;
     _elementReference = inject(ElementRef);
     _fMediator = inject(FMediator);
+    _fPlatform = inject(PlatformService);
+    _injector = inject(Injector);
     disabled = false;
     get hostElement() {
         return this._elementReference.nativeElement;
     }
+    fMultiSelectTrigger = (event) => {
+        return (this._fPlatform.getOS() === EOperationSystem.MAC_OS) ? event.metaKey : event.ctrlKey;
+    };
+    fReassignConnectionTrigger = defaultEventTrigger;
+    fCreateConnectionTrigger = defaultEventTrigger;
     fSelectionChange = new EventEmitter();
     fNodeIntersectedWithConnections = new EventEmitter();
-    emitWhenNodeIntersectedWithConnection = false;
+    fEmitOnNodeIntersect = false;
     fCreateNode = new EventEmitter();
     fReassignConnection = new EventEmitter();
     fCreateConnection = new EventEmitter();
     fDropToGroup = new EventEmitter();
     vCellSize = 1;
     hCellSize = 1;
+    fCellSizeWhileDragging = false;
+    fDragStarted = new EventEmitter();
+    fDragEnded = new EventEmitter();
     plugins;
     constructor(ngZone, _fBrowser) {
         super(ngZone);
         this._fBrowser = _fBrowser;
     }
     ngOnInit() {
-        this._fMediator.send(new AddDndToStoreRequest(this));
+        this._fMediator.execute(new AddDndToStoreRequest(this));
     }
     ngAfterViewInit() {
         super.subscribe(this._fBrowser.document);
     }
     onPointerDown(event) {
+        FInjector.set(this._injector);
         this._fMediator.execute(new InitializeDragSequenceRequest());
         this.plugins.forEach((p) => p.onPointerDown?.(event));
-        this._fMediator.execute(new SingleSelectRequest(event));
-        this._fMediator.execute(new ReassignConnectionPreparationRequest(event));
-        this._fMediator.execute(new CreateConnectionPreparationRequest(event));
-        const isMouseLeftButton = event.isMouseLeftButton();
-        if (!isMouseLeftButton) {
+        this._fMediator.execute(new SingleSelectRequest(event, this.fMultiSelectTrigger));
+        this._fMediator.execute(new ReassignConnectionPreparationRequest(event, this.fReassignConnectionTrigger));
+        this._fMediator.execute(new CreateConnectionPreparationRequest(event, this.fCreateConnectionTrigger));
+        const isMouseLeftOrTouch = event.isMouseLeftButton();
+        if (!isMouseLeftOrTouch) {
             this.finalizeDragSequence();
         }
-        return isMouseLeftButton;
+        return isMouseLeftOrTouch;
     }
     prepareDragSequence(event) {
         this.plugins.forEach((p) => p.prepareDragSequence?.(event));
-        this._fMediator.send(new NodeResizePreparationRequest(event));
-        this._fMediator.send(new NodeMovePreparationRequest(event));
-        this._fMediator.send(new NodeDragToParentPreparationRequest(event));
-        this._fMediator.send(new CanvasMovePreparationRequest(event));
-        this._fMediator.send(new ExternalItemPreparationRequest(event));
-        this._fMediator.send(new PrepareDragSequenceRequest());
+        this._fMediator.execute(new NodeResizePreparationRequest(event));
+        this._fMediator.execute(new NodeMovePreparationRequest(event));
+        this._fMediator.execute(new NodeDragToParentPreparationRequest(event));
+        this._fMediator.execute(new CanvasMovePreparationRequest(event));
+        this._fMediator.execute(new ExternalItemPreparationRequest(event));
+        this._fMediator.execute(new PrepareDragSequenceRequest());
     }
     onSelect(event) {
         this.plugins.forEach((x) => x.onSelect?.(event));
@@ -6184,19 +6227,22 @@ class FDraggableDirective extends FDraggableBase {
         this._fMediator.execute(new NodeResizeFinalizeRequest(event));
         this._fMediator.execute(new NodeMoveFinalizeRequest(event));
         this._fMediator.execute(new NodeDragToParentFinalizeRequest(event));
-        this._fMediator.send(new CanvasMoveFinalizeRequest(event));
+        this._fMediator.execute(new CanvasMoveFinalizeRequest(event));
         this._fMediator.execute(new ExternalItemFinalizeRequest(event));
         this._fMediator.execute(new EndDragSequenceRequest());
+        FInjector.clear();
     }
     finalizeDragSequence() {
         this._fMediator.execute(new EmitSelectionChangeEventRequest());
+        FInjector.clear();
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveDndFromStoreRequest());
+        this._fMediator.execute(new RemoveDndFromStoreRequest());
         super.unsubscribe();
+        FInjector.clear();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FDraggableDirective, deps: [{ token: NgZone, optional: true }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FDraggableDirective, selector: "f-flow[fDraggable]", inputs: { disabled: ["fDraggableDisabled", "disabled"], emitWhenNodeIntersectedWithConnection: ["emitWhenNodeIntersectedWithConnection", "emitWhenNodeIntersectedWithConnection", booleanAttribute], vCellSize: "vCellSize", hCellSize: "hCellSize" }, outputs: { fSelectionChange: "fSelectionChange", fNodeIntersectedWithConnections: "fNodeIntersectedWithConnections", fCreateNode: "fCreateNode", fReassignConnection: "fReassignConnection", fCreateConnection: "fCreateConnection", fDropToGroup: "fDropToGroup" }, queries: [{ propertyName: "plugins", predicate: F_DRAG_AND_DROP_PLUGIN, descendants: true }], exportAs: ["fDraggable"], usesInheritance: true, ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.4", type: FDraggableDirective, selector: "f-flow[fDraggable]", inputs: { disabled: ["fDraggableDisabled", "disabled", booleanAttribute], fMultiSelectTrigger: "fMultiSelectTrigger", fReassignConnectionTrigger: "fReassignConnectionTrigger", fCreateConnectionTrigger: "fCreateConnectionTrigger", fEmitOnNodeIntersect: ["fEmitOnNodeIntersect", "fEmitOnNodeIntersect", booleanAttribute], vCellSize: ["vCellSize", "vCellSize", numberAttribute], hCellSize: ["hCellSize", "hCellSize", numberAttribute], fCellSizeWhileDragging: ["fCellSizeWhileDragging", "fCellSizeWhileDragging", booleanAttribute] }, outputs: { fSelectionChange: "fSelectionChange", fNodeIntersectedWithConnections: "fNodeIntersectedWithConnections", fCreateNode: "fCreateNode", fReassignConnection: "fReassignConnection", fCreateConnection: "fCreateConnection", fDropToGroup: "fDropToGroup", fDragStarted: "fDragStarted", fDragEnded: "fDragEnded" }, queries: [{ propertyName: "plugins", predicate: F_DRAG_AND_DROP_PLUGIN, descendants: true }], exportAs: ["fDraggable"], usesInheritance: true, ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FDraggableDirective, decorators: [{
             type: Directive,
@@ -6211,12 +6257,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
                     type: Optional
                 }] }, { type: i1.BrowserService }], propDecorators: { disabled: [{
                 type: Input,
-                args: ['fDraggableDisabled']
+                args: [{ transform: booleanAttribute, alias: 'fDraggableDisabled' }]
+            }], fMultiSelectTrigger: [{
+                type: Input
+            }], fReassignConnectionTrigger: [{
+                type: Input
+            }], fCreateConnectionTrigger: [{
+                type: Input
             }], fSelectionChange: [{
                 type: Output
             }], fNodeIntersectedWithConnections: [{
                 type: Output
-            }], emitWhenNodeIntersectedWithConnection: [{
+            }], fEmitOnNodeIntersect: [{
                 type: Input,
                 args: [{ transform: booleanAttribute }]
             }], fCreateNode: [{
@@ -6228,9 +6280,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             }], fDropToGroup: [{
                 type: Output
             }], vCellSize: [{
-                type: Input
+                type: Input,
+                args: [{ transform: numberAttribute }]
             }], hCellSize: [{
-                type: Input
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], fCellSizeWhileDragging: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], fDragStarted: [{
+                type: Output
+            }], fDragEnded: [{
+                type: Output
             }], plugins: [{
                 type: ContentChildren,
                 args: [F_DRAG_AND_DROP_PLUGIN, { descendants: true }]
@@ -6335,7 +6396,7 @@ class FMinimapDragHandler {
         return point1.x === point2.x && point1.y === point2.y;
     }
     getNewPosition(eventPoint) {
-        return this.fMediator.send(new CalculateFlowPointFromMinimapPointRequest(this.flowRect, this.canvasPosition, eventPoint, this.minimap));
+        return this.fMediator.execute(new CalculateFlowPointFromMinimapPointRequest(this.flowRect, this.canvasPosition, eventPoint, this.minimap));
     }
     onPointerUp() {
         this.fComponentsStore.fCanvas?.hostElement.classList.remove('f-scaled-animate');
@@ -6356,6 +6417,9 @@ let MinimapDragPreparationExecution = class MinimapDragPreparationExecution {
         this.fDraggableDataContext = fDraggableDataContext;
     }
     handle(request) {
+        if (!this._isValid(request)) {
+            return;
+        }
         const eventPoint = request.event.getPosition();
         const startCanvasPosition = Point.fromPoint(this.fComponentsStore.fCanvas.transform.position);
         this.fComponentsStore.fCanvas.setPosition(this.getNewPosition(eventPoint, request.minimap));
@@ -6367,8 +6431,13 @@ let MinimapDragPreparationExecution = class MinimapDragPreparationExecution {
             new FMinimapDragHandler(this.fComponentsStore, this.fMediator, this.getFlowRect(), startCanvasPosition, eventPoint, request.minimap)
         ];
     }
+    _isValid(request) {
+        return !this.fDraggableDataContext.draggableItems.length &&
+            !!request.event.targetElement.closest('.f-minimap') &&
+            this.fComponentsStore.flowHost.contains(request.event.targetElement);
+    }
     getNewPosition(eventPoint, minimap) {
-        return this.fMediator.send(new CalculateFlowPointFromMinimapPointRequest(this.getFlowRect(), Point.fromPoint(this.fComponentsStore.fCanvas.transform.position), eventPoint, minimap));
+        return this.fMediator.execute(new CalculateFlowPointFromMinimapPointRequest(this.getFlowRect(), Point.fromPoint(this.fComponentsStore.fCanvas.transform.position), eventPoint, minimap));
     }
     getFlowRect() {
         return RectExtensions.fromElement(this.flowHost);
@@ -6383,31 +6452,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: FComponentsStore }, { type: i2$1.FMediator }, { type: FDraggableDataContext }] });
 
-let MinimapDragPreparationValidator = class MinimapDragPreparationValidator {
-    fComponentsStore;
-    fDraggableDataContext;
-    constructor(fComponentsStore, fDraggableDataContext) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
-    handle(request) {
-        return !this.fDraggableDataContext.draggableItems.length &&
-            !!request.event.targetElement.closest('.f-minimap') &&
-            this.fComponentsStore.flowHost.contains(request.event.targetElement);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragPreparationValidator, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragPreparationValidator });
-};
-MinimapDragPreparationValidator = __decorate([
-    FValidatorRegister(MinimapDragPreparationRequest)
-], MinimapDragPreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragPreparationValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }] });
-
 const MINIMAP_DRAG_PREPARATION_PROVIDERS = [
     MinimapDragPreparationExecution,
-    MinimapDragPreparationValidator,
 ];
 
 class MinimapDragFinalizeRequest {
@@ -6423,10 +6469,16 @@ let MinimapDragFinalizeExecution = class MinimapDragFinalizeExecution {
         this.fDraggableDataContext = fDraggableDataContext;
     }
     handle(request) {
+        if (!this._isValid()) {
+            return;
+        }
         this.fDraggableDataContext.draggableItems.forEach((x) => {
             x.onPointerUp?.();
         });
     }
+    _isValid() {
+        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof FMinimapDragHandler);
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragFinalizeExecution, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragFinalizeExecution });
 };
@@ -6437,27 +6489,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: FDraggableDataContext }] });
 
-let MinimapDragFinalizeValidator = class MinimapDragFinalizeValidator {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
-    handle(request) {
-        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof FMinimapDragHandler);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragFinalizeValidator, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragFinalizeValidator });
-};
-MinimapDragFinalizeValidator = __decorate([
-    FValidatorRegister(MinimapDragFinalizeRequest)
-], MinimapDragFinalizeValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: MinimapDragFinalizeValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
-
 const MINIMAP_DRAG_FINALIZE_PROVIDERS = [
     MinimapDragFinalizeExecution,
-    MinimapDragFinalizeValidator,
 ];
 
 class MinimapDrawNodesRequest {
@@ -6584,7 +6617,7 @@ let MinimapCalculateSvgScaleAndViewBoxExecution = class MinimapCalculateSvgScale
         return adjustRectToMinSize(scaledRect, minSize);
     }
     _calculateNodesBoundingBox() {
-        return this._fMediator.send(new CalculateNodesBoundingBoxRequest())
+        return this._fMediator.execute(new CalculateNodesBoundingBoxRequest())
             || RectExtensions.initialize(0, 0, 0, 0);
     }
     _convertFromGlobalToFlowRect(rect) {
@@ -6636,129 +6669,116 @@ class SelectionAreaFinalizeRequest {
     }
 }
 
-let SelectionAreaFinalizeExecution = class SelectionAreaFinalizeExecution {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
-    handle(request) {
-        this.fDraggableDataContext.draggableItems.forEach((x) => {
-            x.onPointerUp?.();
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeExecution, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeExecution });
-};
-SelectionAreaFinalizeExecution = __decorate([
-    FExecutionRegister(SelectionAreaFinalizeRequest)
-], SelectionAreaFinalizeExecution);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeExecution, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
-
 class SelectionAreaDragHandle {
-    fComponentsStore;
-    fSelectionArea;
-    fDraggableDataContext;
-    fMediator;
+    _fComponentsStore;
+    _fSelectionArea;
+    _fDraggableDataContext;
+    _fMediator;
     _canBeSelected = [];
     _selectedByMove = [];
-    get canvasPosition() {
-        return Point.fromPoint(this.fComponentsStore.fCanvas.transform.position)
-            .add(this.fComponentsStore.fCanvas.transform.scaledPosition);
+    get _fCanvasPosition() {
+        return Point.fromPoint(this._fComponentsStore.fCanvas.transform.position)
+            .add(this._fComponentsStore.fCanvas.transform.scaledPosition);
     }
-    constructor(fComponentsStore, fSelectionArea, fDraggableDataContext, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fSelectionArea = fSelectionArea;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fMediator = fMediator;
+    constructor(_fComponentsStore, _fSelectionArea, _fDraggableDataContext, _fMediator) {
+        this._fComponentsStore = _fComponentsStore;
+        this._fSelectionArea = _fSelectionArea;
+        this._fDraggableDataContext = _fDraggableDataContext;
+        this._fMediator = _fMediator;
     }
     prepareDragSequence() {
-        this._canBeSelected = this.fMediator.send(new GetCanBeSelectedItemsRequest());
-        this.fSelectionArea.show();
-        this.fSelectionArea.draw(RectExtensions.initialize(this.fDraggableDataContext.onPointerDownPosition.x, this.fDraggableDataContext.onPointerDownPosition.y));
+        this._canBeSelected = this._fMediator.execute(new GetCanBeSelectedItemsRequest());
+        this._fSelectionArea.show();
+        this._fSelectionArea.draw(RectExtensions.initialize(this._fDraggableDataContext.onPointerDownPosition.x, this._fDraggableDataContext.onPointerDownPosition.y));
     }
     onPointerMove(difference) {
-        const currentPoint = Point.fromPoint(difference).add(this.fDraggableDataContext.onPointerDownPosition);
-        const x = Math.min(this.fDraggableDataContext.onPointerDownPosition.x, currentPoint.x);
-        const y = Math.min(this.fDraggableDataContext.onPointerDownPosition.y, currentPoint.y);
+        const currentPoint = Point.fromPoint(difference).add(this._fDraggableDataContext.onPointerDownPosition);
+        const point = this._getMinimumPoint(this._fDraggableDataContext.onPointerDownPosition, currentPoint);
         const width = Math.abs(difference.x);
         const height = Math.abs(difference.y);
-        this.fSelectionArea.draw(RectExtensions.initialize(x, y, width, height));
+        const fSelectionAreaRect = RectExtensions.initialize(point.x, point.y, width, height);
+        this._fSelectionArea.draw(fSelectionAreaRect);
         this._selectedByMove = [];
         this._canBeSelected.forEach((item) => {
-            item.element.deselect();
-            const itemRect = RectExtensions.addPoint(item.rect, this.canvasPosition);
-            const isIntersect = RectExtensions.intersectionWithRect(itemRect, RectExtensions.initialize(x, y, width, height));
+            item.element.unmarkAsSelected();
+            const fItemRect = RectExtensions.addPoint(item.fRect, this._fCanvasPosition);
+            const isIntersect = RectExtensions.intersectionWithRect(fItemRect, fSelectionAreaRect);
             if (isIntersect) {
-                item.element.select();
+                item.element.markAsSelected();
                 this._selectedByMove.push(item.element);
             }
         });
-        this.fMediator.send(new NotifyTransformChangedRequest());
+        this._fMediator.execute(new NotifyTransformChangedRequest());
+    }
+    _getMinimumPoint(point1, point2) {
+        return PointExtensions.initialize(Math.min(point1.x, point2.x), Math.min(point1.y, point2.y));
     }
     onPointerUp() {
-        this.fSelectionArea.hide();
-        this.fDraggableDataContext.selectedItems.push(...this._selectedByMove);
+        this._fSelectionArea.hide();
+        this._fDraggableDataContext.selectedItems.push(...this._selectedByMove);
         if (this._selectedByMove.length > 0) {
-            this.fDraggableDataContext.isSelectedChanged = true;
+            this._fDraggableDataContext.isSelectedChanged = true;
         }
     }
 }
 
-let SelectionAreaFinalizeValidator = class SelectionAreaFinalizeValidator {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
+let SelectionAreaFinalizeExecution = class SelectionAreaFinalizeExecution {
+    _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
-        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof SelectionAreaDragHandle);
+        if (!this._isValid()) {
+            return;
+        }
+        this._fDraggableDataContext.draggableItems.forEach((x) => {
+            x.onPointerUp?.();
+        });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeValidator, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeValidator });
+    _isValid() {
+        return this._fDraggableDataContext.draggableItems.some((x) => x instanceof SelectionAreaDragHandle);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeExecution });
 };
-SelectionAreaFinalizeValidator = __decorate([
-    FValidatorRegister(SelectionAreaFinalizeRequest)
-], SelectionAreaFinalizeValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeValidator, decorators: [{
+SelectionAreaFinalizeExecution = __decorate([
+    FExecutionRegister(SelectionAreaFinalizeRequest)
+], SelectionAreaFinalizeExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaFinalizeExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
-
-const SELECTION_AREA_FINALIZE_PROVIDERS = [
-    SelectionAreaFinalizeExecution,
-    SelectionAreaFinalizeValidator,
-];
+        }] });
 
 class SelectionAreaPreparationRequest {
     event;
     fSelectionArea;
-    constructor(event, fSelectionArea) {
+    fTrigger;
+    constructor(event, fSelectionArea, fTrigger) {
         this.event = event;
         this.fSelectionArea = fSelectionArea;
+        this.fTrigger = fTrigger;
     }
 }
 
 let SelectionAreaPreparationExecution = class SelectionAreaPreparationExecution {
-    fComponentsStore;
-    fDraggableDataContext;
-    fMediator;
-    get flowHost() {
-        return this.fComponentsStore.fFlow.hostElement;
-    }
-    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
-        this.fComponentsStore = fComponentsStore;
-        this.fDraggableDataContext = fDraggableDataContext;
-        this.fMediator = fMediator;
+    _fMediator = inject(FMediator);
+    _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
+    get _fHost() {
+        return this._fComponentsStore.fFlow.hostElement;
     }
     handle(request) {
-        this.fDraggableDataContext.draggableItems = [
-            new SelectionAreaDragHandle(this.fComponentsStore, request.fSelectionArea, this.fDraggableDataContext, this.fMediator)
+        if (!this._isValid(request)) {
+            return;
+        }
+        this._fDraggableDataContext.draggableItems = [
+            new SelectionAreaDragHandle(this._fComponentsStore, request.fSelectionArea, this._fDraggableDataContext, this._fMediator)
         ];
-        this.fDraggableDataContext.onPointerDownScale = 1;
-        this.fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
-            .elementTransform(this.flowHost);
+        this._fDraggableDataContext.onPointerDownScale = 1;
+        this._fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
+            .elementTransform(this._fHost);
+    }
+    _isValid(request) {
+        return this._fDraggableDataContext.isEmpty()
+            && isValidEventTrigger(request.event.originalEvent, request.fTrigger);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationExecution, deps: [{ token: FComponentsStore }, { token: FDraggableDataContext }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationExecution });
 };
 SelectionAreaPreparationExecution = __decorate([
@@ -6766,41 +6786,11 @@ SelectionAreaPreparationExecution = __decorate([
 ], SelectionAreaPreparationExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FDraggableDataContext }, { type: i2$1.FMediator }] });
-
-let SelectionAreaPreparationValidator = class SelectionAreaPreparationValidator {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
-    handle(request) {
-        return this.isDragHandlesEmpty()
-            && this.isShiftPressed(request.event.originalEvent);
-    }
-    isDragHandlesEmpty() {
-        return !this.fDraggableDataContext.draggableItems.length;
-    }
-    isShiftPressed(event) {
-        return event.shiftKey;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationValidator, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationValidator });
-};
-SelectionAreaPreparationValidator = __decorate([
-    FValidatorRegister(SelectionAreaPreparationRequest)
-], SelectionAreaPreparationValidator);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SelectionAreaPreparationValidator, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
-
-const SELECTION_AREA_PREPARATION_PROVIDERS = [
-    SelectionAreaPreparationExecution,
-    SelectionAreaPreparationValidator,
-];
+        }] });
 
 const F_SELECTION_AREA_DRAG_AND_DROP_PROVIDERS = [
-    ...SELECTION_AREA_FINALIZE_PROVIDERS,
-    ...SELECTION_AREA_PREPARATION_PROVIDERS
+    SelectionAreaPreparationExecution,
+    SelectionAreaFinalizeExecution
 ];
 
 class FSelectionAreaBase {
@@ -6814,6 +6804,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
 class FSelectionAreaComponent extends FSelectionAreaBase {
     _fMediator = inject(FMediator);
     _elementReference = inject(ElementRef);
+    fTrigger = (event) => {
+        return event.shiftKey;
+    };
     get hostElement() {
         return this._elementReference.nativeElement;
     }
@@ -6834,13 +6827,13 @@ class FSelectionAreaComponent extends FSelectionAreaBase {
         style.height = object.height + 'px';
     }
     onPointerDown(event) {
-        this._fMediator.send(new SelectionAreaPreparationRequest(event, this));
+        this._fMediator.execute(new SelectionAreaPreparationRequest(event, this, this.fTrigger));
     }
     onPointerUp(event) {
-        this._fMediator.send(new SelectionAreaFinalizeRequest(event));
+        this._fMediator.execute(new SelectionAreaFinalizeRequest(event));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FSelectionAreaComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FSelectionAreaComponent, selector: "f-selection-area", host: { classAttribute: "f-selection-area f-component" }, providers: [
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FSelectionAreaComponent, selector: "f-selection-area", inputs: { fTrigger: "fTrigger" }, host: { classAttribute: "f-selection-area f-component" }, providers: [
             { provide: F_DRAG_AND_DROP_PLUGIN, useExisting: FSelectionAreaComponent },
         ], usesInheritance: true, ngImport: i0, template: ``, isInline: true, styles: [":host{position:absolute}\n"] });
 }
@@ -6851,7 +6844,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
                     }, providers: [
                         { provide: F_DRAG_AND_DROP_PLUGIN, useExisting: FSelectionAreaComponent },
                     ], styles: [":host{position:absolute}\n"] }]
-        }] });
+        }], propDecorators: { fTrigger: [{
+                type: Input
+            }] } });
 
 const F_SELECTION_AREA_PROVIDERS = [
     FSelectionAreaComponent
@@ -6914,7 +6909,7 @@ let FindInputAtPositionExecution = class FindInputAtPositionExecution {
             return undefined;
         }
         const position = Point.fromPoint(request.toConnectorRect).add(this._calculateDifference(request.pointerPosition));
-        const fClosestInput = this._fMediator.send(new CalculateClosestInputRequest(position, request.canBeConnectedInputs));
+        const fClosestInput = this._fMediator.execute(new CalculateClosestInputRequest(position, request.canBeConnectedInputs));
         return this._isValidClosestInput(fClosestInput) ? fClosestInput : undefined;
     }
     _isValidClosestInput(fClosestInput) {
@@ -6948,9 +6943,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImpor
         }] });
 
 class GetAllCanBeConnectedInputsAndRectsRequest {
-    fOutput;
-    constructor(fOutput) {
-        this.fOutput = fOutput;
+    fOutputOrOutlet;
+    constructor(fOutputOrOutlet) {
+        this.fOutputOrOutlet = fOutputOrOutlet;
     }
 }
 
@@ -6970,7 +6965,7 @@ let GetConnectorAndRectExecution = class GetConnectorAndRectExecution {
         };
     }
     _getConnectorRect(fConnector) {
-        return this._fMediator.send(new GetNormalizedElementRectRequest(fConnector.hostElement, true));
+        return this._fMediator.execute(new GetNormalizedElementRectRequest(fConnector.hostElement, true));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetConnectorAndRectExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetConnectorAndRectExecution });
@@ -6989,25 +6984,25 @@ let GetAllCanBeConnectedInputsAndRectsExecution = class GetAllCanBeConnectedInpu
         return this._fComponentsStore.fInputs;
     }
     handle(payload) {
-        return this._getCanBeConnectedInputs(payload.fOutput).map((x) => {
+        return this._getCanBeConnectedInputs(payload.fOutputOrOutlet).map((x) => {
             return this._fMediator.execute(new GetConnectorAndRectRequest(x));
         });
     }
-    _getCanBeConnectedInputs(fOutput) {
+    _getCanBeConnectedInputs(fOutputOrOutlet) {
         let fInputs = [];
-        if (fOutput.canBeConnectedInputs?.length) {
-            fInputs = this._fInputs.filter((x) => fOutput.canBeConnectedInputs.includes(x.fId));
+        if (fOutputOrOutlet.canBeConnectedInputs?.length) {
+            fInputs = this._fInputs.filter((x) => fOutputOrOutlet.canBeConnectedInputs.includes(x.fId));
         }
         else {
             fInputs = this._fInputs.filter((x) => x.canBeConnected);
-            if (!fOutput.isSelfConnectable) {
-                fInputs = this._filterSelfConnectable(fInputs, fOutput);
+            if (!fOutputOrOutlet.isSelfConnectable) {
+                fInputs = this._filterSelfConnectable(fInputs, fOutputOrOutlet);
             }
         }
         return fInputs;
     }
-    _filterSelfConnectable(fInputs, fOutput) {
-        return fInputs.filter((x) => fOutput.fNodeId !== x.fNodeId);
+    _filterSelfConnectable(fInputs, fOutputOrOutlet) {
+        return fInputs.filter((x) => fOutputOrOutlet.fNodeId !== x.fNodeId);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetAllCanBeConnectedInputsAndRectsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetAllCanBeConnectedInputsAndRectsExecution });
@@ -7195,16 +7190,13 @@ class ClearSelectionRequest {
 }
 
 let ClearSelectionExecution = class ClearSelectionExecution {
-    fDraggableDataContext;
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
+    _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
-        this.fDraggableDataContext.selectedItems.forEach((x) => x.deselect());
-        this.fDraggableDataContext.selectedItems = [];
-        this.fDraggableDataContext.isSelectedChanged = true;
+        this._fDraggableDataContext.selectedItems.forEach((x) => x.unmarkAsSelected());
+        this._fDraggableDataContext.selectedItems = [];
+        this._fDraggableDataContext.isSelectedChanged = true;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ClearSelectionExecution, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ClearSelectionExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ClearSelectionExecution });
 };
 ClearSelectionExecution = __decorate([
@@ -7212,15 +7204,15 @@ ClearSelectionExecution = __decorate([
 ], ClearSelectionExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: ClearSelectionExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
+        }] });
 
 class GetCanBeSelectedItemsRequest {
 }
 
 let GetCanBeSelectedItemsExecution = class GetCanBeSelectedItemsExecution {
-    fDraggableDataContext;
     _fMediator = inject(FMediator);
     _fComponentsStore = inject(FComponentsStore);
+    _fDraggableDataContext = inject(FDraggableDataContext);
     get fNodes() {
         return this._fComponentsStore.fNodes;
     }
@@ -7230,19 +7222,16 @@ let GetCanBeSelectedItemsExecution = class GetCanBeSelectedItemsExecution {
     get transform() {
         return this._fComponentsStore.fCanvas.transform;
     }
-    constructor(fDraggableDataContext) {
-        this.fDraggableDataContext = fDraggableDataContext;
-    }
     handle() {
         return [...this.getNodesWithRects(), ...this.getConnectionsWithRects()].filter((x) => {
-            return !this.fDraggableDataContext.selectedItems.includes(x.element);
+            return !this._fDraggableDataContext.selectedItems.includes(x.element);
         });
     }
     getNodesWithRects() {
         return this.fNodes.filter((x) => !x.fSelectionDisabled).map((x) => {
             return {
                 element: x,
-                rect: RectExtensions.mult(this._fMediator.send(new GetNormalizedElementRectRequest(x.hostElement, false)), this.transform.scale)
+                fRect: RectExtensions.mult(this._fMediator.execute(new GetNormalizedElementRectRequest(x.hostElement, false)), this.transform.scale)
             };
         });
     }
@@ -7250,11 +7239,11 @@ let GetCanBeSelectedItemsExecution = class GetCanBeSelectedItemsExecution {
         return this.fConnections.filter((x) => !x.fSelectionDisabled).map((x) => {
             return {
                 element: x,
-                rect: RectExtensions.mult(this._fMediator.send(new GetNormalizedElementRectRequest(x.boundingElement, false)), this.transform.scale)
+                fRect: RectExtensions.mult(this._fMediator.execute(new GetNormalizedElementRectRequest(x.boundingElement, false)), this.transform.scale)
             };
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeSelectedItemsExecution, deps: [{ token: FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeSelectedItemsExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeSelectedItemsExecution });
 };
 GetCanBeSelectedItemsExecution = __decorate([
@@ -7262,7 +7251,7 @@ GetCanBeSelectedItemsExecution = __decorate([
 ], GetCanBeSelectedItemsExecution);
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: GetCanBeSelectedItemsExecution, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FDraggableDataContext }] });
+        }] });
 
 class GetCurrentSelectionRequest {
 }
@@ -7315,20 +7304,20 @@ let SelectExecution = class SelectExecution {
     _fComponentsStore = inject(FComponentsStore);
     handle(request) {
         this._fDraggableDataContext.selectedItems.forEach((x) => {
-            x.deselect();
+            x.unmarkAsSelected();
         });
         this._fDraggableDataContext.selectedItems = [];
         request.nodes.forEach((key) => {
             const node = this._fComponentsStore.fNodes.find((x) => x.fId === key);
             if (node) {
-                node.select();
+                node.markAsSelected();
                 this._fDraggableDataContext.selectedItems.push(node);
             }
         });
         request.connections.forEach((key) => {
             const connection = this._fComponentsStore.fConnections.find((x) => x.fId === key);
             if (connection) {
-                connection.select();
+                connection.markAsSelected();
                 this._fDraggableDataContext.selectedItems.push(connection);
             }
         });
@@ -7352,15 +7341,15 @@ let SelectAllExecution = class SelectAllExecution {
     _fComponentsStore = inject(FComponentsStore);
     handle(request) {
         this._fDraggableDataContext.selectedItems.forEach((x) => {
-            x.deselect();
+            x.unmarkAsSelected();
         });
         this._fDraggableDataContext.selectedItems = [];
         this._fComponentsStore.fNodes.forEach((x) => {
-            x.select();
+            x.markAsSelected();
             this._fDraggableDataContext.selectedItems.push(x);
         });
         this._fComponentsStore.fConnections.forEach((x) => {
-            x.select();
+            x.markAsSelected();
             this._fDraggableDataContext.selectedItems.push(x);
         });
         this._fDraggableDataContext.isSelectedChanged = true;
@@ -7517,7 +7506,7 @@ let UpdateItemAndChildrenLayersExecution = class UpdateItemAndChildrenLayersExec
         const allElements = Array.from(itemContainer.children);
         const targetIndex = allElements.findIndex((x) => x === item);
         if (this.isAnythingNeedToBeMoved(allElements, targetIndex, elementsThatShouldBeInFront)) {
-            this.fMediator.send(new MoveFrontElementsBeforeTargetElementRequest(itemContainer, allElements, elementsThatShouldBeInFront, targetIndex));
+            this.fMediator.execute(new MoveFrontElementsBeforeTargetElementRequest(itemContainer, allElements, elementsThatShouldBeInFront, targetIndex));
         }
     }
     isAnythingNeedToBeMoved(allElements, targetIndex, elementsThatShouldBeInFront) {
@@ -7539,7 +7528,7 @@ let UpdateItemAndChildrenLayersExecution = class UpdateItemAndChildrenLayersExec
             .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));
     }
     getChildrenNodesAndGroups(fId) {
-        return this.fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId)).map((x) => x.hostElement);
+        return this.fMediator.execute(new GetDeepChildrenNodesAndGroupsRequest(fId)).map((x) => x.hostElement);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: UpdateItemAndChildrenLayersExecution, deps: [{ token: FComponentsStore }, { token: i2$1.FMediator }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: UpdateItemAndChildrenLayersExecution });
@@ -7560,12 +7549,12 @@ let SelectAndUpdateNodeLayerExecution = class SelectAndUpdateNodeLayerExecution
     }
     handle(request) {
         this.selectNodeIfNotSelected(request.fNode);
-        this.fMediator.send(new UpdateItemAndChildrenLayersRequest(request.fNode, request.fNode.hostElement.parentElement));
+        this.fMediator.execute(new UpdateItemAndChildrenLayersRequest(request.fNode, request.fNode.hostElement.parentElement));
     }
     selectNodeIfNotSelected(fNode) {
         if (!this.fDraggableDataContext.selectedItems.includes(fNode) && !fNode.fSelectionDisabled) {
             this.fDraggableDataContext.selectedItems.push(fNode);
-            fNode.select();
+            fNode.markAsSelected();
             this.fDraggableDataContext.isSelectedChanged = true;
         }
     }
@@ -7601,10 +7590,10 @@ let EmitSelectionChangeEventExecution = class EmitSelectionChangeEventExecution
         }
         this._emitSelectionChange(this._getSelection());
         this._fDraggableDataContext.isSelectedChanged = false;
-        this._fMediator.send(new NotifyTransformChangedRequest());
+        this._fMediator.execute(new NotifyTransformChangedRequest());
     }
     _getSelection() {
-        return this._fMediator.send(new GetCurrentSelectionRequest());
+        return this._fMediator.execute(new GetCurrentSelectionRequest());
     }
     _emitSelectionChange(selection) {
         this._fSelectionChange.emit(new FSelectionChangeEvent(selection.nodes, selection.groups, selection.connections));
@@ -7631,6 +7620,10 @@ let EndDragSequenceExecution = class EndDragSequenceExecution {
     handle(request) {
         this._hostElement.classList.remove(F_CSS_CLASS.DRAG_AND_DROP.DRAGGING);
         this._fDraggableDataContext.reset();
+        this._emitDragEnded();
+    }
+    _emitDragEnded() {
+        this._fComponentsStore.fDraggable?.fDragEnded?.emit();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: EndDragSequenceExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: EndDragSequenceExecution });
@@ -7715,9 +7708,13 @@ let StartDragSequenceExecution = class StartDragSequenceExecution {
     handle(request) {
         if (this._fDraggableDataContext.draggableItems.length > 0) {
             this._hostElement.classList.add(F_CSS_CLASS.DRAG_AND_DROP.DRAGGING);
-            this._fMediator.send(new EmitSelectionChangeEventRequest());
+            this._fMediator.execute(new EmitSelectionChangeEventRequest());
+            this._emitDragStarted();
         }
     }
+    _emitDragStarted() {
+        this._fComponentsStore.fDraggable?.fDragStarted?.emit();
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: StartDragSequenceExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: StartDragSequenceExecution });
 };
@@ -7733,7 +7730,7 @@ let PrepareDragSequenceExecution = class PrepareDragSequenceExecution {
     _fDraggableDataContext = inject(FDraggableDataContext);
     handle(request) {
         this._callPrepareDragSequence();
-        this._fMediator.send(new StartDragSequenceRequest());
+        this._fMediator.execute(new StartDragSequenceRequest());
     }
     _callPrepareDragSequence() {
         this._fDraggableDataContext.draggableItems.forEach((item) => {
@@ -7931,9 +7928,9 @@ let GetFlowStateExecution = class GetFlowStateExecution {
         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())
+            nodes: this._fMediator.execute(new GetFlowStateNodesRequest(FNodeDirective)),
+            groups: this._fMediator.execute(new GetFlowStateNodesRequest(FGroupDirective)),
+            connections: this._fMediator.execute(new GetFlowStateConnectionsRequest())
         };
     }
     _getCanvasPosition(transform) {
@@ -8207,7 +8204,7 @@ let UpdateNodeWhenStateOrSizeChangedExecution = class UpdateNodeWhenStateOrSizeC
         const { hostElement, connectors, stateChanges } = request.fComponent;
         new FChannelHub(new FResizeChannel(hostElement), stateChanges).pipe(notifyOnStart(), debounceTime(10)).listen(request.destroyRef, () => {
             this._calculateConnectorsConnectableSide(connectors, hostElement);
-            this._fMediator.send(new NotifyDataChangedRequest());
+            this._fMediator.execute(new NotifyDataChangedRequest());
         });
     }
     _calculateConnectorsConnectableSide(fConnectors, fNodeHost) {
@@ -8481,7 +8478,7 @@ let SortNodeLayersExecution = class SortNodeLayersExecution {
             .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));
     }
     getChildrenNodes(fId) {
-        return this.fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId))
+        return this.fMediator.execute(new GetDeepChildrenNodesAndGroupsRequest(fId))
             .filter((x) => this.fNodesContainer.contains(x.hostElement)).map((x) => x.hostElement);
     }
     moveChildrenNodes(sortedChildrenGroups) {
@@ -8514,7 +8511,7 @@ let SortItemsByParentExecution = class SortItemsByParentExecution {
     fMediator;
     fBrowser;
     fItemsContainer;
-    get fItemsFromContainer() {
+    get _fItemElements() {
         return Array.from(this.fItemsContainer.children);
     }
     constructor(fComponentsStore, fMediator, fBrowser) {
@@ -8524,22 +8521,22 @@ let SortItemsByParentExecution = class SortItemsByParentExecution {
     }
     handle(request) {
         this.fItemsContainer = request.fItemsContainer;
-        this.getItems().forEach((parent) => {
-            this.moveChildrenItems(this.getSortedChildrenItems(parent), parent);
+        this._getItemsOfContainer().forEach((fItem) => {
+            this.moveChildrenItems(this._getSortedChildrenItems(fItem), fItem);
         });
     }
-    getItems() {
-        return this.fComponentsStore.fNodes.filter((x) => this.fItemsContainer.contains(x.hostElement));
+    _getItemsOfContainer() {
+        return this.fComponentsStore.fNodes
+            .filter((x) => this.fItemsContainer.contains(x.hostElement));
     }
-    getSortedChildrenItems(parent) {
-        const allElements = this.fItemsFromContainer;
-        const parentIndex = allElements.indexOf(parent.hostElement);
-        return this.getChildrenGroups(parent.fId)
-            .filter((child) => allElements.indexOf(child) < parentIndex)
-            .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));
+    _getSortedChildrenItems(fItem) {
+        const indexInContainer = this._fItemElements.indexOf(fItem.hostElement);
+        return this._getChildrenItems(fItem.fId)
+            .filter((child) => this._fItemElements.indexOf(child) < indexInContainer)
+            .sort((a, b) => this._fItemElements.indexOf(a) - this._fItemElements.indexOf(b));
     }
-    getChildrenGroups(fId) {
-        return this.fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId))
+    _getChildrenItems(fId) {
+        return this.fMediator.execute(new GetDeepChildrenNodesAndGroupsRequest(fId))
             .filter((x) => this.fItemsContainer.contains(x.hostElement)).map((x) => x.hostElement);
     }
     moveChildrenItems(sortedChildrenItems, parent) {
@@ -8574,9 +8571,9 @@ let SortItemLayersExecution = class SortItemLayersExecution {
         if (!this.fComponentsStore.fCanvas) {
             return;
         }
-        this.fMediator.send(new SortItemsByParentRequest(this.fComponentsStore.fCanvas.fGroupsContainer.nativeElement));
-        this.fMediator.send(new SortNodeLayersRequest());
-        this.fMediator.send(new SortItemsByParentRequest(this.fComponentsStore.fCanvas.fNodesContainer.nativeElement));
+        this.fMediator.execute(new SortItemsByParentRequest(this.fComponentsStore.fCanvas.fGroupsContainer.nativeElement));
+        this.fMediator.execute(new SortNodeLayersRequest());
+        this.fMediator.execute(new SortItemsByParentRequest(this.fComponentsStore.fCanvas.fNodesContainer.nativeElement));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SortItemLayersExecution, deps: [{ token: i2$1.FMediator }, { token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: SortItemLayersExecution });
@@ -8592,6 +8589,13 @@ function createSVGElement(tag, fBrowser) {
     return fBrowser.document.createElementNS('http://www.w3.org/2000/svg', tag);
 }
 
+function isValidEventTrigger(event, fTrigger) {
+    return fTrigger(event);
+}
+function defaultEventTrigger(event) {
+    return true;
+}
+
 var EFTriggerEvent;
 (function (EFTriggerEvent) {
     EFTriggerEvent["WHEEL"] = "wheel";
@@ -8873,16 +8877,16 @@ class FBackgroundComponent extends FBackgroundBase {
     fBackgroundPattern;
     _fMediator = inject(FMediator);
     ngOnInit() {
-        this._fMediator.send(new AddBackgroundToStoreRequest(this));
+        this._fMediator.execute(new AddBackgroundToStoreRequest(this));
     }
     ngAfterContentInit() {
-        this._fMediator.send(new AddPatternToBackgroundRequest(this.fBackgroundPattern));
+        this._fMediator.execute(new AddPatternToBackgroundRequest(this.fBackgroundPattern));
     }
     setTransform(transform) {
         this.fBackgroundPattern?.setTransform(transform);
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveBackgroundFromStoreRequest(this));
+        this._fMediator.execute(new RemoveBackgroundFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FBackgroundComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FBackgroundComponent, selector: "f-background", host: { classAttribute: "f-component f-background" }, providers: [{ provide: F_BACKGROUND, useExisting: FBackgroundComponent }], queries: [{ propertyName: "fBackgroundPattern", first: true, predicate: F_BACKGROUND_PATTERN, descendants: true }], usesInheritance: true, ngImport: i0, template: "<svg><ng-content></ng-content></svg>", isInline: true, styles: [":host{position:absolute;width:100%;height:100%;left:0;top:0;transform-origin:0 0;pointer-events:none}:host svg{width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
@@ -8935,10 +8939,10 @@ class FCanvasComponent extends FCanvasBase {
     _elementReference = inject(ElementRef);
     fCanvasChange = new EventEmitter();
     set position(value) {
-        this._fMediator.send(new InputCanvasPositionRequest(this.transform, value));
+        this._fMediator.execute(new InputCanvasPositionRequest(this.transform, PointExtensions.castToPoint(value)));
     }
     set scale(value) {
-        this._fMediator.send(new InputCanvasScaleRequest(this.transform, value));
+        this._fMediator.execute(new InputCanvasScaleRequest(this.transform, value));
     }
     get hostElement() {
         return this._elementReference.nativeElement;
@@ -8948,26 +8952,26 @@ class FCanvasComponent extends FCanvasBase {
     fConnectionsContainer;
     _fMediator = inject(FMediator);
     ngOnInit() {
-        this._fMediator.send(new AddCanvasToStoreRequest(this));
+        this._fMediator.execute(new AddCanvasToStoreRequest(this));
     }
     redraw() {
-        this._fMediator.send(new SetBackgroundTransformRequest(this.transform));
+        this._fMediator.execute(new SetBackgroundTransformRequest(this.transform));
         this.hostElement.setAttribute("style", `transform: ${TransformModelExtensions.toString(this.transform)}`);
-        this._fMediator.send(new NotifyTransformChangedRequest());
+        this._fMediator.execute(new NotifyTransformChangedRequest());
     }
     redrawWithAnimation() {
-        this._fMediator.send(new SetBackgroundTransformRequest(this.transform));
+        this._fMediator.execute(new SetBackgroundTransformRequest(this.transform));
         this.hostElement.setAttribute("style", `transition: transform ${isMobile() ? 80 : 150}ms ease-in-out; transform: ${TransformModelExtensions.toString(this.transform)}`);
         transitionEnd(this.hostElement, () => this.redraw());
     }
     centerGroupOrNode(id, animated = true) {
-        this._fMediator.send(new CenterGroupOrNodeRequest(id, animated));
+        this._fMediator.execute(new CenterGroupOrNodeRequest(id, animated));
     }
     fitToScreen(toCenter = PointExtensions.initialize(), animated = true) {
-        this._fMediator.send(new FitToFlowRequest(toCenter, animated));
+        this._fMediator.execute(new FitToFlowRequest(toCenter, animated));
     }
     resetScaleAndCenter(animated = true) {
-        this._fMediator.send(new ResetScaleAndCenterRequest(animated));
+        this._fMediator.execute(new ResetScaleAndCenterRequest(animated));
     }
     getScale() {
         return this.transform.scale || 1;
@@ -8979,7 +8983,7 @@ class FCanvasComponent extends FCanvasBase {
         this.setScale(scale, toPosition);
     }
     setScale(scale, toPosition = PointExtensions.initialize()) {
-        this._fMediator.send(new UpdateScaleRequest(scale, toPosition));
+        this._fMediator.execute(new UpdateScaleRequest(scale, toPosition));
     }
     /**
      *  @deprecated Method "resetZoom" is deprecated. Use "resetScale" instead. This method will be removed in version 18.0.0.`,
@@ -8988,10 +8992,10 @@ class FCanvasComponent extends FCanvasBase {
         this.resetScale();
     }
     resetScale() {
-        this._fMediator.send(new ResetScaleRequest());
+        this._fMediator.execute(new ResetScaleRequest());
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveCanvasFromStoreRequest());
+        this._fMediator.execute(new RemoveCanvasFromStoreRequest());
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FCanvasComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FCanvasComponent, selector: "f-canvas", inputs: { position: "position", scale: "scale" }, outputs: { fCanvasChange: "fCanvasChange" }, host: { classAttribute: "f-component f-canvas" }, providers: [
@@ -9052,7 +9056,7 @@ class FMinimapFlowDirective {
     }
     model = new FMinimapData(this.hostElement);
     redraw() {
-        const { scale, viewBox } = this._fMediator.send(new MinimapCalculateSvgScaleAndViewBoxRequest(this.hostElement, this.fMinSize));
+        const { scale, viewBox } = this._fMediator.execute(new MinimapCalculateSvgScaleAndViewBoxRequest(this.hostElement, this.fMinSize));
         this.model = new FMinimapData(this.hostElement, scale, viewBox);
         setRectToViewBox(viewBox, this.hostElement);
     }
@@ -9076,7 +9080,7 @@ class FMinimapCanvasDirective {
     }
     redraw() {
         this._clearCanvas();
-        this._fMediator.send(new MinimapDrawNodesRequest())
+        this._fMediator.execute(new MinimapDrawNodesRequest())
             .forEach((x) => {
             this.hostElement.appendChild(x);
         });
@@ -9101,7 +9105,7 @@ class FMinimapViewDirective {
         return this._elementReference.nativeElement;
     }
     redraw() {
-        setRectToElement(this._fMediator.send(new MinimapCalculateViewBoxRequest()), this.hostElement);
+        setRectToElement(this._fMediator.execute(new MinimapCalculateViewBoxRequest()), this.hostElement);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FMinimapViewDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.4", type: FMinimapViewDirective, selector: "rect[fMinimapView]", host: { classAttribute: "f-component f-minimap-view" }, ngImport: i0 });
@@ -9128,7 +9132,7 @@ class FMinimapComponent {
         this._listenTransformChanges();
     }
     _listenTransformChanges() {
-        this._fMediator.send(new ListenTransformChangesRequest()).pipe(notifyOnStart(), debounceTime(5)).listen(this._destroyRef, () => this._redraw());
+        this._fMediator.execute(new ListenTransformChangesRequest()).pipe(notifyOnStart(), debounceTime(5)).listen(this._destroyRef, () => this._redraw());
     }
     _redraw() {
         if (!this._fBrowser.isBrowser()) {
@@ -9139,10 +9143,10 @@ class FMinimapComponent {
         this.fMinimapCanvas.redraw();
     }
     onPointerDown(event) {
-        this._fMediator.send(new MinimapDragPreparationRequest(event, this.fMinimapFlow.model));
+        this._fMediator.execute(new MinimapDragPreparationRequest(event, this.fMinimapFlow.model));
     }
     onPointerUp(event) {
-        this._fMediator.send(new MinimapDragFinalizeRequest(event));
+        this._fMediator.execute(new MinimapDragFinalizeRequest(event));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FMinimapComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FMinimapComponent, selector: "f-minimap", inputs: { fMinSize: "fMinSize" }, host: { classAttribute: "f-component f-minimap" }, providers: [
@@ -9197,7 +9201,7 @@ class FFlowComponent extends FFlowBase {
         this.fBrowser = fBrowser;
     }
     ngOnInit() {
-        this._fMediator.send(new AddFlowToStoreRequest(this));
+        this._fMediator.execute(new AddFlowToStoreRequest(this));
     }
     ngAfterContentInit() {
         if (!this.fBrowser.isBrowser()) {
@@ -9207,13 +9211,13 @@ class FFlowComponent extends FFlowBase {
         this._listenDataChanges();
     }
     _listenCountChanges() {
-        this._fMediator.send(new ListenCountChangesRequest()).listen(this._destroyRef, () => {
-            this._fMediator.send(new SortItemLayersRequest());
+        this._fMediator.execute(new ListenCountChangesRequest()).listen(this._destroyRef, () => {
+            this._fMediator.execute(new SortItemLayersRequest());
         });
     }
     _listenDataChanges() {
-        this._fMediator.send(new ListenDataChangesRequest()).listen(this._destroyRef, () => {
-            this._fMediator.send(new RedrawConnectionsRequest());
+        this._fMediator.execute(new ListenDataChangesRequest()).listen(this._destroyRef, () => {
+            this._fMediator.execute(new RedrawConnectionsRequest());
             this._emitLoaded();
         });
     }
@@ -9224,34 +9228,34 @@ class FFlowComponent extends FFlowBase {
         }
     }
     redraw() {
-        this._fMediator.send(new NotifyDataChangedRequest());
+        this._fMediator.execute(new NotifyDataChangedRequest());
     }
     reset() {
         this._isLoaded = false;
     }
     getNodesBoundingBox() {
-        return this._fMediator.send(new CalculateNodesBoundingBoxNormalizedPositionRequest());
+        return this._fMediator.execute(new CalculateNodesBoundingBoxNormalizedPositionRequest());
     }
     getSelection() {
-        return this._fMediator.send(new GetCurrentSelectionRequest());
+        return this._fMediator.execute(new GetCurrentSelectionRequest());
     }
     getPositionInFlow(position) {
-        return this._fMediator.send(new GetNormalizedPointRequest(position));
+        return this._fMediator.execute(new GetNormalizedPointRequest(position));
     }
     getState() {
-        return this._fMediator.send(new GetFlowStateRequest());
+        return this._fMediator.execute(new GetFlowStateRequest());
     }
     selectAll() {
-        this._fMediator.send(new SelectAllRequest());
+        this._fMediator.execute(new SelectAllRequest());
     }
     select(nodes, connections) {
-        this._fMediator.send(new SelectRequest(nodes, connections));
+        this._fMediator.execute(new SelectRequest(nodes, connections));
     }
     clearSelection() {
-        this._fMediator.send(new ClearSelectionRequest());
+        this._fMediator.execute(new ClearSelectionRequest());
     }
     ngOnDestroy() {
-        this._fMediator.send(new RemoveFlowFromStoreRequest());
+        this._fMediator.execute(new RemoveFlowFromStoreRequest());
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.4", ngImport: i0, type: FFlowComponent, deps: [{ token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.4", type: FFlowComponent, selector: "f-flow", inputs: { fId: ["fFlowId", "fId"] }, outputs: { fLoaded: "fLoaded" }, host: { properties: { "attr.id": "fId" }, classAttribute: "f-component f-flow" }, providers: [
@@ -9518,5 +9522,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, AddZoomToStoreExecution, AddZoomToStoreRequest, ApplyChildResizeRestrictionsExecution, ApplyChildResizeRestrictionsRequest, ApplyParentResizeRestrictionsExecution, ApplyParentResizeRestrictionsRequest, 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, CalculateClosestInputExecution, CalculateClosestInputRequest, CalculateCommonNodeMoveRestrictionsExecution, CalculateCommonNodeMoveRestrictionsRequest, CalculateConnectionCenterHandler, CalculateConnectionCenterRequest, CalculateConnectionLineByBehaviorExecution, CalculateConnectionLineByBehaviorRequest, CalculateFlowPointFromMinimapPointExecution, CalculateFlowPointFromMinimapPointRequest, CalculateNodeMoveRestrictionsExecution, CalculateNodeMoveRestrictionsRequest, CalculateNodesBoundingBoxExecution, CalculateNodesBoundingBoxNormalizedPositionExecution, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CanvasDragHandler, CanvasMoveFinalizeExecution, CanvasMoveFinalizeRequest, CanvasMovePreparationExecution, CanvasMovePreparationRequest, 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, Deprecated, EFConnectableSide, EFConnectionBehavior, EFConnectionType, EFMarkerType, EFResizeHandleType, EFTriggerEvent, EFZoomAction, EFZoomDirection, 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_CSS_CLASS, 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_FEATURES, F_ZOOM_PROVIDERS, F_ZOOM_TAG, FindInputAtPositionExecution, FindInputAtPositionRequest, FitToFlowExecution, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetAllCanBeConnectedInputsAndRectsExecution, GetAllCanBeConnectedInputsAndRectsRequest, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletRequest, GetCanBeConnectedOutputByOutletValidator, GetCanBeSelectedItemsExecution, GetCanBeSelectedItemsRequest, GetCanvasExecution, GetCanvasRequest, GetConnectorAndRectExecution, GetConnectorAndRectRequest, GetCurrentSelectionExecution, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroupsExecution, GetDeepChildrenNodesAndGroupsRequest, GetElementRoundedRectExecution, GetElementRoundedRectRequest, GetFlowExecution, GetFlowHostElementExecution, GetFlowHostElementRequest, GetFlowRequest, GetFlowStateConnectionsExecution, GetFlowStateConnectionsRequest, GetFlowStateExecution, GetFlowStateNodesExecution, GetFlowStateNodesRequest, GetFlowStateRequest, 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, MarkAllCanBeConnectedInputsExecution, MarkAllCanBeConnectedInputsRequest, 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, RemoveZoomFromStoreExecution, RemoveZoomFromStoreRequest, ResetScaleAndCenterExecution, ResetScaleAndCenterRequest, ResetScaleExecution, ResetScaleRequest, ResetZoomExecution, ResetZoomRequest, 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, SetZoomExecution, SetZoomRequest, SingleSelectExecution, SingleSelectRequest, SortItemLayersExecution, SortItemLayersRequest, SortItemsByParentExecution, SortItemsByParentRequest, SortNodeLayersExecution, SortNodeLayersRequest, StartDragSequenceExecution, StartDragSequenceRequest, UnmarkAllCanBeConnectedInputsExecution, UnmarkAllCanBeConnectedInputsRequest, 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, AddZoomToStoreExecution, AddZoomToStoreRequest, ApplyChildResizeRestrictionsExecution, ApplyChildResizeRestrictionsRequest, ApplyParentResizeRestrictionsExecution, ApplyParentResizeRestrictionsRequest, BaseConnectionDragHandler, 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, CalculateClosestInputExecution, CalculateClosestInputRequest, CalculateCommonNodeMoveLimitsExecution, CalculateCommonNodeMoveLimitsRequest, CalculateConnectionCenterHandler, CalculateConnectionCenterRequest, CalculateConnectionLineByBehaviorExecution, CalculateConnectionLineByBehaviorRequest, CalculateFlowPointFromMinimapPointExecution, CalculateFlowPointFromMinimapPointRequest, CalculateNodeMoveLimitsExecution, CalculateNodeMoveLimitsRequest, CalculateNodesBoundingBoxExecution, CalculateNodesBoundingBoxNormalizedPositionExecution, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CanvasDragHandler, CanvasMoveFinalizeExecution, CanvasMoveFinalizeRequest, CanvasMovePreparationExecution, CanvasMovePreparationRequest, CenterGroupOrNodeExecution, CenterGroupOrNodeRequest, ClearSelectionExecution, ClearSelectionRequest, CreateConnectionDragHandler, CreateConnectionDragHandlerPreparationExecution, CreateConnectionDragHandlerPreparationRequest, CreateConnectionFinalizeExecution, CreateConnectionFinalizeRequest, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparationExecution, CreateConnectionFromOutputPreparationRequest, CreateConnectionMarkersExecution, CreateConnectionMarkersRequest, CreateConnectionPreparationExecution, CreateConnectionPreparationRequest, CreateMoveNodesDragModelFromSelectionExecution, CreateMoveNodesDragModelFromSelectionRequest, DRAG_AND_DROP_COMMON_PROVIDERS, Deprecated, EFConnectableSide, EFConnectionBehavior, EFConnectionType, EFMarkerType, EFResizeHandleType, EFTriggerEvent, EFZoomAction, EFZoomDirection, EXTERNAL_ITEM_FINALIZE_PROVIDERS, EXTERNAL_ITEM_PREPARATION_PROVIDERS, EmitSelectionChangeEventExecution, EmitSelectionChangeEventRequest, EndDragSequenceExecution, EndDragSequenceRequest, ExternalItemDragHandler, ExternalItemFinalizeExecution, ExternalItemFinalizeRequest, ExternalItemPreparationExecution, ExternalItemPreparationRequest, 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, FInjector, 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_CSS_CLASS, 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_FEATURES, F_ZOOM_PROVIDERS, F_ZOOM_TAG, FindInputAtPositionExecution, FindInputAtPositionRequest, FitToFlowExecution, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetAllCanBeConnectedInputsAndRectsExecution, GetAllCanBeConnectedInputsAndRectsRequest, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletRequest, GetCanBeSelectedItemsExecution, GetCanBeSelectedItemsRequest, GetCanvasExecution, GetCanvasRequest, GetConnectorAndRectExecution, GetConnectorAndRectRequest, GetCurrentSelectionExecution, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroupsExecution, GetDeepChildrenNodesAndGroupsRequest, GetElementRoundedRectExecution, GetElementRoundedRectRequest, GetFlowExecution, GetFlowHostElementExecution, GetFlowHostElementRequest, GetFlowRequest, GetFlowStateConnectionsExecution, GetFlowStateConnectionsRequest, GetFlowStateExecution, GetFlowStateNodesExecution, GetFlowStateNodesRequest, GetFlowStateRequest, 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, MarkAllCanBeConnectedInputsExecution, MarkAllCanBeConnectedInputsRequest, MinimapCalculateSvgScaleAndViewBoxExecution, MinimapCalculateSvgScaleAndViewBoxRequest, MinimapCalculateViewBoxExecution, MinimapCalculateViewBoxRequest, MinimapDragFinalizeExecution, MinimapDragFinalizeRequest, MinimapDragPreparationExecution, MinimapDragPreparationRequest, MinimapDrawNodesExecution, MinimapDrawNodesRequest, MoveFrontElementsBeforeTargetElementExecution, MoveFrontElementsBeforeTargetElementRequest, NODE_DRAG_TO_PARENT_FINALIZE_PROVIDERS, NODE_MOVE_PREPARATION_PROVIDERS, NODE_PROVIDERS, NODE_RESIZE_FINALIZE_PROVIDERS, NODE_RESIZE_PROVIDERS, NodeDragHandler, NodeDragToParentDragHandler, NodeDragToParentFinalizeExecution, NodeDragToParentFinalizeRequest, NodeDragToParentPreparationExecution, NodeDragToParentPreparationRequest, NodeMoveFinalizeExecution, NodeMoveFinalizeRequest, NodeMovePreparationExecution, NodeMovePreparationRequest, NodeResizeDragHandler, NodeResizeFinalizeExecution, NodeResizeFinalizeRequest, NodeResizePreparationExecution, NodeResizePreparationRequest, NotifyDataChangedExecution, NotifyDataChangedRequest, NotifyTransformChangedExecution, NotifyTransformChangedRequest, OnPointerMoveExecution, OnPointerMoveRequest, PointBoundsLimiter, 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, RemoveZoomFromStoreExecution, RemoveZoomFromStoreRequest, ResetScaleAndCenterExecution, ResetScaleAndCenterRequest, ResetScaleExecution, ResetScaleRequest, ResetZoomExecution, ResetZoomRequest, SINGLE_SELECT_PROVIDERS, SelectAllExecution, SelectAllRequest, SelectAndUpdateNodeLayerExecution, SelectAndUpdateNodeLayerRequest, SelectExecution, SelectRequest, SelectionAreaDragHandle, SelectionAreaFinalizeExecution, SelectionAreaFinalizeRequest, SelectionAreaPreparationExecution, SelectionAreaPreparationRequest, SetBackgroundTransformExecution, SetBackgroundTransformRequest, SetZoomExecution, SetZoomRequest, SingleSelectExecution, SingleSelectRequest, SortItemLayersExecution, SortItemLayersRequest, SortItemsByParentExecution, SortItemsByParentRequest, SortNodeLayersExecution, SortNodeLayersRequest, SourceConnectionDragHandler, SourceTargetConnectionDragHandler, StartDragSequenceExecution, StartDragSequenceRequest, SummaryNodeDragHandler, TargetConnectionDragHandler, UnmarkAllCanBeConnectedInputsExecution, UnmarkAllCanBeConnectedInputsRequest, UpdateItemAndChildrenLayersExecution, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChangedExecution, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScaleExecution, UpdateScaleRequest, createSVGElement, debounceTime, defaultEventTrigger, fInject, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getExternalItem, getMarkerEndId, getMarkerSelectedEndId, getMarkerSelectedStartId, getMarkerStartId, isExternalItem, isMobile, isNode, isNodeOutlet, isNodeOutput, isValidEventTrigger, mixinChangeSelection, mixinChangeVisibility, notifyOnStart, transitionEnd };
 //# sourceMappingURL=foblex-flow.mjs.map