@foblex/flow 19.1.5 → 19.1.7

package/AI.md

@@ -4,7 +4,7 @@ Use this file as a strict control layer for code generation. Prefer verified pac
 
 ## What This Library Is
 
-`@foblex/flow` is an Angular-native library for building node-based editors, workflow builders, and interactive graph UIs.
+`@foblex/flow` is the most widely adopted node editor library for Angular (by npm weekly downloads) — Angular-native, for production workflow builders, AI pipelines, and interactive diagram editors.
 It provides rendering, connectors, interactions, selection, zoom, and connection drawing. By default your app owns graph records; the optional `withFlowState()` feature maintains typed records and undo/redo that your app explicitly loads and renders.
 
 ## Core Mental Model
@@ -170,7 +170,7 @@ If the toggle is nested inside `fDragHandle`, add `fDragBlocker` to the toggle.
 
 When the flow compiles but looks wrong, verify in this order:
 
-1. **Connection not visible**: `fSourceId` / `fTargetId` does not match any rendered `fConnectorId` exactly (string comparison; `1` vs `'1'` from different sources is a classic mismatch). The connection silently does not render.
+1. **Connection not visible**: `fSourceId` / `fTargetId` does not match any rendered `fConnectorId` exactly. `out-1` vs `out_1` is a mismatch; numeric `1` and string `'1'` normalize to the same id. The connection does not render, and dev mode reports `FF1001` after endpoint resolution settles.
 2. **Blank canvas**: `f-flow` has zero height, or the theme SCSS is not wired in `angular.json`.
 3. **`'f-flow' is not a known element`** or connectors not working: `FFlowModule` missing from the component `imports`.
 4. **Nothing is draggable / no events fire**: `fDraggable` missing on `<f-flow>`.
@@ -185,7 +185,7 @@ When the flow compiles but looks wrong, verify in this order:
 13. **Wrong initial viewport** (`FF1009`): `fitToScreen()` / `resetScaleAndCenter()` / `centerGroupOrNode()` / `resetScaleAndCenterGroupOrNode()` called before nodes were rendered — call them from `(fNodesRendered)` (earliest safe) or `(fFullRendered)`.
 14. **Initial centering appears in managed undo history**: call `resetScaleAndCenter(false, false)` (or pass `emitCanvasChange: false` to another viewport helper) for an application-driven transform.
 
-To verify programmatically: listen to `(fFullRendered)` on `<f-flow>`, then call `flow.getState()` and assert every declared connection resolved to existing connectors.
+To verify programmatically: wait for `(fFullRendered)`, compare the node, group, and connection ids exported by `flow.getState()` with the expected graph, and fail the test on any `FFxxxx` console diagnostic. `getState()` exports registered graph records; it does not by itself prove that connection endpoints resolved. Dev-mode `FF1001` reports an unresolved endpoint.
 
 ## Additional Rules
 

package/README.md

@@ -25,10 +25,10 @@
 <h1 align="center">Foblex Flow</h1>
 
 <p align="center">
-  <strong>Angular-native node-based UI library for building node editors, workflow builders, and interactive graph interfaces.</strong>
+  <strong>The most adopted node editor library for Angular — for production workflow builders, AI pipelines, and interactive diagram editors.</strong>
 </p>
 
