@loopstack/loopstack-studio 0.21.0 → 0.21.1

package/dist/node_modules/@xyflow/react/dist/esm/index.js

@@ -0,0 +1,3280 @@
+"use client";
+import cc from "../../../../classcat/index.js";
+import { ConnectionLineType, ConnectionMode, MarkerType, PanOnScrollMode, Position, ResizeControlVariant, SelectionMode, XYDrag, XYHandle, XYMinimap, XYPanZoom, XYResizer, addEdge, adoptUserNodes, areSetsEqual, calculateNodePosition, createMarkerIds, defaultAriaLabelConfig, devWarn, elementSelectionKeys, errorMessages, evaluateAbsolutePosition, fitViewport, getBezierEdgeCenter, getBezierPath, getBoundsOfRects, getConnectedEdges, getConnectionStatus, getDimensions, getEdgeCenter, getEdgePosition, getElementsToRemove, getElevatedEdgeZIndex, getEventPosition, getHandlePosition, getHostForElement, getInternalNodesBounds, getMarkerId, getNodeDimensions, getNodesBounds, getNodesInside, getOverlappingArea, getSmoothStepPath, getStraightPath, getViewportForBounds, handleExpandParent, infiniteExtent, initialConnection, isEdgeBase, isEdgeVisible, isInputDOMNode, isMacOs, isMouseEvent, isNodeBase, isNumeric, isRectObject, mergeAriaLabelConfig, nodeHasDimensions, nodeToRect, panBy, pointToRendererPoint, rendererPointToPoint, snapPosition, updateAbsolutePositions, updateConnectionLookup, updateNodeInternals, withResolvers } from "../../../system/dist/esm/index.js";
+import { createContext, forwardRef, memo, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { createWithEqualityFn, useStoreWithEqualityFn } from "zustand/traditional";
+import { shallow } from "zustand/shallow";
+import { createPortal } from "react-dom";
+var StoreContext = createContext(null), Provider$1 = StoreContext.Provider, zustandErrorMessage = errorMessages.error001();
+function useStore(e, t) {
+	let n = useContext(StoreContext);
+	if (n === null) throw Error(zustandErrorMessage);
+	return useStoreWithEqualityFn(n, e, t);
+}
+function useStoreApi() {
+	let e = useContext(StoreContext);
+	if (e === null) throw Error(zustandErrorMessage);
+	return useMemo(() => ({
+		getState: e.getState,
+		setState: e.setState,
+		subscribe: e.subscribe
+	}), [e]);
+}
+var style = { display: "none" }, ariaLiveStyle = {
+	position: "absolute",
+	width: 1,
+	height: 1,
+	margin: -1,
+	border: 0,
+	padding: 0,
+	overflow: "hidden",
+	clip: "rect(0px, 0px, 0px, 0px)",
+	clipPath: "inset(100%)"
+}, ARIA_NODE_DESC_KEY = "react-flow__node-desc", ARIA_EDGE_DESC_KEY = "react-flow__edge-desc", ARIA_LIVE_MESSAGE = "react-flow__aria-live", ariaLiveSelector = (e) => e.ariaLiveMessage, ariaLabelConfigSelector = (e) => e.ariaLabelConfig;
+function AriaLiveMessage({ rfId: e }) {
+	let t = useStore(ariaLiveSelector);
+	return jsx("div", {
+		id: `${ARIA_LIVE_MESSAGE}-${e}`,
+		"aria-live": "assertive",
+		"aria-atomic": "true",
+		style: ariaLiveStyle,
+		children: t
+	});
+}
+function A11yDescriptions({ rfId: e, disableKeyboardA11y: t }) {
+	let n = useStore(ariaLabelConfigSelector);
+	return jsxs(Fragment$1, { children: [
+		jsx("div", {
+			id: `${ARIA_NODE_DESC_KEY}-${e}`,
+			style,
+			children: t ? n["node.a11yDescription.default"] : n["node.a11yDescription.keyboardDisabled"]
+		}),
+		jsx("div", {
+			id: `${ARIA_EDGE_DESC_KEY}-${e}`,
+			style,
+			children: n["edge.a11yDescription.default"]
+		}),
+		!t && jsx(AriaLiveMessage, { rfId: e })
+	] });
+}
+var Panel = forwardRef(({ position: t = "top-left", children: n, className: r, style: i, ...a }, o) => jsx("div", {
+	className: cc([
+		"react-flow__panel",
+		r,
+		...`${t}`.split("-")
+	]),
+	style: i,
+	ref: o,
+	...a,
+	children: n
+}));
+Panel.displayName = "Panel";
+function Attribution({ proOptions: e, position: t = "bottom-right" }) {
+	return e?.hideAttribution ? null : jsx(Panel, {
+		position: t,
+		className: "react-flow__attribution",
+		"data-message": "Please only hide this attribution when you are subscribed to React Flow Pro: https://pro.reactflow.dev",
+		children: jsx("a", {
+			href: "https://reactflow.dev",
+			target: "_blank",
+			rel: "noopener noreferrer",
+			"aria-label": "React Flow attribution",
+			children: "React Flow"
+		})
+	});
+}
+var selector$m = (e) => {
+	let t = [], n = [];
+	for (let [, n] of e.nodeLookup) n.selected && t.push(n.internals.userNode);
+	for (let [, t] of e.edgeLookup) t.selected && n.push(t);
+	return {
+		selectedNodes: t,
+		selectedEdges: n
+	};
+}, selectId = (e) => e.id;
+function areEqual(e, t) {
+	return shallow(e.selectedNodes.map(selectId), t.selectedNodes.map(selectId)) && shallow(e.selectedEdges.map(selectId), t.selectedEdges.map(selectId));
+}
+function SelectionListenerInner({ onSelectionChange: e }) {
+	let t = useStoreApi(), { selectedNodes: n, selectedEdges: r } = useStore(selector$m, areEqual);
+	return useEffect(() => {
+		let i = {
+			nodes: n,
+			edges: r
+		};
+		e?.(i), t.getState().onSelectionChangeHandlers.forEach((e) => e(i));
+	}, [
+		n,
+		r,
+		e
+	]), null;
+}
+var changeSelector = (e) => !!e.onSelectionChangeHandlers;
+function SelectionListener({ onSelectionChange: e }) {
+	let t = useStore(changeSelector);
+	return e || t ? jsx(SelectionListenerInner, { onSelectionChange: e }) : null;
+}
+var defaultNodeOrigin = [0, 0], defaultViewport = {
+	x: 0,
+	y: 0,
+	zoom: 1
+}, fieldsToTrack = [.../* @__PURE__ */ "nodes.edges.defaultNodes.defaultEdges.onConnect.onConnectStart.onConnectEnd.onClickConnectStart.onClickConnectEnd.nodesDraggable.autoPanOnNodeFocus.nodesConnectable.nodesFocusable.edgesFocusable.edgesReconnectable.elevateNodesOnSelect.elevateEdgesOnSelect.minZoom.maxZoom.nodeExtent.onNodesChange.onEdgesChange.elementsSelectable.connectionMode.snapGrid.snapToGrid.translateExtent.connectOnClick.defaultEdgeOptions.fitView.fitViewOptions.onNodesDelete.onEdgesDelete.onDelete.onNodeDrag.onNodeDragStart.onNodeDragStop.onSelectionDrag.onSelectionDragStart.onSelectionDragStop.onMoveStart.onMove.onMoveEnd.noPanClassName.nodeOrigin.autoPanOnConnect.autoPanOnNodeDrag.onError.connectionRadius.isValidConnection.selectNodesOnDrag.nodeDragThreshold.connectionDragThreshold.onBeforeDelete.debug.autoPanSpeed.ariaLabelConfig.zIndexMode".split("."), "rfId"], selector$l = (e) => ({
+	setNodes: e.setNodes,
+	setEdges: e.setEdges,
+	setMinZoom: e.setMinZoom,
+	setMaxZoom: e.setMaxZoom,
+	setTranslateExtent: e.setTranslateExtent,
+	setNodeExtent: e.setNodeExtent,
+	reset: e.reset,
+	setDefaultNodesAndEdges: e.setDefaultNodesAndEdges
+}), initPrevValues = {
+	translateExtent: infiniteExtent,
+	nodeOrigin: defaultNodeOrigin,
+	minZoom: .5,
+	maxZoom: 2,
+	elementsSelectable: !0,
+	noPanClassName: "nopan",
+	rfId: "1"
+};
+function StoreUpdater(e) {
+	let { setNodes: t, setEdges: n, setMinZoom: r, setMaxZoom: i, setTranslateExtent: a, setNodeExtent: o, reset: s, setDefaultNodesAndEdges: c } = useStore(selector$l, shallow), l = useStoreApi();
+	useEffect(() => (c(e.defaultNodes, e.defaultEdges), () => {
+		u.current = initPrevValues, s();
+	}), []);
+	let u = useRef(initPrevValues);
+	return useEffect(() => {
+		for (let s of fieldsToTrack) {
+			let c = e[s];
+			c !== u.current[s] && e[s] !== void 0 && (s === "nodes" ? t(c) : s === "edges" ? n(c) : s === "minZoom" ? r(c) : s === "maxZoom" ? i(c) : s === "translateExtent" ? a(c) : s === "nodeExtent" ? o(c) : s === "ariaLabelConfig" ? l.setState({ ariaLabelConfig: mergeAriaLabelConfig(c) }) : s === "fitView" ? l.setState({ fitViewQueued: c }) : s === "fitViewOptions" ? l.setState({ fitViewOptions: c }) : l.setState({ [s]: c }));
+		}
+		u.current = e;
+	}, fieldsToTrack.map((t) => e[t])), null;
+}
+function getMediaQuery() {
+	return typeof window > "u" || !window.matchMedia ? null : window.matchMedia("(prefers-color-scheme: dark)");
+}
+function useColorModeClass(e) {
+	let [t, n] = useState(e === "system" ? null : e);
+	return useEffect(() => {
+		if (e !== "system") {
+			n(e);
+			return;
+		}
+		let t = getMediaQuery(), r = () => n(t?.matches ? "dark" : "light");
+		return r(), t?.addEventListener("change", r), () => {
+			t?.removeEventListener("change", r);
+		};
+	}, [e]), t === null ? getMediaQuery()?.matches ? "dark" : "light" : t;
+}
+var defaultDoc = typeof document < "u" ? document : null;
+function useKeyPress(e = null, t = {
+	target: defaultDoc,
+	actInsideInputWithModifier: !0
+}) {
+	let [n, r] = useState(!1), i = useRef(!1), a = useRef(/* @__PURE__ */ new Set([])), [o, s] = useMemo(() => {
+		if (e !== null) {
+			let t = (Array.isArray(e) ? e : [e]).filter((e) => typeof e == "string").map((e) => e.replace("+", "\n").replace("\n\n", "\n+").split("\n"));
+			return [t, t.reduce((e, t) => e.concat(...t), [])];
+		}
+		return [[], []];
+	}, [e]);
+	return useEffect(() => {
+		let n = t?.target ?? defaultDoc, c = t?.actInsideInputWithModifier ?? !0;
+		if (e !== null) {
+			let e = (e) => {
+				if (i.current = e.ctrlKey || e.metaKey || e.shiftKey || e.altKey, (!i.current || i.current && !c) && isInputDOMNode(e)) return !1;
+				let n = useKeyOrCode(e.code, s);
+				if (a.current.add(e[n]), isMatchingKey(o, a.current, !1)) {
+					let n = e.composedPath?.()?.[0] || e.target, a = n?.nodeName === "BUTTON" || n?.nodeName === "A";
+					t.preventDefault !== !1 && (i.current || !a) && e.preventDefault(), r(!0);
+				}
+			}, l = (e) => {
+				let t = useKeyOrCode(e.code, s);
+				isMatchingKey(o, a.current, !0) ? (r(!1), a.current.clear()) : a.current.delete(e[t]), e.key === "Meta" && a.current.clear(), i.current = !1;
+			}, u = () => {
+				a.current.clear(), r(!1);
+			};
+			return n?.addEventListener("keydown", e), n?.addEventListener("keyup", l), window.addEventListener("blur", u), window.addEventListener("contextmenu", u), () => {
+				n?.removeEventListener("keydown", e), n?.removeEventListener("keyup", l), window.removeEventListener("blur", u), window.removeEventListener("contextmenu", u);
+			};
+		}
+	}, [e, r]), n;
+}
+function isMatchingKey(e, t, n) {
+	return e.filter((e) => n || e.length === t.size).some((e) => e.every((e) => t.has(e)));
+}
+function useKeyOrCode(e, t) {
+	return t.includes(e) ? "code" : "key";
+}
+var useViewportHelper = () => {
+	let e = useStoreApi();
+	return useMemo(() => ({
+		zoomIn: (t) => {
+			let { panZoom: n } = e.getState();
+			return n ? n.scaleBy(1.2, { duration: t?.duration }) : Promise.resolve(!1);
+		},
+		zoomOut: (t) => {
+			let { panZoom: n } = e.getState();
+			return n ? n.scaleBy(1 / 1.2, { duration: t?.duration }) : Promise.resolve(!1);
+		},
+		zoomTo: (t, n) => {
+			let { panZoom: r } = e.getState();
+			return r ? r.scaleTo(t, { duration: n?.duration }) : Promise.resolve(!1);
+		},
+		getZoom: () => e.getState().transform[2],
+		setViewport: async (t, n) => {
+			let { transform: [r, i, a], panZoom: o } = e.getState();
+			return o ? (await o.setViewport({
+				x: t.x ?? r,
+				y: t.y ?? i,
+				zoom: t.zoom ?? a
+			}, n), Promise.resolve(!0)) : Promise.resolve(!1);
+		},
+		getViewport: () => {
+			let [t, n, r] = e.getState().transform;
+			return {
+				x: t,
+				y: n,
+				zoom: r
+			};
+		},
+		setCenter: async (t, n, r) => e.getState().setCenter(t, n, r),
+		fitBounds: async (t, n) => {
+			let { width: r, height: i, minZoom: a, maxZoom: o, panZoom: s } = e.getState(), c = getViewportForBounds(t, r, i, a, o, n?.padding ?? .1);
+			return s ? (await s.setViewport(c, {
+				duration: n?.duration,
+				ease: n?.ease,
+				interpolate: n?.interpolate
+			}), Promise.resolve(!0)) : Promise.resolve(!1);
+		},
+		screenToFlowPosition: (t, n = {}) => {
+			let { transform: r, snapGrid: i, snapToGrid: a, domNode: o } = e.getState();
+			if (!o) return t;
+			let { x: s, y: c } = o.getBoundingClientRect(), l = {
+				x: t.x - s,
+				y: t.y - c
+			}, u = n.snapGrid ?? i;
+			return pointToRendererPoint(l, r, n.snapToGrid ?? a, u);
+		},
+		flowToScreenPosition: (t) => {
+			let { transform: n, domNode: r } = e.getState();
+			if (!r) return t;
+			let { x: i, y: a } = r.getBoundingClientRect(), o = rendererPointToPoint(t, n);
+			return {
+				x: o.x + i,
+				y: o.y + a
+			};
+		}
+	}), []);
+};
+function applyChanges(e, t) {
+	let n = [], r = /* @__PURE__ */ new Map(), i = [];
+	for (let t of e) if (t.type === "add") {
+		i.push(t);
+		continue;
+	} else if (t.type === "remove" || t.type === "replace") r.set(t.id, [t]);
+	else {
+		let e = r.get(t.id);
+		e ? e.push(t) : r.set(t.id, [t]);
+	}
+	for (let e of t) {
+		let t = r.get(e.id);
+		if (!t) {
+			n.push(e);
+			continue;
+		}
+		if (t[0].type === "remove") continue;
+		if (t[0].type === "replace") {
+			n.push({ ...t[0].item });
+			continue;
+		}
+		let i = { ...e };
+		for (let e of t) applyChange(e, i);
+		n.push(i);
+	}
+	return i.length && i.forEach((e) => {
+		e.index === void 0 ? n.push({ ...e.item }) : n.splice(e.index, 0, { ...e.item });
+	}), n;
+}
+function applyChange(e, t) {
+	switch (e.type) {
+		case "select":
+			t.selected = e.selected;
+			break;
+		case "position":
+			e.position !== void 0 && (t.position = e.position), e.dragging !== void 0 && (t.dragging = e.dragging);
+			break;
+		case "dimensions":
+			e.dimensions !== void 0 && (t.measured = { ...e.dimensions }, e.setAttributes && ((e.setAttributes === !0 || e.setAttributes === "width") && (t.width = e.dimensions.width), (e.setAttributes === !0 || e.setAttributes === "height") && (t.height = e.dimensions.height))), typeof e.resizing == "boolean" && (t.resizing = e.resizing);
+			break;
+	}
+}
+function applyNodeChanges(e, t) {
+	return applyChanges(e, t);
+}
+function applyEdgeChanges(e, t) {
+	return applyChanges(e, t);
+}
+function createSelectionChange(e, t) {
+	return {
+		id: e,
+		type: "select",
+		selected: t
+	};
+}
+function getSelectionChanges(e, t = /* @__PURE__ */ new Set(), n = !1) {
+	let r = [];
+	for (let [i, a] of e) {
+		let e = t.has(i);
+		!(a.selected === void 0 && !e) && a.selected !== e && (n && (a.selected = e), r.push(createSelectionChange(a.id, e)));
+	}
+	return r;
+}
+function getElementsDiffChanges({ items: e = [], lookup: t }) {
+	let n = [], r = new Map(e.map((e) => [e.id, e]));
+	for (let [r, i] of e.entries()) {
+		let e = t.get(i.id), a = e?.internals?.userNode ?? e;
+		a !== void 0 && a !== i && n.push({
+			id: i.id,
+			item: i,
+			type: "replace"
+		}), a === void 0 && n.push({
+			item: i,
+			type: "add",
+			index: r
+		});
+	}
+	for (let [e] of t) r.get(e) === void 0 && n.push({
+		id: e,
+		type: "remove"
+	});
+	return n;
+}
+function elementToRemoveChange(e) {
+	return {
+		id: e.id,
+		type: "remove"
+	};
+}
+var isNode = (e) => isNodeBase(e), isEdge = (e) => isEdgeBase(e);
+function fixedForwardRef(e) {
+	return forwardRef(e);
+}
+var useIsomorphicLayoutEffect = typeof window < "u" ? useLayoutEffect : useEffect;
+function useQueue(e) {
+	let [t, n] = useState(BigInt(0)), [r] = useState(() => createQueue(() => n((e) => e + BigInt(1))));
+	return useIsomorphicLayoutEffect(() => {
+		let t = r.get();
+		t.length && (e(t), r.reset());
+	}, [t]), r;
+}
+function createQueue(e) {
+	let t = [];
+	return {
+		get: () => t,
+		reset: () => {
+			t = [];
+		},
+		push: (n) => {
+			t.push(n), e();
+		}
+	};
+}
+var BatchContext = createContext(null);
+function BatchProvider({ children: e }) {
+	let t = useStoreApi(), n = useQueue(useCallback((e) => {
+		let { nodes: n = [], setNodes: r, hasDefaultNodes: i, onNodesChange: a, nodeLookup: o, fitViewQueued: s, onNodesChangeMiddlewareMap: c } = t.getState(), l = n;
+		for (let t of e) l = typeof t == "function" ? t(l) : t;
+		let u = getElementsDiffChanges({
+			items: l,
+			lookup: o
+		});
+		for (let e of c.values()) u = e(u);
+		i && r(l), u.length > 0 ? a?.(u) : s && window.requestAnimationFrame(() => {
+			let { fitViewQueued: e, nodes: n, setNodes: r } = t.getState();
+			e && r(n);
+		});
+	}, [])), r = useQueue(useCallback((e) => {
+		let { edges: n = [], setEdges: r, hasDefaultEdges: i, onEdgesChange: a, edgeLookup: o } = t.getState(), s = n;
+		for (let t of e) s = typeof t == "function" ? t(s) : t;
+		i ? r(s) : a && a(getElementsDiffChanges({
+			items: s,
+			lookup: o
+		}));
+	}, [])), i = useMemo(() => ({
+		nodeQueue: n,
+		edgeQueue: r
+	}), []);
+	return jsx(BatchContext.Provider, {
+		value: i,
+		children: e
+	});
+}
+function useBatchContext() {
+	let e = useContext(BatchContext);
+	if (!e) throw Error("useBatchContext must be used within a BatchProvider");
+	return e;
+}
+var selector$k = (e) => !!e.panZoom;
+function useReactFlow() {
+	let e = useViewportHelper(), t = useStoreApi(), n = useBatchContext(), r = useStore(selector$k), i = useMemo(() => {
+		let e = (e) => t.getState().nodeLookup.get(e), r = (e) => {
+			n.nodeQueue.push(e);
+		}, i = (e) => {
+			n.edgeQueue.push(e);
+		}, a = (e) => {
+			let { nodeLookup: n, nodeOrigin: r } = t.getState(), i = isNode(e) ? e : n.get(e.id), a = i.parentId ? evaluateAbsolutePosition(i.position, i.measured, i.parentId, n, r) : i.position;
+			return nodeToRect({
+				...i,
+				position: a,
+				width: i.measured?.width ?? i.width,
+				height: i.measured?.height ?? i.height
+			});
+		}, o = (e, t, n = { replace: !1 }) => {
+			r((r) => r.map((r) => {
+				if (r.id === e) {
+					let e = typeof t == "function" ? t(r) : t;
+					return n.replace && isNode(e) ? e : {
+						...r,
+						...e
+					};
+				}
+				return r;
+			}));
+		}, s = (e, t, n = { replace: !1 }) => {
+			i((r) => r.map((r) => {
+				if (r.id === e) {
+					let e = typeof t == "function" ? t(r) : t;
+					return n.replace && isEdge(e) ? e : {
+						...r,
+						...e
+					};
+				}
+				return r;
+			}));
+		};
+		return {
+			getNodes: () => t.getState().nodes.map((e) => ({ ...e })),
+			getNode: (t) => e(t)?.internals.userNode,
+			getInternalNode: e,
+			getEdges: () => {
+				let { edges: e = [] } = t.getState();
+				return e.map((e) => ({ ...e }));
+			},
+			getEdge: (e) => t.getState().edgeLookup.get(e),
+			setNodes: r,
+			setEdges: i,
+			addNodes: (e) => {
+				let t = Array.isArray(e) ? e : [e];
+				n.nodeQueue.push((e) => [...e, ...t]);
+			},
+			addEdges: (e) => {
+				let t = Array.isArray(e) ? e : [e];
+				n.edgeQueue.push((e) => [...e, ...t]);
+			},
+			toObject: () => {
+				let { nodes: e = [], edges: n = [], transform: r } = t.getState(), [i, a, o] = r;
+				return {
+					nodes: e.map((e) => ({ ...e })),
+					edges: n.map((e) => ({ ...e })),
+					viewport: {
+						x: i,
+						y: a,
+						zoom: o
+					}
+				};
+			},
+			deleteElements: async ({ nodes: e = [], edges: n = [] }) => {
+				let { nodes: r, edges: i, onNodesDelete: a, onEdgesDelete: o, triggerNodeChanges: s, triggerEdgeChanges: c, onDelete: l, onBeforeDelete: u } = t.getState(), { nodes: d, edges: f } = await getElementsToRemove({
+					nodesToRemove: e,
+					edgesToRemove: n,
+					nodes: r,
+					edges: i,
+					onBeforeDelete: u
+				}), p = f.length > 0, m = d.length > 0;
+				if (p) {
+					let e = f.map(elementToRemoveChange);
+					o?.(f), c(e);
+				}
+				if (m) {
+					let e = d.map(elementToRemoveChange);
+					a?.(d), s(e);
+				}
+				return (m || p) && l?.({
+					nodes: d,
+					edges: f
+				}), {
+					deletedNodes: d,
+					deletedEdges: f
+				};
+			},
+			getIntersectingNodes: (e, n = !0, r) => {
+				let i = isRectObject(e), o = i ? e : a(e), s = r !== void 0;
+				return o ? (r || t.getState().nodes).filter((r) => {
+					let a = t.getState().nodeLookup.get(r.id);
+					if (a && !i && (r.id === e.id || !a.internals.positionAbsolute)) return !1;
+					let c = nodeToRect(s ? r : a), l = getOverlappingArea(c, o);
+					return n && l > 0 || l >= c.width * c.height || l >= o.width * o.height;
+				}) : [];
+			},
+			isNodeIntersecting: (e, t, n = !0) => {
+				let r = isRectObject(e) ? e : a(e);
+				if (!r) return !1;
+				let i = getOverlappingArea(r, t);
+				return n && i > 0 || i >= t.width * t.height || i >= r.width * r.height;
+			},
+			updateNode: o,
+			updateNodeData: (e, t, n = { replace: !1 }) => {
+				o(e, (e) => {
+					let r = typeof t == "function" ? t(e) : t;
+					return n.replace ? {
+						...e,
+						data: r
+					} : {
+						...e,
+						data: {
+							...e.data,
+							...r
+						}
+					};
+				}, n);
+			},
+			updateEdge: s,
+			updateEdgeData: (e, t, n = { replace: !1 }) => {
+				s(e, (e) => {
+					let r = typeof t == "function" ? t(e) : t;
+					return n.replace ? {
+						...e,
+						data: r
+					} : {
+						...e,
+						data: {
+							...e.data,
+							...r
+						}
+					};
+				}, n);
+			},
+			getNodesBounds: (e) => {
+				let { nodeLookup: n, nodeOrigin: r } = t.getState();
+				return getNodesBounds(e, {
+					nodeLookup: n,
+					nodeOrigin: r
+				});
+			},
+			getHandleConnections: ({ type: e, id: n, nodeId: r }) => Array.from(t.getState().connectionLookup.get(`${r}-${e}${n ? `-${n}` : ""}`)?.values() ?? []),
+			getNodeConnections: ({ type: e, handleId: n, nodeId: r }) => Array.from(t.getState().connectionLookup.get(`${r}${e ? n ? `-${e}-${n}` : `-${e}` : ""}`)?.values() ?? []),
+			fitView: async (e) => {
+				let r = t.getState().fitViewResolver ?? withResolvers();
+				return t.setState({
+					fitViewQueued: !0,
+					fitViewOptions: e,
+					fitViewResolver: r
+				}), n.nodeQueue.push((e) => [...e]), r.promise;
+			}
+		};
+	}, []);
+	return useMemo(() => ({
+		...i,
+		...e,
+		viewportInitialized: r
+	}), [r]);
+}
+var selected = (e) => e.selected, win$1 = typeof window < "u" ? window : void 0;
+function useGlobalKeyHandler({ deleteKeyCode: e, multiSelectionKeyCode: t }) {
+	let n = useStoreApi(), { deleteElements: r } = useReactFlow(), i = useKeyPress(e, { actInsideInputWithModifier: !1 }), a = useKeyPress(t, { target: win$1 });
+	useEffect(() => {
+		if (i) {
+			let { edges: e, nodes: t } = n.getState();
+			r({
+				nodes: t.filter(selected),
+				edges: e.filter(selected)
+			}), n.setState({ nodesSelectionActive: !1 });
+		}
+	}, [i]), useEffect(() => {
+		n.setState({ multiSelectionActive: a });
+	}, [a]);
+}
+function useResizeHandler(e) {
+	let t = useStoreApi();
+	useEffect(() => {
+		let n = () => {
+			if (!e.current || !(e.current.checkVisibility?.() ?? !0)) return !1;
+			let n = getDimensions(e.current);
+			(n.height === 0 || n.width === 0) && t.getState().onError?.("004", errorMessages.error004()), t.setState({
+				width: n.width || 500,
+				height: n.height || 500
+			});
+		};
+		if (e.current) {
+			n(), window.addEventListener("resize", n);
+			let t = new ResizeObserver(() => n());
+			return t.observe(e.current), () => {
+				window.removeEventListener("resize", n), t && e.current && t.unobserve(e.current);
+			};
+		}
+	}, []);
+}
+var containerStyle = {
+	position: "absolute",
+	width: "100%",
+	height: "100%",
+	top: 0,
+	left: 0
+}, selector$j = (e) => ({
+	userSelectionActive: e.userSelectionActive,
+	lib: e.lib,
+	connectionInProgress: e.connection.inProgress
+});
+function ZoomPane({ onPaneContextMenu: e, zoomOnScroll: t = !0, zoomOnPinch: n = !0, panOnScroll: r = !1, panOnScrollSpeed: a = .5, panOnScrollMode: o = PanOnScrollMode.Free, zoomOnDoubleClick: s = !0, panOnDrag: c = !0, defaultViewport: l, translateExtent: u, minZoom: f, maxZoom: p, zoomActivationKeyCode: m, preventScrolling: h = !0, children: g, noWheelClassName: _, noPanClassName: v, onViewportChange: y, isControlledViewport: b, paneClickDistance: x, selectionOnDrag: S }) {
+	let C = useStoreApi(), w = useRef(null), { userSelectionActive: T, lib: E, connectionInProgress: D } = useStore(selector$j, shallow), O = useKeyPress(m), k = useRef();
+	useResizeHandler(w);
+	let A = useCallback((e) => {
+		y?.({
+			x: e[0],
+			y: e[1],
+			zoom: e[2]
+		}), b || C.setState({ transform: e });
+	}, [y, b]);
+	return useEffect(() => {
+		if (w.current) {
+			k.current = XYPanZoom({
+				domNode: w.current,
+				minZoom: f,
+				maxZoom: p,
+				translateExtent: u,
+				viewport: l,
+				onDraggingChange: (e) => C.setState((t) => t.paneDragging === e ? t : { paneDragging: e }),
+				onPanZoomStart: (e, t) => {
+					let { onViewportChangeStart: n, onMoveStart: r } = C.getState();
+					r?.(e, t), n?.(t);
+				},
+				onPanZoom: (e, t) => {
+					let { onViewportChange: n, onMove: r } = C.getState();
+					r?.(e, t), n?.(t);
+				},
+				onPanZoomEnd: (e, t) => {
+					let { onViewportChangeEnd: n, onMoveEnd: r } = C.getState();
+					r?.(e, t), n?.(t);
+				}
+			});
+			let { x: e, y: t, zoom: n } = k.current.getViewport();
+			return C.setState({
+				panZoom: k.current,
+				transform: [
+					e,
+					t,
+					n
+				],
+				domNode: w.current.closest(".react-flow")
+			}), () => {
+				k.current?.destroy();
+			};
+		}
+	}, []), useEffect(() => {
+		k.current?.update({
+			onPaneContextMenu: e,
+			zoomOnScroll: t,
+			zoomOnPinch: n,
+			panOnScroll: r,
+			panOnScrollSpeed: a,
+			panOnScrollMode: o,
+			zoomOnDoubleClick: s,
+			panOnDrag: c,
+			zoomActivationKeyPressed: O,
+			preventScrolling: h,
+			noPanClassName: v,
+			userSelectionActive: T,
+			noWheelClassName: _,
+			lib: E,
+			onTransformChange: A,
+			connectionInProgress: D,
+			selectionOnDrag: S,
+			paneClickDistance: x
+		});
+	}, [
+		e,
+		t,
+		n,
+		r,
+		a,
+		o,
+		s,
+		c,
+		O,
+		h,
+		v,
+		T,
+		_,
+		E,
+		A,
+		D,
+		S,
+		x
+	]), jsx("div", {
+		className: "react-flow__renderer",
+		ref: w,
+		style: containerStyle,
+		children: g
+	});
+}
+var selector$i = (e) => ({
+	userSelectionActive: e.userSelectionActive,
+	userSelectionRect: e.userSelectionRect
+});
+function UserSelection() {
+	let { userSelectionActive: e, userSelectionRect: t } = useStore(selector$i, shallow);
+	return e && t ? jsx("div", {
+		className: "react-flow__selection react-flow__container",
+		style: {
+			width: t.width,
+			height: t.height,
+			transform: `translate(${t.x}px, ${t.y}px)`
+		}
+	}) : null;
+}
+var wrapHandler = (e, t) => (n) => {
+	n.target === t.current && e?.(n);
+}, selector$h = (e) => ({
+	userSelectionActive: e.userSelectionActive,
+	elementsSelectable: e.elementsSelectable,
+	connectionInProgress: e.connection.inProgress,
+	dragging: e.paneDragging
+});
+function Pane({ isSelecting: t, selectionKeyPressed: n, selectionMode: r = SelectionMode.Full, panOnDrag: i, paneClickDistance: a, selectionOnDrag: o, onSelectionStart: c, onSelectionEnd: l, onPaneClick: u, onPaneContextMenu: d, onPaneScroll: f, onPaneMouseEnter: p, onPaneMouseMove: m, onPaneMouseLeave: g, children: _ }) {
+	let v = useStoreApi(), { userSelectionActive: y, elementsSelectable: b, dragging: x, connectionInProgress: S } = useStore(selector$h, shallow), C = b && (t || y), w = useRef(null), T = useRef(), E = useRef(/* @__PURE__ */ new Set()), D = useRef(/* @__PURE__ */ new Set()), O = useRef(!1), k = (e) => {
+		if (O.current || S) {
+			O.current = !1;
+			return;
+		}
+		u?.(e), v.getState().resetSelectedElements(), v.setState({ nodesSelectionActive: !1 });
+	}, A = (e) => {
+		if (Array.isArray(i) && i?.includes(2)) {
+			e.preventDefault();
+			return;
+		}
+		d?.(e);
+	}, j = f ? (e) => f(e) : void 0;
+	return jsxs("div", {
+		className: cc(["react-flow__pane", {
+			draggable: i === !0 || Array.isArray(i) && i.includes(0),
+			dragging: x,
+			selection: t
+		}]),
+		onClick: C ? void 0 : wrapHandler(k, w),
+		onContextMenu: wrapHandler(A, w),
+		onWheel: wrapHandler(j, w),
+		onPointerEnter: C ? void 0 : p,
+		onPointerMove: C ? (e) => {
+			let { userSelectionRect: t, transform: i, nodeLookup: o, edgeLookup: l, connectionLookup: u, triggerNodeChanges: d, triggerEdgeChanges: f, defaultEdgeOptions: p, resetSelectedElements: m } = v.getState();
+			if (!T.current || !t) return;
+			let { x: g, y: _ } = getEventPosition(e.nativeEvent, T.current), { startX: y, startY: b } = t;
+			if (!O.current) {
+				let t = n ? 0 : a;
+				if (Math.hypot(g - y, _ - b) <= t) return;
+				m(), c?.(e);
+			}
+			O.current = !0;
+			let x = {
+				startX: y,
+				startY: b,
+				x: g < y ? g : y,
+				y: _ < b ? _ : b,
+				width: Math.abs(g - y),
+				height: Math.abs(_ - b)
+			}, S = E.current, C = D.current;
+			E.current = new Set(getNodesInside(o, x, i, r === SelectionMode.Partial, !0).map((e) => e.id)), D.current = /* @__PURE__ */ new Set();
+			let w = p?.selectable ?? !0;
+			for (let e of E.current) {
+				let t = u.get(e);
+				if (t) for (let { edgeId: e } of t.values()) {
+					let t = l.get(e);
+					t && (t.selectable ?? w) && D.current.add(e);
+				}
+			}
+			areSetsEqual(S, E.current) || d(getSelectionChanges(o, E.current, !0)), areSetsEqual(C, D.current) || f(getSelectionChanges(l, D.current)), v.setState({
+				userSelectionRect: x,
+				userSelectionActive: !0,
+				nodesSelectionActive: !1
+			});
+		} : m,
+		onPointerUp: C ? (e) => {
+			e.button === 0 && (e.target?.releasePointerCapture?.(e.pointerId), !y && e.target === w.current && v.getState().userSelectionRect && k?.(e), v.setState({
+				userSelectionActive: !1,
+				userSelectionRect: null
+			}), O.current && (l?.(e), v.setState({ nodesSelectionActive: E.current.size > 0 })));
+		} : void 0,
+		onPointerDownCapture: C ? (e) => {
+			let { domNode: r } = v.getState();
+			if (T.current = r?.getBoundingClientRect(), !T.current) return;
+			let i = e.target === w.current;
+			if (!i && e.target.closest(".nokey") || !t || !(o && i || n) || e.button !== 0 || !e.isPrimary) return;
+			e.target?.setPointerCapture?.(e.pointerId), O.current = !1;
+			let { x: a, y: s } = getEventPosition(e.nativeEvent, T.current);
+			v.setState({ userSelectionRect: {
+				width: 0,
+				height: 0,
+				startX: a,
+				startY: s,
+				x: a,
+				y: s
+			} }), i || (e.stopPropagation(), e.preventDefault());
+		} : void 0,
+		onClickCapture: C ? (e) => {
+			O.current &&= (e.stopPropagation(), !1);
+		} : void 0,
+		onPointerLeave: g,
+		ref: w,
+		style: containerStyle,
+		children: [_, jsx(UserSelection, {})]
+	});
+}
+function handleNodeClick({ id: e, store: t, unselect: n = !1, nodeRef: r }) {
+	let { addSelectedNodes: i, unselectNodesAndEdges: a, multiSelectionActive: o, nodeLookup: s, onError: c } = t.getState(), l = s.get(e);
+	if (!l) {
+		c?.("012", errorMessages.error012(e));
+		return;
+	}
+	t.setState({ nodesSelectionActive: !1 }), l.selected ? (n || l.selected && o) && (a({
+		nodes: [l],
+		edges: []
+	}), requestAnimationFrame(() => r?.current?.blur())) : i([e]);
+}
+function useDrag({ nodeRef: e, disabled: t = !1, noDragClassName: n, handleSelector: r, nodeId: i, isSelectable: a, nodeClickDistance: o }) {
+	let s = useStoreApi(), [l, u] = useState(!1), d = useRef();
+	return useEffect(() => {
+		d.current = XYDrag({
+			getStoreItems: () => s.getState(),
+			onNodeMouseDown: (t) => {
+				handleNodeClick({
+					id: t,
+					store: s,
+					nodeRef: e
+				});
+			},
+			onDragStart: () => {
+				u(!0);
+			},
+			onDragStop: () => {
+				u(!1);
+			}
+		});
+	}, []), useEffect(() => {
+		if (!(t || !e.current || !d.current)) return d.current.update({
+			noDragClassName: n,
+			handleSelector: r,
+			domNode: e.current,
+			isSelectable: a,
+			nodeId: i,
+			nodeClickDistance: o
+		}), () => {
+			d.current?.destroy();
+		};
+	}, [
+		n,
+		r,
+		t,
+		a,
+		e,
+		i,
+		o
+	]), l;
+}
+var selectedAndDraggable = (e) => (t) => t.selected && (t.draggable || e && t.draggable === void 0);
+function useMoveSelectedNodes() {
+	let e = useStoreApi();
+	return useCallback((t) => {
+		let { nodeExtent: n, snapToGrid: r, snapGrid: i, nodesDraggable: a, onError: o, updateNodePositions: s, nodeLookup: c, nodeOrigin: l } = e.getState(), u = /* @__PURE__ */ new Map(), d = selectedAndDraggable(a), f = r ? i[0] : 5, p = r ? i[1] : 5, m = t.direction.x * f * t.factor, h = t.direction.y * p * t.factor;
+		for (let [, e] of c) {
+			if (!d(e)) continue;
+			let t = {
+				x: e.internals.positionAbsolute.x + m,
+				y: e.internals.positionAbsolute.y + h
+			};
+			r && (t = snapPosition(t, i));
+			let { position: a, positionAbsolute: s } = calculateNodePosition({
+				nodeId: e.id,
+				nextPosition: t,
+				nodeLookup: c,
+				nodeExtent: n,
+				nodeOrigin: l,
+				onError: o
+			});
+			e.position = a, e.internals.positionAbsolute = s, u.set(e.id, e);
+		}
+		s(u);
+	}, []);
+}
+var NodeIdContext = createContext(null), Provider = NodeIdContext.Provider;
+NodeIdContext.Consumer;
+var useNodeId = () => useContext(NodeIdContext), selector$g = (e) => ({
+	connectOnClick: e.connectOnClick,
+	noPanClassName: e.noPanClassName,
+	rfId: e.rfId
+}), connectingSelector = (e, t, r) => (i) => {
+	let { connectionClickStartHandle: a, connectionMode: o, connection: s } = i, { fromHandle: c, toHandle: l, isValid: u } = s, d = l?.nodeId === e && l?.id === t && l?.type === r;
+	return {
+		connectingFrom: c?.nodeId === e && c?.id === t && c?.type === r,
+		connectingTo: d,
+		clickConnecting: a?.nodeId === e && a?.id === t && a?.type === r,
+		isPossibleEndHandle: o === ConnectionMode.Strict ? c?.type !== r : e !== c?.nodeId || t !== c?.id,
+		connectionInProcess: !!c,
+		clickConnectionInProcess: !!a,
+		valid: d && u
+	};
+};
+function HandleComponent({ type: t = "source", position: n = Position.Top, isValidConnection: r, isConnectable: i = !0, isConnectableStart: o = !0, isConnectableEnd: s = !0, id: c, onConnect: u, children: d, className: f, onMouseDown: m, onTouchStart: h, ...g }, _) {
+	let v = c || null, y = t === "target", b = useStoreApi(), S = useNodeId(), { connectOnClick: C, noPanClassName: w, rfId: T } = useStore(selector$g, shallow), { connectingFrom: E, connectingTo: D, clickConnecting: O, isPossibleEndHandle: k, connectionInProcess: A, clickConnectionInProcess: j, valid: M } = useStore(connectingSelector(S, v, t), shallow);
+	S || b.getState().onError?.("010", errorMessages.error010());
+	let N = (e) => {
+		let { defaultEdgeOptions: t, onConnect: n, hasDefaultEdges: r } = b.getState(), i = {
+			...t,
+			...e
+		};
+		if (r) {
+			let { edges: e, setEdges: t } = b.getState();
+			t(addEdge(i, e));
+		}
+		n?.(i), u?.(i);
+	}, P = (e) => {
+		if (!S) return;
+		let t = isMouseEvent(e.nativeEvent);
+		if (o && (t && e.button === 0 || !t)) {
+			let t = b.getState();
+			XYHandle.onPointerDown(e.nativeEvent, {
+				handleDomNode: e.currentTarget,
+				autoPanOnConnect: t.autoPanOnConnect,
+				connectionMode: t.connectionMode,
+				connectionRadius: t.connectionRadius,
+				domNode: t.domNode,
+				nodeLookup: t.nodeLookup,
+				lib: t.lib,
+				isTarget: y,
+				handleId: v,
+				nodeId: S,
+				flowId: t.rfId,
+				panBy: t.panBy,
+				cancelConnection: t.cancelConnection,
+				onConnectStart: t.onConnectStart,
+				onConnectEnd: (...e) => b.getState().onConnectEnd?.(...e),
+				updateConnection: t.updateConnection,
+				onConnect: N,
+				isValidConnection: r || ((...e) => b.getState().isValidConnection?.(...e) ?? !0),
+				getTransform: () => b.getState().transform,
+				getFromHandle: () => b.getState().connection.fromHandle,
+				autoPanSpeed: t.autoPanSpeed,
+				dragThreshold: t.connectionDragThreshold
+			});
+		}
+		t ? m?.(e) : h?.(e);
+	}, F = (e) => {
+		let { onClickConnectStart: n, onClickConnectEnd: i, connectionClickStartHandle: a, connectionMode: s, isValidConnection: c, lib: u, rfId: d, nodeLookup: f, connection: p } = b.getState();
+		if (!S || !a && !o) return;
+		if (!a) {
+			n?.(e.nativeEvent, {
+				nodeId: S,
+				handleId: v,
+				handleType: t
+			}), b.setState({ connectionClickStartHandle: {
+				nodeId: S,
+				type: t,
+				id: v
+			} });
+			return;
+		}
+		let m = getHostForElement(e.target), h = r || c, { connection: g, isValid: _ } = XYHandle.isValid(e.nativeEvent, {
+			handle: {
+				nodeId: S,
+				id: v,
+				type: t
+			},
+			connectionMode: s,
+			fromNodeId: a.nodeId,
+			fromHandleId: a.id || null,
+			fromType: a.type,
+			isValidConnection: h,
+			flowId: d,
+			doc: m,
+			lib: u,
+			nodeLookup: f
+		});
+		_ && g && N(g);
+		let y = structuredClone(p);
+		delete y.inProgress, y.toPosition = y.toHandle ? y.toHandle.position : null, i?.(e, y), b.setState({ connectionClickStartHandle: null });
+	};
+	return jsx("div", {
+		"data-handleid": v,
+		"data-nodeid": S,
+		"data-handlepos": n,
+		"data-id": `${T}-${S}-${v}-${t}`,
+		className: cc([
+			"react-flow__handle",
+			`react-flow__handle-${n}`,
+			"nodrag",
+			w,
+			f,
+			{
+				source: !y,
+				target: y,
+				connectable: i,
+				connectablestart: o,
+				connectableend: s,
+				clickconnecting: O,
+				connectingfrom: E,
+				connectingto: D,
+				valid: M,
+				connectionindicator: i && (!A || k) && (A || j ? s : o)
+			}
+		]),
+		onMouseDown: P,
+		onTouchStart: P,
+		onClick: C ? F : void 0,
+		ref: _,
+		...g,
+		children: d
+	});
+}
+var Handle = memo(fixedForwardRef(HandleComponent));
+function InputNode({ data: e, isConnectable: t, sourcePosition: n = Position.Bottom }) {
+	return jsxs(Fragment$1, { children: [e?.label, jsx(Handle, {
+		type: "source",
+		position: n,
+		isConnectable: t
+	})] });
+}
+function DefaultNode({ data: e, isConnectable: t, targetPosition: n = Position.Top, sourcePosition: r = Position.Bottom }) {
+	return jsxs(Fragment$1, { children: [
+		jsx(Handle, {
+			type: "target",
+			position: n,
+			isConnectable: t
+		}),
+		e?.label,
+		jsx(Handle, {
+			type: "source",
+			position: r,
+			isConnectable: t
+		})
+	] });
+}
+function GroupNode() {
+	return null;
+}
+function OutputNode({ data: e, isConnectable: t, targetPosition: n = Position.Top }) {
+	return jsxs(Fragment$1, { children: [jsx(Handle, {
+		type: "target",
+		position: n,
+		isConnectable: t
+	}), e?.label] });
+}
+var arrowKeyDiffs = {
+	ArrowUp: {
+		x: 0,
+		y: -1
+	},
+	ArrowDown: {
+		x: 0,
+		y: 1
+	},
+	ArrowLeft: {
+		x: -1,
+		y: 0
+	},
+	ArrowRight: {
+		x: 1,
+		y: 0
+	}
+}, builtinNodeTypes = {
+	input: InputNode,
+	default: DefaultNode,
+	output: OutputNode,
+	group: GroupNode
+};
+function getNodeInlineStyleDimensions(e) {
+	return e.internals.handleBounds === void 0 ? {
+		width: e.width ?? e.initialWidth ?? e.style?.width,
+		height: e.height ?? e.initialHeight ?? e.style?.height
+	} : {
+		width: e.width ?? e.style?.width,
+		height: e.height ?? e.style?.height
+	};
+}
+var selector$f = (e) => {
+	let { width: t, height: n, x: r, y: i } = getInternalNodesBounds(e.nodeLookup, { filter: (e) => !!e.selected });
+	return {
+		width: isNumeric(t) ? t : null,
+		height: isNumeric(n) ? n : null,
+		userSelectionActive: e.userSelectionActive,
+		transformString: `translate(${e.transform[0]}px,${e.transform[1]}px) scale(${e.transform[2]}) translate(${r}px,${i}px)`
+	};
+};
+function NodesSelection({ onSelectionContextMenu: t, noPanClassName: n, disableKeyboardA11y: r }) {
+	let i = useStoreApi(), { width: a, height: o, transformString: s, userSelectionActive: c } = useStore(selector$f, shallow), l = useMoveSelectedNodes(), u = useRef(null);
+	useEffect(() => {
+		r || u.current?.focus({ preventScroll: !0 });
+	}, [r]);
+	let d = !c && a !== null && o !== null;
+	if (useDrag({
+		nodeRef: u,
+		disabled: !d
+	}), !d) return null;
+	let f = t ? (e) => {
+		t(e, i.getState().nodes.filter((e) => e.selected));
+	} : void 0;
+	return jsx("div", {
+		className: cc([
+			"react-flow__nodesselection",
+			"react-flow__container",
+			n
+		]),
+		style: { transform: s },
+		children: jsx("div", {
+			ref: u,
+			className: "react-flow__nodesselection-rect",
+			onContextMenu: f,
+			tabIndex: r ? void 0 : -1,
+			onKeyDown: r ? void 0 : (e) => {
+				Object.prototype.hasOwnProperty.call(arrowKeyDiffs, e.key) && (e.preventDefault(), l({
+					direction: arrowKeyDiffs[e.key],
+					factor: e.shiftKey ? 4 : 1
+				}));
+			},
+			style: {
+				width: a,
+				height: o
+			}
+		})
+	});
+}
+var win = typeof window < "u" ? window : void 0, selector$e = (e) => ({
+	nodesSelectionActive: e.nodesSelectionActive,
+	userSelectionActive: e.userSelectionActive
+});
+function FlowRendererComponent({ children: e, onPaneClick: t, onPaneMouseEnter: n, onPaneMouseMove: r, onPaneMouseLeave: i, onPaneContextMenu: a, onPaneScroll: o, paneClickDistance: s, deleteKeyCode: c, selectionKeyCode: l, selectionOnDrag: u, selectionMode: d, onSelectionStart: f, onSelectionEnd: p, multiSelectionKeyCode: m, panActivationKeyCode: h, zoomActivationKeyCode: g, elementsSelectable: _, zoomOnScroll: v, zoomOnPinch: y, panOnScroll: b, panOnScrollSpeed: x, panOnScrollMode: S, zoomOnDoubleClick: C, panOnDrag: w, defaultViewport: T, translateExtent: E, minZoom: D, maxZoom: O, preventScrolling: k, onSelectionContextMenu: A, noWheelClassName: j, noPanClassName: M, disableKeyboardA11y: N, onViewportChange: P, isControlledViewport: F }) {
+	let { nodesSelectionActive: I, userSelectionActive: L } = useStore(selector$e, shallow), R = useKeyPress(l, { target: win }), z = useKeyPress(h, { target: win }), B = z || w, V = z || b, H = u && B !== !0, U = R || L || H;
+	return useGlobalKeyHandler({
+		deleteKeyCode: c,
+		multiSelectionKeyCode: m
+	}), jsx(ZoomPane, {
+		onPaneContextMenu: a,
+		elementsSelectable: _,
+		zoomOnScroll: v,
+		zoomOnPinch: y,
+		panOnScroll: V,
+		panOnScrollSpeed: x,
+		panOnScrollMode: S,
+		zoomOnDoubleClick: C,
+		panOnDrag: !R && B,
+		defaultViewport: T,
+		translateExtent: E,
+		minZoom: D,
+		maxZoom: O,
+		zoomActivationKeyCode: g,
+		preventScrolling: k,
+		noWheelClassName: j,
+		noPanClassName: M,
+		onViewportChange: P,
+		isControlledViewport: F,
+		paneClickDistance: s,
+		selectionOnDrag: H,
+		children: jsxs(Pane, {
+			onSelectionStart: f,
+			onSelectionEnd: p,
+			onPaneClick: t,
+			onPaneMouseEnter: n,
+			onPaneMouseMove: r,
+			onPaneMouseLeave: i,
+			onPaneContextMenu: a,
+			onPaneScroll: o,
+			panOnDrag: B,
+			isSelecting: !!U,
+			selectionMode: d,
+			selectionKeyPressed: R,
+			paneClickDistance: s,
+			selectionOnDrag: H,
+			children: [e, I && jsx(NodesSelection, {
+				onSelectionContextMenu: A,
+				noPanClassName: M,
+				disableKeyboardA11y: N
+			})]
+		})
+	});
+}
+FlowRendererComponent.displayName = "FlowRenderer";
+var FlowRenderer = memo(FlowRendererComponent), selector$d = (e) => (t) => e ? getNodesInside(t.nodeLookup, {
+	x: 0,
+	y: 0,
+	width: t.width,
+	height: t.height
+}, t.transform, !0).map((e) => e.id) : Array.from(t.nodeLookup.keys());
+function useVisibleNodeIds(e) {
+	return useStore(useCallback(selector$d(e), [e]), shallow);
+}
+var selector$c = (e) => e.updateNodeInternals;
+function useResizeObserver() {
+	let e = useStore(selector$c), [t] = useState(() => typeof ResizeObserver > "u" ? null : new ResizeObserver((t) => {
+		let n = /* @__PURE__ */ new Map();
+		t.forEach((e) => {
+			let t = e.target.getAttribute("data-id");
+			n.set(t, {
+				id: t,
+				nodeElement: e.target,
+				force: !0
+			});
+		}), e(n);
+	}));
+	return useEffect(() => () => {
+		t?.disconnect();
+	}, [t]), t;
+}
+function useNodeObserver({ node: e, nodeType: t, hasDimensions: n, resizeObserver: r }) {
+	let i = useStoreApi(), a = useRef(null), o = useRef(null), s = useRef(e.sourcePosition), c = useRef(e.targetPosition), l = useRef(t), u = n && !!e.internals.handleBounds;
+	return useEffect(() => {
+		a.current && !e.hidden && (!u || o.current !== a.current) && (o.current && r?.unobserve(o.current), r?.observe(a.current), o.current = a.current);
+	}, [u, e.hidden]), useEffect(() => () => {
+		o.current &&= (r?.unobserve(o.current), null);
+	}, []), useEffect(() => {
+		if (a.current) {
+			let n = l.current !== t, r = s.current !== e.sourcePosition, o = c.current !== e.targetPosition;
+			(n || r || o) && (l.current = t, s.current = e.sourcePosition, c.current = e.targetPosition, i.getState().updateNodeInternals(new Map([[e.id, {
+				id: e.id,
+				nodeElement: a.current,
+				force: !0
+			}]])));
+		}
+	}, [
+		e.id,
+		t,
+		e.sourcePosition,
+		e.targetPosition
+	]), a;
+}
+function NodeWrapper({ id: t, onClick: n, onMouseEnter: r, onMouseMove: i, onMouseLeave: a, onContextMenu: o, onDoubleClick: s, nodesDraggable: c, elementsSelectable: l, nodesConnectable: u, nodesFocusable: d, resizeObserver: f, noDragClassName: p, noPanClassName: m, disableKeyboardA11y: h, rfId: g, nodeTypes: _, nodeClickDistance: v, onError: y }) {
+	let { node: S, internals: C, isParent: w } = useStore((e) => {
+		let n = e.nodeLookup.get(t), r = e.parentLookup.has(t);
+		return {
+			node: n,
+			internals: n.internals,
+			isParent: r
+		};
+	}, shallow), T = S.type || "default", E = _?.[T] || builtinNodeTypes[T];
+	E === void 0 && (y?.("003", errorMessages.error003(T)), T = "default", E = _?.default || builtinNodeTypes.default);
+	let D = !!(S.draggable || c && S.draggable === void 0), O = !!(S.selectable || l && S.selectable === void 0), k = !!(S.connectable || u && S.connectable === void 0), A = !!(S.focusable || d && S.focusable === void 0), j = useStoreApi(), M = nodeHasDimensions(S), N = useNodeObserver({
+		node: S,
+		nodeType: T,
+		hasDimensions: M,
+		resizeObserver: f
+	}), P = useDrag({
+		nodeRef: N,
+		disabled: S.hidden || !D,
+		noDragClassName: p,
+		handleSelector: S.dragHandle,
+		nodeId: t,
+		isSelectable: O,
+		nodeClickDistance: v
+	}), F = useMoveSelectedNodes();
+	if (S.hidden) return null;
+	let I = getNodeDimensions(S), L = getNodeInlineStyleDimensions(S), R = O || D || n || r || i || a, B = r ? (e) => r(e, { ...C.userNode }) : void 0, H = i ? (e) => i(e, { ...C.userNode }) : void 0, U = a ? (e) => a(e, { ...C.userNode }) : void 0, W = o ? (e) => o(e, { ...C.userNode }) : void 0, G = s ? (e) => s(e, { ...C.userNode }) : void 0, K = (e) => {
+		let { selectNodesOnDrag: r, nodeDragThreshold: i } = j.getState();
+		O && (!r || !D || i > 0) && handleNodeClick({
+			id: t,
+			store: j,
+			nodeRef: N
+		}), n && n(e, { ...C.userNode });
+	}, q = (e) => {
+		if (!(isInputDOMNode(e.nativeEvent) || h)) {
+			if (elementSelectionKeys.includes(e.key) && O) handleNodeClick({
+				id: t,
+				store: j,
+				unselect: e.key === "Escape",
+				nodeRef: N
+			});
+			else if (D && S.selected && Object.prototype.hasOwnProperty.call(arrowKeyDiffs, e.key)) {
+				e.preventDefault();
+				let { ariaLabelConfig: t } = j.getState();
+				j.setState({ ariaLiveMessage: t["node.a11yDescription.ariaLiveMessage"]({
+					direction: e.key.replace("Arrow", "").toLowerCase(),
+					x: ~~C.positionAbsolute.x,
+					y: ~~C.positionAbsolute.y
+				}) }), F({
+					direction: arrowKeyDiffs[e.key],
+					factor: e.shiftKey ? 4 : 1
+				});
+			}
+		}
+	}, J = () => {
+		if (h || !N.current?.matches(":focus-visible")) return;
+		let { transform: e, width: n, height: r, autoPanOnNodeFocus: i, setCenter: a } = j.getState();
+		i && (getNodesInside(new Map([[t, S]]), {
+			x: 0,
+			y: 0,
+			width: n,
+			height: r
+		}, e, !0).length > 0 || a(S.position.x + I.width / 2, S.position.y + I.height / 2, { zoom: e[2] }));
+	};
+	return jsx("div", {
+		className: cc([
+			"react-flow__node",
+			`react-flow__node-${T}`,
+			{ [m]: D },
+			S.className,
+			{
+				selected: S.selected,
+				selectable: O,
+				parent: w,
+				draggable: D,
+				dragging: P
+			}
+		]),
+		ref: N,
+		style: {
+			zIndex: C.z,
+			transform: `translate(${C.positionAbsolute.x}px,${C.positionAbsolute.y}px)`,
+			pointerEvents: R ? "all" : "none",
+			visibility: M ? "visible" : "hidden",
+			...S.style,
+			...L
+		},
+		"data-id": t,
+		"data-testid": `rf__node-${t}`,
+		onMouseEnter: B,
+		onMouseMove: H,
+		onMouseLeave: U,
+		onContextMenu: W,
+		onClick: K,
+		onDoubleClick: G,
+		onKeyDown: A ? q : void 0,
+		tabIndex: A ? 0 : void 0,
+		onFocus: A ? J : void 0,
+		role: S.ariaRole ?? (A ? "group" : void 0),
+		"aria-roledescription": "node",
+		"aria-describedby": h ? void 0 : `${ARIA_NODE_DESC_KEY}-${g}`,
+		"aria-label": S.ariaLabel,
+		...S.domAttributes,
+		children: jsx(Provider, {
+			value: t,
+			children: jsx(E, {
+				id: t,
+				data: S.data,
+				type: T,
+				positionAbsoluteX: C.positionAbsolute.x,
+				positionAbsoluteY: C.positionAbsolute.y,
+				selected: S.selected ?? !1,
+				selectable: O,
+				draggable: D,
+				deletable: S.deletable ?? !0,
+				isConnectable: k,
+				sourcePosition: S.sourcePosition,
+				targetPosition: S.targetPosition,
+				dragging: P,
+				dragHandle: S.dragHandle,
+				zIndex: C.z,
+				parentId: S.parentId,
+				...I
+			})
+		})
+	});
+}
+var NodeWrapper$1 = memo(NodeWrapper), selector$b = (e) => ({
+	nodesDraggable: e.nodesDraggable,
+	nodesConnectable: e.nodesConnectable,
+	nodesFocusable: e.nodesFocusable,
+	elementsSelectable: e.elementsSelectable,
+	onError: e.onError
+});
+function NodeRendererComponent(e) {
+	let { nodesDraggable: t, nodesConnectable: n, nodesFocusable: r, elementsSelectable: i, onError: a } = useStore(selector$b, shallow), o = useVisibleNodeIds(e.onlyRenderVisibleElements), s = useResizeObserver();
+	return jsx("div", {
+		className: "react-flow__nodes",
+		style: containerStyle,
+		children: o.map((o) => jsx(NodeWrapper$1, {
+			id: o,
+			nodeTypes: e.nodeTypes,
+			nodeExtent: e.nodeExtent,
+			onClick: e.onNodeClick,
+			onMouseEnter: e.onNodeMouseEnter,
+			onMouseMove: e.onNodeMouseMove,
+			onMouseLeave: e.onNodeMouseLeave,
+			onContextMenu: e.onNodeContextMenu,
+			onDoubleClick: e.onNodeDoubleClick,
+			noDragClassName: e.noDragClassName,
+			noPanClassName: e.noPanClassName,
+			rfId: e.rfId,
+			disableKeyboardA11y: e.disableKeyboardA11y,
+			resizeObserver: s,
+			nodesDraggable: t,
+			nodesConnectable: n,
+			nodesFocusable: r,
+			elementsSelectable: i,
+			nodeClickDistance: e.nodeClickDistance,
+			onError: a
+		}, o))
+	});
+}
+NodeRendererComponent.displayName = "NodeRenderer";
+var NodeRenderer = memo(NodeRendererComponent);
+function useVisibleEdgeIds(e) {
+	return useStore(useCallback((t) => {
+		if (!e) return t.edges.map((e) => e.id);
+		let n = [];
+		if (t.width && t.height) for (let e of t.edges) {
+			let r = t.nodeLookup.get(e.source), i = t.nodeLookup.get(e.target);
+			r && i && isEdgeVisible({
+				sourceNode: r,
+				targetNode: i,
+				width: t.width,
+				height: t.height,
+				transform: t.transform
+			}) && n.push(e.id);
+		}
+		return n;
+	}, [e]), shallow);
+}
+var ArrowSymbol = ({ color: e = "none", strokeWidth: t = 1 }) => jsx("polyline", {
+	className: "arrow",
+	style: {
+		strokeWidth: t,
+		...e && { stroke: e }
+	},
+	strokeLinecap: "round",
+	fill: "none",
+	strokeLinejoin: "round",
+	points: "-5,-4 0,0 -5,4"
+}), ArrowClosedSymbol = ({ color: e = "none", strokeWidth: t = 1 }) => jsx("polyline", {
+	className: "arrowclosed",
+	style: {
+		strokeWidth: t,
+		...e && {
+			stroke: e,
+			fill: e
+		}
+	},
+	strokeLinecap: "round",
+	strokeLinejoin: "round",
+	points: "-5,-4 0,0 -5,4 -5,-4"
+}), MarkerSymbols = {
+	[MarkerType.Arrow]: ArrowSymbol,
+	[MarkerType.ArrowClosed]: ArrowClosedSymbol
+};
+function useMarkerSymbol(e) {
+	let t = useStoreApi();
+	return useMemo(() => Object.prototype.hasOwnProperty.call(MarkerSymbols, e) ? MarkerSymbols[e] : (t.getState().onError?.("009", errorMessages.error009(e)), null), [e]);
+}
+var Marker = ({ id: e, type: t, color: n, width: r = 12.5, height: i = 12.5, markerUnits: a = "strokeWidth", strokeWidth: o, orient: s = "auto-start-reverse" }) => {
+	let c = useMarkerSymbol(t);
+	return c ? jsx("marker", {
+		className: "react-flow__arrowhead",
+		id: e,
+		markerWidth: `${r}`,
+		markerHeight: `${i}`,
+		viewBox: "-10 -10 20 20",
+		markerUnits: a,
+		orient: s,
+		refX: "0",
+		refY: "0",
+		children: jsx(c, {
+			color: n,
+			strokeWidth: o
+		})
+	}) : null;
+}, MarkerDefinitions = ({ defaultColor: e, rfId: t }) => {
+	let n = useStore((e) => e.edges), r = useStore((e) => e.defaultEdgeOptions), i = useMemo(() => createMarkerIds(n, {
+		id: t,
+		defaultColor: e,
+		defaultMarkerStart: r?.markerStart,
+		defaultMarkerEnd: r?.markerEnd
+	}), [
+		n,
+		r,
+		t,
+		e
+	]);
+	return i.length ? jsx("svg", {
+		className: "react-flow__marker",
+		"aria-hidden": "true",
+		children: jsx("defs", { children: i.map((e) => jsx(Marker, {
+			id: e.id,
+			type: e.type,
+			color: e.color,
+			width: e.width,
+			height: e.height,
+			markerUnits: e.markerUnits,
+			strokeWidth: e.strokeWidth,
+			orient: e.orient
+		}, e.id)) })
+	}) : null;
+};
+MarkerDefinitions.displayName = "MarkerDefinitions";
+var MarkerDefinitions$1 = memo(MarkerDefinitions);
+function EdgeTextComponent({ x: t, y: n, label: r, labelStyle: i, labelShowBg: a = !0, labelBgStyle: o, labelBgPadding: s = [2, 4], labelBgBorderRadius: c = 2, children: l, className: u, ...d }) {
+	let [f, p] = useState({
+		x: 1,
+		y: 0,
+		width: 0,
+		height: 0
+	}), m = cc(["react-flow__edge-textwrapper", u]), h = useRef(null);
+	return useEffect(() => {
+		if (h.current) {
+			let e = h.current.getBBox();
+			p({
+				x: e.x,
+				y: e.y,
+				width: e.width,
+				height: e.height
+			});
+		}
+	}, [r]), r ? jsxs("g", {
+		transform: `translate(${t - f.width / 2} ${n - f.height / 2})`,
+		className: m,
+		visibility: f.width ? "visible" : "hidden",
+		...d,
+		children: [
+			a && jsx("rect", {
+				width: f.width + 2 * s[0],
+				x: -s[0],
+				y: -s[1],
+				height: f.height + 2 * s[1],
+				className: "react-flow__edge-textbg",
+				style: o,
+				rx: c,
+				ry: c
+			}),
+			jsx("text", {
+				className: "react-flow__edge-text",
+				y: f.height / 2,
+				dy: "0.3em",
+				ref: h,
+				style: i,
+				children: r
+			}),
+			l
+		]
+	}) : null;
+}
+EdgeTextComponent.displayName = "EdgeText";
+var EdgeText = memo(EdgeTextComponent);
+function BaseEdge({ path: t, labelX: n, labelY: r, label: i, labelStyle: a, labelShowBg: o, labelBgStyle: s, labelBgPadding: c, labelBgBorderRadius: l, interactionWidth: u = 20, ...d }) {
+	return jsxs(Fragment$1, { children: [
+		jsx("path", {
+			...d,
+			d: t,
+			fill: "none",
+			className: cc(["react-flow__edge-path", d.className])
+		}),
+		u ? jsx("path", {
+			d: t,
+			fill: "none",
+			strokeOpacity: 0,
+			strokeWidth: u,
+			className: "react-flow__edge-interaction"
+		}) : null,
+		i && isNumeric(n) && isNumeric(r) ? jsx(EdgeText, {
+			x: n,
+			y: r,
+			label: i,
+			labelStyle: a,
+			labelShowBg: o,
+			labelBgStyle: s,
+			labelBgPadding: c,
+			labelBgBorderRadius: l
+		}) : null
+	] });
+}
+function getControl({ pos: e, x1: t, y1: n, x2: r, y2: i }) {
+	return e === Position.Left || e === Position.Right ? [.5 * (t + r), n] : [t, .5 * (n + i)];
+}
+function getSimpleBezierPath({ sourceX: e, sourceY: t, sourcePosition: n = Position.Bottom, targetX: r, targetY: i, targetPosition: o = Position.Top }) {
+	let [s, c] = getControl({
+		pos: n,
+		x1: e,
+		y1: t,
+		x2: r,
+		y2: i
+	}), [l, u] = getControl({
+		pos: o,
+		x1: r,
+		y1: i,
+		x2: e,
+		y2: t
+	}), [d, f, p, m] = getBezierEdgeCenter({
+		sourceX: e,
+		sourceY: t,
+		targetX: r,
+		targetY: i,
+		sourceControlX: s,
+		sourceControlY: c,
+		targetControlX: l,
+		targetControlY: u
+	});
+	return [
+		`M${e},${t} C${s},${c} ${l},${u} ${r},${i}`,
+		d,
+		f,
+		p,
+		m
+	];
+}
+function createSimpleBezierEdge(e) {
+	return memo(({ id: t, sourceX: n, sourceY: r, targetX: i, targetY: a, sourcePosition: o, targetPosition: s, label: c, labelStyle: l, labelShowBg: u, labelBgStyle: d, labelBgPadding: f, labelBgBorderRadius: p, style: m, markerEnd: h, markerStart: g, interactionWidth: _ }) => {
+		let [v, y, b] = getSimpleBezierPath({
+			sourceX: n,
+			sourceY: r,
+			sourcePosition: o,
+			targetX: i,
+			targetY: a,
+			targetPosition: s
+		});
+		return jsx(BaseEdge, {
+			id: e.isInternal ? void 0 : t,
+			path: v,
+			labelX: y,
+			labelY: b,
+			label: c,
+			labelStyle: l,
+			labelShowBg: u,
+			labelBgStyle: d,
+			labelBgPadding: f,
+			labelBgBorderRadius: p,
+			style: m,
+			markerEnd: h,
+			markerStart: g,
+			interactionWidth: _
+		});
+	});
+}
+var SimpleBezierEdge = createSimpleBezierEdge({ isInternal: !1 }), SimpleBezierEdgeInternal = createSimpleBezierEdge({ isInternal: !0 });
+SimpleBezierEdge.displayName = "SimpleBezierEdge", SimpleBezierEdgeInternal.displayName = "SimpleBezierEdgeInternal";
+function createSmoothStepEdge(e) {
+	return memo(({ id: t, sourceX: n, sourceY: r, targetX: i, targetY: o, label: s, labelStyle: c, labelShowBg: l, labelBgStyle: u, labelBgPadding: d, labelBgBorderRadius: f, style: p, sourcePosition: m = Position.Bottom, targetPosition: h = Position.Top, markerEnd: g, markerStart: _, pathOptions: v, interactionWidth: y }) => {
+		let [b, x, S] = getSmoothStepPath({
+			sourceX: n,
+			sourceY: r,
+			sourcePosition: m,
+			targetX: i,
+			targetY: o,
+			targetPosition: h,
+			borderRadius: v?.borderRadius,
+			offset: v?.offset,
+			stepPosition: v?.stepPosition
+		});
+		return jsx(BaseEdge, {
+			id: e.isInternal ? void 0 : t,
+			path: b,
+			labelX: x,
+			labelY: S,
+			label: s,
+			labelStyle: c,
+			labelShowBg: l,
+			labelBgStyle: u,
+			labelBgPadding: d,
+			labelBgBorderRadius: f,
+			style: p,
+			markerEnd: g,
+			markerStart: _,
+			interactionWidth: y
+		});
+	});
+}
+var SmoothStepEdge = createSmoothStepEdge({ isInternal: !1 }), SmoothStepEdgeInternal = createSmoothStepEdge({ isInternal: !0 });
+SmoothStepEdge.displayName = "SmoothStepEdge", SmoothStepEdgeInternal.displayName = "SmoothStepEdgeInternal";
+function createStepEdge(e) {
+	return memo(({ id: t, ...n }) => {
+		let r = e.isInternal ? void 0 : t;
+		return jsx(SmoothStepEdge, {
+			...n,
+			id: r,
+			pathOptions: useMemo(() => ({
+				borderRadius: 0,
+				offset: n.pathOptions?.offset
+			}), [n.pathOptions?.offset])
+		});
+	});
+}
+var StepEdge = createStepEdge({ isInternal: !1 }), StepEdgeInternal = createStepEdge({ isInternal: !0 });
+StepEdge.displayName = "StepEdge", StepEdgeInternal.displayName = "StepEdgeInternal";
+function createStraightEdge(e) {
+	return memo(({ id: t, sourceX: n, sourceY: r, targetX: i, targetY: a, label: o, labelStyle: s, labelShowBg: c, labelBgStyle: l, labelBgPadding: u, labelBgBorderRadius: d, style: f, markerEnd: p, markerStart: m, interactionWidth: h }) => {
+		let [g, _, v] = getStraightPath({
+			sourceX: n,
+			sourceY: r,
+			targetX: i,
+			targetY: a
+		});
+		return jsx(BaseEdge, {
+			id: e.isInternal ? void 0 : t,
+			path: g,
+			labelX: _,
+			labelY: v,
+			label: o,
+			labelStyle: s,
+			labelShowBg: c,
+			labelBgStyle: l,
+			labelBgPadding: u,
+			labelBgBorderRadius: d,
+			style: f,
+			markerEnd: p,
+			markerStart: m,
+			interactionWidth: h
+		});
+	});
+}
+var StraightEdge = createStraightEdge({ isInternal: !1 }), StraightEdgeInternal = createStraightEdge({ isInternal: !0 });
+StraightEdge.displayName = "StraightEdge", StraightEdgeInternal.displayName = "StraightEdgeInternal";
+function createBezierEdge(e) {
+	return memo(({ id: t, sourceX: n, sourceY: r, targetX: i, targetY: o, sourcePosition: s = Position.Bottom, targetPosition: c = Position.Top, label: l, labelStyle: u, labelShowBg: d, labelBgStyle: f, labelBgPadding: p, labelBgBorderRadius: m, style: h, markerEnd: g, markerStart: _, pathOptions: v, interactionWidth: y }) => {
+		let [b, x, S] = getBezierPath({
+			sourceX: n,
+			sourceY: r,
+			sourcePosition: s,
+			targetX: i,
+			targetY: o,
+			targetPosition: c,
+			curvature: v?.curvature
+		});
+		return jsx(BaseEdge, {
+			id: e.isInternal ? void 0 : t,
+			path: b,
+			labelX: x,
+			labelY: S,
+			label: l,
+			labelStyle: u,
+			labelShowBg: d,
+			labelBgStyle: f,
+			labelBgPadding: p,
+			labelBgBorderRadius: m,
+			style: h,
+			markerEnd: g,
+			markerStart: _,
+			interactionWidth: y
+		});
+	});
+}
+var BezierEdge = createBezierEdge({ isInternal: !1 }), BezierEdgeInternal = createBezierEdge({ isInternal: !0 });
+BezierEdge.displayName = "BezierEdge", BezierEdgeInternal.displayName = "BezierEdgeInternal";
+var builtinEdgeTypes = {
+	default: BezierEdgeInternal,
+	straight: StraightEdgeInternal,
+	step: StepEdgeInternal,
+	smoothstep: SmoothStepEdgeInternal,
+	simplebezier: SimpleBezierEdgeInternal
+}, nullPosition = {
+	sourceX: null,
+	sourceY: null,
+	targetX: null,
+	targetY: null,
+	sourcePosition: null,
+	targetPosition: null
+}, shiftX = (e, t, n) => n === Position.Left ? e - t : n === Position.Right ? e + t : e, shiftY = (e, t, n) => n === Position.Top ? e - t : n === Position.Bottom ? e + t : e, EdgeUpdaterClassName = "react-flow__edgeupdater";
+function EdgeAnchor({ position: t, centerX: n, centerY: r, radius: i = 10, onMouseDown: a, onMouseEnter: o, onMouseOut: s, type: c }) {
+	return jsx("circle", {
+		onMouseDown: a,
+		onMouseEnter: o,
+		onMouseOut: s,
+		className: cc([EdgeUpdaterClassName, `${EdgeUpdaterClassName}-${c}`]),
+		cx: shiftX(n, i, t),
+		cy: shiftY(r, i, t),
+		r: i,
+		stroke: "transparent",
+		fill: "transparent"
+	});
+}
+function EdgeUpdateAnchors({ isReconnectable: e, reconnectRadius: t, edge: n, sourceX: r, sourceY: i, targetX: a, targetY: o, sourcePosition: s, targetPosition: c, onReconnect: u, onReconnectStart: d, onReconnectEnd: f, setReconnecting: p, setUpdateHover: m }) {
+	let h = useStoreApi(), g = (e, t) => {
+		if (e.button !== 0) return;
+		let { autoPanOnConnect: r, domNode: i, connectionMode: a, connectionRadius: o, lib: s, onConnectStart: c, cancelConnection: m, nodeLookup: g, rfId: _, panBy: v, updateConnection: y } = h.getState(), b = t.type === "target";
+		XYHandle.onPointerDown(e.nativeEvent, {
+			autoPanOnConnect: r,
+			connectionMode: a,
+			connectionRadius: o,
+			domNode: i,
+			handleId: t.id,
+			nodeId: t.nodeId,
+			nodeLookup: g,
+			isTarget: b,
+			edgeUpdaterType: t.type,
+			lib: s,
+			flowId: _,
+			cancelConnection: m,
+			panBy: v,
+			isValidConnection: (...e) => h.getState().isValidConnection?.(...e) ?? !0,
+			onConnect: (e) => u?.(n, e),
+			onConnectStart: (r, i) => {
+				p(!0), d?.(e, n, t.type), c?.(r, i);
+			},
+			onConnectEnd: (...e) => h.getState().onConnectEnd?.(...e),
+			onReconnectEnd: (e, r) => {
+				p(!1), f?.(e, n, t.type, r);
+			},
+			updateConnection: y,
+			getTransform: () => h.getState().transform,
+			getFromHandle: () => h.getState().connection.fromHandle,
+			dragThreshold: h.getState().connectionDragThreshold,
+			handleDomNode: e.currentTarget
+		});
+	}, _ = (e) => g(e, {
+		nodeId: n.target,
+		id: n.targetHandle ?? null,
+		type: "target"
+	}), v = (e) => g(e, {
+		nodeId: n.source,
+		id: n.sourceHandle ?? null,
+		type: "source"
+	}), y = () => m(!0), b = () => m(!1);
+	return jsxs(Fragment$1, { children: [(e === !0 || e === "source") && jsx(EdgeAnchor, {
+		position: s,
+		centerX: r,
+		centerY: i,
+		radius: t,
+		onMouseDown: _,
+		onMouseEnter: y,
+		onMouseOut: b,
+		type: "source"
+	}), (e === !0 || e === "target") && jsx(EdgeAnchor, {
+		position: c,
+		centerX: a,
+		centerY: o,
+		radius: t,
+		onMouseDown: v,
+		onMouseEnter: y,
+		onMouseOut: b,
+		type: "target"
+	})] });
+}
+function EdgeWrapper({ id: t, edgesFocusable: n, edgesReconnectable: r, elementsSelectable: i, onClick: a, onDoubleClick: o, onContextMenu: s, onMouseEnter: c, onMouseMove: l, onMouseLeave: u, reconnectRadius: d, onReconnect: f, onReconnectStart: p, onReconnectEnd: m, rfId: h, edgeTypes: g, noPanClassName: _, onError: v, disableKeyboardA11y: y }) {
+	let S = useStore((e) => e.edgeLookup.get(t)), C = useStore((e) => e.defaultEdgeOptions);
+	S = C ? {
+		...C,
+		...S
+	} : S;
+	let w = S.type || "default", T = g?.[w] || builtinEdgeTypes[w];
+	T === void 0 && (v?.("011", errorMessages.error011(w)), w = "default", T = g?.default || builtinEdgeTypes.default);
+	let E = !!(S.focusable || n && S.focusable === void 0), D = f !== void 0 && (S.reconnectable || r && S.reconnectable === void 0), O = !!(S.selectable || i && S.selectable === void 0), k = useRef(null), [A, M] = useState(!1), [P, F] = useState(!1), I = useStoreApi(), { zIndex: L, sourceX: z, sourceY: B, targetX: V, targetY: H, sourcePosition: U, targetPosition: W } = useStore(useCallback((e) => {
+		let n = e.nodeLookup.get(S.source), r = e.nodeLookup.get(S.target);
+		if (!n || !r) return {
+			zIndex: S.zIndex,
+			...nullPosition
+		};
+		let i = getEdgePosition({
+			id: t,
+			sourceNode: n,
+			targetNode: r,
+			sourceHandle: S.sourceHandle || null,
+			targetHandle: S.targetHandle || null,
+			connectionMode: e.connectionMode,
+			onError: v
+		});
+		return {
+			zIndex: getElevatedEdgeZIndex({
+				selected: S.selected,
+				zIndex: S.zIndex,
+				sourceNode: n,
+				targetNode: r,
+				elevateOnSelect: e.elevateEdgesOnSelect,
+				zIndexMode: e.zIndexMode
+			}),
+			...i || nullPosition
+		};
+	}, [
+		S.source,
+		S.target,
+		S.sourceHandle,
+		S.targetHandle,
+		S.selected,
+		S.zIndex
+	]), shallow), G = useMemo(() => S.markerStart ? `url('#${getMarkerId(S.markerStart, h)}')` : void 0, [S.markerStart, h]), K = useMemo(() => S.markerEnd ? `url('#${getMarkerId(S.markerEnd, h)}')` : void 0, [S.markerEnd, h]);
+	if (S.hidden || z === null || B === null || V === null || H === null) return null;
+	let q = (e) => {
+		let { addSelectedEdges: n, unselectNodesAndEdges: r, multiSelectionActive: i } = I.getState();
+		O && (I.setState({ nodesSelectionActive: !1 }), S.selected && i ? (r({
+			nodes: [],
+			edges: [S]
+		}), k.current?.blur()) : n([t])), a && a(e, S);
+	}, J = o ? (e) => {
+		o(e, { ...S });
+	} : void 0, Y = s ? (e) => {
+		s(e, { ...S });
+	} : void 0, X = c ? (e) => {
+		c(e, { ...S });
+	} : void 0, Z = l ? (e) => {
+		l(e, { ...S });
+	} : void 0, Vn = u ? (e) => {
+		u(e, { ...S });
+	} : void 0;
+	return jsx("svg", {
+		style: { zIndex: L },
+		children: jsxs("g", {
+			className: cc([
+				"react-flow__edge",
+				`react-flow__edge-${w}`,
+				S.className,
+				_,
+				{
+					selected: S.selected,
+					animated: S.animated,
+					inactive: !O && !a,
+					updating: A,
+					selectable: O
+				}
+			]),
+			onClick: q,
+			onDoubleClick: J,
+			onContextMenu: Y,
+			onMouseEnter: X,
+			onMouseMove: Z,
+			onMouseLeave: Vn,
+			onKeyDown: E ? (e) => {
+				if (!y && elementSelectionKeys.includes(e.key) && O) {
+					let { unselectNodesAndEdges: n, addSelectedEdges: r } = I.getState();
+					e.key === "Escape" ? (k.current?.blur(), n({ edges: [S] })) : r([t]);
+				}
+			} : void 0,
+			tabIndex: E ? 0 : void 0,
+			role: S.ariaRole ?? (E ? "group" : "img"),
+			"aria-roledescription": "edge",
+			"data-id": t,
+			"data-testid": `rf__edge-${t}`,
+			"aria-label": S.ariaLabel === null ? void 0 : S.ariaLabel || `Edge from ${S.source} to ${S.target}`,
+			"aria-describedby": E ? `${ARIA_EDGE_DESC_KEY}-${h}` : void 0,
+			ref: k,
+			...S.domAttributes,
+			children: [!P && jsx(T, {
+				id: t,
+				source: S.source,
+				target: S.target,
+				type: S.type,
+				selected: S.selected,
+				animated: S.animated,
+				selectable: O,
+				deletable: S.deletable ?? !0,
+				label: S.label,
+				labelStyle: S.labelStyle,
+				labelShowBg: S.labelShowBg,
+				labelBgStyle: S.labelBgStyle,
+				labelBgPadding: S.labelBgPadding,
+				labelBgBorderRadius: S.labelBgBorderRadius,
+				sourceX: z,
+				sourceY: B,
+				targetX: V,
+				targetY: H,
+				sourcePosition: U,
+				targetPosition: W,
+				data: S.data,
+				style: S.style,
+				sourceHandleId: S.sourceHandle,
+				targetHandleId: S.targetHandle,
+				markerStart: G,
+				markerEnd: K,
+				pathOptions: "pathOptions" in S ? S.pathOptions : void 0,
+				interactionWidth: S.interactionWidth
+			}), D && jsx(EdgeUpdateAnchors, {
+				edge: S,
+				isReconnectable: D,
+				reconnectRadius: d,
+				onReconnect: f,
+				onReconnectStart: p,
+				onReconnectEnd: m,
+				sourceX: z,
+				sourceY: B,
+				targetX: V,
+				targetY: H,
+				sourcePosition: U,
+				targetPosition: W,
+				setUpdateHover: M,
+				setReconnecting: F
+			})]
+		})
+	});
+}
+var EdgeWrapper$1 = memo(EdgeWrapper), selector$a = (e) => ({
+	edgesFocusable: e.edgesFocusable,
+	edgesReconnectable: e.edgesReconnectable,
+	elementsSelectable: e.elementsSelectable,
+	connectionMode: e.connectionMode,
+	onError: e.onError
+});
+function EdgeRendererComponent({ defaultMarkerColor: e, onlyRenderVisibleElements: t, rfId: n, edgeTypes: r, noPanClassName: i, onReconnect: a, onEdgeContextMenu: o, onEdgeMouseEnter: s, onEdgeMouseMove: c, onEdgeMouseLeave: l, onEdgeClick: u, reconnectRadius: d, onEdgeDoubleClick: f, onReconnectStart: p, onReconnectEnd: m, disableKeyboardA11y: h }) {
+	let { edgesFocusable: g, edgesReconnectable: _, elementsSelectable: v, onError: y } = useStore(selector$a, shallow), b = useVisibleEdgeIds(t);
+	return jsxs("div", {
+		className: "react-flow__edges",
+		children: [jsx(MarkerDefinitions$1, {
+			defaultColor: e,
+			rfId: n
+		}), b.map((e) => jsx(EdgeWrapper$1, {
+			id: e,
+			edgesFocusable: g,
+			edgesReconnectable: _,
+			elementsSelectable: v,
+			noPanClassName: i,
+			onReconnect: a,
+			onContextMenu: o,
+			onMouseEnter: s,
+			onMouseMove: c,
+			onMouseLeave: l,
+			onClick: u,
+			reconnectRadius: d,
+			onDoubleClick: f,
+			onReconnectStart: p,
+			onReconnectEnd: m,
+			rfId: n,
+			onError: y,
+			edgeTypes: r,
+			disableKeyboardA11y: h
+		}, e))]
+	});
+}
+EdgeRendererComponent.displayName = "EdgeRenderer";
+var EdgeRenderer = memo(EdgeRendererComponent), selector$9 = (e) => `translate(${e.transform[0]}px,${e.transform[1]}px) scale(${e.transform[2]})`;
+function Viewport({ children: e }) {
+	return jsx("div", {
+		className: "react-flow__viewport xyflow__viewport react-flow__container",
+		style: { transform: useStore(selector$9) },
+		children: e
+	});
+}
+function useOnInitHandler(e) {
+	let t = useReactFlow(), n = useRef(!1);
+	useEffect(() => {
+		!n.current && t.viewportInitialized && e && (setTimeout(() => e(t), 1), n.current = !0);
+	}, [e, t.viewportInitialized]);
+}
+var selector$8 = (e) => e.panZoom?.syncViewport;
+function useViewportSync(e) {
+	let t = useStore(selector$8), n = useStoreApi();
+	return useEffect(() => {
+		e && (t?.(e), n.setState({ transform: [
+			e.x,
+			e.y,
+			e.zoom
+		] }));
+	}, [e, t]), null;
+}
+function storeSelector$1(e) {
+	return e.connection.inProgress ? {
+		...e.connection,
+		to: pointToRendererPoint(e.connection.to, e.transform)
+	} : { ...e.connection };
+}
+function getSelector(e) {
+	return e ? (t) => e(storeSelector$1(t)) : storeSelector$1;
+}
+function useConnection(e) {
+	return useStore(getSelector(e), shallow);
+}
+var selector$7 = (e) => ({
+	nodesConnectable: e.nodesConnectable,
+	isValid: e.connection.isValid,
+	inProgress: e.connection.inProgress,
+	width: e.width,
+	height: e.height
+});
+function ConnectionLineWrapper({ containerStyle: t, style: n, type: r, component: i }) {
+	let { nodesConnectable: a, width: o, height: s, isValid: c, inProgress: l } = useStore(selector$7, shallow);
+	return o && a && l ? jsx("svg", {
+		style: t,
+		width: o,
+		height: s,
+		className: "react-flow__connectionline react-flow__container",
+		children: jsx("g", {
+			className: cc(["react-flow__connection", getConnectionStatus(c)]),
+			children: jsx(ConnectionLine, {
+				style: n,
+				type: r,
+				CustomComponent: i,
+				isValid: c
+			})
+		})
+	}) : null;
+}
+var ConnectionLine = ({ style: e, type: n = ConnectionLineType.Bezier, CustomComponent: r, isValid: i }) => {
+	let { inProgress: a, from: o, fromNode: s, fromHandle: c, fromPosition: l, to: u, toNode: d, toHandle: f, toPosition: p, pointer: m } = useConnection();
+	if (!a) return;
+	if (r) return jsx(r, {
+		connectionLineType: n,
+		connectionLineStyle: e,
+		fromNode: s,
+		fromHandle: c,
+		fromX: o.x,
+		fromY: o.y,
+		toX: u.x,
+		toY: u.y,
+		fromPosition: l,
+		toPosition: p,
+		connectionStatus: getConnectionStatus(i),
+		toNode: d,
+		toHandle: f,
+		pointer: m
+	});
+	let h = "", g = {
+		sourceX: o.x,
+		sourceY: o.y,
+		sourcePosition: l,
+		targetX: u.x,
+		targetY: u.y,
+		targetPosition: p
+	};
+	switch (n) {
+		case ConnectionLineType.Bezier:
+			[h] = getBezierPath(g);
+			break;
+		case ConnectionLineType.SimpleBezier:
+			[h] = getSimpleBezierPath(g);
+			break;
+		case ConnectionLineType.Step:
+			[h] = getSmoothStepPath({
+				...g,
+				borderRadius: 0
+			});
+			break;
+		case ConnectionLineType.SmoothStep:
+			[h] = getSmoothStepPath(g);
+			break;
+		default: [h] = getStraightPath(g);
+	}
+	return jsx("path", {
+		d: h,
+		fill: "none",
+		className: "react-flow__connection-path",
+		style: e
+	});
+};
+ConnectionLine.displayName = "ConnectionLine";
+var emptyTypes = {};
+function useNodeOrEdgeTypesWarning(e = emptyTypes) {
+	let t = useRef(e), n = useStoreApi();
+	useEffect(() => {
+		if (process.env.NODE_ENV === "development") {
+			let r = new Set([...Object.keys(t.current), ...Object.keys(e)]);
+			for (let i of r) if (t.current[i] !== e[i]) {
+				n.getState().onError?.("002", errorMessages.error002());
+				break;
+			}
+			t.current = e;
+		}
+	}, [e]);
+}
+function useStylesLoadedWarning() {
+	let e = useStoreApi(), t = useRef(!1);
+	useEffect(() => {
+		if (process.env.NODE_ENV === "development" && !t.current) {
+			let n = document.querySelector(".react-flow__pane");
+			n && window.getComputedStyle(n).zIndex !== "1" && e.getState().onError?.("013", errorMessages.error013("react")), t.current = !0;
+		}
+	}, []);
+}
+function GraphViewComponent({ nodeTypes: e, edgeTypes: t, onInit: n, onNodeClick: r, onEdgeClick: i, onNodeDoubleClick: a, onEdgeDoubleClick: o, onNodeMouseEnter: s, onNodeMouseMove: c, onNodeMouseLeave: l, onNodeContextMenu: u, onSelectionContextMenu: d, onSelectionStart: f, onSelectionEnd: p, connectionLineType: m, connectionLineStyle: h, connectionLineComponent: g, connectionLineContainerStyle: _, selectionKeyCode: v, selectionOnDrag: y, selectionMode: b, multiSelectionKeyCode: x, panActivationKeyCode: S, zoomActivationKeyCode: C, deleteKeyCode: w, onlyRenderVisibleElements: T, elementsSelectable: E, defaultViewport: D, translateExtent: O, minZoom: k, maxZoom: A, preventScrolling: j, defaultMarkerColor: M, zoomOnScroll: N, zoomOnPinch: P, panOnScroll: F, panOnScrollSpeed: I, panOnScrollMode: L, zoomOnDoubleClick: R, panOnDrag: z, onPaneClick: B, onPaneMouseEnter: V, onPaneMouseMove: H, onPaneMouseLeave: U, onPaneScroll: W, onPaneContextMenu: G, paneClickDistance: K, nodeClickDistance: q, onEdgeContextMenu: J, onEdgeMouseEnter: Y, onEdgeMouseMove: X, onEdgeMouseLeave: Z, reconnectRadius: Vn, onReconnect: Hn, onReconnectStart: Un, onReconnectEnd: Wn, noDragClassName: Gn, noWheelClassName: Kn, noPanClassName: Q, disableKeyboardA11y: $, nodeExtent: qn, rfId: Jn, viewport: Yn, onViewportChange: Xn }) {
+	return useNodeOrEdgeTypesWarning(e), useNodeOrEdgeTypesWarning(t), useStylesLoadedWarning(), useOnInitHandler(n), useViewportSync(Yn), jsx(FlowRenderer, {
+		onPaneClick: B,
+		onPaneMouseEnter: V,
+		onPaneMouseMove: H,
+		onPaneMouseLeave: U,
+		onPaneContextMenu: G,
+		onPaneScroll: W,
+		paneClickDistance: K,
+		deleteKeyCode: w,
+		selectionKeyCode: v,
+		selectionOnDrag: y,
+		selectionMode: b,
+		onSelectionStart: f,
+		onSelectionEnd: p,
+		multiSelectionKeyCode: x,
+		panActivationKeyCode: S,
+		zoomActivationKeyCode: C,
+		elementsSelectable: E,
+		zoomOnScroll: N,
+		zoomOnPinch: P,
+		zoomOnDoubleClick: R,
+		panOnScroll: F,
+		panOnScrollSpeed: I,
+		panOnScrollMode: L,
+		panOnDrag: z,
+		defaultViewport: D,
+		translateExtent: O,
+		minZoom: k,
+		maxZoom: A,
+		onSelectionContextMenu: d,
+		preventScrolling: j,
+		noDragClassName: Gn,
+		noWheelClassName: Kn,
+		noPanClassName: Q,
+		disableKeyboardA11y: $,
+		onViewportChange: Xn,
+		isControlledViewport: !!Yn,
+		children: jsxs(Viewport, { children: [
+			jsx(EdgeRenderer, {
+				edgeTypes: t,
+				onEdgeClick: i,
+				onEdgeDoubleClick: o,
+				onReconnect: Hn,
+				onReconnectStart: Un,
+				onReconnectEnd: Wn,
+				onlyRenderVisibleElements: T,
+				onEdgeContextMenu: J,
+				onEdgeMouseEnter: Y,
+				onEdgeMouseMove: X,
+				onEdgeMouseLeave: Z,
+				reconnectRadius: Vn,
+				defaultMarkerColor: M,
+				noPanClassName: Q,
+				disableKeyboardA11y: $,
+				rfId: Jn
+			}),
+			jsx(ConnectionLineWrapper, {
+				style: h,
+				type: m,
+				component: g,
+				containerStyle: _
+			}),
+			jsx("div", { className: "react-flow__edgelabel-renderer" }),
+			jsx(NodeRenderer, {
+				nodeTypes: e,
+				onNodeClick: r,
+				onNodeDoubleClick: a,
+				onNodeMouseEnter: s,
+				onNodeMouseMove: c,
+				onNodeMouseLeave: l,
+				onNodeContextMenu: u,
+				nodeClickDistance: q,
+				onlyRenderVisibleElements: T,
+				noPanClassName: Q,
+				noDragClassName: Gn,
+				disableKeyboardA11y: $,
+				nodeExtent: qn,
+				rfId: Jn
+			}),
+			jsx("div", { className: "react-flow__viewport-portal" })
+		] })
+	});
+}
+GraphViewComponent.displayName = "GraphView";
+var GraphView = memo(GraphViewComponent), getInitialState = ({ nodes: e, edges: t, defaultNodes: r, defaultEdges: i, width: a, height: o, fitView: s, fitViewOptions: c, minZoom: l = .5, maxZoom: u = 2, nodeOrigin: d, nodeExtent: f, zIndexMode: p = "basic" } = {}) => {
+	let h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = i ?? t ?? [], S = r ?? e ?? [], C = d ?? [0, 0], w = f ?? infiniteExtent;
+	updateConnectionLookup(_, b, x);
+	let T = adoptUserNodes(S, h, g, {
+		nodeOrigin: C,
+		nodeExtent: w,
+		zIndexMode: p
+	}), E = [
+		0,
+		0,
+		1
+	];
+	if (s && a && o) {
+		let { x: e, y: t, zoom: n } = getViewportForBounds(getInternalNodesBounds(h, { filter: (e) => !!((e.width || e.initialWidth) && (e.height || e.initialHeight)) }), a, o, l, u, c?.padding ?? .1);
+		E = [
+			e,
+			t,
+			n
+		];
+	}
+	return {
+		rfId: "1",
+		width: a ?? 0,
+		height: o ?? 0,
+		transform: E,
+		nodes: S,
+		nodesInitialized: T,
+		nodeLookup: h,
+		parentLookup: g,
+		edges: x,
+		edgeLookup: b,
+		connectionLookup: _,
+		onNodesChange: null,
+		onEdgesChange: null,
+		hasDefaultNodes: r !== void 0,
+		hasDefaultEdges: i !== void 0,
+		panZoom: null,
+		minZoom: l,
+		maxZoom: u,
+		translateExtent: infiniteExtent,
+		nodeExtent: w,
+		nodesSelectionActive: !1,
+		userSelectionActive: !1,
+		userSelectionRect: null,
+		connectionMode: ConnectionMode.Strict,
+		domNode: null,
+		paneDragging: !1,
+		noPanClassName: "nopan",
+		nodeOrigin: C,
+		nodeDragThreshold: 1,
+		connectionDragThreshold: 1,
+		snapGrid: [15, 15],
+		snapToGrid: !1,
+		nodesDraggable: !0,
+		nodesConnectable: !0,
+		nodesFocusable: !0,
+		edgesFocusable: !0,
+		edgesReconnectable: !0,
+		elementsSelectable: !0,
+		elevateNodesOnSelect: !0,
+		elevateEdgesOnSelect: !0,
+		selectNodesOnDrag: !0,
+		multiSelectionActive: !1,
+		fitViewQueued: s ?? !1,
+		fitViewOptions: c,
+		fitViewResolver: null,
+		connection: { ...initialConnection },
+		connectionClickStartHandle: null,
+		connectOnClick: !0,
+		ariaLiveMessage: "",
+		autoPanOnConnect: !0,
+		autoPanOnNodeDrag: !0,
+		autoPanOnNodeFocus: !0,
+		autoPanSpeed: 15,
+		connectionRadius: 20,
+		onError: devWarn,
+		isValidConnection: void 0,
+		onSelectionChangeHandlers: [],
+		lib: "react",
+		debug: !1,
+		ariaLabelConfig: defaultAriaLabelConfig,
+		zIndexMode: p,
+		onNodesChangeMiddlewareMap: /* @__PURE__ */ new Map(),
+		onEdgesChangeMiddlewareMap: /* @__PURE__ */ new Map()
+	};
+}, createStore = ({ nodes: e, edges: t, defaultNodes: n, defaultEdges: r, width: i, height: o, fitView: s, fitViewOptions: c, minZoom: l, maxZoom: u, nodeOrigin: d, nodeExtent: f, zIndexMode: p }) => createWithEqualityFn((h, g) => {
+	async function _() {
+		let { nodeLookup: e, panZoom: t, fitViewOptions: n, fitViewResolver: r, width: i, height: a, minZoom: o, maxZoom: s } = g();
+		t && (await fitViewport({
+			nodes: e,
+			width: i,
+			height: a,
+			panZoom: t,
+			minZoom: o,
+			maxZoom: s
+		}, n), r?.resolve(!0), h({ fitViewResolver: null }));
+	}
+	return {
+		...getInitialState({
+			nodes: e,
+			edges: t,
+			width: i,
+			height: o,
+			fitView: s,
+			fitViewOptions: c,
+			minZoom: l,
+			maxZoom: u,
+			nodeOrigin: d,
+			nodeExtent: f,
+			defaultNodes: n,
+			defaultEdges: r,
+			zIndexMode: p
+		}),
+		setNodes: (e) => {
+			let { nodeLookup: t, parentLookup: n, nodeOrigin: r, elevateNodesOnSelect: i, fitViewQueued: a, zIndexMode: o } = g(), s = adoptUserNodes(e, t, n, {
+				nodeOrigin: r,
+				nodeExtent: f,
+				elevateNodesOnSelect: i,
+				checkEquality: !0,
+				zIndexMode: o
+			});
+			a && s ? (_(), h({
+				nodes: e,
+				nodesInitialized: s,
+				fitViewQueued: !1,
+				fitViewOptions: void 0
+			})) : h({
+				nodes: e,
+				nodesInitialized: s
+			});
+		},
+		setEdges: (e) => {
+			let { connectionLookup: t, edgeLookup: n } = g();
+			updateConnectionLookup(t, n, e), h({ edges: e });
+		},
+		setDefaultNodesAndEdges: (e, t) => {
+			if (e) {
+				let { setNodes: t } = g();
+				t(e), h({ hasDefaultNodes: !0 });
+			}
+			if (t) {
+				let { setEdges: e } = g();
+				e(t), h({ hasDefaultEdges: !0 });
+			}
+		},
+		updateNodeInternals: (e) => {
+			let { triggerNodeChanges: t, nodeLookup: n, parentLookup: r, domNode: i, nodeOrigin: a, nodeExtent: o, debug: s, fitViewQueued: c, zIndexMode: l } = g(), { changes: u, updatedInternals: d } = updateNodeInternals(e, n, r, i, a, o, l);
+			d && (updateAbsolutePositions(n, r, {
+				nodeOrigin: a,
+				nodeExtent: o,
+				zIndexMode: l
+			}), c ? (_(), h({
+				fitViewQueued: !1,
+				fitViewOptions: void 0
+			})) : h({}), u?.length > 0 && (s && console.log("React Flow: trigger node changes", u), t?.(u)));
+		},
+		updateNodePositions: (e, t = !1) => {
+			let n = [], r = [], { nodeLookup: i, triggerNodeChanges: o, connection: s, updateConnection: c, onNodesChangeMiddlewareMap: l } = g();
+			for (let [o, l] of e) {
+				let e = i.get(o), u = !!(e?.expandParent && e?.parentId && l?.position), d = {
+					id: o,
+					type: "position",
+					position: u ? {
+						x: Math.max(0, l.position.x),
+						y: Math.max(0, l.position.y)
+					} : l.position,
+					dragging: t
+				};
+				if (e && s.inProgress && s.fromNode.id === e.id) {
+					let t = getHandlePosition(e, s.fromHandle, Position.Left, !0);
+					c({
+						...s,
+						from: t
+					});
+				}
+				u && e.parentId && n.push({
+					id: o,
+					parentId: e.parentId,
+					rect: {
+						...l.internals.positionAbsolute,
+						width: l.measured.width ?? 0,
+						height: l.measured.height ?? 0
+					}
+				}), r.push(d);
+			}
+			if (n.length > 0) {
+				let { parentLookup: e, nodeOrigin: t } = g(), a = handleExpandParent(n, i, e, t);
+				r.push(...a);
+			}
+			for (let e of l.values()) r = e(r);
+			o(r);
+		},
+		triggerNodeChanges: (e) => {
+			let { onNodesChange: t, setNodes: n, nodes: r, hasDefaultNodes: i, debug: a } = g();
+			e?.length && (i && n(applyNodeChanges(e, r)), a && console.log("React Flow: trigger node changes", e), t?.(e));
+		},
+		triggerEdgeChanges: (e) => {
+			let { onEdgesChange: t, setEdges: n, edges: r, hasDefaultEdges: i, debug: a } = g();
+			e?.length && (i && n(applyEdgeChanges(e, r)), a && console.log("React Flow: trigger edge changes", e), t?.(e));
+		},
+		addSelectedNodes: (e) => {
+			let { multiSelectionActive: t, edgeLookup: n, nodeLookup: r, triggerNodeChanges: i, triggerEdgeChanges: a } = g();
+			if (t) {
+				i(e.map((e) => createSelectionChange(e, !0)));
+				return;
+			}
+			i(getSelectionChanges(r, new Set([...e]), !0)), a(getSelectionChanges(n));
+		},
+		addSelectedEdges: (e) => {
+			let { multiSelectionActive: t, edgeLookup: n, nodeLookup: r, triggerNodeChanges: i, triggerEdgeChanges: a } = g();
+			if (t) {
+				a(e.map((e) => createSelectionChange(e, !0)));
+				return;
+			}
+			a(getSelectionChanges(n, new Set([...e]))), i(getSelectionChanges(r, /* @__PURE__ */ new Set(), !0));
+		},
+		unselectNodesAndEdges: ({ nodes: e, edges: t } = {}) => {
+			let { edges: n, nodes: r, nodeLookup: i, triggerNodeChanges: a, triggerEdgeChanges: o } = g(), s = e || r, c = t || n, l = [];
+			for (let e of s) {
+				if (!e.selected) continue;
+				let t = i.get(e.id);
+				t && (t.selected = !1), l.push(createSelectionChange(e.id, !1));
+			}
+			let u = [];
+			for (let e of c) e.selected && u.push(createSelectionChange(e.id, !1));
+			a(l), o(u);
+		},
+		setMinZoom: (e) => {
+			let { panZoom: t, maxZoom: n } = g();
+			t?.setScaleExtent([e, n]), h({ minZoom: e });
+		},
+		setMaxZoom: (e) => {
+			let { panZoom: t, minZoom: n } = g();
+			t?.setScaleExtent([n, e]), h({ maxZoom: e });
+		},
+		setTranslateExtent: (e) => {
+			g().panZoom?.setTranslateExtent(e), h({ translateExtent: e });
+		},
+		resetSelectedElements: () => {
+			let { edges: e, nodes: t, triggerNodeChanges: n, triggerEdgeChanges: r, elementsSelectable: i } = g();
+			if (!i) return;
+			let a = t.reduce((e, t) => t.selected ? [...e, createSelectionChange(t.id, !1)] : e, []), o = e.reduce((e, t) => t.selected ? [...e, createSelectionChange(t.id, !1)] : e, []);
+			n(a), r(o);
+		},
+		setNodeExtent: (e) => {
+			let { nodes: t, nodeLookup: n, parentLookup: r, nodeOrigin: i, elevateNodesOnSelect: a, nodeExtent: o, zIndexMode: s } = g();
+			e[0][0] === o[0][0] && e[0][1] === o[0][1] && e[1][0] === o[1][0] && e[1][1] === o[1][1] || (adoptUserNodes(t, n, r, {
+				nodeOrigin: i,
+				nodeExtent: e,
+				elevateNodesOnSelect: a,
+				checkEquality: !1,
+				zIndexMode: s
+			}), h({ nodeExtent: e }));
+		},
+		panBy: (e) => {
+			let { transform: t, width: n, height: r, panZoom: i, translateExtent: a } = g();
+			return panBy({
+				delta: e,
+				panZoom: i,
+				transform: t,
+				translateExtent: a,
+				width: n,
+				height: r
+			});
+		},
+		setCenter: async (e, t, n) => {
+			let { width: r, height: i, maxZoom: a, panZoom: o } = g();
+			if (!o) return Promise.resolve(!1);
+			let s = n?.zoom === void 0 ? a : n.zoom;
+			return await o.setViewport({
+				x: r / 2 - e * s,
+				y: i / 2 - t * s,
+				zoom: s
+			}, {
+				duration: n?.duration,
+				ease: n?.ease,
+				interpolate: n?.interpolate
+			}), Promise.resolve(!0);
+		},
+		cancelConnection: () => {
+			h({ connection: { ...initialConnection } });
+		},
+		updateConnection: (e) => {
+			h({ connection: e });
+		},
+		reset: () => h({ ...getInitialState() })
+	};
+}, Object.is);
+function ReactFlowProvider({ initialNodes: e, initialEdges: t, defaultNodes: n, defaultEdges: r, initialWidth: i, initialHeight: a, initialMinZoom: o, initialMaxZoom: s, initialFitViewOptions: c, fitView: l, nodeOrigin: u, nodeExtent: d, zIndexMode: f, children: p }) {
+	let [m] = useState(() => createStore({
+		nodes: e,
+		edges: t,
+		defaultNodes: n,
+		defaultEdges: r,
+		width: i,
+		height: a,
+		fitView: l,
+		minZoom: o,
+		maxZoom: s,
+		fitViewOptions: c,
+		nodeOrigin: u,
+		nodeExtent: d,
+		zIndexMode: f
+	}));
+	return jsx(Provider$1, {
+		value: m,
+		children: jsx(BatchProvider, { children: p })
+	});
+}
+function Wrapper({ children: e, nodes: t, edges: n, defaultNodes: r, defaultEdges: i, width: a, height: o, fitView: s, fitViewOptions: c, minZoom: l, maxZoom: u, nodeOrigin: d, nodeExtent: f, zIndexMode: p }) {
+	return useContext(StoreContext) ? jsx(Fragment$1, { children: e }) : jsx(ReactFlowProvider, {
+		initialNodes: t,
+		initialEdges: n,
+		defaultNodes: r,
+		defaultEdges: i,
+		initialWidth: a,
+		initialHeight: o,
+		fitView: s,
+		initialFitViewOptions: c,
+		initialMinZoom: l,
+		initialMaxZoom: u,
+		nodeOrigin: d,
+		nodeExtent: f,
+		zIndexMode: p,
+		children: e
+	});
+}
+var wrapperStyle = {
+	width: "100%",
+	height: "100%",
+	overflow: "hidden",
+	position: "relative",
+	zIndex: 0
+};
+function ReactFlow({ nodes: n, edges: r, defaultNodes: a, defaultEdges: o, className: c, nodeTypes: l, edgeTypes: u, onNodeClick: d, onEdgeClick: f, onInit: p, onMove: m, onMoveStart: h, onMoveEnd: g, onConnect: _, onConnectStart: v, onConnectEnd: y, onClickConnectStart: b, onClickConnectEnd: x, onNodeMouseEnter: S, onNodeMouseMove: C, onNodeMouseLeave: w, onNodeContextMenu: T, onNodeDoubleClick: E, onNodeDragStart: D, onNodeDrag: O, onNodeDragStop: k, onNodesDelete: A, onEdgesDelete: j, onDelete: M, onSelectionChange: N, onSelectionDragStart: P, onSelectionDrag: F, onSelectionDragStop: I, onSelectionContextMenu: L, onSelectionStart: R, onSelectionEnd: z, onBeforeDelete: B, connectionMode: V, connectionLineType: H = ConnectionLineType.Bezier, connectionLineStyle: U, connectionLineComponent: W, connectionLineContainerStyle: G, deleteKeyCode: K = "Backspace", selectionKeyCode: J = "Shift", selectionOnDrag: Y = !1, selectionMode: X = SelectionMode.Full, panActivationKeyCode: Z = "Space", multiSelectionKeyCode: Hn = isMacOs() ? "Meta" : "Control", zoomActivationKeyCode: Un = isMacOs() ? "Meta" : "Control", snapToGrid: Wn, snapGrid: Gn, onlyRenderVisibleElements: Kn = !1, selectNodesOnDrag: Q, nodesDraggable: $, autoPanOnNodeFocus: qn, nodesConnectable: Jn, nodesFocusable: Yn, nodeOrigin: Xn = defaultNodeOrigin, edgesFocusable: Zn, edgesReconnectable: Qn, elementsSelectable: $n = !0, defaultViewport: er = defaultViewport, minZoom: tr = .5, maxZoom: nr = 2, translateExtent: rr = infiniteExtent, preventScrolling: ir = !0, nodeExtent: ar, defaultMarkerColor: or = "#b1b1b7", zoomOnScroll: sr = !0, zoomOnPinch: cr = !0, panOnScroll: lr = !1, panOnScrollSpeed: ur = .5, panOnScrollMode: dr = PanOnScrollMode.Free, zoomOnDoubleClick: fr = !0, panOnDrag: pr = !0, onPaneClick: mr, onPaneMouseEnter: hr, onPaneMouseMove: gr, onPaneMouseLeave: _r, onPaneScroll: vr, onPaneContextMenu: yr, paneClickDistance: br = 1, nodeClickDistance: xr = 0, children: Sr, onReconnect: Cr, onReconnectStart: wr, onReconnectEnd: Tr, onEdgeContextMenu: Er, onEdgeDoubleClick: Dr, onEdgeMouseEnter: Or, onEdgeMouseMove: kr, onEdgeMouseLeave: Ar, reconnectRadius: jr = 10, onNodesChange: Mr, onEdgesChange: Nr, noDragClassName: Pr = "nodrag", noWheelClassName: Fr = "nowheel", noPanClassName: Ir = "nopan", fitView: Lr, fitViewOptions: Rr, connectOnClick: zr, attributionPosition: Br, proOptions: Vr, defaultEdgeOptions: Hr, elevateNodesOnSelect: Ur = !0, elevateEdgesOnSelect: Wr = !1, disableKeyboardA11y: Gr = !1, autoPanOnConnect: Kr, autoPanOnNodeDrag: qr, autoPanSpeed: Jr, connectionRadius: Yr, isValidConnection: Xr, onError: Zr, style: Qr, id: $r, nodeDragThreshold: ei, connectionDragThreshold: ti, viewport: ni, onViewportChange: ri, width: ii, height: ai, colorMode: oi = "light", debug: si, onScroll: ci, ariaLabelConfig: li, zIndexMode: ui = "basic", ...di }, fi) {
+	let pi = $r || "1", mi = useColorModeClass(oi), hi = useCallback((e) => {
+		e.currentTarget.scrollTo({
+			top: 0,
+			left: 0,
+			behavior: "instant"
+		}), ci?.(e);
+	}, [ci]);
+	return jsx("div", {
+		"data-testid": "rf__wrapper",
+		...di,
+		onScroll: hi,
+		style: {
+			...Qr,
+			...wrapperStyle
+		},
+		ref: fi,
+		className: cc([
+			"react-flow",
+			c,
+			mi
+		]),
+		id: $r,
+		role: "application",
+		children: jsxs(Wrapper, {
+			nodes: n,
+			edges: r,
+			width: ii,
+			height: ai,
+			fitView: Lr,
+			fitViewOptions: Rr,
+			minZoom: tr,
+			maxZoom: nr,
+			nodeOrigin: Xn,
+			nodeExtent: ar,
+			zIndexMode: ui,
+			children: [
+				jsx(GraphView, {
+					onInit: p,
+					onNodeClick: d,
+					onEdgeClick: f,
+					onNodeMouseEnter: S,
+					onNodeMouseMove: C,
+					onNodeMouseLeave: w,
+					onNodeContextMenu: T,
+					onNodeDoubleClick: E,
+					nodeTypes: l,
+					edgeTypes: u,
+					connectionLineType: H,
+					connectionLineStyle: U,
+					connectionLineComponent: W,
+					connectionLineContainerStyle: G,
+					selectionKeyCode: J,
+					selectionOnDrag: Y,
+					selectionMode: X,
+					deleteKeyCode: K,
+					multiSelectionKeyCode: Hn,
+					panActivationKeyCode: Z,
+					zoomActivationKeyCode: Un,
+					onlyRenderVisibleElements: Kn,
+					defaultViewport: er,
+					translateExtent: rr,
+					minZoom: tr,
+					maxZoom: nr,
+					preventScrolling: ir,
+					zoomOnScroll: sr,
+					zoomOnPinch: cr,
+					zoomOnDoubleClick: fr,
+					panOnScroll: lr,
+					panOnScrollSpeed: ur,
+					panOnScrollMode: dr,
+					panOnDrag: pr,
+					onPaneClick: mr,
+					onPaneMouseEnter: hr,
+					onPaneMouseMove: gr,
+					onPaneMouseLeave: _r,
+					onPaneScroll: vr,
+					onPaneContextMenu: yr,
+					paneClickDistance: br,
+					nodeClickDistance: xr,
+					onSelectionContextMenu: L,
+					onSelectionStart: R,
+					onSelectionEnd: z,
+					onReconnect: Cr,
+					onReconnectStart: wr,
+					onReconnectEnd: Tr,
+					onEdgeContextMenu: Er,
+					onEdgeDoubleClick: Dr,
+					onEdgeMouseEnter: Or,
+					onEdgeMouseMove: kr,
+					onEdgeMouseLeave: Ar,
+					reconnectRadius: jr,
+					defaultMarkerColor: or,
+					noDragClassName: Pr,
+					noWheelClassName: Fr,
+					noPanClassName: Ir,
+					rfId: pi,
+					disableKeyboardA11y: Gr,
+					nodeExtent: ar,
+					viewport: ni,
+					onViewportChange: ri
+				}),
+				jsx(StoreUpdater, {
+					nodes: n,
+					edges: r,
+					defaultNodes: a,
+					defaultEdges: o,
+					onConnect: _,
+					onConnectStart: v,
+					onConnectEnd: y,
+					onClickConnectStart: b,
+					onClickConnectEnd: x,
+					nodesDraggable: $,
+					autoPanOnNodeFocus: qn,
+					nodesConnectable: Jn,
+					nodesFocusable: Yn,
+					edgesFocusable: Zn,
+					edgesReconnectable: Qn,
+					elementsSelectable: $n,
+					elevateNodesOnSelect: Ur,
+					elevateEdgesOnSelect: Wr,
+					minZoom: tr,
+					maxZoom: nr,
+					nodeExtent: ar,
+					onNodesChange: Mr,
+					onEdgesChange: Nr,
+					snapToGrid: Wn,
+					snapGrid: Gn,
+					connectionMode: V,
+					translateExtent: rr,
+					connectOnClick: zr,
+					defaultEdgeOptions: Hr,
+					fitView: Lr,
+					fitViewOptions: Rr,
+					onNodesDelete: A,
+					onEdgesDelete: j,
+					onDelete: M,
+					onNodeDragStart: D,
+					onNodeDrag: O,
+					onNodeDragStop: k,
+					onSelectionDrag: F,
+					onSelectionDragStart: P,
+					onSelectionDragStop: I,
+					onMove: m,
+					onMoveStart: h,
+					onMoveEnd: g,
+					noPanClassName: Ir,
+					nodeOrigin: Xn,
+					rfId: pi,
+					autoPanOnConnect: Kr,
+					autoPanOnNodeDrag: qr,
+					autoPanSpeed: Jr,
+					onError: Zr,
+					connectionRadius: Yr,
+					isValidConnection: Xr,
+					selectNodesOnDrag: Q,
+					nodeDragThreshold: ei,
+					connectionDragThreshold: ti,
+					onBeforeDelete: B,
+					debug: si,
+					ariaLabelConfig: li,
+					zIndexMode: ui
+				}),
+				jsx(SelectionListener, { onSelectionChange: N }),
+				Sr,
+				jsx(Attribution, {
+					proOptions: Vr,
+					position: Br
+				}),
+				jsx(A11yDescriptions, {
+					rfId: pi,
+					disableKeyboardA11y: Gr
+				})
+			]
+		})
+	});
+}
+var index = fixedForwardRef(ReactFlow), selector$6 = (e) => e.domNode?.querySelector(".react-flow__edgelabel-renderer");
+function EdgeLabelRenderer({ children: e }) {
+	let t = useStore(selector$6);
+	return t ? createPortal(e, t) : null;
+}
+function useNodesState(e) {
+	let [t, n] = useState(e);
+	return [
+		t,
+		n,
+		useCallback((e) => n((t) => applyNodeChanges(e, t)), [])
+	];
+}
+function useEdgesState(e) {
+	let [t, n] = useState(e);
+	return [
+		t,
+		n,
+		useCallback((e) => n((t) => applyEdgeChanges(e, t)), [])
+	];
+}
+errorMessages.error014();
+function LinePattern({ dimensions: t, lineWidth: n, variant: r, className: i }) {
+	return jsx("path", {
+		strokeWidth: n,
+		d: `M${t[0] / 2} 0 V${t[1]} M0 ${t[1] / 2} H${t[0]}`,
+		className: cc([
+			"react-flow__background-pattern",
+			r,
+			i
+		])
+	});
+}
+function DotPattern({ radius: t, className: n }) {
+	return jsx("circle", {
+		cx: t,
+		cy: t,
+		r: t,
+		className: cc([
+			"react-flow__background-pattern",
+			"dots",
+			n
+		])
+	});
+}
+var BackgroundVariant;
+(function(e) {
+	e.Lines = "lines", e.Dots = "dots", e.Cross = "cross";
+})(BackgroundVariant ||= {});
+var defaultSize = {
+	[BackgroundVariant.Dots]: 1,
+	[BackgroundVariant.Lines]: 1,
+	[BackgroundVariant.Cross]: 6
+}, selector$3 = (e) => ({
+	transform: e.transform,
+	patternId: `pattern-${e.rfId}`
+});
+function BackgroundComponent({ id: t, variant: n = BackgroundVariant.Dots, gap: r = 20, size: i, lineWidth: a = 1, offset: o = 0, color: s, bgColor: c, style: l, className: u, patternClassName: d }) {
+	let f = useRef(null), { transform: p, patternId: m } = useStore(selector$3, shallow), h = i || defaultSize[n], g = n === BackgroundVariant.Dots, _ = n === BackgroundVariant.Cross, v = Array.isArray(r) ? r : [r, r], y = [v[0] * p[2] || 1, v[1] * p[2] || 1], b = h * p[2], x = Array.isArray(o) ? o : [o, o], S = _ ? [b, b] : y, C = [x[0] * p[2] || 1 + S[0] / 2, x[1] * p[2] || 1 + S[1] / 2], w = `${m}${t || ""}`;
+	return jsxs("svg", {
+		className: cc(["react-flow__background", u]),
+		style: {
+			...l,
+			...containerStyle,
+			"--xy-background-color-props": c,
+			"--xy-background-pattern-color-props": s
+		},
+		ref: f,
+		"data-testid": "rf__background",
+		children: [jsx("pattern", {
+			id: w,
+			x: p[0] % y[0],
+			y: p[1] % y[1],
+			width: y[0],
+			height: y[1],
+			patternUnits: "userSpaceOnUse",
+			patternTransform: `translate(-${C[0]},-${C[1]})`,
+			children: g ? jsx(DotPattern, {
+				radius: b / 2,
+				className: d
+			}) : jsx(LinePattern, {
+				dimensions: S,
+				lineWidth: a,
+				variant: n,
+				className: d
+			})
+		}), jsx("rect", {
+			x: "0",
+			y: "0",
+			width: "100%",
+			height: "100%",
+			fill: `url(#${w})`
+		})]
+	});
+}
+BackgroundComponent.displayName = "Background";
+var Background = memo(BackgroundComponent);
+function PlusIcon() {
+	return jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		viewBox: "0 0 32 32",
+		children: jsx("path", { d: "M32 18.133H18.133V32h-4.266V18.133H0v-4.266h13.867V0h4.266v13.867H32z" })
+	});
+}
+function MinusIcon() {
+	return jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		viewBox: "0 0 32 5",
+		children: jsx("path", { d: "M0 0h32v4.2H0z" })
+	});
+}
+function FitViewIcon() {
+	return jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		viewBox: "0 0 32 30",
+		children: jsx("path", { d: "M3.692 4.63c0-.53.4-.938.939-.938h5.215V0H4.708C2.13 0 0 2.054 0 4.63v5.216h3.692V4.631zM27.354 0h-5.2v3.692h5.17c.53 0 .984.4.984.939v5.215H32V4.631A4.624 4.624 0 0027.354 0zm.954 24.83c0 .532-.4.94-.939.94h-5.215v3.768h5.215c2.577 0 4.631-2.13 4.631-4.707v-5.139h-3.692v5.139zm-23.677.94c-.531 0-.939-.4-.939-.94v-5.138H0v5.139c0 2.577 2.13 4.707 4.708 4.707h5.138V25.77H4.631z" })
+	});
+}
+function LockIcon() {
+	return jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		viewBox: "0 0 25 32",
+		children: jsx("path", { d: "M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0 8 0 4.571 3.429 4.571 7.619v3.048H3.048A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047zm4.724-13.866H7.467V7.619c0-2.59 2.133-4.724 4.723-4.724 2.591 0 4.724 2.133 4.724 4.724v3.048z" })
+	});
+}
+function UnlockIcon() {
+	return jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		viewBox: "0 0 25 32",
+		children: jsx("path", { d: "M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0c-4.114 1.828-1.37 2.133.305 2.438 1.676.305 4.42 2.59 4.42 5.181v3.048H3.047A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047z" })
+	});
+}
+function ControlButton({ children: t, className: n, ...r }) {
+	return jsx("button", {
+		type: "button",
+		className: cc(["react-flow__controls-button", n]),
+		...r,
+		children: t
+	});
+}
+var selector$2 = (e) => ({
+	isInteractive: e.nodesDraggable || e.nodesConnectable || e.elementsSelectable,
+	minZoomReached: e.transform[2] <= e.minZoom,
+	maxZoomReached: e.transform[2] >= e.maxZoom,
+	ariaLabelConfig: e.ariaLabelConfig
+});
+function ControlsComponent({ style: t, showZoom: n = !0, showFitView: r = !0, showInteractive: i = !0, fitViewOptions: a, onZoomIn: o, onZoomOut: s, onFitView: c, onInteractiveChange: l, className: u, children: d, position: f = "bottom-left", orientation: p = "vertical", "aria-label": m }) {
+	let h = useStoreApi(), { isInteractive: g, minZoomReached: _, maxZoomReached: v, ariaLabelConfig: y } = useStore(selector$2, shallow), { zoomIn: b, zoomOut: x, fitView: S } = useReactFlow(), C = () => {
+		b(), o?.();
+	}, w = () => {
+		x(), s?.();
+	}, T = () => {
+		S(a), c?.();
+	}, E = () => {
+		h.setState({
+			nodesDraggable: !g,
+			nodesConnectable: !g,
+			elementsSelectable: !g
+		}), l?.(!g);
+	};
+	return jsxs(Panel, {
+		className: cc([
+			"react-flow__controls",
+			p === "horizontal" ? "horizontal" : "vertical",
+			u
+		]),
+		position: f,
+		style: t,
+		"data-testid": "rf__controls",
+		"aria-label": m ?? y["controls.ariaLabel"],
+		children: [
+			n && jsxs(Fragment$1, { children: [jsx(ControlButton, {
+				onClick: C,
+				className: "react-flow__controls-zoomin",
+				title: y["controls.zoomIn.ariaLabel"],
+				"aria-label": y["controls.zoomIn.ariaLabel"],
+				disabled: v,
+				children: jsx(PlusIcon, {})
+			}), jsx(ControlButton, {
+				onClick: w,
+				className: "react-flow__controls-zoomout",
+				title: y["controls.zoomOut.ariaLabel"],
+				"aria-label": y["controls.zoomOut.ariaLabel"],
+				disabled: _,
+				children: jsx(MinusIcon, {})
+			})] }),
+			r && jsx(ControlButton, {
+				className: "react-flow__controls-fitview",
+				onClick: T,
+				title: y["controls.fitView.ariaLabel"],
+				"aria-label": y["controls.fitView.ariaLabel"],
+				children: jsx(FitViewIcon, {})
+			}),
+			i && jsx(ControlButton, {
+				className: "react-flow__controls-interactive",
+				onClick: E,
+				title: y["controls.interactive.ariaLabel"],
+				"aria-label": y["controls.interactive.ariaLabel"],
+				children: jsx(g ? UnlockIcon : LockIcon, {})
+			}),
+			d
+		]
+	});
+}
+ControlsComponent.displayName = "Controls";
+var Controls = memo(ControlsComponent);
+function MiniMapNodeComponent({ id: t, x: n, y: r, width: i, height: a, style: o, color: s, strokeColor: c, strokeWidth: l, className: u, borderRadius: d, shapeRendering: f, selected: p, onClick: m }) {
+	let { background: h, backgroundColor: g } = o || {}, _ = s || h || g;
+	return jsx("rect", {
+		className: cc([
+			"react-flow__minimap-node",
+			{ selected: p },
+			u
+		]),
+		x: n,
+		y: r,
+		rx: d,
+		ry: d,
+		width: i,
+		height: a,
+		style: {
+			fill: _,
+			stroke: c,
+			strokeWidth: l
+		},
+		shapeRendering: f,
+		onClick: m ? (e) => m(e, t) : void 0
+	});
+}
+var MiniMapNode = memo(MiniMapNodeComponent), selectorNodeIds = (e) => e.nodes.map((e) => e.id), getAttrFunction = (e) => e instanceof Function ? e : () => e;
+function MiniMapNodes({ nodeStrokeColor: e, nodeColor: t, nodeClassName: n = "", nodeBorderRadius: r = 5, nodeStrokeWidth: i, nodeComponent: a = MiniMapNode, onClick: o }) {
+	let s = useStore(selectorNodeIds, shallow), c = getAttrFunction(t), l = getAttrFunction(e), u = getAttrFunction(n), d = typeof window > "u" || window.chrome ? "crispEdges" : "geometricPrecision";
+	return jsx(Fragment$1, { children: s.map((e) => jsx(NodeComponentWrapper, {
+		id: e,
+		nodeColorFunc: c,
+		nodeStrokeColorFunc: l,
+		nodeClassNameFunc: u,
+		nodeBorderRadius: r,
+		nodeStrokeWidth: i,
+		NodeComponent: a,
+		onClick: o,
+		shapeRendering: d
+	}, e)) });
+}
+function NodeComponentWrapperInner({ id: e, nodeColorFunc: t, nodeStrokeColorFunc: n, nodeClassNameFunc: r, nodeBorderRadius: i, nodeStrokeWidth: a, shapeRendering: o, NodeComponent: s, onClick: c }) {
+	let { node: l, x: u, y: d, width: f, height: p } = useStore((t) => {
+		let n = t.nodeLookup.get(e);
+		if (!n) return {
+			node: void 0,
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+		let r = n.internals.userNode, { x: i, y: a } = n.internals.positionAbsolute, { width: o, height: s } = getNodeDimensions(r);
+		return {
+			node: r,
+			x: i,
+			y: a,
+			width: o,
+			height: s
+		};
+	}, shallow);
+	return !l || l.hidden || !nodeHasDimensions(l) ? null : jsx(s, {
+		x: u,
+		y: d,
+		width: f,
+		height: p,
+		style: l.style,
+		selected: !!l.selected,
+		className: r(l),
+		color: t(l),
+		borderRadius: i,
+		strokeColor: n(l),
+		strokeWidth: a,
+		shapeRendering: o,
+		onClick: c,
+		id: l.id
+	});
+}
+var NodeComponentWrapper = memo(NodeComponentWrapperInner), MiniMapNodes$1 = memo(MiniMapNodes), defaultWidth = 200, defaultHeight = 150, filterHidden = (e) => !e.hidden, selector$1 = (e) => {
+	let t = {
+		x: -e.transform[0] / e.transform[2],
+		y: -e.transform[1] / e.transform[2],
+		width: e.width / e.transform[2],
+		height: e.height / e.transform[2]
+	};
+	return {
+		viewBB: t,
+		boundingRect: e.nodeLookup.size > 0 ? getBoundsOfRects(getInternalNodesBounds(e.nodeLookup, { filter: filterHidden }), t) : t,
+		rfId: e.rfId,
+		panZoom: e.panZoom,
+		translateExtent: e.translateExtent,
+		flowWidth: e.width,
+		flowHeight: e.height,
+		ariaLabelConfig: e.ariaLabelConfig
+	};
+}, ARIA_LABEL_KEY = "react-flow__minimap-desc";
+function MiniMapComponent({ style: t, className: n, nodeStrokeColor: r, nodeColor: i, nodeClassName: a = "", nodeBorderRadius: o = 5, nodeStrokeWidth: s, nodeComponent: c, bgColor: l, maskColor: d, maskStrokeColor: f, maskStrokeWidth: p, position: m = "bottom-right", onClick: h, onNodeClick: g, pannable: _ = !1, zoomable: v = !1, ariaLabel: y, inversePan: b, zoomStep: x = 1, offsetScale: S = 5 }) {
+	let C = useStoreApi(), w = useRef(null), { boundingRect: T, viewBB: E, rfId: D, panZoom: O, translateExtent: k, flowWidth: A, flowHeight: j, ariaLabelConfig: M } = useStore(selector$1, shallow), N = t?.width ?? defaultWidth, P = t?.height ?? defaultHeight, F = T.width / N, I = T.height / P, L = Math.max(F, I), R = L * N, z = L * P, B = S * L, V = T.x - (R - T.width) / 2 - B, H = T.y - (z - T.height) / 2 - B, U = R + B * 2, W = z + B * 2, G = `${ARIA_LABEL_KEY}-${D}`, K = useRef(0), q = useRef();
+	K.current = L, useEffect(() => {
+		if (w.current && O) return q.current = XYMinimap({
+			domNode: w.current,
+			panZoom: O,
+			getTransform: () => C.getState().transform,
+			getViewScale: () => K.current
+		}), () => {
+			q.current?.destroy();
+		};
+	}, [O]), useEffect(() => {
+		q.current?.update({
+			translateExtent: k,
+			width: A,
+			height: j,
+			inversePan: b,
+			pannable: _,
+			zoomStep: x,
+			zoomable: v
+		});
+	}, [
+		_,
+		v,
+		b,
+		x,
+		k,
+		A,
+		j
+	]);
+	let J = h ? (e) => {
+		let [t, n] = q.current?.pointer(e) || [0, 0];
+		h(e, {
+			x: t,
+			y: n
+		});
+	} : void 0, Y = g ? useCallback((e, t) => {
+		let n = C.getState().nodeLookup.get(t).internals.userNode;
+		g(e, n);
+	}, []) : void 0, X = y ?? M["minimap.ariaLabel"];
+	return jsx(Panel, {
+		position: m,
+		style: {
+			...t,
+			"--xy-minimap-background-color-props": typeof l == "string" ? l : void 0,
+			"--xy-minimap-mask-background-color-props": typeof d == "string" ? d : void 0,
+			"--xy-minimap-mask-stroke-color-props": typeof f == "string" ? f : void 0,
+			"--xy-minimap-mask-stroke-width-props": typeof p == "number" ? p * L : void 0,
+			"--xy-minimap-node-background-color-props": typeof i == "string" ? i : void 0,
+			"--xy-minimap-node-stroke-color-props": typeof r == "string" ? r : void 0,
+			"--xy-minimap-node-stroke-width-props": typeof s == "number" ? s : void 0
+		},
+		className: cc(["react-flow__minimap", n]),
+		"data-testid": "rf__minimap",
+		children: jsxs("svg", {
+			width: N,
+			height: P,
+			viewBox: `${V} ${H} ${U} ${W}`,
+			className: "react-flow__minimap-svg",
+			role: "img",
+			"aria-labelledby": G,
+			ref: w,
+			onClick: J,
+			children: [
+				X && jsx("title", {
+					id: G,
+					children: X
+				}),
+				jsx(MiniMapNodes$1, {
+					onClick: Y,
+					nodeColor: i,
+					nodeStrokeColor: r,
+					nodeBorderRadius: o,
+					nodeClassName: a,
+					nodeStrokeWidth: s,
+					nodeComponent: c
+				}),
+				jsx("path", {
+					className: "react-flow__minimap-mask",
+					d: `M${V - B},${H - B}h${U + B * 2}v${W + B * 2}h${-U - B * 2}z
+        M${E.x},${E.y}h${E.width}v${E.height}h${-E.width}z`,
+					fillRule: "evenodd",
+					pointerEvents: "none"
+				})
+			]
+		})
+	});
+}
+MiniMapComponent.displayName = "MiniMap", memo(MiniMapComponent);
+var scaleSelector = (e) => (t) => e ? `${Math.max(1 / t.transform[2], 1)}` : void 0, defaultPositions = {
+	[ResizeControlVariant.Line]: "right",
+	[ResizeControlVariant.Handle]: "bottom-right"
+};
+function ResizeControl({ nodeId: t, position: n, variant: r = ResizeControlVariant.Handle, className: i, style: a = void 0, children: s, color: c, minWidth: l = 10, minHeight: u = 10, maxWidth: d = Number.MAX_VALUE, maxHeight: p = Number.MAX_VALUE, keepAspectRatio: m = !1, resizeDirection: h, autoScale: g = !0, shouldResize: _, onResizeStart: v, onResize: y, onResizeEnd: b }) {
+	let x = useNodeId(), C = typeof t == "string" ? t : x, w = useStoreApi(), T = useRef(null), E = r === ResizeControlVariant.Handle, D = useStore(useCallback(scaleSelector(E && g), [E, g]), shallow), O = useRef(null), k = n ?? defaultPositions[r];
+	return useEffect(() => {
+		if (!(!T.current || !C)) return O.current ||= XYResizer({
+			domNode: T.current,
+			nodeId: C,
+			getStoreItems: () => {
+				let { nodeLookup: e, transform: t, snapGrid: n, snapToGrid: r, nodeOrigin: i, domNode: a } = w.getState();
+				return {
+					nodeLookup: e,
+					transform: t,
+					snapGrid: n,
+					snapToGrid: r,
+					nodeOrigin: i,
+					paneDomNode: a
+				};
+			},
+			onChange: (e, t) => {
+				let { triggerNodeChanges: n, nodeLookup: r, parentLookup: i, nodeOrigin: a } = w.getState(), o = [], s = {
+					x: e.x,
+					y: e.y
+				}, c = r.get(C);
+				if (c && c.expandParent && c.parentId) {
+					let t = c.origin ?? a, n = e.width ?? c.measured.width ?? 0, l = e.height ?? c.measured.height ?? 0, u = handleExpandParent([{
+						id: c.id,
+						parentId: c.parentId,
+						rect: {
+							width: n,
+							height: l,
+							...evaluateAbsolutePosition({
+								x: e.x ?? c.position.x,
+								y: e.y ?? c.position.y
+							}, {
+								width: n,
+								height: l
+							}, c.parentId, r, t)
+						}
+					}], r, i, a);
+					o.push(...u), s.x = e.x ? Math.max(t[0] * n, e.x) : void 0, s.y = e.y ? Math.max(t[1] * l, e.y) : void 0;
+				}
+				if (s.x !== void 0 && s.y !== void 0) {
+					let e = {
+						id: C,
+						type: "position",
+						position: { ...s }
+					};
+					o.push(e);
+				}
+				if (e.width !== void 0 && e.height !== void 0) {
+					let t = {
+						id: C,
+						type: "dimensions",
+						resizing: !0,
+						setAttributes: h ? h === "horizontal" ? "width" : "height" : !0,
+						dimensions: {
+							width: e.width,
+							height: e.height
+						}
+					};
+					o.push(t);
+				}
+				for (let e of t) {
+					let t = {
+						...e,
+						type: "position"
+					};
+					o.push(t);
+				}
+				n(o);
+			},
+			onEnd: ({ width: e, height: t }) => {
+				let n = {
+					id: C,
+					type: "dimensions",
+					resizing: !1,
+					dimensions: {
+						width: e,
+						height: t
+					}
+				};
+				w.getState().triggerNodeChanges([n]);
+			}
+		}), O.current.update({
+			controlPosition: k,
+			boundaries: {
+				minWidth: l,
+				minHeight: u,
+				maxWidth: d,
+				maxHeight: p
+			},
+			keepAspectRatio: m,
+			resizeDirection: h,
+			onResizeStart: v,
+			onResize: y,
+			onResizeEnd: b,
+			shouldResize: _
+		}), () => {
+			O.current?.destroy();
+		};
+	}, [
+		k,
+		l,
+		u,
+		d,
+		p,
+		m,
+		v,
+		y,
+		b,
+		_
+	]), jsx("div", {
+		className: cc([
+			"react-flow__resize-control",
+			"nodrag",
+			...k.split("-"),
+			r,
+			i
+		]),
+		ref: T,
+		style: {
+			...a,
+			scale: D,
+			...c && { [E ? "backgroundColor" : "borderColor"]: c }
+		},
+		children: s
+	});
+}
+memo(ResizeControl);
+export { Background, BackgroundVariant, BaseEdge, Controls, EdgeLabelRenderer, Handle, ReactFlowProvider, index, useEdgesState, useNodesState, useReactFlow };