@statelyai/layout 0.0.1 → 0.0.2

package/dist/{layered-Dd868WZY.mjs → layered-QwJn2gb2.mjs}

@@ -1721,6 +1721,14 @@ function applyPostCompaction(input, placement, routes) {
 	input.settings["compaction.postCompaction.constraints"];
 	if (strategy === "NONE") return placement;
 	const rects = placement.rectByNodeId;
+	const originalEndpointsByEdgeId = new Map([...routes?.pointsByEdgeId ?? []].flatMap(([edgeId, points]) => {
+		const start = points[0];
+		const end = points.at(-1);
+		return start && end ? [[edgeId, {
+			start: { ...start },
+			end: { ...end }
+		}]] : [];
+	}));
 	const compactables = [...rects].map(([id, rect]) => {
 		const longEdgeDummy = id.startsWith("__layout_dummy:") && rect.width === 0 && rect.height === 0;
 		const incidentEdge = longEdgeDummy ? input.graph.edges.find((edge) => edge.sourceId === id || edge.targetId === id) : void 0;
@@ -1736,6 +1744,7 @@ function applyPostCompaction(input, placement, routes) {
 		};
 	});
 	if (routes) for (const [edgeId, readonlyPoints] of routes.pointsByEdgeId) {
+		if (routes.outsideFeedbackEdgeIds?.has(edgeId)) continue;
 		const points = readonlyPoints;
 		for (let index = 0; index + 1 < points.length; index++) {
 			const first = points[index];
@@ -1756,7 +1765,10 @@ function applyPostCompaction(input, placement, routes) {
 	}
 	const verticalSpacing = (left, right) => left.kind === "node" && right.kind === "node" ? input.spacing.node : left.kind === "segment" && right.kind === "segment" && left.edgeId === right.edgeId ? 1 : Number(input.settings[left.kind === "segment" && right.kind === "segment" ? "spacing.edgeEdge" : "spacing.edgeNode"] ?? 10);
 	const horizontalSpacing = (left, right) => left.kind === "node" && right.kind === "node" ? input.spacing.node : left.kind === "segment" && right.kind === "segment" && left.edgeId === right.edgeId ? 0 : Number(input.settings[left.kind === "segment" && right.kind === "segment" ? "spacing.edgeEdge" : "spacing.edgeNode"] ?? 10);
+	const centerLabeledEdgeIds = new Set(input.graph.edges.filter((edge) => (edge.width ?? 0) > 0 && (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER").map((edge) => edge.id));
+	const labelFlowLocked = new Set(compactables.filter((item) => item.kind === "segment" && item.edgeId !== void 0 && centerLabeledEdgeIds.has(item.edgeId)).map((item) => item.id));
 	const compact$1 = (direction, locked = /* @__PURE__ */ new Set()) => {
+		locked = new Set([...labelFlowLocked, ...locked]);
 		const nodes = compactables.map((item) => ({
 			...item,
 			x: direction === "RIGHT" ? -item.x - item.width : item.x,
@@ -1823,6 +1835,7 @@ function applyPostCompaction(input, placement, routes) {
 			for (const node of input.graph.nodes) {
 				const targets = outgoing.get(node.id) ?? [];
 				if (targets.length <= (incomingDegree.get(node.id) ?? 0) || targets.length === 0) continue;
+				if (input.graph.edges.some((edge) => edge.sourceId === node.id && centerLabeledEdgeIds.has(edge.id))) continue;
 				const item = itemByNodeId.get(node.id);
 				if (!item) continue;
 				const upper = Math.min(...targets.map((targetId) => (itemByNodeId.get(targetId)?.x ?? item.x) - item.width - input.spacing.node));
@@ -1830,6 +1843,49 @@ function applyPostCompaction(input, placement, routes) {
 			}
 		}
 	}
+	if (strategy === "EDGE_LENGTH" && input.settings["nodePlacement.favorStraightEdges"] === true && (input.direction === "down" || input.direction === "up")) {
+		const itemByNodeId = new Map(compactables.flatMap((item) => item.kind === "node" && item.nodeId ? [[item.nodeId, item]] : []));
+		const incomingDegree = new Map(input.graph.nodes.map((node) => [node.id, 0]));
+		for (const edge of input.graph.edges) if (edge.sourceId !== edge.targetId) incomingDegree.set(edge.targetId, (incomingDegree.get(edge.targetId) ?? 0) + 1);
+		for (const edge of input.graph.edges) {
+			if (edge.sourceId === edge.targetId || (incomingDegree.get(edge.targetId) ?? 0) !== 1) continue;
+			const endpoints$2 = originalEndpointsByEdgeId.get(edge.id);
+			const source = itemByNodeId.get(edge.sourceId);
+			const target = itemByNodeId.get(edge.targetId);
+			if (!endpoints$2 || !source || !target) continue;
+			if (!(input.direction === "down" ? endpoints$2.start.y < endpoints$2.end.y : endpoints$2.start.y > endpoints$2.end.y)) continue;
+			const desiredTargetX = source.x + (endpoints$2.start.x - source.originalX) - (endpoints$2.end.x - target.originalX);
+			if (compactables.some((candidate) => {
+				if (candidate.kind !== "node" || candidate === target) return false;
+				if (!(candidate.y < target.y + target.height && candidate.y + candidate.height > target.y)) return false;
+				const spacing = input.spacing.node;
+				return desiredTargetX < candidate.x + candidate.width + spacing && desiredTargetX + target.width + spacing > candidate.x;
+			})) continue;
+			target.x = desiredTargetX;
+			const alignedX = source.x + (endpoints$2.start.x - source.originalX);
+			for (const segment of compactables) if (segment.kind === "segment" && segment.edgeId === edge.id) segment.x = alignedX;
+		}
+	}
+	if (input.direction === "right" && centerLabeledEdgeIds.size > 0) {
+		const itemByNodeId = new Map(compactables.flatMap((item) => item.kind === "node" && item.nodeId ? [[item.nodeId, item]] : []));
+		const edgeNodeSpacing = Number(input.settings["spacing.edgeNodeBetweenLayers"] ?? 10);
+		for (const edge of input.graph.edges) {
+			if (!centerLabeledEdgeIds.has(edge.id)) continue;
+			const source = itemByNodeId.get(edge.sourceId);
+			const target = itemByNodeId.get(edge.targetId);
+			const originalEndpoints = originalEndpointsByEdgeId.get(edge.id);
+			if (!source || !target || !originalEndpoints || originalEndpoints.start.x >= originalEndpoints.end.x) continue;
+			const tracks = compactables.filter((item) => item.kind === "segment" && item.edgeId === edge.id);
+			const track = tracks.length > 0 ? Math.max(...tracks.map((item) => item.x)) : void 0;
+			const targetNode = input.graph.nodes.find((node) => node.id === edge.targetId);
+			const targetPort = targetNode?.ports?.find((port) => port.name === edge.targetPort);
+			if (track !== void 0 && targetNode !== void 0 && targetPort !== void 0 && (targetPort.width ?? 8) === 0 && (targetPort.height ?? 8) === 0 && input.nodeSettings?.(targetNode)?.portConstraints === "FIXED_SIDE" && input.graph.edges.filter((candidate) => candidate.targetId === edge.targetId).length > input.graph.edges.filter((candidate) => candidate.sourceId === edge.sourceId).length) source.x = Math.max(source.x, track - edgeNodeSpacing - (edge.width ?? 0) - input.spacing.layer - source.width);
+			else {
+				const routeStart = track !== void 0 ? track + edgeNodeSpacing : source.x + source.width + input.spacing.layer;
+				target.x = Math.max(target.x, routeStart + (edge.width ?? 0) + input.spacing.layer);
+			}
+		}
+	}
 	const offset = input.padding.left - Math.min(...compactables.map((item) => item.x));
 	for (const item of compactables) item.x += offset;
 	const nodeDeltaById = /* @__PURE__ */ new Map();
@@ -1846,14 +1902,71 @@ function applyPostCompaction(input, placement, routes) {
 		item.points[1].x += delta;
 	}
 	if (routes) {
+		const edgeRouting = input.settings.edgeRouting ?? "ORTHOGONAL";
+		const compactedSplineControls = routes.splineNubControlsByEdgeId ? new Map(routes.splineNubControlsByEdgeId) : void 0;
 		const edgeById = new Map(input.graph.edges.map((edge) => [edge.id, edge]));
 		for (const [edgeId, readonlyPoints] of routes.pointsByEdgeId) {
-			const points = readonlyPoints;
+			const points = [...readonlyPoints];
 			const edge = edgeById.get(edgeId);
 			if (!edge || points.length === 0) continue;
-			points[0].x += nodeDeltaById.get(edge.sourceId) ?? 0;
-			points.at(-1).x += nodeDeltaById.get(edge.targetId) ?? 0;
+			const originalEndpoints = originalEndpointsByEdgeId.get(edgeId);
+			if (originalEndpoints) {
+				points[0] = {
+					...originalEndpoints.start,
+					x: originalEndpoints.start.x + (nodeDeltaById.get(edge.sourceId) ?? 0)
+				};
+				points[points.length - 1] = {
+					...originalEndpoints.end,
+					x: originalEndpoints.end.x + (nodeDeltaById.get(edge.targetId) ?? 0)
+				};
+				if (routes.outsideFeedbackEdgeIds?.has(edgeId)) {
+					const horizontal = input.direction === "left" || input.direction === "right";
+					const startDelta = points[0].x - originalEndpoints.start.x;
+					const endDelta = points.at(-1).x - originalEndpoints.end.x;
+					if (horizontal && points.length >= 6) {
+						for (const index of [1, 2]) points[index] = {
+							...points[index],
+							x: points[index].x + startDelta
+						};
+						for (const index of [points.length - 3, points.length - 2]) points[index] = {
+							...points[index],
+							x: points[index].x + endDelta
+						};
+					} else if (!horizontal && points.length >= 4) {
+						points[1] = {
+							...points[1],
+							x: points[1].x + startDelta
+						};
+						points[points.length - 2] = {
+							...points[points.length - 2],
+							x: points[points.length - 2].x + endDelta
+						};
+					}
+				}
+			}
+			let compactedPoints = points;
+			if (edgeRouting === "ORTHOGONAL") {
+				const horizontal = input.direction === "left" || input.direction === "right";
+				const orthogonal = [];
+				for (const [index, point] of points.entries()) {
+					const previous = orthogonal.at(-1);
+					if (previous && Math.abs(previous.x - point.x) > 1e-9 && Math.abs(previous.y - point.y) > 1e-9) {
+						const approachingTarget = index === points.length - 1;
+						orthogonal.push(horizontal === approachingTarget ? {
+							x: previous.x,
+							y: point.y
+						} : {
+							x: point.x,
+							y: previous.y
+						});
+					}
+					orthogonal.push(point);
+				}
+				compactedPoints = simplifyRoute$1(orthogonal);
+			} else if (edgeRouting === "SPLINES") compactedSplineControls?.delete(edgeId);
+			routes.pointsByEdgeId.set(edgeId, compactedPoints);
 		}
+		if (compactedSplineControls) routes.splineNubControlsByEdgeId = compactedSplineControls;
 	}
 	return placement;
 }
@@ -2046,8 +2159,16 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		const forward = input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT" || sourceFlow <= targetFlow;
 		const feedback = input.settings.feedbackEdges === true && orientation?.reversedEdgeIds.has(edge.id) === true;
 		const directionReversed = input.direction === "left" || input.direction === "up";
-		const sourceSide = feedback ? directionReversed ? "before" : "after" : forward ? "after" : "before";
-		const targetSide = feedback ? directionReversed ? "after" : "before" : forward ? "before" : "after";
+		const endpointSide = (nodeId, portName) => {
+			const node = nodeById.get(nodeId);
+			const port = node?.ports?.find((candidate) => candidate.name === portName);
+			const constraints = node ? input.nodeSettings?.(node)?.portConstraints : void 0;
+			if (!node || !port || constraints !== "FIXED_SIDE" && constraints !== "FIXED_ORDER" && constraints !== "FIXED_RATIO" && constraints !== "FIXED_POS") return;
+			const configured = input.portSettings?.(port, node)?.["port.side"];
+			return configured === "WEST" || configured === "NORTH" ? "before" : configured === "EAST" || configured === "SOUTH" ? "after" : void 0;
+		};
+		const sourceSide = endpointSide(edge.sourceId, edge.sourcePort) ?? (feedback ? directionReversed ? "before" : "after" : forward ? "after" : "before");
+		const targetSide = endpointSide(edge.targetId, edge.targetPort) ?? (feedback ? directionReversed ? "after" : "before" : forward ? "before" : "after");
 		const sourceKey = `${edge.sourceId}:${sourceSide}`;
 		const targetKey = `${edge.targetId}:${targetSide}`;
 		const sourceGroup = groups.get(sourceKey) ?? [];
@@ -2169,8 +2290,14 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 function routeEdges(style) {
 	return (input, orientation, placement) => {
 		const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
+		const hasZeroFixedSideTarget = (edge) => {
+			const target = nodeById.get(edge.targetId);
+			const port = target?.ports?.find((candidate) => candidate.name === edge.targetPort);
+			return target !== void 0 && port !== void 0 && (port.width ?? 8) === 0 && (port.height ?? 8) === 0 && input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE";
+		};
 		const pointsByEdgeId = /* @__PURE__ */ new Map();
 		const splineNubControlsByEdgeId = /* @__PURE__ */ new Map();
+		const outsideFeedbackEdgeIds = /* @__PURE__ */ new Set();
 		const horizontal = input.direction === "left" || input.direction === "right";
 		const reverse = input.direction === "up" || input.direction === "left";
 		const mutableRects = placement.rectByNodeId;
@@ -2181,6 +2308,35 @@ function routeEdges(style) {
 			loops.push(edge);
 			selfLoopsByNodeId.set(edge.sourceId, loops);
 		}
+		const selfLoopEntriesByX = [...selfLoopsByNodeId].sort(([leftId], [rightId]) => (mutableRects.get(leftId)?.x ?? 0) - (mutableRects.get(rightId)?.x ?? 0));
+		for (const [id, loops] of selfLoopEntriesByX) {
+			const rect = mutableRects.get(id);
+			const node = nodeById.get(id);
+			if (!rect || !node) continue;
+			const eastLoops = loops.filter((edge) => {
+				const sourcePort = node.ports?.find((port) => port.name === edge.sourcePort);
+				const targetPort = node.ports?.find((port) => port.name === edge.targetPort);
+				return sourcePort !== void 0 && targetPort !== void 0 && input.portSettings?.(sourcePort, node)?.["port.side"] === "EAST" && input.portSettings?.(targetPort, node)?.["port.side"] === "EAST";
+			});
+			if (eastLoops.length === 0) continue;
+			const selfLoopSpacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
+			const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
+			const exteriorWidth = selfLoopSpacing + eastLoops.reduce((sum, edge) => sum + (edge.width ?? 0) + labelSpacing, 1);
+			const nodeRight = rect.x + rect.width;
+			const rightCandidates = [...mutableRects.entries()].filter(([candidateId, candidateRect]) => candidateId !== id && candidateRect.x >= nodeRight - 1e-9);
+			if (rightCandidates.length === 0) continue;
+			const nextX = Math.min(...rightCandidates.map(([, candidateRect]) => candidateRect.x));
+			const shift = nodeRight + exteriorWidth + input.spacing.node - nextX;
+			if (shift <= 0) continue;
+			for (const [candidateId, candidateRect] of mutableRects) {
+				if (candidateId === id || candidateRect.x < nextX - 1e-9) continue;
+				mutableRects.set(candidateId, {
+					...candidateRect,
+					x: candidateRect.x + shift
+				});
+			}
+		}
+		const northReserveByLayer = /* @__PURE__ */ new Map();
 		for (const [id, loops] of selfLoopsByNodeId) {
 			const rect = mutableRects.get(id);
 			if (!rect) continue;
@@ -2198,12 +2354,17 @@ function routeEdges(style) {
 			else {
 				const sideLoopCount = distribution === "NORTH_SOUTH" ? Math.ceil(loops.length / 2) : loops.length;
 				const reserve = (ordering === "SEQUENCED" ? Math.min(1, sideLoopCount) : sideLoopCount) * spacing + splineOffset;
-				mutableRects.set(id, {
-					...rect,
-					y: rect.y + reserve
-				});
+				northReserveByLayer.set(rect.y, Math.max(northReserveByLayer.get(rect.y) ?? 0, reserve));
 			}
 		}
+		const northReserves = [...northReserveByLayer].sort(([left], [right]) => left - right);
+		for (const [candidateId, candidateRect] of mutableRects) {
+			const reserve = northReserves.reduce((total, [layerY, layerReserve]) => candidateRect.y + 1e-9 >= layerY ? total + layerReserve : total, 0);
+			if (reserve > 0) mutableRects.set(candidateId, {
+				...candidateRect,
+				y: candidateRect.y + reserve
+			});
+		}
 		const edgeLabelSideSelection = input.settings["edgeLabels.sideSelection"] ?? "SMART_DOWN";
 		if (edgeLabelSideSelection === "ALWAYS_UP" || edgeLabelSideSelection === "SMART_UP" || edgeLabelSideSelection === "DIRECTION_UP") {
 			let crossShift = 0;
@@ -2243,12 +2404,13 @@ function routeEdges(style) {
 		}
 		const labelExtraByGap = flowLayers.slice(0, -1).map(() => 0);
 		for (const edge of input.graph.edges) {
-			if ((edge.width ?? 0) <= 0) continue;
+			const labelFlowSize = horizontal ? edge.width ?? 0 : edge.height ?? 0;
+			if (labelFlowSize <= 0) continue;
 			const sourceLayer = flowLayerByNodeId.get(edge.sourceId);
 			const targetLayer = flowLayerByNodeId.get(edge.targetId);
 			if (sourceLayer === void 0 || targetLayer === void 0) continue;
 			if (Math.abs(sourceLayer - targetLayer) !== 1) continue;
-			const extra = (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER" ? (edge.width ?? 0) + input.spacing.layer : (edge.width ?? 0) + Number(input.settings["spacing.edgeLabel"] ?? 2);
+			const extra = (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER" ? labelFlowSize + input.spacing.layer : labelFlowSize + Number(input.settings["spacing.edgeLabel"] ?? 2);
 			const gap = Math.min(sourceLayer, targetLayer);
 			labelExtraByGap[gap] = Math.max(labelExtraByGap[gap] ?? 0, extra);
 		}
@@ -2493,13 +2655,15 @@ function routeEdges(style) {
 				bounds.start = nextStart;
 				bounds.end = nextStart + size;
 				const slots = slotsByGap[layerNo] ?? 0;
-				const gapSpacing = slots === 0 ? existingGapByLayer[layerNo] ?? input.spacing.layer : Math.max(preservesNodeFlexibilityGap ? existingGapByLayer[layerNo] ?? input.spacing.layer : input.spacing.layer, 2 * edgeNodeSpacing + Math.max(0, slots - 1) * edgeEdgeSpacing);
+				const routesNearTarget = candidatesByGap[layerNo]?.some((candidate) => hasZeroFixedSideTarget(candidate.edge) && candidatesByGap[layerNo].filter(({ edge }) => edge.targetId === candidate.edge.targetId).length > candidatesByGap[layerNo].filter(({ edge }) => edge.sourceId === candidate.edge.sourceId).length);
+				const preservedGap = (existingGapByLayer[layerNo] ?? input.spacing.layer) - (routesNearTarget ? edgeEdgeSpacing : 0);
+				const gapSpacing = slots === 0 ? existingGapByLayer[layerNo] ?? input.spacing.layer : Math.max(preservesNodeFlexibilityGap || (labelExtraByGap[layerNo] ?? 0) > 0 ? preservedGap : input.spacing.layer, 2 * edgeNodeSpacing + Math.max(0, slots - 1) * edgeEdgeSpacing);
 				nextStart = bounds.end + gapSpacing;
 			}
 			implicitEndpoints = implicitEdgeEndpoints(input, placement, orientation);
 			for (const [gap, candidates] of candidatesByGap.entries()) for (const candidate of candidates) {
 				if (candidate.straight) continue;
-				const firstTrack = (flowLayers[gap]?.end ?? 0) + edgeNodeSpacing + (candidate.slot ?? 0) * edgeEdgeSpacing;
+				const firstTrack = input.direction === "right" && hasZeroFixedSideTarget(candidate.edge) && candidates.filter(({ edge }) => edge.targetId === candidate.edge.targetId).length > candidates.filter(({ edge }) => edge.sourceId === candidate.edge.sourceId).length ? (flowLayers[gap + 1]?.start ?? 0) - edgeNodeSpacing - (candidate.slot ?? 0) * edgeEdgeSpacing : (flowLayers[gap]?.end ?? 0) + edgeNodeSpacing + (candidate.slot ?? 0) * edgeEdgeSpacing;
 				if (candidate.secondSlot !== void 0 && candidate.crossover !== void 0) orthogonalDetourByEdgeId.set(candidate.edge.id, {
 					firstTrack,
 					secondTrack: (flowLayers[gap]?.end ?? 0) + edgeNodeSpacing + candidate.secondSlot * edgeEdgeSpacing,
@@ -2663,7 +2827,7 @@ function routeEdges(style) {
 					}] : [];
 				});
 				const incoming = segments.map(() => 0);
-				for (const dependency of acyclicDependencies) incoming[dependency.target]++;
+				for (const dependency of acyclicDependencies) incoming[dependency.target] = (incoming[dependency.target] ?? 0) + 1;
 				const queue = incoming.flatMap((count, index) => count === 0 ? [index] : []);
 				const rank = segments.map(() => 0);
 				for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
@@ -2745,67 +2909,88 @@ function routeEdges(style) {
 			const sourceRect = placement.rectByNodeId.get(edge.sourceId);
 			const targetRect = placement.rectByNodeId.get(edge.targetId);
 			if (!source || !target || !sourceRect || !targetRect) continue;
-			if (input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id)) {
-				const spacing = Number(input.settings["spacing.edgeNode"] ?? 10);
+			const reversedEdge = orientation.reversedEdgeIds.has(edge.id);
+			const feedbackSourcePort = source.ports?.find((port) => port.name === edge.sourcePort);
+			const feedbackTargetPort = target.ports?.find((port) => port.name === edge.targetPort);
+			const feedbackSourcePortSide = feedbackSourcePort ? input.portSettings?.(feedbackSourcePort, source)?.["port.side"] : void 0;
+			const feedbackTargetPortSide = feedbackTargetPort ? input.portSettings?.(feedbackTargetPort, target)?.["port.side"] : void 0;
+			const sourceAwaySide = horizontal ? sourceRect.x < targetRect.x ? "WEST" : "EAST" : sourceRect.y < targetRect.y ? "NORTH" : "SOUTH";
+			const targetAwaySide = horizontal ? sourceRect.x < targetRect.x ? "EAST" : "WEST" : sourceRect.y < targetRect.y ? "SOUTH" : "NORTH";
+			const sameSideSelfLoop = source.id === target.id && feedbackSourcePortSide !== void 0 && feedbackSourcePortSide === feedbackTargetPortSide;
+			const fixedSideFeedback = style === "ORTHOGONAL" && !sameSideSelfLoop && (feedbackSourcePortSide === sourceAwaySide || feedbackTargetPortSide === targetAwaySide);
+			if (input.settings.feedbackEdges === true && reversedEdge || fixedSideFeedback) {
+				if (fixedSideFeedback) outsideFeedbackEdgeIds.add(edge.id);
+				const crossSpacing = Number(input.settings["spacing.edgeNode"] ?? 10);
+				const flowSpacing = fixedSideFeedback ? Number(input.settings["spacing.edgeNodeBetweenLayers"] ?? 10) + (source.id === target.id ? Number(input.settings["spacing.nodeSelfLoop"] ?? 10) : 0) : crossSpacing;
+				const sourceFallback$1 = implicitEndpoints.get(edge.id)?.source ?? {
+					x: sourceRect.x + sourceRect.width / 2,
+					y: sourceRect.y + sourceRect.height / 2
+				};
+				const targetFallback$1 = implicitEndpoints.get(edge.id)?.target ?? {
+					x: targetRect.x + targetRect.width / 2,
+					y: targetRect.y + targetRect.height / 2
+				};
+				const start$1 = fixedSideFeedback ? getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback$1, input.direction, input) : sourceFallback$1;
+				const end$1 = fixedSideFeedback ? getPortPoint(target, edge.targetPort, targetRect, targetFallback$1, input.direction, input) : targetFallback$1;
 				if (horizontal) {
-					const sign = reverse ? -1 : 1;
-					const start$1 = {
-						x: sign > 0 ? sourceRect.x + sourceRect.width : sourceRect.x,
-						y: sourceRect.y + sourceRect.height / 2
-					};
-					const end$1 = {
-						x: sign > 0 ? targetRect.x : targetRect.x + targetRect.width,
-						y: targetRect.y + targetRect.height / 2
-					};
-					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.y + rect.height)) + spacing;
+					const sign = fixedSideFeedback ? Math.sign(sourceRect.x - targetRect.x) || 1 : reverse ? -1 : 1;
+					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.y + rect.height)) + crossSpacing + (fixedSideFeedback ? .5 : 0);
+					const preserveCenters = fixedSideFeedback && input.settings.unnecessaryBendpoints === true;
 					pointsByEdgeId.set(edge.id, [
 						start$1,
 						{
-							x: start$1.x + sign * spacing,
+							x: start$1.x + sign * flowSpacing,
 							y: start$1.y
 						},
 						{
-							x: start$1.x + sign * spacing,
+							x: start$1.x + sign * flowSpacing,
 							y: outerCross
 						},
+						...preserveCenters ? [{
+							x: sourceRect.x + sourceRect.width / 2,
+							y: outerCross
+						}, {
+							x: targetRect.x + targetRect.width / 2,
+							y: outerCross
+						}] : [],
 						{
-							x: end$1.x - sign * spacing,
+							x: end$1.x - sign * flowSpacing,
 							y: outerCross
 						},
 						{
-							x: end$1.x - sign * spacing,
+							x: end$1.x - sign * flowSpacing,
 							y: end$1.y
 						},
 						end$1
 					]);
 				} else {
-					const sign = reverse ? -1 : 1;
-					const start$1 = {
-						x: sourceRect.x + sourceRect.width / 2,
-						y: sign > 0 ? sourceRect.y + sourceRect.height : sourceRect.y
-					};
-					const end$1 = {
-						x: targetRect.x + targetRect.width / 2,
-						y: sign > 0 ? targetRect.y : targetRect.y + targetRect.height
-					};
-					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.x + rect.width)) + spacing;
+					const sign = fixedSideFeedback ? Math.sign(sourceRect.y - targetRect.y) || 1 : reverse ? -1 : 1;
+					const outerCross = Math.max(...[...placement.rectByNodeId.values()].map((rect) => rect.x + rect.width)) + crossSpacing + (fixedSideFeedback ? .5 : 0);
+					const preserveCenters = fixedSideFeedback && input.settings.unnecessaryBendpoints === true;
 					pointsByEdgeId.set(edge.id, [
 						start$1,
 						{
 							x: start$1.x,
-							y: start$1.y + sign * spacing
+							y: start$1.y + sign * flowSpacing
 						},
 						{
 							x: outerCross,
-							y: start$1.y + sign * spacing
+							y: start$1.y + sign * flowSpacing
 						},
+						...preserveCenters ? [{
+							x: outerCross,
+							y: sourceRect.y + sourceRect.height / 2
+						}, {
+							x: outerCross,
+							y: targetRect.y + targetRect.height / 2
+						}] : [],
 						{
 							x: outerCross,
-							y: end$1.y - sign * spacing
+							y: end$1.y - sign * flowSpacing
 						},
 						{
 							x: end$1.x,
-							y: end$1.y - sign * spacing
+							y: end$1.y - sign * flowSpacing
 						},
 						end$1
 					]);
@@ -2870,6 +3055,75 @@ function routeEdges(style) {
 				const distribution = nodeSettings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
 				const ordering = nodeSettings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
 				if (style === "ORTHOGONAL") {
+					if (sameSideSelfLoop) {
+						const endpoints$2 = implicitEndpoints.get(edge.id);
+						const start$2 = getPortPoint(source, edge.sourcePort, sourceRect, endpoints$2?.source ?? {
+							x: sourceRect.x + sourceRect.width / 2,
+							y: sourceRect.y + sourceRect.height / 2
+						}, input.direction, input);
+						const end$2 = getPortPoint(target, edge.targetPort, targetRect, endpoints$2?.target ?? {
+							x: targetRect.x + targetRect.width / 2,
+							y: targetRect.y + targetRect.height / 2
+						}, input.direction, input);
+						const side = feedbackSourcePortSide;
+						const sameSideLoops = loops.filter((candidate) => {
+							const candidateSourcePort = source.ports?.find((port) => port.name === candidate.sourcePort);
+							const candidateTargetPort = source.ports?.find((port) => port.name === candidate.targetPort);
+							const candidateSourceSide = candidateSourcePort ? input.portSettings?.(candidateSourcePort, source)?.["port.side"] : void 0;
+							const candidateTargetSide = candidateTargetPort ? input.portSettings?.(candidateTargetPort, source)?.["port.side"] : void 0;
+							return candidateSourceSide === side && candidateTargetSide === side;
+						});
+						const sameSideLoopIndex = sameSideLoops.findIndex((candidate) => candidate.id === edge.id);
+						const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
+						const trackDistance = spacing + sameSideLoops.slice(0, Math.max(0, sameSideLoopIndex)).reduce((extent$1, candidate) => extent$1 + (side === "EAST" || side === "WEST" ? candidate.width ?? 0 : candidate.height ?? 0) + labelSpacing, 0);
+						if (side === "EAST" || side === "WEST") {
+							const nodeRects = [...placement.rectByNodeId.values()];
+							const minimumNodeX = Math.min(...nodeRects.map((rect) => rect.x));
+							const maximumNodeX = Math.max(...nodeRects.map((rect) => rect.x + rect.width));
+							const maximumNodeY = Math.max(...nodeRects.map((rect) => rect.y + rect.height));
+							const precedingLabelHeight = sameSideLoops.slice(0, Math.max(0, sameSideLoopIndex)).reduce((extent$1, candidate) => extent$1 + (candidate.height ?? 0) + labelSpacing, 0);
+							const nearTrack = side === "EAST" ? sourceRect.x + sourceRect.width + spacing : sourceRect.x - spacing;
+							const farTrack = side === "EAST" ? maximumNodeX + trackDistance + (edge.width ?? 0) : minimumNodeX - trackDistance - (edge.width ?? 0);
+							const exteriorY = maximumNodeY + spacing + precedingLabelHeight + (edge.height ?? 0) / 2 + .5;
+							pointsByEdgeId.set(edge.id, [
+								start$2,
+								{
+									x: nearTrack,
+									y: start$2.y
+								},
+								{
+									x: nearTrack,
+									y: exteriorY
+								},
+								{
+									x: farTrack,
+									y: exteriorY
+								},
+								{
+									x: farTrack,
+									y: end$2.y
+								},
+								end$2
+							]);
+							outsideFeedbackEdgeIds.add(edge.id);
+							continue;
+						}
+						const track$1 = side === "SOUTH" ? sourceRect.y + sourceRect.height + trackDistance : sourceRect.y - trackDistance;
+						pointsByEdgeId.set(edge.id, [
+							start$2,
+							{
+								x: start$2.x,
+								y: track$1
+							},
+							{
+								x: end$2.x,
+								y: track$1
+							},
+							end$2
+						]);
+						outsideFeedbackEdgeIds.add(edge.id);
+						continue;
+					}
 					const routeHorizontalSide = (side, indexOnSide, countOnSide) => {
 						const denominator = countOnSide * 2 + 1;
 						const sequenced = ordering === "SEQUENCED";
@@ -3035,8 +3289,15 @@ function routeEdges(style) {
 				x: targetRect.x + targetRect.width / 2,
 				y: targetRect.y + (reverse ? targetRect.height : 0)
 			});
-			const start = getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction, input);
-			const end = getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction, input);
+			const sourcePort = source.ports?.find((port) => port.name === edge.sourcePort);
+			const targetPort = target.ports?.find((port) => port.name === edge.targetPort);
+			const sourcePortSide = sourcePort ? input.portSettings?.(sourcePort, source)?.["port.side"] : void 0;
+			const targetPortSide = targetPort ? input.portSettings?.(targetPort, target)?.["port.side"] : void 0;
+			const fallbackMatchesPortSide = (fallback, rect, side) => side === void 0 || side === "UNDEFINED" || side === "EAST" && Math.abs(fallback.x - rect.x - rect.width) < 1e-9 || side === "WEST" && Math.abs(fallback.x - rect.x) < 1e-9 || side === "SOUTH" && Math.abs(fallback.y - rect.y - rect.height) < 1e-9 || side === "NORTH" && Math.abs(fallback.y - rect.y) < 1e-9;
+			const sourceFixedSide = sourcePort !== void 0 && fallbackMatchesPortSide(sourceFallback, sourceRect, sourcePortSide) && (sourcePort.width ?? 8) === 0 && (sourcePort.height ?? 8) === 0 && input.nodeSettings?.(source)?.portConstraints === "FIXED_SIDE" && input.graph.edges.filter((candidate) => candidate.sourceId === edge.sourceId && candidate.sourcePort === edge.sourcePort).length === 1;
+			const targetFixedSide = targetPort !== void 0 && fallbackMatchesPortSide(targetFallback, targetRect, targetPortSide) && (targetPort.width ?? 8) === 0 && (targetPort.height ?? 8) === 0 && input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE" && input.graph.edges.filter((candidate) => candidate.targetId === edge.targetId && candidate.targetPort === edge.targetPort).length === 1;
+			const start = sourceFixedSide ? sourceFallback : getPortPoint(source, edge.sourcePort, sourceRect, sourceFallback, input.direction, input);
+			const end = targetFixedSide ? targetFallback : getPortPoint(target, edge.targetPort, targetRect, targetFallback, input.direction, input);
 			const sourceLayer = flowLayerByNodeId.get(edge.sourceId) ?? 0;
 			const targetLayer = flowLayerByNodeId.get(edge.targetId) ?? 0;
 			const earlierLayer = Math.min(sourceLayer, targetLayer);
@@ -3181,7 +3442,8 @@ function routeEdges(style) {
 		}
 		return {
 			pointsByEdgeId,
-			splineNubControlsByEdgeId
+			splineNubControlsByEdgeId,
+			outsideFeedbackEdgeIds
 		};
 	};
 }
@@ -3616,7 +3878,7 @@ function normalizeAndBalance(nodes, previousLayerCounts) {
 	}
 	return filling;
 }
-function runNetworkSimplex(nodes, edges, iterationLimit, previousLayerCounts, balance = true) {
+function runNetworkSimplex(nodes, _edges, iterationLimit, previousLayerCounts, balance = true) {
 	const orderedEdges = nodes.flatMap((node) => node.outgoing);
 	orderedEdges.forEach((edge, index) => edge.order = index);
 	assignInitialLayers(nodes);
@@ -3890,10 +4152,21 @@ function splitLongEdges(input, orientation, assignment) {
 	const originalEdgeBySegmentId = /* @__PURE__ */ new Map();
 	const usedNodeIds = new Set(nodes.map((node) => node.id));
 	const originalNodeIds = new Set(usedNodeIds);
+	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
+	const forwardSourceSide = input.direction === "right" ? "EAST" : input.direction === "left" ? "WEST" : input.direction === "down" ? "SOUTH" : "NORTH";
+	const forwardTargetSide = input.direction === "right" ? "WEST" : input.direction === "left" ? "EAST" : input.direction === "down" ? "NORTH" : "SOUTH";
 	for (const edge of input.graph.edges) {
 		const sourceLayer = layerByNodeId.get(edge.sourceId) ?? 0;
 		const targetLayer = layerByNodeId.get(edge.targetId) ?? 0;
-		if (Math.abs(targetLayer - sourceLayer) <= 1 || edge.sourceId === edge.targetId || input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id)) {
+		const span = Math.abs(targetLayer - sourceLayer);
+		const source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		const sourcePort = source?.ports?.find((port) => port.name === edge.sourcePort);
+		const targetPort = target?.ports?.find((port) => port.name === edge.targetPort);
+		const sourceSide = source && sourcePort ? input.portSettings?.(sourcePort, source)?.["port.side"] : void 0;
+		const targetSide = target && targetPort ? input.portSettings?.(targetPort, target)?.["port.side"] : void 0;
+		const fixedSideFeedback = sourceLayer > targetLayer && (source !== void 0 && input.nodeSettings?.(source)?.portConstraints === "FIXED_SIDE" && sourceSide === forwardSourceSide || target !== void 0 && input.nodeSettings?.(target)?.portConstraints === "FIXED_SIDE" && targetSide === forwardTargetSide);
+		if (span <= 1 || edge.sourceId === edge.targetId || input.settings.feedbackEdges === true && orientation.reversedEdgeIds.has(edge.id) || fixedSideFeedback) {
 			edges.push(edge);
 			originalEdgeBySegmentId.set(edge.id, edge);
 			if (orientation.reversedEdgeIds.has(edge.id)) reversedEdgeIds.add(edge.id);
@@ -4055,7 +4328,9 @@ function joinLongEdgeRoutes(routes, segmentIdsByEdgeId, preserveInternalDuplicat
 		return result;
 	};
 	const pointsByEdgeId = /* @__PURE__ */ new Map();
+	const outsideFeedbackEdgeIds = /* @__PURE__ */ new Set();
 	for (const [edgeId, segmentIds] of segmentIdsByEdgeId) {
+		if (segmentIds.some((segmentId) => routes.outsideFeedbackEdgeIds?.has(segmentId))) outsideFeedbackEdgeIds.add(edgeId);
 		if (convertLongSplines && segmentIds.length > 1) {
 			const segments = segmentIds.map((segmentId) => routes.pointsByEdgeId.get(segmentId) ?? []).filter((points$1) => points$1.length >= 2);
 			if (segments.length > 1) {
@@ -4128,7 +4403,10 @@ function joinLongEdgeRoutes(routes, segmentIdsByEdgeId, preserveInternalDuplicat
 		} else for (const segmentId of segmentIds) appendPoints(points, routes.pointsByEdgeId.get(segmentId) ?? [], preserveInternalDuplicates || segmentIds.length === 1);
 		pointsByEdgeId.set(edgeId, preserveInternalDuplicates || segmentIds.length === 1 ? points : simplify(points));
 	}
-	return { pointsByEdgeId };
+	return {
+		pointsByEdgeId,
+		outsideFeedbackEdgeIds
+	};
 }
 
 //#endregion
@@ -8554,19 +8832,52 @@ function runLayeredPipeline(graph, options, context) {
 		};
 		routes.pointsByEdgeId.set(edge.id, points);
 	}
+	const routedPortAnchors = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const points = routes.pointsByEdgeId.get(edge.id);
+		const first = points?.[0];
+		const last = points?.at(-1);
+		if (edge.sourcePort !== void 0 && first && graph.edges.filter((candidate) => candidate.sourceId === edge.sourceId && candidate.sourcePort === edge.sourcePort).length === 1) routedPortAnchors.set(`${edge.sourceId}\0${edge.sourcePort}`, first);
+		if (edge.targetPort !== void 0 && last && graph.edges.filter((candidate) => candidate.targetId === edge.targetId && candidate.targetPort === edge.targetPort).length === 1) routedPortAnchors.set(`${edge.targetId}\0${edge.targetPort}`, last);
+	}
 	const nodes = graph.nodes.map((node) => {
 		const rect = placement.rectByNodeId.get(node.id);
 		if (!rect) throw new Error(`Node placement missing for ${node.id}`);
-		const ports = placePorts(node.ports, rect, direction, (port) => input.portSettings?.(port, node), {
+		let ports = placePorts(node.ports, rect, direction, (port) => input.portSettings?.(port, node), {
 			...options.settings,
 			...options.nodeSettings?.(node)
 		});
+		if (options.nodeSettings?.(node)?.portConstraints === "FIXED_SIDE") ports = ports?.map((port) => {
+			if ((port.width ?? 8) !== 0 || (port.height ?? 8) !== 0) return port;
+			const anchor = routedPortAnchors.get(`${node.id}\0${port.name}`);
+			if (!anchor || port.x === void 0 || port.y === void 0) return port;
+			const configuredAnchor = (input.portSettings?.(port, node))?.["port.anchor"];
+			const width = port.width ?? 0;
+			const height = port.height ?? 0;
+			const defaultAnchorX = port.x >= rect.width ? width : port.x + width <= 0 ? 0 : width / 2;
+			const defaultAnchorY = port.y >= rect.height ? height : port.y + height <= 0 ? 0 : height / 2;
+			const x = anchor.x - rect.x - (configuredAnchor?.x ?? defaultAnchorX);
+			const y = anchor.y - rect.y - (configuredAnchor?.y ?? defaultAnchorY);
+			return {
+				...port,
+				x: x === 0 && Object.is(port.x, -0) ? port.x : x,
+				y: y === 0 && Object.is(port.y, -0) ? port.y : y
+			};
+		});
 		return {
 			...node,
 			...rect,
 			...ports === void 0 ? {} : { ports }
 		};
 	});
+	const feedbackNodeRects = graph.nodes.flatMap((node) => {
+		const rect = placement.rectByNodeId.get(node.id);
+		return rect ? [rect] : [];
+	});
+	const minimumFeedbackNodeX = Math.min(...feedbackNodeRects.map((rect) => rect.x));
+	const maximumFeedbackNodeX = Math.max(...feedbackNodeRects.map((rect) => rect.x + rect.width));
+	const minimumFeedbackNodeY = Math.min(...feedbackNodeRects.map((rect) => rect.y));
+	const maximumFeedbackNodeY = Math.max(...feedbackNodeRects.map((rect) => rect.y + rect.height));
 	const edges = graph.edges.map((edge) => {
 		const points = [...routes.pointsByEdgeId.get(edge.id) ?? []];
 		const midpoint = getPolylineMidpoint(points);
@@ -8582,9 +8893,44 @@ function runLayeredPipeline(graph, options, context) {
 		const labelDummyRect = placement.rectByNodeId.get(expanded.labelDummyIdByEdgeId.get(edge.id) ?? "");
 		const edgeLabelSideSelection = options.settings?.["edgeLabels.sideSelection"] ?? "SMART_DOWN";
 		const placeLabelUp = edgeLabelSideSelection === "ALWAYS_UP" || edgeLabelSideSelection === "SMART_UP" || edgeLabelSideSelection === "DIRECTION_UP";
-		const routeX = labelPlacement === "TAIL" ? firstPoint.x + labelSpacing : labelPlacement === "HEAD" ? lastPoint.x - width - labelSpacing : midpoint.x - width / 2;
-		const routeY = labelPlacement === "CENTER" && inlineLabel ? midpoint.y - height / 2 - .5 : labelPlacement === "CENTER" && placeLabelUp ? midpoint.y - height - labelSpacing - Math.round(edgeThickness / 2) : (labelPlacement === "CENTER" ? midpoint.y : (firstPoint.y + lastPoint.y) / 2) + labelSpacing + Math.round(edgeThickness / 2);
 		const horizontal = direction === "left" || direction === "right";
+		const verticalTrack = horizontal ? points.find((point, index) => {
+			const next = points[index + 1];
+			return next !== void 0 && point.x === next.x && point.y !== next.y;
+		}) : void 0;
+		const secondPoint = points[1];
+		const beforeLastPoint = points.at(-2);
+		const flowDelta = horizontal ? lastPoint.x - firstPoint.x : lastPoint.y - firstPoint.y;
+		const firstLeadDelta = secondPoint ? horizontal ? secondPoint.x - firstPoint.x : secondPoint.y - firstPoint.y : 0;
+		const lastLeadDelta = beforeLastPoint ? horizontal ? lastPoint.x - beforeLastPoint.x : lastPoint.y - beforeLastPoint.y : 0;
+		const outsideFeedback = routes.outsideFeedbackEdgeIds?.has(edge.id) === true || secondPoint !== void 0 && beforeLastPoint !== void 0 && flowDelta !== 0 && firstLeadDelta * flowDelta < 0 && lastLeadDelta * flowDelta < 0;
+		const horizontalFeedbackCandidate = outsideFeedback ? points.flatMap((point, index) => {
+			const next = points[index + 1];
+			return next !== void 0 && point.y === next.y && (point.y < minimumFeedbackNodeY || point.y > maximumFeedbackNodeY) ? [{
+				start: point,
+				end: next,
+				length: Math.abs(next.x - point.x)
+			}] : [];
+		}).sort((left, right) => right.length - left.length)[0] : void 0;
+		const verticalFeedbackCandidate = outsideFeedback ? points.flatMap((point, index) => {
+			const next = points[index + 1];
+			return next !== void 0 && point.x === next.x && (point.x < minimumFeedbackNodeX || point.x > maximumFeedbackNodeX) ? [{
+				start: point,
+				end: next,
+				length: Math.abs(next.y - point.y)
+			}] : [];
+		}).sort((left, right) => right.length - left.length)[0] : void 0;
+		const sourceNode = graph.nodes.find((node) => node.id === edge.sourceId);
+		const sourcePort = sourceNode?.ports?.find((port) => port.name === edge.sourcePort);
+		const targetPort = sourceNode?.ports?.find((port) => port.name === edge.targetPort);
+		const sourcePortSide = sourceNode && sourcePort ? options.portSettings?.(sourcePort, sourceNode)?.["port.side"] : void 0;
+		const targetPortSide = sourceNode && targetPort ? options.portSettings?.(targetPort, sourceNode)?.["port.side"] : void 0;
+		const horizontalFeedbackTrack = edge.sourceId === edge.targetId && (sourcePortSide === "EAST" || sourcePortSide === "WEST") && targetPortSide === sourcePortSide || (horizontalFeedbackCandidate?.length ?? -1) >= (verticalFeedbackCandidate?.length ?? -1) ? horizontalFeedbackCandidate : void 0;
+		const verticalFeedbackTrack = horizontalFeedbackTrack ? void 0 : verticalFeedbackCandidate;
+		const trackNearTarget = verticalTrack !== void 0 && Math.abs(lastPoint.x - verticalTrack.x) < Math.abs(verticalTrack.x - firstPoint.x);
+		const edgeNodeSpacing = Number(options.settings?.["spacing.edgeNodeBetweenLayers"] ?? 10);
+		const routeX = labelPlacement === "TAIL" ? firstPoint.x + labelSpacing : labelPlacement === "HEAD" ? lastPoint.x - width - labelSpacing : inlineLabel && horizontalFeedbackTrack ? (horizontalFeedbackTrack.start.x + horizontalFeedbackTrack.end.x - width) / 2 : inlineLabel && verticalFeedbackTrack ? verticalFeedbackTrack.start.x > (minimumFeedbackNodeX + maximumFeedbackNodeX) / 2 ? verticalFeedbackTrack.start.x + labelSpacing + 1 : verticalFeedbackTrack.start.x - labelSpacing - width - 1 : inlineLabel && verticalTrack ? (direction === "right" ? trackNearTarget : !trackNearTarget) ? verticalTrack.x - edgeNodeSpacing - width : verticalTrack.x + edgeNodeSpacing : inlineLabel ? horizontal ? Math.floor(midpoint.x - width / 2) : Math.ceil(midpoint.x - width / 2) : midpoint.x - width / 2;
+		const routeY = labelPlacement === "CENTER" && inlineLabel && horizontalFeedbackTrack ? horizontalFeedbackTrack.start.y - height / 2 - .5 : labelPlacement === "CENTER" && inlineLabel && verticalFeedbackTrack ? (verticalFeedbackTrack.start.y + verticalFeedbackTrack.end.y - height) / 2 : labelPlacement === "CENTER" && inlineLabel ? midpoint.y - height / 2 - .5 : labelPlacement === "CENTER" && placeLabelUp ? midpoint.y - height - labelSpacing - Math.round(edgeThickness / 2) : (labelPlacement === "CENTER" ? midpoint.y : (firstPoint.y + lastPoint.y) / 2) + labelSpacing + Math.round(edgeThickness / 2);
 		const x = labelPlacement === "CENTER" && horizontal && labelDummyRect ? labelDummyRect.x : routeX;
 		const y = labelPlacement === "CENTER" && !horizontal && labelDummyRect ? labelDummyRect.y : routeY;
 		return {