-Foblex Flow gives Angular teams a simple way to start building graph-based products without adopting a React-first mental model. Begin with `f-flow`, `f-canvas`, nodes, and connections, then add richer editor features only when your product needs them.
+Foblex Flow ships the hard parts of a production node editor — drag logic, hit-testing, SVG connection paths, reassign, selection, zoom, and undo/redo — as Angular-native building blocks. Begin with `f-flow`, `f-canvas`, nodes, and connections, then add richer editor features only when your product needs them. It powers production products such as [Luware Nimbus](https://luware.com/products/nimbus), [ProcessMIX](https://processmix.com/), [XpertAI](https://xpertai.cn/en/), and [EpicStaff](https://www.epicstaff.ai/).
 
 Use it to create workflow builders, AI low-code tools, call-flow editors, UML diagrams, internal back-office tools, and other node-based interfaces. Start with app-owned graph records, or opt into managed records and undo/redo with `withFlowState()`; validation, persistence, permissions, and domain logic remain application concerns in both modes.
 
@@ -40,8 +40,17 @@ Use it to create workflow builders, AI low-code tools, call-flow editors, UML di
 
 Current `19.x` releases target Angular `17.3+`. If your app is on Angular 12-17.2, check the [Angular Version Compatibility](https://flow.foblex.com/docs/angular-version-compatibility) guide first and pin the matching Foblex Flow line before installing.
 
+## Built for AI Coding Agents
+
+Foblex Flow treats AI coding agents as first-class users: the package ships a version-matched guide at `node_modules/@foblex/flow/AI.md`, `ng add` writes workspace agent rules, and stable `FFxxxx` diagnostics give agents a concrete pass/fail signal. Before generating code, verify Foblex-specific selectors and APIs against that guide or the linked official reference; do not infer APIs from other node editor libraries.
+
+Choose the integration deliberately: classic mode keeps graph records in the application, while optional `provideFFlow(withFlowState())` provides typed managed records and undo/redo for supported operations. Verify generated flows using the APIs and `FFxxxx` diagnostics described in the shipped guide.
+
+[AI setup guide](https://flow.foblex.com/docs/ai) · [Full curated LLM-readable reference](https://flow.foblex.com/llms-full.txt)
+
 ## Why Foblex Flow
 
+- The most adopted node editor library built for Angular, by npm weekly downloads — maintained full-time since 2022 and used in production commercial products.
 - Easy starting path: most editors begin with `f-flow`, `f-canvas`, nodes, connectors, and connections.
 - Angular-first API that fits Angular apps instead of wrapping a React-style state model.
 - Built for real editor interactions: drag to connect, drag to reassign, selection, zoom, minimap, snapping, alignment helpers, and waypoints.
@@ -65,7 +74,7 @@ Current `19.x` releases target Angular `17.3+`. If your app is on Angular 12-17.
 | Integration   | Classic event-driven API with app-owned records, or optional `withFlowState()` managed records, snapshots, and undo/redo; SSR-safe, zoneless-ready                        |
 | AI tooling    | `llms.txt`, bundled `AI.md`, `ng add` writes agent rules, dev diagnostics with stable `FFxxxx` error codes                                                                |
 
-Coming from React Flow? Read the honest comparison: [React Flow vs Foblex Flow for Angular teams](https://flow.foblex.com/docs/react-flow-vs-foblex-flow-for-angular-teams).
+Comparing options? Read the honest comparisons: [React Flow vs Foblex Flow for Angular teams](https://flow.foblex.com/docs/react-flow-vs-foblex-flow-for-angular-teams) and [ngx-vflow vs Foblex Flow](https://flow.foblex.com/docs/ngx-vflow-vs-foblex-flow).
 
 ## Choose Your State Integration
 
@@ -191,7 +200,7 @@ That is the rendering mental model: `f-flow` hosts the editor, `f-canvas` pans a
 
 ### For AI Agents and LLMs
 
-- [llms.txt](https://flow.foblex.com/llms.txt) — docs index for agents; [llms-full.txt](https://flow.foblex.com/llms-full.txt) — complete LLM-readable API reference
+- [llms.txt](https://flow.foblex.com/llms.txt) — docs index for agents; [llms-full.txt](https://flow.foblex.com/llms-full.txt) — full curated LLM-readable reference
 - [AI usage guide](https://github.com/Foblex/f-flow/blob/main/libs/f-flow/AI.md) — strict code-generation rules, also shipped inside this package at `node_modules/@foblex/flow/AI.md`
 
 ## Community and Support

package/fesm2022/foblex-flow.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, ElementRef, DestroyRef, Injector, input, effect, untracked, Directive, signal, numberAttribute, model, booleanAttribute, ChangeDetectionStrategy, Component, viewChild, Input, computed, contentChildren, contentChild, Renderer2, output, NgZone, ViewContainerRef, TemplateRef, runInInjectionContext, EventEmitter, Output, afterNextRender, NgModule } from '@angular/core';
+import { InjectionToken, inject, Injectable, ElementRef, DestroyRef, Injector, input, effect, untracked, Directive, signal, computed, numberAttribute, model, booleanAttribute, ChangeDetectionStrategy, Component, viewChild, Input, contentChildren, contentChild, Renderer2, output, NgZone, ViewContainerRef, TemplateRef, runInInjectionContext, EventEmitter, Output, afterNextRender, NgModule } from '@angular/core';
 import { TransformModelExtensions, PointExtensions, RectExtensions, GetIntersections, RoundedRect, Point, LineExtensions, SizeExtensions, setRectToElement, adjustRectToMinSize, setRectToViewBox } from '@foblex/2d';
 import { __decorate } from 'tslib';
 import { FExecutionRegister, FMediator } from '@foblex/mediator';
@@ -1971,6 +1971,21 @@ const F_CONNECTION_WAYPOINTS = new InjectionToken('F_CONNECTION_WAYPOINTS');
 class FConnectionWaypointsBase {
     hostElement = inject((ElementRef)).nativeElement;
     candidates = signal([], ...(ngDevMode ? [{ debugName: "candidates" }] : []));
+    /**
+     * Handle display positions supplied by the line builder (for example the
+     * bend apex of a rounded segment corner). The waypoint model itself is
+     * untouched — dragging and events always operate on the real waypoints.
+     */
+    handles = signal([], ...(ngDevMode ? [{ debugName: "handles" }] : []));
+    /**
+     * Where the waypoint handles are drawn and hit-tested: the builder-supplied
+     * positions when they cover every waypoint, otherwise the waypoints
+     * themselves.
+     */
+    displayedWaypoints = computed(() => {
+        const handles = this.handles();
+        return handles.length === this.waypoints().length ? handles : this.waypoints();
+    }, ...(ngDevMode ? [{ debugName: "displayedWaypoints" }] : []));
     _activeIndex = 0;
     _waypoints = [];
     insert(candidate) {
@@ -2005,7 +2020,11 @@ function findWaypointCandidate(connection, position) {
 function findExistingWaypoint(connection, position) {
     const component = connection.fWaypoints();
     const radius = component?.radius() || 8;
-    return component?.waypoints().find((x) => isPointerInsidePoint(position, x, radius));
+    // Handles can be drawn slightly off the raw waypoint (on the bend apex of a
+    // rounded corner), so hit-test where they are rendered but hand back the
+    // real waypoint — dragging always operates on the model value.
+    const index = (component?.displayedWaypoints() ?? []).findIndex((x) => isPointerInsidePoint(position, x, radius));
+    return index >= 0 ? component?.waypoints()[index] : undefined;
 }
 
 function pickWaypoint(connections, position) {
@@ -2060,13 +2079,13 @@ class FConnectionWaypoints extends FConnectionWaypointsBase {
         this._notifyDataChanged();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FConnectionWaypoints, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.9", type: FConnectionWaypoints, isStandalone: true, selector: "f-connection-waypoints", inputs: { radius: { classPropertyName: "radius", publicName: "radius", isSignal: true, isRequired: false, transformFunction: null }, waypoints: { classPropertyName: "waypoints", publicName: "waypoints", isSignal: true, isRequired: false, transformFunction: null }, visibility: { classPropertyName: "visibility", publicName: "visibility", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { waypoints: "waypointsChange" }, host: { classAttribute: "f-component f-connection-waypoints" }, providers: [{ provide: F_CONNECTION_WAYPOINTS, useExisting: FConnectionWaypoints }], usesInheritance: true, ngImport: i0, template: "@if (visibility()) {\n  <svg xmlns=\"http://www.w3.org/2000/svg\">\n    <g>\n      @for (candidate of candidates(); track $index) {\n        <circle\n          [attr.r]=\"radius()\"\n          class=\"f-candidate\"\n          [attr.cx]=\"candidate.x\"\n          [attr.cy]=\"candidate.y\"\n        ></circle>\n      }\n      @for (point of waypoints(); track $index) {\n        <circle\n          [attr.r]=\"radius()\"\n          (contextmenu)=\"remove($index, $event)\"\n          class=\"f-waypoint\"\n          [attr.cx]=\"point.x\"\n          [attr.cy]=\"point.y\"\n        ></circle>\n      }\n    </g>\n  </svg>\n}\n\n", styles: [":host{pointer-events:none;position:absolute}svg{display:block;vertical-align:middle;position:absolute;overflow:visible}circle{pointer-events:visible}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.9", type: FConnectionWaypoints, isStandalone: true, selector: "f-connection-waypoints", inputs: { radius: { classPropertyName: "radius", publicName: "radius", isSignal: true, isRequired: false, transformFunction: null }, waypoints: { classPropertyName: "waypoints", publicName: "waypoints", isSignal: true, isRequired: false, transformFunction: null }, visibility: { classPropertyName: "visibility", publicName: "visibility", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { waypoints: "waypointsChange" }, host: { classAttribute: "f-component f-connection-waypoints" }, providers: [{ provide: F_CONNECTION_WAYPOINTS, useExisting: FConnectionWaypoints }], usesInheritance: true, ngImport: i0, template: "@if (visibility()) {\n<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <g>\n    @for (candidate of candidates(); track $index) {\n    <circle\n      [attr.r]=\"radius()\"\n      class=\"f-candidate\"\n      [attr.cx]=\"candidate.x\"\n      [attr.cy]=\"candidate.y\"\n    ></circle>\n    } @for (point of displayedWaypoints(); track $index) {\n    <circle\n      [attr.r]=\"radius()\"\n      (contextmenu)=\"remove($index, $event)\"\n      class=\"f-waypoint\"\n      [attr.cx]=\"point.x\"\n      [attr.cy]=\"point.y\"\n    ></circle>\n    }\n  </g>\n</svg>\n}\n", styles: [":host{pointer-events:none;position:absolute}svg{display:block;vertical-align:middle;position:absolute;overflow:visible}circle{pointer-events:visible}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FConnectionWaypoints, decorators: [{
             type: Component,
             args: [{ selector: 'f-connection-waypoints', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, host: {
                         class: 'f-component f-connection-waypoints',
-                    }, providers: [{ provide: F_CONNECTION_WAYPOINTS, useExisting: FConnectionWaypoints }], template: "@if (visibility()) {\n  <svg xmlns=\"http://www.w3.org/2000/svg\">\n    <g>\n      @for (candidate of candidates(); track $index) {\n        <circle\n          [attr.r]=\"radius()\"\n          class=\"f-candidate\"\n          [attr.cx]=\"candidate.x\"\n          [attr.cy]=\"candidate.y\"\n        ></circle>\n      }\n      @for (point of waypoints(); track $index) {\n        <circle\n          [attr.r]=\"radius()\"\n          (contextmenu)=\"remove($index, $event)\"\n          class=\"f-waypoint\"\n          [attr.cx]=\"point.x\"\n          [attr.cy]=\"point.y\"\n        ></circle>\n      }\n    </g>\n  </svg>\n}\n\n", styles: [":host{pointer-events:none;position:absolute}svg{display:block;vertical-align:middle;position:absolute;overflow:visible}circle{pointer-events:visible}\n"] }]
+                    }, providers: [{ provide: F_CONNECTION_WAYPOINTS, useExisting: FConnectionWaypoints }], template: "@if (visibility()) {\n<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <g>\n    @for (candidate of candidates(); track $index) {\n    <circle\n      [attr.r]=\"radius()\"\n      class=\"f-candidate\"\n      [attr.cx]=\"candidate.x\"\n      [attr.cy]=\"candidate.y\"\n    ></circle>\n    } @for (point of displayedWaypoints(); track $index) {\n    <circle\n      [attr.r]=\"radius()\"\n      (contextmenu)=\"remove($index, $event)\"\n      class=\"f-waypoint\"\n      [attr.cx]=\"point.x\"\n      [attr.cy]=\"point.y\"\n    ></circle>\n    }\n  </g>\n</svg>\n}\n", styles: [":host{pointer-events:none;position:absolute}svg{display:block;vertical-align:middle;position:absolute;overflow:visible}circle{pointer-events:visible}\n"] }]
         }], propDecorators: { radius: [{ type: i0.Input, args: [{ isSignal: true, alias: "radius", required: false }] }], waypoints: [{ type: i0.Input, args: [{ isSignal: true, alias: "waypoints", required: false }] }, { type: i0.Output, args: ["waypointsChange"] }], visibility: [{ type: i0.Input, args: [{ isSignal: true, alias: "visibility", required: false }] }] } });
 
 var EFMarkerType;
@@ -2642,6 +2661,29 @@ function dist(a, b) {
     return Math.hypot(b.x - a.x, b.y - a.y);
 }
 
+/**
+ * Control point for a cubic segment end that lies on an intermediate waypoint.
+ * The tangent runs from the previous toward the next neighbor (Catmull-Rom
+ * style), so the two segments meeting at the waypoint share one tangent
+ * direction and the curve passes through it smoothly. Connector sides shape
+ * only the real endpoints of the connection, never the waypoints.
+ *
+ * `distance` is positive for an outgoing control point and negative for an
+ * incoming one.
+ */
+function calculateSmoothControlPoint(anchor, previous, next, distance) {
+    const dx = next.x - previous.x;
+    const dy = next.y - previous.y;
+    const length = Math.hypot(dx, dy);
+    if (length === 0) {
+        return { x: anchor.x, y: anchor.y };
+    }
+    return {
+        x: anchor.x + (dx / length) * distance,
+        y: anchor.y + (dy / length) * distance,
+    };
+}
+
 function mergePointChains(chains) {
     const out = [];
     for (const chain of chains) {
@@ -2763,13 +2805,19 @@ class CalculateAdaptiveCurveData {
         const clampedOffset = Math.max(0, offset ?? 0);
         const anchors = buildConnectionAnchors(source, target, waypoints);
         const segments = [];
+        // Connector sides shape only the first and the last tangent; at
+        // intermediate waypoints both adjacent segments share one Catmull-Rom
+        // style tangent, so the curve passes through waypoints without kinks.
         for (let i = 0; i < anchors.length - 1; i++) {
             const a = anchors[i];
             const b = anchors[i + 1];
-            const h0 = CalculateAdaptiveCurveData._handleLength(a, b, sourceSide, clampedOffset);
-            const h3 = CalculateAdaptiveCurveData._handleLength(b, a, targetSide, clampedOffset);
-            const c1 = CalculateAdaptiveCurveData._softControl(sourceSide, a, b, h0);
-            const c2 = CalculateAdaptiveCurveData._softControl(targetSide, b, a, h3);
+            const handle = Math.hypot(b.x - a.x, b.y - a.y) / 3;
+            const c1 = i === 0
+                ? CalculateAdaptiveCurveData._softControl(sourceSide, a, b, CalculateAdaptiveCurveData._handleLength(a, b, sourceSide, clampedOffset))
+                : calculateSmoothControlPoint(a, anchors[i - 1], b, handle);
+            const c2 = i === anchors.length - 2
+                ? CalculateAdaptiveCurveData._softControl(targetSide, b, a, CalculateAdaptiveCurveData._handleLength(b, a, targetSide, clampedOffset))
+                : calculateSmoothControlPoint(b, a, anchors[i + 2], -handle);
             segments.push({ p0: a, c1, c2, p3: b, chainIndex: i });
         }
         const points = sampleMultiCubicUniform(segments, 12);
@@ -2787,11 +2835,19 @@ class CalculateBezierCurveData {
     handle({ source, sourceSide, target, targetSide, offset, waypoints, }) {
         const anchors = buildConnectionAnchors(source, target, waypoints);
         const segments = [];
+        // Connector sides shape only the first and the last tangent; at
+        // intermediate waypoints both adjacent segments share one Catmull-Rom
+        // style tangent, so the curve passes through waypoints without kinks.
         for (let i = 0; i < anchors.length - 1; i++) {
             const a = anchors[i];
             const b = anchors[i + 1];
-            const c1 = getAnglePoint(sourceSide, a, b, offset ?? 0);
-            const c2 = getAnglePoint(targetSide, b, a, offset ?? 0);
+            const handle = Math.hypot(b.x - a.x, b.y - a.y) / 3;
+            const c1 = i === 0
+                ? getAnglePoint(sourceSide, a, b, offset ?? 0)
+                : calculateSmoothControlPoint(a, anchors[i - 1], b, handle);
+            const c2 = i === anchors.length - 2
+                ? getAnglePoint(targetSide, b, a, offset ?? 0)
+                : calculateSmoothControlPoint(b, a, anchors[i + 2], -handle);
             segments.push({ p0: a, c1, c2, p3: b, chainIndex: i });
         }
         const points = sampleMultiCubicUniform(segments, 12);
@@ -2894,6 +2950,38 @@ function createSegmentLinePath(points, borderRadius) {
     parts.push(`L ${last.x + END_EPS} ${last.y + END_EPS}`);
     return parts.join(' ');
 }
+/**
+ * The point of the rendered path closest to corner `b` — the apex of the
+ * rounded bend `getBend` produces for it, or `b` itself when the corner is
+ * rendered sharp. Uses the same bend-size clamping as `getBend`, so the
+ * result always lies on the path.
+ */
+function calculateCornerApex(a, b, c, size) {
+    if (size <= 0) {
+        return { x: b.x, y: b.y };
+    }
+    const collinearX = Math.abs(a.x - b.x) <= EPS$1 && Math.abs(b.x - c.x) <= EPS$1;
+    const collinearY = Math.abs(a.y - b.y) <= EPS$1 && Math.abs(b.y - c.y) <= EPS$1;
+    if (collinearX || collinearY) {
+        return { x: b.x, y: b.y };
+    }
+    const ab = Math.hypot(b.x - a.x, b.y - a.y);
+    const bc = Math.hypot(c.x - b.x, c.y - b.y);
+    const bendSize = Math.min(ab * 0.5, bc * 0.5, size);
+    if (bendSize < MIN_VISIBLE || ab === 0 || bc === 0) {
+        return { x: b.x, y: b.y };
+    }
+    // The bend is a quadratic from (b - bendSize*din) to (b + bendSize*dout)
+    // with control b; its apex at t = 0.5 is b + 0.25 * bendSize * (dout - din).
+    const dinX = (b.x - a.x) / ab;
+    const dinY = (b.y - a.y) / ab;
+    const doutX = (c.x - b.x) / bc;
+    const doutY = (c.y - b.y) / bc;
+    return {
+        x: b.x + 0.25 * bendSize * (doutX - dinX),
+        y: b.y + 0.25 * bendSize * (doutY - dinY),
+    };
+}
 function getBend(a, b, c, size) {
     const x = b.x;
     const y = b.y;
@@ -2933,17 +3021,24 @@ const CONNECTOR_SIDE_POINT = {
     [EFConnectableSide.BOTTOM]: PointExtensions.initialize(0, 1),
     [EFConnectableSide.AUTO]: PointExtensions.initialize(0, 0),
 };
+const HARD_VIOLATION_SCORE = 1000;
+const ARRIVAL_AXIS_SCORE = 8;
+const BEND_SCORE = 1;
+const LENGTH_SCORE = 1e-6;
+const NODE_ZONE_SCORE = 1;
+const NODE_ZONE_SCORE_LIMIT = 600;
 class CalculateSegmentLineData {
     handle({ source, sourceSide, target, targetSide, waypoints, offset, radius, }) {
         const anchors = buildConnectionAnchors(source, target, waypoints);
-        const chains = [];
+        const chains = anchors.length === 2
+            ? [this._getPathPoints(source, sourceSide, target, targetSide, offset ?? 0)]
+            : this._buildWaypointChains(anchors, sourceSide, targetSide, offset ?? 0);
         const candidates = [];
-        for (let i = 0; i < anchors.length - 1; i++) {
-            const a = anchors[i];
-            const b = anchors[i + 1];
-            const points = this._getPathPoints(a, sourceSide, b, targetSide, offset ?? 0);
-            chains.push(points);
-            candidates.push(...calculatePolylineCandidates(points));
+        for (const chain of chains) {
+            const candidate = this._calculateChainCandidate(chain);
+            if (candidate) {
+                candidates.push(candidate);
+            }
         }
         const polyline = normalizePolyline(mergePointChains(chains));
         const penultimatePoint = polyline.length > 1 ? polyline[polyline.length - 2] : source;
@@ -2954,8 +3049,205 @@ class CalculateSegmentLineData {
             secondPoint,
             points: polyline,
             candidates,
+            waypointHandles: this._calculateWaypointHandles(waypoints ?? [], polyline, radius ?? 0),
         };
     }
+    /**
+     * Display positions for the waypoint handles. A waypoint that is a rounded
+     * corner of the polyline maps to the apex of its bend, so the handle sits on
+     * the rendered path; a waypoint lying mid-segment is already on the line.
+     */
+    _calculateWaypointHandles(waypoints, polyline, radius) {
+        return waypoints.map((waypoint) => {
+            const index = polyline.findIndex((point) => point.x === waypoint.x && point.y === waypoint.y);
+            if (index <= 0 || index >= polyline.length - 1) {
+                return { x: waypoint.x, y: waypoint.y };
+            }
+            return calculateCornerApex(polyline[index - 1], waypoint, polyline[index + 1], radius);
+        });
+    }
+    /**
+     * Routes the connection through intermediate waypoints. Connector sides and
+     * the connector gap apply only at the real endpoints; waypoints are
+     * pass-through anchors, so no connector-like stubs appear around them. Each
+     * chain is an explicit orthogonal route that never doubles back on the
+     * direction it arrived with — a same-line reversal would be collapsed by
+     * polyline normalization and would detach the path from the waypoint.
+     */
+    _buildWaypointChains(anchors, sourceSide, targetSide, offset) {
+        const sourceDirection = CONNECTOR_SIDE_POINT[sourceSide];
+        const targetDirection = CONNECTOR_SIDE_POINT[targetSide];
+        const nodeZones = [
+            { anchor: anchors[0], direction: { x: -sourceDirection.x, y: -sourceDirection.y } },
+            {
+                anchor: anchors[anchors.length - 1],
+                direction: { x: -targetDirection.x, y: -targetDirection.y },
+            },
+        ].filter((zone) => zone.direction.x !== 0 || zone.direction.y !== 0);
+        const chains = [];
+        let leaveDirection = null;
+        for (let i = 0; i < anchors.length - 1; i++) {
+            const a = anchors[i];
+            const b = anchors[i + 1];
+            const isFirstChain = i === 0;
+            const isLastChain = i === anchors.length - 2;
+            let chain;
+            if (isFirstChain) {
+                const sourceGap = {
+                    x: a.x + sourceDirection.x * offset,
+                    y: a.y + sourceDirection.y * offset,
+                };
+                const route = this._routeOrthogonal(sourceGap, sourceDirection, b, null, nodeZones);
+                chain = [a, ...route];
+            }
+            else if (isLastChain) {
+                const targetGap = {
+                    x: b.x + targetDirection.x * offset,
+                    y: b.y + targetDirection.y * offset,
+                };
+                const stubDirection = { x: -targetDirection.x, y: -targetDirection.y };
+                const route = this._routeOrthogonal(a, leaveDirection, targetGap, stubDirection, nodeZones);
+                chain = [...route, b];
+            }
+            else {
+                chain = this._routeOrthogonal(a, leaveDirection, b, null, nodeZones);
+            }
+            chains.push(chain);
+            leaveDirection = this._calculateArrivalDirection(isLastChain ? chain.slice(0, -1) : chain);
+        }
+        return chains;
+    }
+    /**
+     * Connects two points with an axis-aligned route. Candidates are the
+     * straight segment, both L-shapes, and both Z-shapes; the route that keeps
+     * the constraints wins. `leaveDirection` is the motion the path arrived
+     * with (its reversal as a first move is forbidden); `stubDirection` is the
+     * upcoming connector stub motion (arriving against it is forbidden).
+     * A non-dominant-axis arrival is only softly penalized, so waypoints are
+     * entered along the axis they are farther away on.
+     */
+    _routeOrthogonal(from, leaveDirection, to, stubDirection, nodeZones) {
+        if (from.x === to.x && from.y === to.y) {
+            return [from];
+        }
+        const corners = [];
+        if (from.x === to.x || from.y === to.y) {
+            corners.push([]);
+        }
+        corners.push([{ x: to.x, y: from.y }]);
+        corners.push([{ x: from.x, y: to.y }]);
+        const centerBetweenPoints = calculateCenterBetweenPoints(from, to);
+        corners.push([
+            { x: centerBetweenPoints.x, y: from.y },
+            { x: centerBetweenPoints.x, y: to.y },
+        ]);
+        corners.push([
+            { x: from.x, y: centerBetweenPoints.y },
+            { x: to.x, y: centerBetweenPoints.y },
+        ]);
+        const dominantAxis = Math.abs(to.x - from.x) >= Math.abs(to.y - from.y) ? 'x' : 'y';
+        let bestRoute = null;
+        let bestScore = Number.POSITIVE_INFINITY;
+        for (const cornerPoints of corners) {
+            const route = this._compactRoute([from, ...cornerPoints, to]);
+            const score = this._scoreRoute(route, leaveDirection, stubDirection, dominantAxis, nodeZones);
+            if (score < bestScore) {
+                bestScore = score;
+                bestRoute = route;
+            }
+        }
+        return bestRoute ?? [from, to];
+    }
+    _compactRoute(points) {
+        const route = [points[0]];
+        for (let i = 1; i < points.length; i++) {
+            const last = route[route.length - 1];
+            if (points[i].x !== last.x || points[i].y !== last.y) {
+                route.push(points[i]);
+            }
+        }
+        return route;
+    }
+    _scoreRoute(route, leaveDirection, stubDirection, dominantAxis, nodeZones) {
+        let score = 0;
+        let length = 0;
+        let zoneLength = 0;
+        for (let i = 0; i < route.length - 1; i++) {
+            length += Math.abs(route[i + 1].x - route[i].x) + Math.abs(route[i + 1].y - route[i].y);
+            for (const zone of nodeZones) {
+                zoneLength += this._calculateSegmentLengthInZone(route[i], route[i + 1], zone);
+            }
+        }
+        score += Math.min(NODE_ZONE_SCORE_LIMIT, zoneLength * NODE_ZONE_SCORE);
+        const first = this._segmentDirection(route[0], route[1]);
+        if (leaveDirection &&
+            (leaveDirection.x !== 0 || leaveDirection.y !== 0) &&
+            first.x === -leaveDirection.x &&
+            first.y === -leaveDirection.y) {
+            score += HARD_VIOLATION_SCORE;
+        }
+        const arrival = this._segmentDirection(route[route.length - 2], route[route.length - 1]);
+        if (stubDirection && arrival.x === -stubDirection.x && arrival.y === -stubDirection.y) {
+            score += HARD_VIOLATION_SCORE;
+        }
+        if (!stubDirection && arrival[dominantAxis] === 0) {
+            score += ARRIVAL_AXIS_SCORE;
+        }
+        return score + (route.length - 2) * BEND_SCORE + length * LENGTH_SCORE;
+    }
+    _segmentDirection(a, b) {
+        return { x: Math.sign(b.x - a.x), y: Math.sign(b.y - a.y) };
+    }
+    /**
+     * Length of the part of an axis-aligned segment lying inside the half-plane
+     * behind a connector (where the endpoint's node body is).
+     */
+    _calculateSegmentLengthInZone(a, b, zone) {
+        const zoneAxis = zone.direction.x !== 0 ? 'x' : 'y';
+        const zoneSign = zone.direction[zoneAxis];
+        const boundary = zone.anchor[zoneAxis];
+        const start = (a[zoneAxis] - boundary) * zoneSign;
+        const end = (b[zoneAxis] - boundary) * zoneSign;
+        if (start <= 0 && end <= 0) {
+            return 0;
+        }
+        const segmentLength = Math.abs(b.x - a.x) + Math.abs(b.y - a.y);
+        if (a[zoneAxis] === b[zoneAxis]) {
+            return segmentLength;
+        }
+        const insideLength = Math.max(start, end) - Math.max(0, Math.min(start, end));
+        return Math.min(segmentLength, Math.max(0, insideLength));
+    }
+    /**
+     * Waypoint-creation candidate for one chain: the midpoint of its longest
+     * straight segment. Corner rounding consumes at most half of each adjacent
+     * segment, so this point always lies on the rendered path — a length-based
+     * chain midpoint can land on a rounded corner and float off the line.
+     */
+    _calculateChainCandidate(chain) {
+        let bestLength = 0;
+        let candidate = null;
+        for (let i = 0; i < chain.length - 1; i++) {
+            const length = Math.abs(chain[i + 1].x - chain[i].x) + Math.abs(chain[i + 1].y - chain[i].y);
+            if (length > bestLength) {
+                bestLength = length;
+                candidate = {
+                    x: (chain[i].x + chain[i + 1].x) / 2,
+                    y: (chain[i].y + chain[i + 1].y) / 2,
+                };
+            }
+        }
+        return candidate;
+    }
+    _calculateArrivalDirection(chain) {
+        for (let i = chain.length - 1; i > 0; i--) {
+            const direction = this._segmentDirection(chain[i - 1], chain[i]);
+            if (direction.x !== 0 || direction.y !== 0) {
+                return direction;
+            }
+        }
+        return null;
+    }
     _getPathPoints(source, sourceSide, target, targetSide, offset) {
         const sourceDirection = CONNECTOR_SIDE_POINT[sourceSide];
         const targetDirection = CONNECTOR_SIDE_POINT[targetSide];
@@ -3531,11 +3823,12 @@ class FConnectionBase extends MIXIN_BASE$1 {
     }
     setLine({ point1, point2 }) {
         this.line = LineExtensions.initialize(point1, point2);
-        const { path, points, penultimatePoint, secondPoint, candidates } = this._getPathResult(point1, point2);
+        const { path, points, penultimatePoint, secondPoint, candidates, waypointHandles } = this._getPathResult(point1, point2);
         this.path = path;
         this._penultimatePoint = penultimatePoint || point1;
         this._secondPoint = secondPoint || point2;
         this.fWaypoints()?.candidates.set(candidates || []);
+        this.fWaypoints()?.handles.set(waypointHandles || []);
         this._contentLayoutEngine.layout(points || [], this._contents());
     }
     _contents() {
@@ -24423,5 +24716,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AddCanvasToStore, AddCanvasToStoreRequest, AddConnectionForCreateToStore, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStore, AddConnectionMarkerToStoreRequest, AddConnectionToStore, AddConnectionToStoreRequest, AddConnectorToStore, AddConnectorToStoreRequest, AddDndToStore, AddDndToStoreRequest, AddFlowToStore, AddFlowToStoreRequest, AddNodeToStore, AddNodeToStoreRequest, AddPatternToBackground, AddPatternToBackgroundRequest, AddSnapConnectionToStore, AddSnapConnectionToStoreRequest, ApplyChildResizeConstraints, ApplyChildResizeConstraintsRequest, ApplyConnectionRender, ApplyConnectionRenderRequest, ApplyConnectionWorkerResult, ApplyConnectionWorkerResultRequest, ApplyParentResizeConstraints, ApplyParentResizeConstraintsRequest, AttachDragNodeHandlerFromSelection, AttachDragNodeHandlerFromSelectionRequest, AttachResizeConnectionDragHandlersToNode, AttachResizeConnectionDragHandlersToNodeRequest, AttachSoftParentConnectionDragHandlersToNode, AttachSoftParentConnectionDragHandlersToNodeRequest, AttachSourceConnectionDragHandlersToNode, AttachSourceConnectionDragHandlersToNodeRequest, AttachTargetConnectionDragHandlersToNode, AttachTargetConnectionDragHandlersToNodeRequest, BuildConnectionLine, BuildConnectionLineRequest, BuildConnectionWorkerBatch, BuildConnectionWorkerBatchRequest, BuildConnectionWorkerPayloadItem, BuildConnectionWorkerPayloadItemRequest, BuildDragNodeConstraints, BuildDragNodeConstraintsRequest, CALCULATABLE_SIDES, COMMON_PROVIDERS, CONNECTABLE_SIDE_EPSILON, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateAdaptiveCurveData, CalculateBezierCurveData, CalculateChangedRectFromDifference, CalculateChangedRectFromDifferenceRequest, CalculateClosestConnector, CalculateClosestConnectorRequest, CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByConnectedPositionsRequest, CalculateConnectableSideByInternalPosition, CalculateConnectableSideByInternalPositionRequest, CalculateConnectionsState, CalculateConnectionsStateRequest, CalculateConnectorsConnectableSides, CalculateConnectorsConnectableSidesRequest, CalculateDirectChildrenUnionRect, CalculateDirectChildrenUnionRectRequest, CalculateFlowPointFromMinimapPoint, CalculateFlowPointFromMinimapPointRequest, CalculateFlowState, CalculateFlowStateRequest, CalculateInputConnections, CalculateInputConnectionsRequest, CalculateNodesBoundingBox, CalculateNodesBoundingBoxNormalizedPosition, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CalculateNodesState, CalculateNodesStateRequest, CalculateOutputConnections, CalculateOutputConnectionsRequest, CalculateResizeLimits, CalculateResizeLimitsRequest, CalculateSegmentLineData, CalculateSelectableItems, CalculateSelectableItemsRequest, CalculateSourceConnectorsToConnect, CalculateSourceConnectorsToConnectRequest, CalculateStraightLineData, CalculateTargetConnectorsToConnect, CalculateTargetConnectorsToConnectRequest, CenterBasedDeltaCalculator, CenterGroupOrNode, CenterGroupOrNodeRequest, CenterOfMassSelectionStrategy, ChainPushCollisionResolver, ClearSelection, ClearSelectionRequest, CompleteConnectionRedraw, CompleteConnectionRedrawRequest, ConnectableSidesScheduler, ConnectedSubgraphScopeFilter, ConnectionBehaviourBuilder, ConnectionBehaviourBuilderRequest, ConnectionContentLayoutEngine, ConnectionLineBuilder, ConnectionLineBuilderRequest, ConnectionRedrawState, ConnectionWorkerState, CreateConnectionCreateDragHandler, CreateConnectionCreateDragHandlerRequest, CreateConnectionFinalize, CreateConnectionFinalizeRequest, CreateConnectionFromConnectorPreparation, CreateConnectionFromConnectorPreparationRequest, CreateConnectionFromOutletPreparation, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparation, CreateConnectionFromOutputPreparationRequest, CreateConnectionHandler, CreateConnectionMarkers, CreateConnectionMarkersRequest, CreateConnectionPreparation, CreateConnectionPreparationRequest, CreateDragNodeHandler, CreateDragNodeHandlerRequest, CreateDragNodeHierarchy, CreateDragNodeHierarchyRequest, DRAG_AND_DROP_COMMON_PROVIDERS, DRAG_AUTO_PAN_PROVIDERS, DRAG_CANVAS_PROVIDERS, DRAG_CONNECTIONS_PROVIDERS, DRAG_DROP_TO_GROUP_PROVIDERS, DRAG_EXTERNAL_ITEM_HANDLER_KIND, DRAG_EXTERNAL_ITEM_HANDLER_TYPE, DRAG_EXTERNAL_ITEM_PROVIDERS, DRAG_MINIMAP_HANDLER_KIND, DRAG_MINIMAP_HANDLER_TYPE, DRAG_MINIMAP_PROVIDERS, DRAG_NODE_HANDLER_KIND, DRAG_NODE_HANDLER_TYPE, DRAG_SELECTION_AREA_PROVIDERS, DRAG_SELECT_BY_POINTER_PROVIDERS, DeltaClamp, Deprecated, DetectConnectionsUnderDragNode, DetectConnectionsUnderDragNodeRequest, DisableConnectionWorker, DisableConnectionWorkerRequest, DownstreamConnectionsSelectionStrategy, DragAndDropBase, DragCanvasFinalize, DragCanvasFinalizeRequest, DragCanvasHandler, DragCanvasPreparation, DragCanvasPreparationRequest, DragConnectionWaypointFinalize, DragConnectionWaypointFinalizeRequest, DragConnectionWaypointHandler, DragConnectionWaypointPreparation, DragConnectionWaypointPreparationRequest, DragExternalItemCreatePlaceholder, DragExternalItemCreatePlaceholderRequest, DragExternalItemCreatePreview, DragExternalItemCreatePreviewRequest, DragExternalItemFinalize, DragExternalItemFinalizeRequest, DragExternalItemHandler, DragExternalItemPreparation, DragExternalItemPreparationRequest, DragHandlerBase, DragHandlerInjector, DragMinimapFinalize, DragMinimapFinalizeRequest, DragMinimapHandler, DragMinimapPreparation, DragMinimapPreparationRequest, DragNodeConnectionBothSidesHandler, DragNodeConnectionHandlerBase, DragNodeConnectionSourceHandler, DragNodeConnectionTargetHandler, DragNodeDeltaConstraints, DragNodeFinalize, DragNodeFinalizeRequest, DragNodeHandler, DragNodeHierarchy, DragNodeItemHandler, DragNodePreparation, DragNodePreparationRequest, DropToGroupFinalize, DropToGroupFinalizeRequest, DropToGroupHandler, DropToGroupPreparation, DropToGroupPreparationRequest, ECanvasRedrawContext, EFCanvasLayer, EFConnectableSide, EFConnectionBehavior, EFConnectionConnectableSide, EFConnectionType, EFFlowFeatureKind, EFLayoutDirection, EFLayoutMode, EFMarkerType, EFReflowAxis, EFReflowCollision, EFReflowDeltaSource, EFReflowMode, EFReflowScope, EFResizeHandleType, EFZoomDirection, EMPTY_REFLOW_PLAN, EdgeBasedDeltaCalculator, EmitConnectionsChanges, EmitConnectionsChangesRequest, EmitEndDragSequenceEvent, EmitEndDragSequenceEventRequest, EmitSelectionChangeEvent, EmitSelectionChangeEventRequest, EmitStartDragSequenceEvent, EmitStartDragSequenceEventRequest, EnsureConnectionWorker, EnsureConnectionWorkerRequest, EventExtensions, ExternalRectConstraint, FA11yAnnouncer, FA11yController, FAutoPan, FAutoPanBase, FBackgroundBase, FBackgroundComponent, FCache, FCacheConnector, FCacheConnectorKeyFactory, FCacheNode, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FClickConnectFlow, FComponentsStore, FConnectionBase, FConnectionComponent, FConnectionComponentsParent, FConnectionContent, FConnectionContentBase, FConnectionDragHandleBase, FConnectionDragHandleEnd, FConnectionDragHandleStart, FConnectionForCreateComponent, FConnectionGradient, FConnectionGradientBase, FConnectionGradientRenderer, FConnectionGradientRendererBase, FConnectionMarker, FConnectionMarkerArrow, FConnectionMarkerBase, FConnectionMarkerCircle, FConnectionMarkerRegistry, FConnectionPath, FConnectionPathBase, FConnectionRegistry, FConnectionSelection, FConnectionSelectionBase, FConnectionWaypoints, FConnectionWaypointsBase, FConnectionWaypointsChangedEvent, FConnectorBase, FConnectorDirective, FConnectorRegistry, FControlSchemeController, FCreateConnectionEvent, FCreateConnectionSession, FCreateNodeEvent, FDeleteSelectedEvent, FDragBlockerDirective, FDragExternalItemStartEventData, FDragHandleDirective, FDragHandlerResult, FDragNodeStartEventData, FDragStartedEvent, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItem, FExternalItemBase, FExternalItemPlaceholder, FExternalItemPreview, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FFlowState, FFlowStateController, FGroupDirective, FIdRegistryBase, FLayoutController, FLayoutEngine, FLineAlignmentComponent, FMagneticLines, FMagneticLinesBase, FMagneticRects, FMagneticRectsBase, FMinimapBase, FMinimapCanvasDirective, FMinimapComponent, FMinimapFlowDirective, FMinimapState, FMinimapViewDirective, FMoveNodesEvent, FNodeBase, FNodeConnectionsIntersectionEvent, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FNodeRegistry, FReassignConnectionEvent, FRectPatternComponent, FReflowBaselineTracker, FReflowController, FReflowCycleGuard, FReflowIgnore, FReflowIgnoreRegistry, FReflowOrchestrator, FReflowPlanner, FResizeChannel, FResizeHandleDirective, FResizeNodeStartEventData, FRotateHandleDirective, FRotateNodeStartEventData, FSelectionArea, FSelectionAreaBase, FSelectionChangeEvent, FSingleRegistryBase, FSnapConnectionComponent, FSourceConnectorBase, FVirtualFor, FZoomBase, FZoomDirective, F_A11Y_CONFIG, F_AUTO_PAN_PROVIDERS, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CACHE_FEATURES, F_CACHE_OPTIONS, F_CANVAS, F_CANVAS_CONFIG, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_COMPONENTS_PARENT, F_CONNECTION_CONTENT, F_CONNECTION_DRAG_HANDLE_END, F_CONNECTION_DRAG_HANDLE_START, F_CONNECTION_FEATURES, F_CONNECTION_FLOW, F_CONNECTION_GRADIENT, F_CONNECTION_IMPORTS_EXPORTS, F_CONNECTION_MARKER, F_CONNECTION_PATH, F_CONNECTION_PROVIDERS, F_CONNECTION_SELECTION, F_CONNECTION_WAYPOINTS, F_CONNECTOR, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_CONTROL_SCHEME_CONFIG, F_CSS_CLASS, F_DEFAULT_A11Y_CONFIG, F_DEFAULT_A11Y_KEYS, F_DEFAULT_A11Y_MESSAGES, F_DEFAULT_CONTROL_SCHEME, F_DEFAULT_LAYER_ORDER, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_DRAG_SELECT_CONTROL_SCHEME, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_CONFIG, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_FLOW_STATE_CONFIG, F_LAYOUT, F_LAYOUT_OPTIONS, F_LINE_ALIGNMENT_PROVIDERS, F_MAGNETIC_LINES, F_MAGNETIC_LINES_PROVIDERS, F_MAGNETIC_RECTS, F_MAGNETIC_RECTS_PROVIDERS, F_MINIMAP_BASE, F_MINIMAP_FEATURES, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_REFLOW_CONFIG, F_REFLOW_PROVIDERS, F_SCROLL_PAN_CONTROL_SCHEME, F_SELECTED_CLASS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_VIRTUAL_FOR_PROVIDERS, F_ZOOM, F_ZOOM_FEATURES, F_ZOOM_PROVIDERS, FindConnectableConnectorUsingPriorityAndPosition, FindConnectableConnectorUsingPriorityAndPositionRequest, FitToChildNodesAndGroups, FitToChildNodesAndGroupsRequest, FitToFlow, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetCachedFCacheRect, GetCachedFCacheRectRequest, GetChildNodeIds, GetChildNodeIdsRequest, GetConnectorRectReference, GetConnectorRectReferenceRequest, GetCurrentSelection, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroups, GetDeepChildrenNodesAndGroupsRequest, GetFlow, GetFlowRequest, GetNodePadding, GetNodePaddingRequest, GetNormalizedConnectorRect, GetNormalizedConnectorRectRequest, GetNormalizedElementRect, GetNormalizedElementRectRequest, GetNormalizedParentNodeRect, GetNormalizedParentNodeRectRequest, GetNormalizedPoint, GetNormalizedPointRequest, GetParentNodes, GetParentNodesRequest, GlobalScopeFilter, GridSnapper, GroupScopeFilter, HandleConnectionWorkerMessage, HandleConnectionWorkerMessageRequest, IMouseEvent, INSTANCES, IPointerEvent, IPointerUpEvent, ITouchDownEvent, ITouchMoveEvent, InitializeDragSequence, InitializeDragSequenceRequest, InputCanvasPosition, InputCanvasPositionRequest, InputCanvasScale, InputCanvasScaleRequest, InvalidateFCacheNode, InvalidateFCacheNodeRequest, IsArrayHasParentNode, IsArrayHasParentNodeRequest, IsConnectionRedrawCurrent, IsConnectionRedrawCurrentRequest, IsConnectionWorkerEnabled, IsConnectionWorkerEnabledRequest, IsDragStarted, IsDragStartedRequest, ListenConnectionsChanges, ListenConnectionsChangesRequest, ListenNodesChanges, ListenNodesChangesRequest, ListenTransformChanges, ListenTransformChangesRequest, LogExecutionTime, MOUSE_EVENT_IGNORE_TIME, MagneticLineElement, MagneticLineRenderer, MagneticLinesHandler, MagneticLinesPreparation, MagneticLinesPreparationRequest, MagneticRectElement, MagneticRectsHandler, MagneticRectsPreparation, MagneticRectsPreparationRequest, MagneticRectsRenderer, MarkConnectableConnectors, MarkConnectableConnectorsRequest, MarkConnectionConnectorsAsConnected, MarkConnectionConnectorsAsConnectedRequest, MinimapCalculateViewRect, MinimapCalculateViewRectRequest, MinimapCalculateViewport, MinimapCalculateViewportRequest, MinimapDrawNodes, MinimapDrawNodesRequest, MinimapNodeRects, MoveFrontElementsBeforeTargetElement, MoveFrontElementsBeforeTargetElementRequest, NODE_PROVIDERS, NODE_RESIZE_PROVIDERS, NODE_ROTATE_PROVIDERS, NotifyFullRendered, NotifyFullRenderedRequest, NotifyNodesRendered, NotifyNodesRenderedRequest, NotifyTransformChanged, NotifyTransformChangedRequest, OnPointerMove, OnPointerMoveRequest, PINCH_TO_ZOOM_PROVIDERS, PinchToZoomFinalize, PinchToZoomFinalizeRequest, PinchToZoomHandler, PinchToZoomPreparation, PinchToZoomPreparationRequest, Polyline, PolylineContentAlign, PolylineContentPlace, PolylineSampler, PrepareDragSequence, PrepareDragSequenceRequest, PreventDefaultIsExternalItem, PreventDefaultIsExternalItemRequest, QueueConnectionRedraw, QueueConnectionRedrawRequest, QueueConnectionRedrawState, RESIZE_DIRECTIONS, RESIZE_NODE_HANDLER_KIND, RESIZE_NODE_HANDLER_TYPE, ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE, ReadNodeBoundsWithPaddings, ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse, ReassignConnectionFinalize, ReassignConnectionFinalizeRequest, ReassignConnectionHandler, ReassignConnectionPreparation, ReassignConnectionPreparationRequest, ReassignConnectionSourceHandler, ReassignConnectionTargetHandler, RedrawCanvasWithAnimation, RedrawCanvasWithAnimationRequest, RedrawConnections, RedrawConnectionsRequest, RegisterFCacheConnector, RegisterFCacheConnectorRequest, RegisterFCacheNode, RegisterFCacheNodeRequest, RegisterPluginInstance, RegisterPluginInstanceRequest, RemoveCanvasFromStore, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStore, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStore, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStore, RemoveConnectionMarkerFromStoreRequest, RemoveConnectionWaypoint, RemoveConnectionWaypointRequest, RemoveConnectorFromStore, RemoveConnectorFromStoreRequest, RemoveDndFromStore, RemoveDndFromStoreRequest, RemoveFlowFromStore, RemoveFlowFromStoreRequest, RemoveNodeFromStore, RemoveNodeFromStoreRequest, RemovePluginInstance, RemovePluginInstanceRequest, RemoveSnapConnectionFromStore, RemoveSnapConnectionFromStoreRequest, RenderConnection, RenderConnectionFromGeometry, RenderConnectionFromGeometryRequest, RenderConnectionRequest, RenderConnectionWithLine, RenderConnectionWithLineRequest, RenderLifecycleState, ResetConnectionWorkerRuntime, ResetConnectionWorkerRuntimeRequest, ResetRenderLifecycle, ResetRenderLifecycleRequest, ResetScale, ResetScaleAndCenter, ResetScaleAndCenterRequest, ResetScaleRequest, ResetZoom, ResetZoomRequest, ResizeNodeConnectionBothSidesHandler, ResizeNodeConnectionHandlerBase, ResizeNodeConnectionSourceHandler, ResizeNodeConnectionTargetHandler, ResizeNodeFinalize, ResizeNodeFinalizeRequest, ResizeNodeHandler, ResizeNodePreparation, ResizeNodePreparationRequest, ResolveConnectableOutputForOutlet, ResolveConnectableOutputForOutletRequest, ResolveConnectionEndpointRect, ResolveConnectionEndpointRectRequest, ResolveConnectionEndpointRotationContext, ResolveConnectionEndpointRotationContextRequest, ResolveConnectionEndpoints, ResolveConnectionEndpointsRequest, ResolveConnectionGeometry, ResolveConnectionGeometryRequest, RotateNodeFinalize, RotateNodeFinalizeRequest, RotateNodeHandler, RotateNodePreparation, RotateNodePreparationRequest, RunAutoPanFrame, RunAutoPanFrameRequest, RunConnectionRedrawSlice, RunConnectionRedrawSliceRequest, RunConnectionWorker, RunConnectionWorkerBatch, RunConnectionWorkerBatchRequest, RunConnectionWorkerRequest, RunDevDiagnostics, RunDevDiagnosticsRequest, ScheduleAutoPanFrame, ScheduleAutoPanFrameRequest, ScrollCanvas, ScrollCanvasRequest, Select, SelectAll, SelectAllRequest, SelectAndUpdateNodeLayer, SelectAndUpdateNodeLayerRequest, SelectByPointer, SelectByPointerRequest, SelectRequest, SelectionAreaFinalize, SelectionAreaFinalizeRequest, SelectionAreaHandler, SelectionAreaPreparation, SelectionAreaPreparationRequest, SetBackgroundTransform, SetBackgroundTransformRequest, SetFCacheConnectorRect, SetFCacheConnectorRectRequest, SetFCacheNodeRect, SetFCacheNodeRectRequest, SetZoom, SetZoomRequest, ShouldUseConnectionWorker, ShouldUseConnectionWorkerRequest, SortDropCandidatesByLayer, SortDropCandidatesByLayerRequest, SortItemLayers, SortItemLayersRequest, SortItemsByParent, SortItemsByParentRequest, SortNodeLayers, SortNodeLayersRequest, StartConnectionRedraw, StartConnectionRedrawRequest, StartConnectionWorkerRedraw, StartConnectionWorkerRedrawRequest, StopAutoPan, StopAutoPanRequest, StopCollisionResolver, UnmarkConnectableConnectors, UnmarkConnectableConnectorsRequest, UnregisterFCacheConnector, UnregisterFCacheConnectorRequest, UnregisterFCacheNode, UnregisterFCacheNodeRequest, UpdateFCacheRectByElement, UpdateFCacheRectByElementRequest, UpdateItemAndChildrenLayers, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChanged, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScale, UpdateScaleRequest, WaitForConnectionsRendered, WaitForConnectionsRenderedRequest, XRangeSelectionStrategy, afterNextPaint, buildConnectionAnchors, buildCornerMidPointsAndApplyOffsets, calculateAutoPanAxisDelta, calculateAutoPanDelta, calculateCenterBetweenPoints, calculateCurveCandidates, calculateDifferenceAfterRotation, calculateMagneticGuides, calculateMagneticRects, calculatePointerInFlow, calculatePolylineCandidates, calculatePositionAfterRotation, castToConnectorType, coerceMarkerType, computeEdgeDeltas, createConnectionDomIdentifier, createConnectionSelectionDomIdentifier, createConnectionWorkerUrl, createGradientDomIdentifier, createGradientDomUrl, createMultiCubicPath, createSVGElement, createSegmentLinePath, cubicBezierAtT, debounceAnimationFrame, debounceMicrotask, debounceTime, defaultEventTrigger, determineSide, expandRectByOverflow, fDiagnosticMessage, fInstanceKey, fProvideCache, fSuppressDevWarnings, fWarnOnce, filterConnectableTargets, findExistingWaypoint, findNodeOrGroupContaining, findSourceConnector, findSpatialNeighbor, findTargetConnector, findWaypointCandidate, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getAllSourceConnectors, getAllTargetConnectors, getExternalItemHost, infinityMinMax, injectFlowState, isCalculateMode, isConnectionWorkerRuntimeSupported, isConnector, isDragBlocker, isDragExternalItemHandler, isDragHandleEnd, isDragHandleStart, isDragMinimapHandler, isDragNodeHandler, isExternalItem, isFDevMode, isMobile, isNode, isNodeOutlet, isNodeOutput, isOnFlowBackground, isOutletConnector, isPointerInsidePoint, isPointerInsideStartOrEndDragHandles, isResizeNodeHandler, isRotateHandle, isRotateNodeHandler, isSourceConnector, isTargetConnector, isValidEventTrigger, mergeA11yConfig, mergeControlSchemeConfig, mergeFCanvasConfig, mergeFlowStateConfig, mergeLayoutNodes, mergePointChains, mergeReflowConfig, middleButtonEventTrigger, mixinChangeSelection, mixinChangeVisibility, normalizeFlowLayoutData, normalizePolyline, notifyOnStart, pickWaypoint, primaryButtonEventTrigger, provideFFlow, provideFLayout, rebaseAutoPanPointerDownPosition, rectFromPoint, requireSourceConnector, requireTargetConnector, resolveAutoPanMode, resolveConnectionWorkerRuntime, resolveLayerOrder, revokeConnectionWorkerUrl, sampleCubicBezierUniform, sampleMultiCubicUniform, stringAttribute, takeOne, transitionEnd, withA11y, withConnectionFlow, withControlScheme, withFCanvas, withFlowState, withReflowOnResize, withinSnapThreshold };
+export { AddCanvasToStore, AddCanvasToStoreRequest, AddConnectionForCreateToStore, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStore, AddConnectionMarkerToStoreRequest, AddConnectionToStore, AddConnectionToStoreRequest, AddConnectorToStore, AddConnectorToStoreRequest, AddDndToStore, AddDndToStoreRequest, AddFlowToStore, AddFlowToStoreRequest, AddNodeToStore, AddNodeToStoreRequest, AddPatternToBackground, AddPatternToBackgroundRequest, AddSnapConnectionToStore, AddSnapConnectionToStoreRequest, ApplyChildResizeConstraints, ApplyChildResizeConstraintsRequest, ApplyConnectionRender, ApplyConnectionRenderRequest, ApplyConnectionWorkerResult, ApplyConnectionWorkerResultRequest, ApplyParentResizeConstraints, ApplyParentResizeConstraintsRequest, AttachDragNodeHandlerFromSelection, AttachDragNodeHandlerFromSelectionRequest, AttachResizeConnectionDragHandlersToNode, AttachResizeConnectionDragHandlersToNodeRequest, AttachSoftParentConnectionDragHandlersToNode, AttachSoftParentConnectionDragHandlersToNodeRequest, AttachSourceConnectionDragHandlersToNode, AttachSourceConnectionDragHandlersToNodeRequest, AttachTargetConnectionDragHandlersToNode, AttachTargetConnectionDragHandlersToNodeRequest, BuildConnectionLine, BuildConnectionLineRequest, BuildConnectionWorkerBatch, BuildConnectionWorkerBatchRequest, BuildConnectionWorkerPayloadItem, BuildConnectionWorkerPayloadItemRequest, BuildDragNodeConstraints, BuildDragNodeConstraintsRequest, CALCULATABLE_SIDES, COMMON_PROVIDERS, CONNECTABLE_SIDE_EPSILON, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateAdaptiveCurveData, CalculateBezierCurveData, CalculateChangedRectFromDifference, CalculateChangedRectFromDifferenceRequest, CalculateClosestConnector, CalculateClosestConnectorRequest, CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByConnectedPositionsRequest, CalculateConnectableSideByInternalPosition, CalculateConnectableSideByInternalPositionRequest, CalculateConnectionsState, CalculateConnectionsStateRequest, CalculateConnectorsConnectableSides, CalculateConnectorsConnectableSidesRequest, CalculateDirectChildrenUnionRect, CalculateDirectChildrenUnionRectRequest, CalculateFlowPointFromMinimapPoint, CalculateFlowPointFromMinimapPointRequest, CalculateFlowState, CalculateFlowStateRequest, CalculateInputConnections, CalculateInputConnectionsRequest, CalculateNodesBoundingBox, CalculateNodesBoundingBoxNormalizedPosition, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CalculateNodesState, CalculateNodesStateRequest, CalculateOutputConnections, CalculateOutputConnectionsRequest, CalculateResizeLimits, CalculateResizeLimitsRequest, CalculateSegmentLineData, CalculateSelectableItems, CalculateSelectableItemsRequest, CalculateSourceConnectorsToConnect, CalculateSourceConnectorsToConnectRequest, CalculateStraightLineData, CalculateTargetConnectorsToConnect, CalculateTargetConnectorsToConnectRequest, CenterBasedDeltaCalculator, CenterGroupOrNode, CenterGroupOrNodeRequest, CenterOfMassSelectionStrategy, ChainPushCollisionResolver, ClearSelection, ClearSelectionRequest, CompleteConnectionRedraw, CompleteConnectionRedrawRequest, ConnectableSidesScheduler, ConnectedSubgraphScopeFilter, ConnectionBehaviourBuilder, ConnectionBehaviourBuilderRequest, ConnectionContentLayoutEngine, ConnectionLineBuilder, ConnectionLineBuilderRequest, ConnectionRedrawState, ConnectionWorkerState, CreateConnectionCreateDragHandler, CreateConnectionCreateDragHandlerRequest, CreateConnectionFinalize, CreateConnectionFinalizeRequest, CreateConnectionFromConnectorPreparation, CreateConnectionFromConnectorPreparationRequest, CreateConnectionFromOutletPreparation, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparation, CreateConnectionFromOutputPreparationRequest, CreateConnectionHandler, CreateConnectionMarkers, CreateConnectionMarkersRequest, CreateConnectionPreparation, CreateConnectionPreparationRequest, CreateDragNodeHandler, CreateDragNodeHandlerRequest, CreateDragNodeHierarchy, CreateDragNodeHierarchyRequest, DRAG_AND_DROP_COMMON_PROVIDERS, DRAG_AUTO_PAN_PROVIDERS, DRAG_CANVAS_PROVIDERS, DRAG_CONNECTIONS_PROVIDERS, DRAG_DROP_TO_GROUP_PROVIDERS, DRAG_EXTERNAL_ITEM_HANDLER_KIND, DRAG_EXTERNAL_ITEM_HANDLER_TYPE, DRAG_EXTERNAL_ITEM_PROVIDERS, DRAG_MINIMAP_HANDLER_KIND, DRAG_MINIMAP_HANDLER_TYPE, DRAG_MINIMAP_PROVIDERS, DRAG_NODE_HANDLER_KIND, DRAG_NODE_HANDLER_TYPE, DRAG_SELECTION_AREA_PROVIDERS, DRAG_SELECT_BY_POINTER_PROVIDERS, DeltaClamp, Deprecated, DetectConnectionsUnderDragNode, DetectConnectionsUnderDragNodeRequest, DisableConnectionWorker, DisableConnectionWorkerRequest, DownstreamConnectionsSelectionStrategy, DragAndDropBase, DragCanvasFinalize, DragCanvasFinalizeRequest, DragCanvasHandler, DragCanvasPreparation, DragCanvasPreparationRequest, DragConnectionWaypointFinalize, DragConnectionWaypointFinalizeRequest, DragConnectionWaypointHandler, DragConnectionWaypointPreparation, DragConnectionWaypointPreparationRequest, DragExternalItemCreatePlaceholder, DragExternalItemCreatePlaceholderRequest, DragExternalItemCreatePreview, DragExternalItemCreatePreviewRequest, DragExternalItemFinalize, DragExternalItemFinalizeRequest, DragExternalItemHandler, DragExternalItemPreparation, DragExternalItemPreparationRequest, DragHandlerBase, DragHandlerInjector, DragMinimapFinalize, DragMinimapFinalizeRequest, DragMinimapHandler, DragMinimapPreparation, DragMinimapPreparationRequest, DragNodeConnectionBothSidesHandler, DragNodeConnectionHandlerBase, DragNodeConnectionSourceHandler, DragNodeConnectionTargetHandler, DragNodeDeltaConstraints, DragNodeFinalize, DragNodeFinalizeRequest, DragNodeHandler, DragNodeHierarchy, DragNodeItemHandler, DragNodePreparation, DragNodePreparationRequest, DropToGroupFinalize, DropToGroupFinalizeRequest, DropToGroupHandler, DropToGroupPreparation, DropToGroupPreparationRequest, ECanvasRedrawContext, EFCanvasLayer, EFConnectableSide, EFConnectionBehavior, EFConnectionConnectableSide, EFConnectionType, EFFlowFeatureKind, EFLayoutDirection, EFLayoutMode, EFMarkerType, EFReflowAxis, EFReflowCollision, EFReflowDeltaSource, EFReflowMode, EFReflowScope, EFResizeHandleType, EFZoomDirection, EMPTY_REFLOW_PLAN, EdgeBasedDeltaCalculator, EmitConnectionsChanges, EmitConnectionsChangesRequest, EmitEndDragSequenceEvent, EmitEndDragSequenceEventRequest, EmitSelectionChangeEvent, EmitSelectionChangeEventRequest, EmitStartDragSequenceEvent, EmitStartDragSequenceEventRequest, EnsureConnectionWorker, EnsureConnectionWorkerRequest, EventExtensions, ExternalRectConstraint, FA11yAnnouncer, FA11yController, FAutoPan, FAutoPanBase, FBackgroundBase, FBackgroundComponent, FCache, FCacheConnector, FCacheConnectorKeyFactory, FCacheNode, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FClickConnectFlow, FComponentsStore, FConnectionBase, FConnectionComponent, FConnectionComponentsParent, FConnectionContent, FConnectionContentBase, FConnectionDragHandleBase, FConnectionDragHandleEnd, FConnectionDragHandleStart, FConnectionForCreateComponent, FConnectionGradient, FConnectionGradientBase, FConnectionGradientRenderer, FConnectionGradientRendererBase, FConnectionMarker, FConnectionMarkerArrow, FConnectionMarkerBase, FConnectionMarkerCircle, FConnectionMarkerRegistry, FConnectionPath, FConnectionPathBase, FConnectionRegistry, FConnectionSelection, FConnectionSelectionBase, FConnectionWaypoints, FConnectionWaypointsBase, FConnectionWaypointsChangedEvent, FConnectorBase, FConnectorDirective, FConnectorRegistry, FControlSchemeController, FCreateConnectionEvent, FCreateConnectionSession, FCreateNodeEvent, FDeleteSelectedEvent, FDragBlockerDirective, FDragExternalItemStartEventData, FDragHandleDirective, FDragHandlerResult, FDragNodeStartEventData, FDragStartedEvent, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItem, FExternalItemBase, FExternalItemPlaceholder, FExternalItemPreview, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FFlowState, FFlowStateController, FGroupDirective, FIdRegistryBase, FLayoutController, FLayoutEngine, FLineAlignmentComponent, FMagneticLines, FMagneticLinesBase, FMagneticRects, FMagneticRectsBase, FMinimapBase, FMinimapCanvasDirective, FMinimapComponent, FMinimapFlowDirective, FMinimapState, FMinimapViewDirective, FMoveNodesEvent, FNodeBase, FNodeConnectionsIntersectionEvent, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FNodeRegistry, FReassignConnectionEvent, FRectPatternComponent, FReflowBaselineTracker, FReflowController, FReflowCycleGuard, FReflowIgnore, FReflowIgnoreRegistry, FReflowOrchestrator, FReflowPlanner, FResizeChannel, FResizeHandleDirective, FResizeNodeStartEventData, FRotateHandleDirective, FRotateNodeStartEventData, FSelectionArea, FSelectionAreaBase, FSelectionChangeEvent, FSingleRegistryBase, FSnapConnectionComponent, FSourceConnectorBase, FVirtualFor, FZoomBase, FZoomDirective, F_A11Y_CONFIG, F_AUTO_PAN_PROVIDERS, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CACHE_FEATURES, F_CACHE_OPTIONS, F_CANVAS, F_CANVAS_CONFIG, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_COMPONENTS_PARENT, F_CONNECTION_CONTENT, F_CONNECTION_DRAG_HANDLE_END, F_CONNECTION_DRAG_HANDLE_START, F_CONNECTION_FEATURES, F_CONNECTION_FLOW, F_CONNECTION_GRADIENT, F_CONNECTION_IMPORTS_EXPORTS, F_CONNECTION_MARKER, F_CONNECTION_PATH, F_CONNECTION_PROVIDERS, F_CONNECTION_SELECTION, F_CONNECTION_WAYPOINTS, F_CONNECTOR, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_CONTROL_SCHEME_CONFIG, F_CSS_CLASS, F_DEFAULT_A11Y_CONFIG, F_DEFAULT_A11Y_KEYS, F_DEFAULT_A11Y_MESSAGES, F_DEFAULT_CONTROL_SCHEME, F_DEFAULT_LAYER_ORDER, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_DRAG_SELECT_CONTROL_SCHEME, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_CONFIG, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_FLOW_STATE_CONFIG, F_LAYOUT, F_LAYOUT_OPTIONS, F_LINE_ALIGNMENT_PROVIDERS, F_MAGNETIC_LINES, F_MAGNETIC_LINES_PROVIDERS, F_MAGNETIC_RECTS, F_MAGNETIC_RECTS_PROVIDERS, F_MINIMAP_BASE, F_MINIMAP_FEATURES, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_REFLOW_CONFIG, F_REFLOW_PROVIDERS, F_SCROLL_PAN_CONTROL_SCHEME, F_SELECTED_CLASS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_VIRTUAL_FOR_PROVIDERS, F_ZOOM, F_ZOOM_FEATURES, F_ZOOM_PROVIDERS, FindConnectableConnectorUsingPriorityAndPosition, FindConnectableConnectorUsingPriorityAndPositionRequest, FitToChildNodesAndGroups, FitToChildNodesAndGroupsRequest, FitToFlow, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetCachedFCacheRect, GetCachedFCacheRectRequest, GetChildNodeIds, GetChildNodeIdsRequest, GetConnectorRectReference, GetConnectorRectReferenceRequest, GetCurrentSelection, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroups, GetDeepChildrenNodesAndGroupsRequest, GetFlow, GetFlowRequest, GetNodePadding, GetNodePaddingRequest, GetNormalizedConnectorRect, GetNormalizedConnectorRectRequest, GetNormalizedElementRect, GetNormalizedElementRectRequest, GetNormalizedParentNodeRect, GetNormalizedParentNodeRectRequest, GetNormalizedPoint, GetNormalizedPointRequest, GetParentNodes, GetParentNodesRequest, GlobalScopeFilter, GridSnapper, GroupScopeFilter, HandleConnectionWorkerMessage, HandleConnectionWorkerMessageRequest, IMouseEvent, INSTANCES, IPointerEvent, IPointerUpEvent, ITouchDownEvent, ITouchMoveEvent, InitializeDragSequence, InitializeDragSequenceRequest, InputCanvasPosition, InputCanvasPositionRequest, InputCanvasScale, InputCanvasScaleRequest, InvalidateFCacheNode, InvalidateFCacheNodeRequest, IsArrayHasParentNode, IsArrayHasParentNodeRequest, IsConnectionRedrawCurrent, IsConnectionRedrawCurrentRequest, IsConnectionWorkerEnabled, IsConnectionWorkerEnabledRequest, IsDragStarted, IsDragStartedRequest, ListenConnectionsChanges, ListenConnectionsChangesRequest, ListenNodesChanges, ListenNodesChangesRequest, ListenTransformChanges, ListenTransformChangesRequest, LogExecutionTime, MOUSE_EVENT_IGNORE_TIME, MagneticLineElement, MagneticLineRenderer, MagneticLinesHandler, MagneticLinesPreparation, MagneticLinesPreparationRequest, MagneticRectElement, MagneticRectsHandler, MagneticRectsPreparation, MagneticRectsPreparationRequest, MagneticRectsRenderer, MarkConnectableConnectors, MarkConnectableConnectorsRequest, MarkConnectionConnectorsAsConnected, MarkConnectionConnectorsAsConnectedRequest, MinimapCalculateViewRect, MinimapCalculateViewRectRequest, MinimapCalculateViewport, MinimapCalculateViewportRequest, MinimapDrawNodes, MinimapDrawNodesRequest, MinimapNodeRects, MoveFrontElementsBeforeTargetElement, MoveFrontElementsBeforeTargetElementRequest, NODE_PROVIDERS, NODE_RESIZE_PROVIDERS, NODE_ROTATE_PROVIDERS, NotifyFullRendered, NotifyFullRenderedRequest, NotifyNodesRendered, NotifyNodesRenderedRequest, NotifyTransformChanged, NotifyTransformChangedRequest, OnPointerMove, OnPointerMoveRequest, PINCH_TO_ZOOM_PROVIDERS, PinchToZoomFinalize, PinchToZoomFinalizeRequest, PinchToZoomHandler, PinchToZoomPreparation, PinchToZoomPreparationRequest, Polyline, PolylineContentAlign, PolylineContentPlace, PolylineSampler, PrepareDragSequence, PrepareDragSequenceRequest, PreventDefaultIsExternalItem, PreventDefaultIsExternalItemRequest, QueueConnectionRedraw, QueueConnectionRedrawRequest, QueueConnectionRedrawState, RESIZE_DIRECTIONS, RESIZE_NODE_HANDLER_KIND, RESIZE_NODE_HANDLER_TYPE, ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE, ReadNodeBoundsWithPaddings, ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse, ReassignConnectionFinalize, ReassignConnectionFinalizeRequest, ReassignConnectionHandler, ReassignConnectionPreparation, ReassignConnectionPreparationRequest, ReassignConnectionSourceHandler, ReassignConnectionTargetHandler, RedrawCanvasWithAnimation, RedrawCanvasWithAnimationRequest, RedrawConnections, RedrawConnectionsRequest, RegisterFCacheConnector, RegisterFCacheConnectorRequest, RegisterFCacheNode, RegisterFCacheNodeRequest, RegisterPluginInstance, RegisterPluginInstanceRequest, RemoveCanvasFromStore, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStore, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStore, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStore, RemoveConnectionMarkerFromStoreRequest, RemoveConnectionWaypoint, RemoveConnectionWaypointRequest, RemoveConnectorFromStore, RemoveConnectorFromStoreRequest, RemoveDndFromStore, RemoveDndFromStoreRequest, RemoveFlowFromStore, RemoveFlowFromStoreRequest, RemoveNodeFromStore, RemoveNodeFromStoreRequest, RemovePluginInstance, RemovePluginInstanceRequest, RemoveSnapConnectionFromStore, RemoveSnapConnectionFromStoreRequest, RenderConnection, RenderConnectionFromGeometry, RenderConnectionFromGeometryRequest, RenderConnectionRequest, RenderConnectionWithLine, RenderConnectionWithLineRequest, RenderLifecycleState, ResetConnectionWorkerRuntime, ResetConnectionWorkerRuntimeRequest, ResetRenderLifecycle, ResetRenderLifecycleRequest, ResetScale, ResetScaleAndCenter, ResetScaleAndCenterRequest, ResetScaleRequest, ResetZoom, ResetZoomRequest, ResizeNodeConnectionBothSidesHandler, ResizeNodeConnectionHandlerBase, ResizeNodeConnectionSourceHandler, ResizeNodeConnectionTargetHandler, ResizeNodeFinalize, ResizeNodeFinalizeRequest, ResizeNodeHandler, ResizeNodePreparation, ResizeNodePreparationRequest, ResolveConnectableOutputForOutlet, ResolveConnectableOutputForOutletRequest, ResolveConnectionEndpointRect, ResolveConnectionEndpointRectRequest, ResolveConnectionEndpointRotationContext, ResolveConnectionEndpointRotationContextRequest, ResolveConnectionEndpoints, ResolveConnectionEndpointsRequest, ResolveConnectionGeometry, ResolveConnectionGeometryRequest, RotateNodeFinalize, RotateNodeFinalizeRequest, RotateNodeHandler, RotateNodePreparation, RotateNodePreparationRequest, RunAutoPanFrame, RunAutoPanFrameRequest, RunConnectionRedrawSlice, RunConnectionRedrawSliceRequest, RunConnectionWorker, RunConnectionWorkerBatch, RunConnectionWorkerBatchRequest, RunConnectionWorkerRequest, RunDevDiagnostics, RunDevDiagnosticsRequest, ScheduleAutoPanFrame, ScheduleAutoPanFrameRequest, ScrollCanvas, ScrollCanvasRequest, Select, SelectAll, SelectAllRequest, SelectAndUpdateNodeLayer, SelectAndUpdateNodeLayerRequest, SelectByPointer, SelectByPointerRequest, SelectRequest, SelectionAreaFinalize, SelectionAreaFinalizeRequest, SelectionAreaHandler, SelectionAreaPreparation, SelectionAreaPreparationRequest, SetBackgroundTransform, SetBackgroundTransformRequest, SetFCacheConnectorRect, SetFCacheConnectorRectRequest, SetFCacheNodeRect, SetFCacheNodeRectRequest, SetZoom, SetZoomRequest, ShouldUseConnectionWorker, ShouldUseConnectionWorkerRequest, SortDropCandidatesByLayer, SortDropCandidatesByLayerRequest, SortItemLayers, SortItemLayersRequest, SortItemsByParent, SortItemsByParentRequest, SortNodeLayers, SortNodeLayersRequest, StartConnectionRedraw, StartConnectionRedrawRequest, StartConnectionWorkerRedraw, StartConnectionWorkerRedrawRequest, StopAutoPan, StopAutoPanRequest, StopCollisionResolver, UnmarkConnectableConnectors, UnmarkConnectableConnectorsRequest, UnregisterFCacheConnector, UnregisterFCacheConnectorRequest, UnregisterFCacheNode, UnregisterFCacheNodeRequest, UpdateFCacheRectByElement, UpdateFCacheRectByElementRequest, UpdateItemAndChildrenLayers, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChanged, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScale, UpdateScaleRequest, WaitForConnectionsRendered, WaitForConnectionsRenderedRequest, XRangeSelectionStrategy, afterNextPaint, buildConnectionAnchors, buildCornerMidPointsAndApplyOffsets, calculateAutoPanAxisDelta, calculateAutoPanDelta, calculateCenterBetweenPoints, calculateCornerApex, calculateCurveCandidates, calculateDifferenceAfterRotation, calculateMagneticGuides, calculateMagneticRects, calculatePointerInFlow, calculatePolylineCandidates, calculatePositionAfterRotation, calculateSmoothControlPoint, castToConnectorType, coerceMarkerType, computeEdgeDeltas, createConnectionDomIdentifier, createConnectionSelectionDomIdentifier, createConnectionWorkerUrl, createGradientDomIdentifier, createGradientDomUrl, createMultiCubicPath, createSVGElement, createSegmentLinePath, cubicBezierAtT, debounceAnimationFrame, debounceMicrotask, debounceTime, defaultEventTrigger, determineSide, expandRectByOverflow, fDiagnosticMessage, fInstanceKey, fProvideCache, fSuppressDevWarnings, fWarnOnce, filterConnectableTargets, findExistingWaypoint, findNodeOrGroupContaining, findSourceConnector, findSpatialNeighbor, findTargetConnector, findWaypointCandidate, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getAllSourceConnectors, getAllTargetConnectors, getExternalItemHost, infinityMinMax, injectFlowState, isCalculateMode, isConnectionWorkerRuntimeSupported, isConnector, isDragBlocker, isDragExternalItemHandler, isDragHandleEnd, isDragHandleStart, isDragMinimapHandler, isDragNodeHandler, isExternalItem, isFDevMode, isMobile, isNode, isNodeOutlet, isNodeOutput, isOnFlowBackground, isOutletConnector, isPointerInsidePoint, isPointerInsideStartOrEndDragHandles, isResizeNodeHandler, isRotateHandle, isRotateNodeHandler, isSourceConnector, isTargetConnector, isValidEventTrigger, mergeA11yConfig, mergeControlSchemeConfig, mergeFCanvasConfig, mergeFlowStateConfig, mergeLayoutNodes, mergePointChains, mergeReflowConfig, middleButtonEventTrigger, mixinChangeSelection, mixinChangeVisibility, normalizeFlowLayoutData, normalizePolyline, notifyOnStart, pickWaypoint, primaryButtonEventTrigger, provideFFlow, provideFLayout, rebaseAutoPanPointerDownPosition, rectFromPoint, requireSourceConnector, requireTargetConnector, resolveAutoPanMode, resolveConnectionWorkerRuntime, resolveLayerOrder, revokeConnectionWorkerUrl, sampleCubicBezierUniform, sampleMultiCubicUniform, stringAttribute, takeOne, transitionEnd, withA11y, withConnectionFlow, withControlScheme, withFCanvas, withFlowState, withReflowOnResize, withinSnapThreshold };
 //# sourceMappingURL=foblex-flow.mjs.map